Designing the LSTM network in Keras

Loading...

Del curso dictado por IBM

Applied AI with DeepLearning

208 calificaciones

IBM

Applied AI with DeepLearning

208 calificaciones

Curso 3 de 4 en SpecializationAdvanced Data Science with IBM

>>> By enrolling in this course you agree to the End User License Agreement as set out in the FAQ. Once enrolled you can access the license in the Resources area <<< This course, Applied Artificial Intelligence with DeepLearning, is part of the IBM Advanced Data Science Certificate which IBM is currently creating and gives you easy access to the invaluable insights into Deep Learning models used by experts in Natural Language Processing, Computer Vision, Time Series Analysis, and many other disciplines. We’ll learn about the fundamentals of Linear Algebra and Neural Networks. Then we introduce the most popular DeepLearning Frameworks like Keras, TensorFlow, PyTorch, DeepLearning4J and Apache SystemML. Keras and TensorFlow are making up the greatest portion of this course. We learn about Anomaly Detection, Time Series Forecasting, Image Recognition and Natural Language Processing by building up models using Keras one real-life examples from IoT (Internet of Things), Financial Marked Data, Literature or Image Databases. Finally, we learn how to scale those artificial brains using Kubernetes, Apache Spark and GPUs. IMPORTANT: THIS COURSE ALONE IS NOT SUFFICIENT TO OBTAIN THE "IBM Watson IoT Certified Data Scientist certificate". You need to take three other courses where two of them are currently built. The Specialization will be ready late spring, early summer 2018 Using these approaches, no matter what your skill levels in topics you would like to master, you can change your thinking and change your life. If you’re already an expert, this peep under the mental hood will give your ideas for turbocharging successful creation and deployment of DeepLearning models. If you’re struggling, you’ll see a structured treasure trove of practical techniques that walk you through what you need to do to get on track. If you’ve ever wanted to become better at anything, this course will help serve as your guide. Prerequisites: Some coding skills are necessary. Preferably python, but any other programming language will do fine. Also some basic understanding of math (linear algebra) is a plus, but we will cover that part in the first week as well. If you choose to take this course and earn the Coursera course certificate, you will also earn an IBM digital badge. To find out more about IBM digital badges follow the link ibm.biz/badging.

De la lección

DeepLearning Applications

Introduction to Time Series Forecasting4:13

Stateful vs. Stateless LSTMs6:33

Number of Time Steps, Epochs, Training and Validation8:42

Trainin Set Size4:57

Input and Output Data Construction7:18

Designing the LSTM network in Keras10:06

Anatomy of a LSTM Node12:41

Number of Parameters7:04

Training and loading a saved model4:24

Conoce a los instructores

Romeo Kienzler
Chief Data Scientist, Course Lead
IBM Watson IoT
Niketan Pansare
Senior Software Engineer
IBM Research
Tom Hanlon
Training Director
Skymind
Max Pumperla
Deep Learning Engineer
Ilja Rasin
Data Scientist
IBM Watson Health

Welcome back. In the last session we have defined,

we have constructed the input and output data as extreme and widely.

Now we are coming to the most interesting topic which is designing of the LSTM network.

But first of all,

we need to import some required packages.

So, what we are importing here,

we're importing here dense class,

we're importing here input layer,

LSTM layer, and we're importing here the model class.

I also have here import h5py package

because I use it to store the trained LSTM model.

So, let's start. The first class which we have here is the input layer.

We're using here functional API of Keras.

There are two flavors of how we can designed neural networks with Keras,

one is sequential API.

This is the most known actually.

And another one is the functional API which is much more flexible.

So, I have decided to start to learn immediately with functional API because later on,

you will see that you can do much easier more complicated things with functional API.

So, first layer is the input layer.

As always every neural network needs an input.

It takes the argument batch shape.

This is a three dimensional arrays.

So, it consist of batch size which we have defined as 64,

it has timesteps which are 10,

and it has number of parameters.

So, we are dealing only with

crude oil prices and this is only one dimension which we have.

So, we are predicting the crude oil price is one dimension,

so we have here only one.

So, suppose we would predict crude oil price for Europe,

crude oil price for US at the same timesteps,

so we would have here two parameters but we have only one.

And the output of

this class we are storing in the input is one parameter.

Secondly, we are defining the LSTM layer.

This LSTM layer takes its arguments several parameters.

So actually, if you look at Keras documentation,

you will see that it has a lot of parameters

but we are dealing only with the most important ones.

And here the first one is the number of LSTM notes.

So, if I have here only one node,

we can see the whole layer is a one node,

is a one memory cell.

This is what I have spoken about in the previous session.

I said that LSTM layer is roughly equal to one node,

to one LSTM cell.

This is really very roughly,

and I have said it not to confuse you with too much information at that point of time.

But now, we know LSTM layer can take much more nodes,

you can say also neuron's.

So, here I have decided to

use 10 nodes in the both layers.

So, we see 10 nodes,

then we see stateful true.

So, we have decided that our LSTM network will be stateful therefore,

we are setting it's true.

So, the second one is the return sequences,

it's a separate point.

And we're setting here return sequences, true.

That means that it will return the whole sequence,

the whole output sequence for every timesteps.

So, we have here 10 timesteps,

it will return a sequence of 10 outputs.

And this one, the output of this layer will be the input of the next layer which is,

actually this is architecture of stacked LSTM layers.

And you'll see that the output of this LSTM layer is stored here, lstm_1_mae.

And it goes as input into the next layer lstm_1_mae here.

And if you look carefully on the whole structure,

you'll see that the input layer is stored here in this variable, inputs_1_mae.

This output of this layer goes as input into the next layer here.

So, then we have output of the LSTM layer which is stored here lstm_1_mae,

and it goes as input into the next LSTM layer.

The output of this layer is lst_2_mae,

so now we have the structure.

And now, we need a dense layer,

dense actually is a fully connected layer.

As you know from another neural networks which are actually

consisting only from such layers like multilayer perceptron,

this is a typical picture of neural network they consisting of

dense layers and we need this layer to output our data.

So, it takes one argument which is units.

Units Is again, one.

This is the same as one here.

This is only one dimension.

We are dealing only with one thing which we are going to

predict which is the crude oil price, one unit.

And this class takes its input lstm_2_mae from here,

and we have the output.

So, now we are defining the model.

The model class takes two arguments,

the inputs which is the input layer and the outputs which is the output layer,

this is the output_1_mae.

And this is already our regressor.

So, if we define the model we have our regressor,

we have our model.

In the last step we have to compile this model.

So, meaning that the whole thing,

the whole structure will be built-up and connected.

So we call this compile method,

everything what we described here is going to be designed and connected.

So, we use this optimizer and the compile method.

We're using optimizer which is Adam,

and we use loss function which is mean absolute error.

In the next sessions, we are going to see that we can use also another function,

another loss function which is called MSE, means squared error.

And we are going to compare which loss function performs better,

mean absolute error or mean squared error,

and what are the differences.

So, now we can execute this.

And we see this is our LSTM layer.

It has input layer,

it has two LSTM layer,

and it has dense layer.

In the next session,

we're going to dive deeper into the structure and we're going to

look onto anatomy of the LSTM layer.

And until the next time,

stay tuned, enjoy. Bye.

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2019 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play