Hello guys.
We are going to continue discussion with respect to simple RNN.
Now in this particular video, we are going to develop an end to end deep learning project using simple
RNN for this.
Uh, the data set that I'm actually going to take is something called as IMDb data set.
And this is nothing, but it is a movie reviews data set.
Now, our main task is that in our data set, you will be able to see that we will be having some text
and some output labels.
Text will be specifically the reviews and your output label will be having something like positive or
negative.
Okay.
So with the help of simple RNN, what we are basically going to do is that we are going to train this
model and we are going to see that how we can do this specific prediction and we'll not stop here.
We'll also do this entire deployment in the cloud.
And for this I'm also going to perform some trainings, uh, in my local machine.
Okay.
Now, for all those who do not have a powerful machine, you can also go ahead and execute this in Google
Colab.
Okay, Google Colab, you can go to the Google Colab and you can probably create your model.
Okay.
Basically train the model because in Google Colab they even provide you GPUs.
Okay.
Free free GPUs, free GPUs.
And it's not like I'm just taking a very small data set.
It will be good number of datas like over here, 50,000 records will be specifically there.
Now before I go ahead and probably create this end to end deep learning project, understand what we
are going to do in this deep learning project.
Okay, so I have my first of all, I'll just draw the architecture.
I have my input data.
So this is my data set, the reviews data set.
We will take this data.
We will perform some feature engineering.
And we also say it as feature transformation.
After we do this, we need to keep ready for this particular data so that it will be ingested, uh,
in the simple RNN for training the entire neural networks.
Right.
So after this we will go ahead and build our simple RNN.
So we will probably take a simple RNN architecture.
We will feed this data.
We will train it completely.
Once we train it here we are going to get our model file which I will be storing it in the form of dot
h5 file.
Okay, dot h5 file is nothing but a kind of format, like how in machine learning we use pickle file.
Similarly, in deep learning we use.
If you are using Keras, you can actually convert that into a dot h5 file.
Okay.
Then after this, uh, we will go ahead and create a Streamlit web app, Streamlit web app, and then
we will further do the deployment.
Okay.
We will further do the deployment.
Perfect.
Now this is, uh, the entire, uh, fundamental things that we are specifically going to do in this
particular project.
Okay.
Now, the best thing over here is that, uh, how do we go ahead and implementing this?
Okay.
Over here, data set feature engineering, Streamlit web app and deployment.
This, uh, we obviously have seen even in an the major thing will be training the simple RNN.
Now, this simple RNN will definitely have two important components.
Okay, I will be talking more about it.
One is something called as embedding layer.
We also need to use embedding layer over here.
Now what is this embedding layer we will just talk about in some time.
And along with this we will also use a simple RNN for training our neural network.
So both of them we really need to use.
Okay.
Now let me just talk more about this embedding layer.
What does this exactly mean?
As you know, if I just take the simple RNN.
Okay, you know how what is the architecture of simple RNN?
So this is my simple RNN over here.
And if we just make sure that we unfold this with respect to time, it will look something like this.
Right?
This we have already discussed in our theoretical session.
Theoretical session.
Like this.
And it will go on till my last layer.
And finally I'll have my output.
And this will probably go to my sigmoid or softmax.
And then we get y hat.
Okay.
So this is the process that we specifically use.
But along with this you know let's let's consider any of my text.
Let's say in my data set I have a text and this is my output.
Let's say in this text I have some inputs like X11X12X13X14.
And then I have my output over here it can be 0 or 1.
Let's say it is zero okay.
Similarly in my next sentence it will be X21X22X23X24.
And this will be one.
And you know, whenever we are doing the forward and the backward propagation with respect to every
sentence, we give words by words, right?
Initially we give X11, then in t is equal to two we give X12, then X13, then X14.
Okay.
Now this X11X12X13.
These are words right.
And we really need to convert these words into vectors okay.
So here you will be seeing that we also have to convert this words into vectors.
Vectors with respect to some dimensions, which I will be passing it over here right now.
Already we have discussed about this architecture, but one thing that I never discussed about specifically
in deep learning how this words are converted into vectors.
Okay.
And here is what your embedding layer comes into picture.
Embedding layer we have another embedding layer like this.
Let's consider like this.
Okay.
And this embedding layer is responsible in converting your words into vectors.
This embedding layer uses something called as word embeddings.
I hope you have some idea about word two vec.
Word two vec is a kind of a word embedding techniques, which we can also specifically use in the embedding
layer.
Now in the next video before we start this entire project, we really need to understand about embedding
layer.
And that is what we are going to discuss.
First of all, we will go ahead and discuss about how does embedding layer work.
And then we will try to understand the mathematical intuition.
Okay.
We'll just try to understand the intuition.
Along with this we will also do some practical implementation because unless and until we don't know
this right, it will be very difficult to understand the project.
So both of this I will try to cover it up okay.
For you all.
So, uh, this was just an introduction video about this end to end project.
Now in our next video we will talk about word embeddings, embedding layer and feature representation.
What exactly is this feature representation okay.
So let's go ahead and discuss this in the next video.
Thank you.