- [Narrator] In the last video we were
looking at this particular function.
It's a very non linear function.
And we were picturing it as a transformation
that takes every point x, y in space to the point
x plus sign y, y plus sign of x.
And moreover, we zoomed in on a specific point.
And let me actually write down what
point we zoomed in on, it was (-2,1).
That's something we're gonna want to record here (-2,1).
And I added couple extra grid lines around it
just so we can see in detail what the transformation
does to points that are in the neighborhood of that point.
And over here, this square shows the zoomed
in version of that neighborhood.
And what we saw is that even though the
function as a whole, as a transformation,
looks rather complicated, around that one point,
it looks like a linear function.
It's locally linear so what I'll show you here
is what matrix is gonna tell you the linear
function that this looks like.
And this is gonna be kind of two by two matrix.
I'll make a lot of room for ourselves here.
It'll be a two by two matrix and the way
to think about it is to first go back
to our original setup before the transformation.
And think of just a tiny step to the right.
What I'm gonna think of as a little, partial x.
A tiny step in the x direction.
And what that turns into after the transformation
is gonna be some tiny step in the output space.
And here let me actually kind of draw on
what that tiny step turned into.
It's no longer purely in the x direction.
It has some rightward component.
But now also some downward component.
And to be able to represent this in a nice way,
what I'm gonna do is instead of writing the
entire function as something with
a vector valued output, I'm gonna go ahead
and represent this as a two separate scalar value functions.
I'm gonna write the scalar value functions f1 of x, y.
So I'm just giving a name to x plus sign y.
And f2 of x, y, again all I'm doing is
giving a name to the functions we already have written down.
When I look at this vector, the
consequence of taking a tiny d, x step
in the input space that corresponds to
some two d movement in the output space.
And the x component of that movement.
Right if I was gonna draw this out
and say hey, what's the x component of that movement.
That's something we think of as a little
partial change in f1, the x component of our output.
And if we divide this, if we take you know
partial f1 divided by the size of that
initial tiny change, it basically scales
it up to be a normal sized vector.
Not a tiny nudge but something that's more
constant that doesn't shrink as we
zoom in further and further.
And then similarly the change in the y direction,
right the vertical component of that step
that was still caused by the dx.
Right, it's still caused by that initial
step to the right, that is gonna be
the tiny, partial change in f2.
The y component of the output cause
here we're all just looking in the output space
that was caused by a partial change in the x direction.
And again I kind of like to think about this
we're dividing by a tiny amount.
This partial f2 is really a tiny, tiny nudge.
But by dividing by the size of the initial
tiny nudge that caused it, we're getting
something that's basically a number.
Something that doesn't shrink when
we consider more and more zoomed in versions.
So that, that's all what happens when
we take a tiny step in the x direction.
But another thing you could do, another thing you can
consider is a tiny step in the y direction.
Right cause we wanna know, hey, if
you take a single step some tiny unit upward,
what does that turn into after the transformation.
And what that looks like is this vector
that still has some upward component.
But it also has a rightward component.
And now I'm gonna write its components
as the second column of the matrix.
Because as we know when you're representing
a linear transformation with a matrix,
the first column tells you where the first
basis vector goes and the second column
shows where the second basis vector goes.
If that feels unfamiliar, either
check out the refresher video or
maybe go and look at some of the linear algebra content.
But to figure out the coordinates of this guy,
we do basically the same thing.
Let's say first of all, the change in the x direction
here, the x component of this nudge vector.
That's gonna be given as a partial change to f1, right,
to the x component of the output.
Here we're looking in the outputs base.
We're dealing with f1, f1 and f2
and we're asking what that change was
that was caused by a tiny change in the y direction.
So the change in f1 caused by some tiny step in the y
direction divided by the size of that tiny step.
And then the y component of our output here.
The y component of the step in the outputs base
that was caused by the initial tiny
step upward in the input space.
Well that is the change of f2,
second component of our output as caused by dy.
As caused by that little partial y.
And of course all of this is very specific
to the point that we started at right.
We started at the point (-2,1).
So each of these partial derivatives
is something that really we're saying,
don't take the function, evaluate it at the point (2,-1),
and when you evaluate each one of these
at the point (2,-1) you'll get some number.
And that will give you a very
concrete two by two matrix that's gonna
represent the linear transformation that this
guy looks like once you've zoomed in.
So this matrix here that's full of all
of the partial derivatives has a very special name.
It's called as you may have guessed, the Jacobian.
Or more fully you'd call it the Jacobian Matrix.
And one way to think about it is that it
carries all of the partial differential information right.
It's taking into account both of these components
of the output and both possible inputs.
And giving you a kind of a grid of
what all the partial derivatives are.
But as I hope you see, it's much
more than just a way of recording
what all the partial derivatives are.
There's a reason for organizing it
like this in particular and it really
does come down to this idea of local linearity.
If you understand that the Jacobian Matrix
is fundamentally supposed to represent
what a transformation looks like when you zoom
in near a specific point, almost everything else
about it will start to fall in place.
And in the next video, I'll go ahead
and actually compute this just to
show you what the process looks like.
And how the result we get kind of
matches with the picture we're
looking at, see you then.