PyTorch Lecture 02 Linear Model Video Lecture - Pytorch A Complete Guide

this second actor we're gonna introduce
linear model
last time we briefly talked about the
machine learning and how it works so we
are using labeled training data sets in
a trainer model and then once the model
is trained using our data set test
called the test data set we evaluate our
model that's where the concept of
machine learning particularly we call
this type of machine learning as a
supervised learning because we are
providing the data set with answers
which train them with supervised this
machine learning and then the first task
we want to do here is that we want to
design our model for the machine
learning which takes input as an X and a
predict Y you not identify the best
model for this we need to look the data
carefully what's the input and the what
what is the output in our cases if you
spend more time probably you can get a
higher score if you spend less time you
can you can get a lower score so through
data as as basically linear
relationships not only this case you can
find in fact many many cases that has a
linear relationship for example if you
want to predict house price based on the
size of the house usually they have
linear relationships or if you want to
predict the weight of a human then you
can see the height and the weight they
usually have linear correlations so
linear is really important pretty simple
but it's really good to start with so in
our case we are using exactly that idea
so the input of our system is X then we
do some sort of linear and then we
cannot predict Y here so especially we
are going to use head mark here to
saying that all this is the Y prediction
so in notation in the mathematical
notation we can say
x times W which is some variable called
weight and then + bias another variable
called B that's exactly our model looks
like in our slide by the way this is a
little bit complicated so we cannot wrap
this bias so we will simplify our model
with a very simple x times W which is a
variable and then if we have this kind
of linear form we can draw this line for
the Y for given impetuses
x given input this is why and then for
given data set this is actually our the
true line but unfortunately our machine
does not have any insights from this
data so what they do is that usually we
can start this w with a very much random
value and then from this random value we
want to fit this line this guess to the
real Tara's that this is process of the
learning so for example let's say this
is guess 1 we have one random guess 1
and then this is another random gets 2
so probably we have more cases like this
random guesses in the code here is that
we want to find out where we want to
make this line closer to the true line
here which is provided by our data
training data sets and then we need to
measure which line is better so that we
can move towards to close through the
true line so what is the best way to
measure it so basic idea is that from
given data points we can just measure
the distance this is sort of the simple
idea what is this failure this value is
y and this value is y hat
so we basically find out differences
between these two since it doesn't
matter it's going to be plus difference
or minus difference so usually we do
scare on this and they we call this one
as
so entire goal of this machine learning
is that we want to make this one really
small so that our line will be close to
the true line so more formally we're
gonna say that this error or sometimes
we call the loss is defined by Y head
minus y which we compute the differences
and then to scale and then Y head is
something like this so that we can just
express in this form the let's see some
example here so W once again it's a
random guess so we want to see how this
loss can change using different or
different guests of the W so we can
start with W when W is 3 so then the Y
head can be computed in this w 3w times
X so it's a 1 times 3 is 3 and then when
X is 2 it's going to be 6 when X is 3 is
going to be 9 then once we have this Y
head what we can do is that we can
complete loss it's basically to find out
the differences and then to scare for
example here if the differences is 1 1
square is 1
and here the differences is 2 so 2
squared is 4 and here the difference is
is 3 so 3 in secures it is 9 and then
because we have three different data
sets what we're gonna do is that we to
average on this some of the differences
so now some of the loss similarly when
this is another case Y when W is for we
can compute the Y hat values and then we
find the differences and then we to
scare so this is really bigger than
previous so that our loss Patri dataset
is sum of 3 divided by 3 so basically
the mean over the loss we can continue
this process basically what we want to
do is we want to understand
how this lost function or lost value is
changing based on different W values
similarly when W is zero we can compute
like this and then see the difference is
and then compute the rows in a very
simple we're gonna continue this one's
when W is one we can also compute our
head and then we can find all the rows
and then we can find that min over the
loss and then when WH to this is
interesting case because we predict
something correctly everything correctly
so the loss is basically zero so which
means that our loss correctly indicates
that the errors within our prediction
and then real value so more formally
we're gonna say that this loss is some
of the all data points and then we
divide by n so it's like average so
we're gonna call this one as MSE is mean
square error that we can compute in this
way so if you express all the loss as
MSE and when which W is zero the MSE is
something like this when W is one ms is
four point seven and when w 2m s is zero
and went average three ms is this and
then when double is for ms e is eighteen
point seven so when we talk about
machine learning we want to find out the
value W value that minimizes MSE
automatically in this case it's very
easy so you can manually compute and
then figure out what is the best value
but once we have as many parameters many
weights we cannot do this anymore so we
have to find some automatic way to
identify this location so in order to do
that we want to understand these graphs
a little bit better so that what we're
gonna do is that here for a given W we
can compute the loss and then we can try
to put a point here so for example when
W is zero
the loss is eighteen point seven around
here when W is one
it's the MSE is something 4.7 so it's
going to be run to here when W is 2 is
gonna be 0 and 1 w is 3 it's about 1/7
you can get here and the 1 when W is for
is gonna be something like this also if
you can't compute in the middle 3.5 it's
gonna be something so probably it looks
like a very nice curve so the learning
is actually try to identify the weight
value which minimize the loss in these
cases at this point we want to identify
this value automatically that's what
we're gonna talk about the next lecture
oh poor we get there we're gonna
pre-plea to some hands-on experience
using our model so what we want to do is
that we want to program all these using
a Python so first we have to define this
model
so basically it gets X as an input and
they will produce Y head which is
prediction so we kind of make this one
as a function in Python or forward and
then it gets X and as input the return
will be automatically it's very simple
so x times W in W in our cases will take
any ring the bell you can start over one
point zero any point any random value we
can start with then how can I complete
loss loss we need X & Y again so here
using the X we can we can compute the
predicted value and then using the Y we
can find the differences and then be to
square and then we can just use these
two functions and try to compute a loss
for all W so first of all this is our
guest but the W will move between 0 to 4
and it is stable 0.1 in this case and
then at every step we're gonna print out
w value and then we have
some of the laws we initialize it and
then we call in each three different
data sets and then get x-value and
y-value first we're gonna get the
prediction value and then using this
prediction value we can compare the loss
and then we sum at this loss and they
were gonna print it this out and then
MSE and each iteration you can print out
divided by three which is a mean value
as you can see as W is zero the MSE
becomes something like this as you be
completed and then as W is going to
change the MSE also going to change then
if we want we can print we can actually
draw this in very nice graph phone like
this suburban Apple we have two
variables which can basically save what
is the W value at the point and what is
the MSE bedroo here so which are saving
this value in the weekend of Sprint and
they will see very nice graph like this
so this is our entire program so
hopefully you have no problem to
understand that how we're going to
implement this one using simple Python
and how we're gonna complete loss based
on our equation so before we move on to
compute this one automatically I provide
a few exercises for you
so first of all try to identify other
interesting linear prediction problems
and then if you can get some data set
you can draw the cost graph for
especially maybe one dataset
the next lecture we're gonna talk about
how we're gonna find out the W value
which give us the lowest cost
automatically you would call gradient
descent algorithm