- [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.