PyTorch Lecture 04: Back-propagation and Autograd Video Lecture | Pytorch: A Complete Guide - AI & ML

I'm going to cover a very important
concept called pet propagation in our
previous lectures we designed our system
using a very simple linear model which
takes X as input and Y head as an apple
we first design our loss function and
they will complete the gradient of loss
with respect to W and they we apply the
gradient descent algorithm to identify W
which minimizes the loss this process is
called a training process for the
gradient we just manually computed
because the our model was extremely
simple however if we have a very
complicated network like this then we
often are using nonlinearities between
these nodes in this case manually
computing this gradient becomes very
difficult or even impossible
most better way is that just using chain
rule on the computational graph slam
explain what is channel first so suppose
we have a two functions like G on the
square and F underscore like this which
means that G underscore get X as an
input and they produce G has an output
and they are connected which means G is
used as input of F and then produce F as
an upload so what we want to know here
is that we want to compute the gradient
of F with respect to X which means that
D F and G X of course this combination
is not to complicate the probably just
compute at once however a better way is
that we just divided them into two
functions and compute the gradient one
by one let's start with F on the square
so the input of F 1 the square is G so
finding out the gradient of F with
respect to G is trivial at the same
manner we can compute the gradient of G
with respect X which is also easy
because we know what is G on the square
and then basically we just combine these
two together to compute the final
gradients this is called a chain rule a
very nice thing about this channel is
that let's say this is connected with
many other nodes eventually we'll
produce loss so our final goal here is
that we want to compute the gradient of
loss with respect to X so in this case
for somehow we cannot compute everything
together and then what we can do is that
we can compute each gradients and we
just combine them this is called a
channel and the back propagation I'm
going to show you one concrete example
suppose this is just the one node in a
big huge network there is a function
called F which takes x and y and produce
s G now of course it's connected with
many other nodes and then eventually
will produce loss and what we want to
know here is that we want to know how
what is the gradient of loss with
respect to X also same here we want to
know that gradient slope loss and with
respect to X but we're gonna apply the
channel which means that we can compare
to one by one the first step is that we
can convert local gradients we know what
is the function f so finding out the
gradient of G with respect to each input
is trivial so we can compute this and
this and then the second assuming that
we for some how we cut this value from
our previous computations and then we
just apply our channel to compute this
ones which is trivial like a channel we
just can apply this one first
time's our local grievance so this is
how we're gonna compete one by one so
let me give you a concrete example
within real values let's suppose our F
the function is multiplied so this will
called a multiple like 8 and then the
first thing what we gonna do is they to
power the pass for keep on real input so
in this case let's say X equal to Y 3
it's a given and then we just compute
all values to Y is 3 so G is gonna be 6
so we just do forward pass pass and they
memorize this value and then the next
step is that we're gonna compare to
these local gradients so local gradient
is because we know what is this skate
it's easy so G is X X times y and if we
want to compute this and this is trivial
this becomes y and then the same manner
we can compute this this one becomes X
so we can compare to local gradient and
then for some how this one is given and
then we want to compute this value so
this one is already given with a 5 it's
5 times this we already computed Y which
is y and then Y we know the values of 5
times 3 here it becomes 15 in the same
manner also we can compute this value so
this is how we can apply the forward
pass with a concrete value which is
given first and they memorize the value
and then to backward propagations using
the applying the chain rule let's apply
this idea to our model which is simple
linear model how can I draw
computational graph for this model the
idea is that we just introduced a
multiply gates
then gets xnw as an input and produce
who I had like this and how about our
loss eventually what we want to compute
is the loss of the gradient of loss so
we have to connect this loss in our
craft
so it takes Y hat as an input and they
we need another input called the Y and
then here is the gate - Kate and then we
do have a scanner gate so it's two
operations so we have two different
nodes one is - Kate one is care gate
first - gate with the Y has minus y and
they will produce value called s and s
will be input of this care gate
eventually become a loss and the first
we're gonna apply the forward pass for a
given value X is 1 y equal 2 and then W
is 1 like our previous example then for
the passes chibios just we put the value
here X is 1 the ratio is 1 and then x is
becomes 1 and then now Y is given to - 1
minus 2 becomes minus 1 and then this
square is becomes 1 this is how we're
gonna do it for the past just compute
this value and memorize this value and
our second step is doing backward
propagation in order to do this we first
need to complete local gradients for
each gate we know the what's the gate
and identifying local gradients becomes
trivial so for example here this gate is
scared so we can compute this directly
so the input is s so that the gradient
for this is 2 s in a similar manner we
can compute all the local gradients
because we know what's the function and
what is the input output relationship
it's trivial to compute and then we just
apply one by one in backwater manner and
just compute this value so here this
gradients
t loss TS what is that
is to s that what is s in this case is
minus one so that to s becomes minus two
and now we're going to move in to
compute the gradients for the next
so in this cases we want to know that
the loss and dy head so why we don't
have to compute this gradient spot is x
and y below because we cannot change it
only we can compute the gradient that we
can change so in this case this week as
the Omega this one as a chain rule and
they we already know what is this value
which is minus two and they will also
notice just two times and they find the
discretions and then we move in and if
we want to compute the gradients of loss
with respect to W and then we can
express this one using the chain rule
like this and then here we already
computed this one which is minus two and
they Rinat our local gradients which is
X in this cases and we know the value of
x here so we just do this do we get this
minus two as our final gradients and if
you can remember our previous example
and they are result properly you see
these numbers when we compute the
gradients manually when X is 1 Y is 2
the gradient towards minus 2 which is
exactly same value using this
computational graph and backward
propagation as an exercise you can try
with different xvalue and see you can
manually compute these gradients using
this computational graph and then to
chain rule
and now we introduce this bias term here
so we add it on and then see if you can
also compute the gradient using this
computational graph in a backward
propagation let's move on to our
hands-on section so very nice thing
about the Pythons is that you don't have
to conduct these propagations by
yourself
the spiders can automatically build the
computational graph and then complete
all the gradients for you only one thing
you need to do is to use just their
variable so first in order to use
variable just to create the tensor and
then use this variable wrapper and then
you can also say oh I need to compute a
gradient and that's it and then after
that we just build on some operations on
using these variables and they're gonna
build this computational graph
automatically for you in our example
just we are just using this W as a PHP
poor so this for the function just to
get X as input and then it times X W
this is variable so the old operations
with the variable will construct a
computational graph all the adults are
the same once we build a computational
graph using the variable so it looks
something like this some variable W and
then certain node and then we complete
loss
so it's L will be here so this is how
we're gonna complete our loss function
and then get L and then because
everything here is computational graph
we can call health at backward special
function and then this is exactly doing
the pegboard operations as we explained
and then compute the gradients of every
variable then how we're gonna get the
this loss gradients with respect to W so
this will be stored in W that create
data
so we can just use this data if you want
to print out only one value just you can
just use like this since our W is now
variable usually it keeps the data the
real value at the W dot data so updating
is W dot data
- this alpha and then this is our
gradient that is automatically computed
with using this backward function and
then at each iterations we just
initialize our gradients this is our
entire training process if we see the
output of this program which is very
similar to our previous example using
the manual computation so you can
compare this to output that are actually
almost the same so in summary using the
PI torch we can just perform backward
and forward and backward propagations
very easy so pythons will automatically
draw or construct this computational
graph as long as you're using this
variable and then we just call this loss
function with an input value and they
all conduct the forward path and then if
you want to compute the gradients using
this backward just call this last value
that L that backward then you will do a
backward propagation and complete all
the gradients so especially we are
interested in this value the gradient of
loss with respect to W can use will be
this value will be saved in W that
create and then we can just using this W
back read data we can update the value
of the W is saved in the data now W is
the variable so just update this data
using this alpha with our gradients then
this is how we can update it's very
simple using Python just they can
compute this gradient automatically for
us
as an exercise you can try to implement
everything using numpy or just a pure
Python without using Python so that you
can fully understand the concept of
propagations and this computational
graph and then in the similar manner you
can just compute the gradients with a
slightly different model then you can
try to do manually and then also you can
try to using the Python in the next
lecture now we're going to jump into the
pie chart and then fully leverage the
spiders to build a model