WEBVTT Kind: captions; Language: en-US

NOTE
Created on 2024-02-07T20:56:50.6784114Z by ClassTranscribe

00:01:05.170 --> 00:01:05.740
All right.

00:01:05.740 --> 00:01:06.410
Good morning.

00:01:07.400 --> 00:01:08.500
Happy Valentine's Day.

00:01:12.140 --> 00:01:16.250
So let's just start with some thinking.

00:01:16.250 --> 00:01:17.940
Warm up with some review questions.

00:01:17.940 --> 00:01:20.285
So just as a reminder, there's

00:01:20.285 --> 00:01:23.370
questions posted on the main page for

00:01:23.370 --> 00:01:24.250
each of the lectures.

00:01:24.250 --> 00:01:26.230
Couple days, usually after the lecture.

00:01:27.300 --> 00:01:29.060
So they are good review for the exam or

00:01:29.060 --> 00:01:30.350
just to refresh?

00:01:31.620 --> 00:01:34.450
So, first question, these are true,

00:01:34.450 --> 00:01:34.860
false.

00:01:34.860 --> 00:01:36.390
So there's just two answers.

00:01:37.710 --> 00:01:39.710
Unlike SVM, linear and logistic

00:01:39.710 --> 00:01:42.210
regression loss always adds a nonzero

00:01:42.210 --> 00:01:44.280
penalty over all training data points.

00:01:45.300 --> 00:01:46.970
How many people think that's true?

00:01:50.360 --> 00:01:52.040
How many people think it's False?

00:01:54.790 --> 00:01:56.690
I think the abstains have it.

00:01:57.990 --> 00:02:01.560
Alright, so this is true because

00:02:01.560 --> 00:02:03.260
logistic regression you always have a

00:02:03.260 --> 00:02:04.376
log probability loss.

00:02:04.376 --> 00:02:06.000
So that applies to every training

00:02:06.000 --> 00:02:10.595
example, where SVM by contrast only has

00:02:10.595 --> 00:02:12.340
loss on points that are within the

00:02:12.340 --> 00:02:12.590
margin.

00:02:12.590 --> 00:02:14.300
So as long as you're really confident,

00:02:14.300 --> 00:02:16.270
SVM doesn't really care about you.

00:02:16.880 --> 00:02:19.500
But logistic regression still does.

00:02:20.430 --> 00:02:23.670
So second question are we talked about

00:02:23.670 --> 00:02:25.640
the Pegasus algorithm for SVM which is

00:02:25.640 --> 00:02:28.170
doing like a gradient descent where you

00:02:28.170 --> 00:02:30.300
process examples one at a time or in

00:02:30.300 --> 00:02:31.250
small batches?

00:02:31.860 --> 00:02:35.580
And after each Example you compute the

00:02:35.580 --> 00:02:36.370
gradient.

00:02:37.140 --> 00:02:39.830
Of the error for those examples with

00:02:39.830 --> 00:02:41.140
respect to the Weights, and then you

00:02:41.140 --> 00:02:44.110
take a step to reduce your loss.

00:02:45.320 --> 00:02:47.280
That's the Pegasus algorithm when it's

00:02:47.280 --> 00:02:48.250
applied to SVM.

00:02:50.220 --> 00:02:53.900
So is it true?

00:02:53.900 --> 00:02:55.240
I guess I sort of.

00:02:56.480 --> 00:02:59.063
Said part of this, but is it true that

00:02:59.063 --> 00:03:01.170
this increases the computational

00:03:01.170 --> 00:03:03.668
efficiency versus like optimizing over

00:03:03.668 --> 00:03:04.460
the full data set?

00:03:04.460 --> 00:03:06.136
If you were to take a gradient over the

00:03:06.136 --> 00:03:07.589
full data set, True.

00:03:09.720 --> 00:03:10.550
OK, False.

00:03:12.460 --> 00:03:14.290
It's how many people think it's True.

00:03:14.290 --> 00:03:15.260
Put your hand up.

00:03:16.100 --> 00:03:18.100
How many people think it's False?

00:03:18.100 --> 00:03:18.959
Put your hand up.

00:03:18.960 --> 00:03:20.060
I don't think it's False, but I'm

00:03:20.060 --> 00:03:21.712
putting my hand up.

00:03:21.712 --> 00:03:22.690
It's true.

00:03:22.690 --> 00:03:24.016
So it does.

00:03:24.016 --> 00:03:26.230
It does give a big efficiency gain

00:03:26.230 --> 00:03:27.560
because you don't have to keep on

00:03:27.560 --> 00:03:29.205
computing the gradient over all the

00:03:29.205 --> 00:03:31.070
samples, which would be really slow.

00:03:31.070 --> 00:03:32.750
You just have to do it over a small

00:03:32.750 --> 00:03:34.240
number of samples and still take a

00:03:34.240 --> 00:03:34.980
productive step.

00:03:35.730 --> 00:03:38.510
And furthermore, it's a much better

00:03:38.510 --> 00:03:39.550
optimization algorithm.

00:03:39.550 --> 00:03:40.980
It gives you the ability to escape

00:03:40.980 --> 00:03:44.180
local minima to find better solutions,

00:03:44.180 --> 00:03:46.340
even if locally.

00:03:47.620 --> 00:03:49.370
Even if locally, there's nowhere to go

00:03:49.370 --> 00:03:51.480
to improve the total score of your data

00:03:51.480 --> 00:03:51.690
set.

00:03:53.270 --> 00:03:53.580
All right.

00:03:53.580 --> 00:03:56.460
And then the third question, Pegasus

00:03:56.460 --> 00:03:58.350
has a disadvantage that the larger the

00:03:58.350 --> 00:04:00.130
training data set, the slower it can be

00:04:00.130 --> 00:04:02.770
optimized to reach a particular test

00:04:02.770 --> 00:04:03.000
error.

00:04:03.000 --> 00:04:04.020
Is that true or false?

00:04:06.150 --> 00:04:08.710
So how many people think that is true?

00:04:11.020 --> 00:04:12.580
And how many people think that is

00:04:12.580 --> 00:04:12.980
False?

00:04:14.530 --> 00:04:16.290
So there's more falses, and that's

00:04:16.290 --> 00:04:16.705
correct.

00:04:16.705 --> 00:04:18.145
Yeah, it's False.

00:04:18.145 --> 00:04:21.280
The bigger your training set, it means

00:04:21.280 --> 00:04:23.265
that given a certain number of

00:04:23.265 --> 00:04:24.450
iterations, you're just going to see

00:04:24.450 --> 00:04:28.445
more new examples, and so you will take

00:04:28.445 --> 00:04:31.679
more informative steps of your

00:04:31.680 --> 00:04:32.310
gradient.

00:04:32.310 --> 00:04:35.060
And so you're given the same number of

00:04:35.060 --> 00:04:37.415
iterations, you're going to reach a

00:04:37.415 --> 00:04:38.990
given test error faster.

00:04:40.370 --> 00:04:42.340
To fully optimize over the data set,

00:04:42.340 --> 00:04:43.640
it's going to take more time.

00:04:43.640 --> 00:04:46.290
If you want to do say 300 passes

00:04:46.290 --> 00:04:47.804
through the data, then if you have more

00:04:47.804 --> 00:04:49.730
data then it's going to take longer to

00:04:49.730 --> 00:04:51.350
do those 300 passes.

00:04:51.350 --> 00:04:52.960
But you're going to reach the same test

00:04:52.960 --> 00:04:54.680
error a lot faster if you keep getting

00:04:54.680 --> 00:04:56.946
new examples then if you are processing

00:04:56.946 --> 00:04:58.820
the same examples over and over again.

00:05:02.240 --> 00:05:05.480
So the reason, one of the reasons that

00:05:05.480 --> 00:05:08.360
I talked about SVM and Pegasus is as an

00:05:08.360 --> 00:05:10.980
introduction to Perceptrons and MLPS.

00:05:11.790 --> 00:05:14.210
Because the optimization algorithm used

00:05:14.210 --> 00:05:16.260
for used in Pegasus.

00:05:17.060 --> 00:05:18.700
It's the same as what's used for

00:05:18.700 --> 00:05:22.070
Perceptrons and is extended when we do

00:05:22.070 --> 00:05:23.380
Backprop in MLP's.

00:05:24.410 --> 00:05:25.900
So I'm going to talk about what is the

00:05:25.900 --> 00:05:26.360
Perceptron?

00:05:26.360 --> 00:05:28.050
What is an MLP?

00:05:28.050 --> 00:05:29.050
Multilayer perceptron?

00:05:29.970 --> 00:05:32.790
And then how do we optimize it with SGD

00:05:32.790 --> 00:05:34.685
and Back propagation with some examples

00:05:34.685 --> 00:05:36.000
and demos and stuff?

00:05:37.300 --> 00:05:39.733
Alright, so Perceptron is actually just

00:05:39.733 --> 00:05:41.940
a linear classifier or linear

00:05:41.940 --> 00:05:42.670
predictor.

00:05:42.670 --> 00:05:45.490
It's you could say a linear logistic

00:05:45.490 --> 00:05:48.080
regressor is one form of a Perceptron

00:05:48.080 --> 00:05:49.797
and a linear regressor is another form

00:05:49.797 --> 00:05:50.600
of a Perceptron.

00:05:51.830 --> 00:05:54.275
What makes it a Perceptron is just like

00:05:54.275 --> 00:05:56.100
how you think about it or how you draw

00:05:56.100 --> 00:05:56.595
it.

00:05:56.595 --> 00:05:59.290
So in the representation you typically

00:05:59.290 --> 00:06:01.740
see a Perceptron as you have like some

00:06:01.740 --> 00:06:02.115
inputs.

00:06:02.115 --> 00:06:04.420
So these could be like pixels of an

00:06:04.420 --> 00:06:07.870
image, your features, the temperature

00:06:07.870 --> 00:06:09.640
data, whatever the features that you're

00:06:09.640 --> 00:06:10.640
going to use for prediction.

00:06:11.420 --> 00:06:13.179
And then you have some Weights.

00:06:13.180 --> 00:06:15.900
Those get multiplied by the inputs and

00:06:15.900 --> 00:06:16.580
summed up.

00:06:16.580 --> 00:06:18.500
And then you have your output

00:06:18.500 --> 00:06:19.450
prediction.

00:06:19.450 --> 00:06:22.220
And you may have if you have a

00:06:22.220 --> 00:06:25.180
classifier, you would say that if

00:06:25.180 --> 00:06:27.960
Weights X, this is a dot.

00:06:27.960 --> 00:06:29.650
SO dot product is the same as W

00:06:29.650 --> 00:06:32.170
transpose X plus some bias term.

00:06:32.170 --> 00:06:33.890
If it's greater than zero, then you

00:06:33.890 --> 00:06:35.424
predict A1, if it's less than zero, you

00:06:35.424 --> 00:06:36.189
predict a -, 1.

00:06:36.840 --> 00:06:38.316
So it's basically the same as the

00:06:38.316 --> 00:06:40.610
linear SVM, logistic regressor,

00:06:40.610 --> 00:06:42.140
anything any other kind of linear

00:06:42.140 --> 00:06:42.450
model.

00:06:44.690 --> 00:06:46.956
But you draw it as this network, as

00:06:46.956 --> 00:06:48.680
this little tiny network with a bunch

00:06:48.680 --> 00:06:50.180
of Weights and input and output.

00:06:53.260 --> 00:06:54.910
Though whoops.

00:06:54.910 --> 00:06:56.190
Skip something?

00:06:56.190 --> 00:06:56.680
No.

00:06:56.680 --> 00:06:59.530
OK, all right, so how do we optimize

00:06:59.530 --> 00:07:00.566
the Perceptron?

00:07:00.566 --> 00:07:03.010
So let's say you can have different

00:07:03.010 --> 00:07:04.539
error functions on the Perceptron.

00:07:04.540 --> 00:07:06.166
But let's say we have a squared error.

00:07:06.166 --> 00:07:09.010
So the prediction of the Perceptron is.

00:07:09.010 --> 00:07:10.670
Like I said before, it's a linear

00:07:10.670 --> 00:07:12.450
function, so it's a sum of the Weights

00:07:12.450 --> 00:07:14.630
times the inputs plus some bias term.

00:07:16.260 --> 00:07:18.660
And you could have a square a square

00:07:18.660 --> 00:07:20.820
error which says that you want the

00:07:20.820 --> 00:07:22.360
prediction to be close to the target.

00:07:24.240 --> 00:07:25.250
And then?

00:07:26.430 --> 00:07:31.100
So the update rule or the optimization

00:07:31.100 --> 00:07:34.350
is based on taking a step to update

00:07:34.350 --> 00:07:36.010
each of your Weights in order to

00:07:36.010 --> 00:07:38.520
decrease the error for particular

00:07:38.520 --> 00:07:39.200
examples.

00:07:40.470 --> 00:07:42.330
So to do that, we need to take the

00:07:42.330 --> 00:07:44.830
partial derivative of the error with

00:07:44.830 --> 00:07:46.320
respect to each of the Weights.

00:07:48.650 --> 00:07:50.137
And we're going to use the chain rule

00:07:50.137 --> 00:07:50.835
to do that.

00:07:50.835 --> 00:07:52.310
So I put the chain rule here for

00:07:52.310 --> 00:07:52.770
reference.

00:07:52.770 --> 00:07:53.890
So the chain rule says.

00:07:54.630 --> 00:07:57.010
If you have some function of X, that's

00:07:57.010 --> 00:07:59.250
actually a function of a function of X,

00:07:59.250 --> 00:08:00.280
so F of G of X.

00:08:01.110 --> 00:08:04.860
Then the derivative of that function H

00:08:04.860 --> 00:08:07.490
is the derivative of the outer function

00:08:07.490 --> 00:08:09.567
with the arguments of the inner

00:08:09.567 --> 00:08:12.086
function times the derivative of the

00:08:12.086 --> 00:08:12.789
inner function.

00:08:14.210 --> 00:08:16.660
If I apply that Chain Rule here, I've

00:08:16.660 --> 00:08:18.980
got a square function here, so I take

00:08:18.980 --> 00:08:20.290
the derivative of this.

00:08:21.030 --> 00:08:24.599
And I get 2 times the inside, so that's

00:08:24.600 --> 00:08:26.800
my F prime of G of X and that's over

00:08:26.800 --> 00:08:29.140
here, so two times of X -, Y.

00:08:29.990 --> 00:08:32.020
Times the derivative of the inside

00:08:32.020 --> 00:08:34.170
function, which is F of X -, Y.

00:08:34.970 --> 00:08:37.240
And the derivative of this guy with

00:08:37.240 --> 00:08:40.880
respect to WI will just be XI, because

00:08:40.880 --> 00:08:42.387
there's only one term, there's a.

00:08:42.387 --> 00:08:44.930
There's a big sum here, but only one of

00:08:44.930 --> 00:08:48.345
their terms involves WI, and that term

00:08:48.345 --> 00:08:51.005
is wixi, and all the rest are zero.

00:08:51.005 --> 00:08:52.820
I mean, all the rest don't involve it,

00:08:52.820 --> 00:08:53.870
so the derivative is 0.

00:08:54.860 --> 00:08:55.160
Right.

00:08:56.420 --> 00:08:59.840
So this gives me my update rule is 2 *

00:08:59.840 --> 00:09:02.380
F of X -, y times XI.

00:09:03.300 --> 00:09:04.860
So in other words, if my prediction is

00:09:04.860 --> 00:09:07.800
too high and XI is positive or wait,

00:09:07.800 --> 00:09:08.720
let me get to the update.

00:09:08.720 --> 00:09:10.539
OK, so first the update is.

00:09:10.540 --> 00:09:11.940
I'm going to subtract that off because

00:09:11.940 --> 00:09:13.150
I want to reduce the error so it's

00:09:13.150 --> 00:09:14.350
gradient descent.

00:09:14.350 --> 00:09:16.400
So I want the gradient to go down

00:09:16.400 --> 00:09:16.730
South.

00:09:16.730 --> 00:09:18.826
I take my weight and I subtract the

00:09:18.826 --> 00:09:20.260
gradient with some learning rate or

00:09:20.260 --> 00:09:20.940
step size.

00:09:21.770 --> 00:09:25.220
So of X -, Y is positive and XI is

00:09:25.220 --> 00:09:25.630
positive.

00:09:26.560 --> 00:09:27.970
That means that.

00:09:28.670 --> 00:09:30.548
That I'm overshooting and I want my

00:09:30.548 --> 00:09:32.000
weight to go down.

00:09:32.000 --> 00:09:34.929
If X -, Y is negative and XI is

00:09:34.930 --> 00:09:37.809
positive, then I want my weight to go

00:09:37.810 --> 00:09:38.870
in the opposite direction.

00:09:38.870 --> 00:09:39.200
Question.

00:09:44.340 --> 00:09:47.000
This update or this derivative?

00:09:51.770 --> 00:09:55.975
So first we're trying to figure out how

00:09:55.975 --> 00:09:58.740
do we minimize this error function?

00:09:58.740 --> 00:10:01.620
How do we change our Weights in a way

00:10:01.620 --> 00:10:03.490
that will reduce our error a bit for

00:10:03.490 --> 00:10:05.080
this for these particular examples?

00:10:06.420 --> 00:10:10.110
And if you want to know like how you.

00:10:10.710 --> 00:10:13.146
How you change the value, how some

00:10:13.146 --> 00:10:16.080
change in your parameters will change

00:10:16.080 --> 00:10:18.049
the output of some function.

00:10:18.050 --> 00:10:19.753
Then you take the derivative of that

00:10:19.753 --> 00:10:20.950
function with respect to your

00:10:20.950 --> 00:10:21.300
parameters.

00:10:21.300 --> 00:10:22.913
So that gives you like the slope of the

00:10:22.913 --> 00:10:24.400
function as you change your parameters.

00:10:25.490 --> 00:10:28.175
So that's why we're taking the partial

00:10:28.175 --> 00:10:29.732
derivative and then the partial

00:10:29.732 --> 00:10:30.960
derivative says like how you would

00:10:30.960 --> 00:10:32.430
change your parameters to increase the

00:10:32.430 --> 00:10:34.920
function, so we subtract that from the

00:10:34.920 --> 00:10:36.030
from the original value.

00:10:37.190 --> 00:10:37.500
OK.

00:10:39.410 --> 00:10:40.010
Question.

00:10:53.040 --> 00:10:54.590
So the question is, what if you had

00:10:54.590 --> 00:10:56.100
like additional labels?

00:10:56.100 --> 00:10:58.290
Then you would end up with essentially

00:10:58.290 --> 00:11:02.227
you have different F of X, so you'd

00:11:02.227 --> 00:11:04.261
have like one of X, F2 of X, et cetera.

00:11:04.261 --> 00:11:06.780
You'd have 1F of X for each label that

00:11:06.780 --> 00:11:07.600
you're producing.

00:11:10.740 --> 00:11:10.985
Yes.

00:11:10.985 --> 00:11:12.500
So you need to update their weights and

00:11:12.500 --> 00:11:13.120
they would all.

00:11:13.120 --> 00:11:14.820
In the case of a Perceptron, they'd all

00:11:14.820 --> 00:11:16.360
be independent because they're all just

00:11:16.360 --> 00:11:17.630
like linear models.

00:11:17.630 --> 00:11:20.060
So it would end up being essentially

00:11:20.060 --> 00:11:23.010
the same as training N Perceptrons to

00:11:23.010 --> 00:11:24.220
do and outputs.

00:11:25.810 --> 00:11:28.710
But yeah, that becomes a little more

00:11:28.710 --> 00:11:30.430
complicated in the case of MLPS where

00:11:30.430 --> 00:11:32.060
you could Share intermediate features,

00:11:32.060 --> 00:11:33.620
but we'll get to that a little bit.

00:11:35.340 --> 00:11:36.690
So here's my update.

00:11:36.690 --> 00:11:38.500
So I'm going to improve the weights a

00:11:38.500 --> 00:11:40.630
little bit to do reduce the error on

00:11:40.630 --> 00:11:42.640
these particular examples, and I just

00:11:42.640 --> 00:11:45.540
put the two into the learning rate.

00:11:45.540 --> 00:11:47.250
Sometimes people write this error is

00:11:47.250 --> 00:11:49.200
1/2 of this just so they don't have to

00:11:49.200 --> 00:11:50.150
deal with the two.

00:11:51.580 --> 00:11:53.130
Right, so here's the whole optimization

00:11:53.130 --> 00:11:53.630
algorithm.

00:11:54.600 --> 00:11:56.140
Randomly initialize my Weights.

00:11:56.140 --> 00:11:57.930
For example, I say W is drawn from some

00:11:57.930 --> 00:11:59.660
Gaussian with a mean of zero and

00:11:59.660 --> 00:12:00.590
standard deviation of.

00:12:01.380 --> 00:12:05.320
0.50 point 05 so just initialize them

00:12:05.320 --> 00:12:05.850
small.

00:12:06.870 --> 00:12:09.400
And then for each iteration or epoch.

00:12:09.400 --> 00:12:10.900
An epoch is like a cycle through the

00:12:10.900 --> 00:12:11.635
training data.

00:12:11.635 --> 00:12:14.050
I split the data into batches so I

00:12:14.050 --> 00:12:16.420
could have a batch size of 1 or 128,

00:12:16.420 --> 00:12:19.980
but I just chunk it into different sets

00:12:19.980 --> 00:12:21.219
that are partition of the data.

00:12:22.120 --> 00:12:23.740
And I set my learning rate.

00:12:23.740 --> 00:12:25.940
For example, this is the schedule used

00:12:25.940 --> 00:12:27.230
by Pegasus.

00:12:27.230 --> 00:12:29.150
But sometimes people use a constant

00:12:29.150 --> 00:12:29.660
learning rate.

00:12:31.140 --> 00:12:33.459
And then for each batch and for each

00:12:33.460 --> 00:12:34.040
weight.

00:12:34.880 --> 00:12:37.630
I have my update rule so I have this

00:12:37.630 --> 00:12:39.315
gradient for each.

00:12:39.315 --> 00:12:41.675
I take the sum over all the examples in

00:12:41.675 --> 00:12:42.330
my batch.

00:12:43.120 --> 00:12:46.480
And then I get the output the

00:12:46.480 --> 00:12:48.920
prediction for that sample subtract it

00:12:48.920 --> 00:12:50.510
from the true value according to my

00:12:50.510 --> 00:12:51.290
training labels.

00:12:52.200 --> 00:12:55.510
By the Input for that weight, which is

00:12:55.510 --> 00:12:58.810
xni, I sum that up, divide by the total

00:12:58.810 --> 00:13:00.260
number of samples in my batch.

00:13:00.910 --> 00:13:05.010
And then I take a step in that negative

00:13:05.010 --> 00:13:07.070
direction weighted by the learning

00:13:07.070 --> 00:13:07.460
rate.

00:13:07.460 --> 00:13:09.120
So if the learning rates really high,

00:13:09.120 --> 00:13:10.920
I'm going to take really big steps, but

00:13:10.920 --> 00:13:12.790
then you risk like overstepping the

00:13:12.790 --> 00:13:15.933
minimum or even kind of bouncing out of

00:13:15.933 --> 00:13:18.910
a into like a undefined solution.

00:13:19.540 --> 00:13:21.100
If you're learning is really low, then

00:13:21.100 --> 00:13:22.650
it's just going to take a long time to

00:13:22.650 --> 00:13:23.090
converge.

00:13:24.570 --> 00:13:26.820
Perceptrons it's a linear model, so

00:13:26.820 --> 00:13:28.610
it's Fully optimizable.

00:13:28.610 --> 00:13:30.910
You can always it's possible to find

00:13:30.910 --> 00:13:32.060
global minimum.

00:13:32.060 --> 00:13:34.220
It's a really nicely behaved

00:13:34.220 --> 00:13:35.400
optimization problem.

00:13:41.540 --> 00:13:45.580
So you can have different losses if I

00:13:45.580 --> 00:13:47.840
instead of having a squared loss if I

00:13:47.840 --> 00:13:49.980
had a logistic loss for example.

00:13:50.650 --> 00:13:53.110
Then it would mean that I have this

00:13:53.110 --> 00:13:55.170
function that the Perceptron is still

00:13:55.170 --> 00:13:56.660
computing this linear function.

00:13:57.260 --> 00:13:59.220
But then I say that my error is a

00:13:59.220 --> 00:14:01.290
negative log probability of the True

00:14:01.290 --> 00:14:03.220
label given the features.

00:14:04.450 --> 00:14:06.280
And where the probability is given by

00:14:06.280 --> 00:14:07.740
this Sigmoid function.

00:14:08.640 --> 00:14:12.230
Which is 1 / 1 + E to the negative like

00:14:12.230 --> 00:14:14.060
F of Y of F of X so.

00:14:15.050 --> 00:14:15.730
So this.

00:14:15.810 --> 00:14:16.430


00:14:17.800 --> 00:14:21.280
Now the derivative of this you can.

00:14:21.280 --> 00:14:23.536
It's not super complicated to take this

00:14:23.536 --> 00:14:25.050
derivative, but it does involve like

00:14:25.050 --> 00:14:27.510
several lines and I decide it's not

00:14:27.510 --> 00:14:29.833
really worth stepping through the

00:14:29.833 --> 00:14:30.109
lines.

00:14:30.880 --> 00:14:33.974
The main point is that for any kind of

00:14:33.974 --> 00:14:35.908
activation function, you can compute

00:14:35.908 --> 00:14:37.843
the derivative of that activation

00:14:37.843 --> 00:14:40.208
function, or for any kind of error

00:14:40.208 --> 00:14:41.920
function, I mean you can compute the

00:14:41.920 --> 00:14:43.190
derivative of that error function.

00:14:44.000 --> 00:14:45.480
And then you plug it in there.

00:14:45.480 --> 00:14:50.453
So now this becomes Y&X and I times and

00:14:50.453 --> 00:14:53.990
it works out to 1 minus the probability

00:14:53.990 --> 00:14:56.170
of the correct label given the data.

00:14:57.450 --> 00:14:58.705
So this kind of makes sense.

00:14:58.705 --> 00:15:02.120
So if this plus this.

00:15:02.210 --> 00:15:02.440
OK.

00:15:03.080 --> 00:15:04.930
This ends up being a plus because I'm

00:15:04.930 --> 00:15:06.760
decreasing the negative log likelihood,

00:15:06.760 --> 00:15:08.696
which is the same as increasing the log

00:15:08.696 --> 00:15:08.999
likelihood.

00:15:09.790 --> 00:15:14.120
And if XNXN is positive and Y is

00:15:14.120 --> 00:15:15.750
positive then I want to increase the

00:15:15.750 --> 00:15:18.680
score further and so I want the weight

00:15:18.680 --> 00:15:19.740
to go up.

00:15:20.690 --> 00:15:24.610
And the step size will be weighted by

00:15:24.610 --> 00:15:26.050
how wrong I was.

00:15:26.050 --> 00:15:29.540
So 1 minus the probability of y = y N

00:15:29.540 --> 00:15:30.910
given XN is like how wrong I was if

00:15:30.910 --> 00:15:31.370
this is.

00:15:32.010 --> 00:15:33.490
If I was perfectly correct, then this

00:15:33.490 --> 00:15:34.380
is going to be zero.

00:15:34.380 --> 00:15:35.557
I don't need to take any step.

00:15:35.557 --> 00:15:38.240
If I was completely confidently wrong,

00:15:38.240 --> 00:15:39.500
then this is going to be one and so

00:15:39.500 --> 00:15:40.320
I'll take a bigger step.

00:15:43.020 --> 00:15:47.330
Right, so the, so just the.

00:15:47.410 --> 00:15:50.280
Step depends on the loss, but with any

00:15:50.280 --> 00:15:51.950
loss you can do a similar kind of

00:15:51.950 --> 00:15:53.670
strategy as long as you can take a

00:15:53.670 --> 00:15:54.640
derivative of the loss.

00:15:58.860 --> 00:15:59.150
OK.

00:16:02.620 --> 00:16:06.160
Alright, so let's see, is a Perceptron

00:16:06.160 --> 00:16:06.550
enough?

00:16:06.550 --> 00:16:10.046
So which of these functions do you

00:16:10.046 --> 00:16:14.166
think can be fit with the Perceptron?

00:16:14.166 --> 00:16:17.085
So what about the first function?

00:16:17.085 --> 00:16:19.036
Do you think we can fit that with the

00:16:19.036 --> 00:16:19.349
Perceptron?

00:16:21.040 --> 00:16:21.600
Yeah.

00:16:21.600 --> 00:16:23.050
What about the second one?

00:16:26.950 --> 00:16:29.620
OK, yeah, some people are confidently

00:16:29.620 --> 00:16:33.150
yes, and some people are not so sure we

00:16:33.150 --> 00:16:34.170
will see.

00:16:34.170 --> 00:16:35.320
What about this function?

00:16:37.440 --> 00:16:38.599
Yeah, definitely not.

00:16:38.600 --> 00:16:40.260
Well, I'm giving away, but definitely

00:16:40.260 --> 00:16:41.010
not that one, right?

00:16:42.700 --> 00:16:43.920
All right, so let's see.

00:16:43.920 --> 00:16:45.030
So here's Demo.

00:16:46.770 --> 00:16:48.060
I'm going to switch.

00:16:48.060 --> 00:16:49.205
I only have one.

00:16:49.205 --> 00:16:51.620
I only have one USB port, so.

00:16:54.050 --> 00:16:56.210
I don't want to use my touchpad.

00:17:06.710 --> 00:17:07.770
OK.

00:17:07.770 --> 00:17:08.500
Don't go there.

00:17:08.500 --> 00:17:09.120
OK.

00:17:31.910 --> 00:17:34.170
OK, so I've got some functions here.

00:17:34.170 --> 00:17:35.889
I've got that linear function that I

00:17:35.889 --> 00:17:36.163
showed.

00:17:36.163 --> 00:17:38.378
I've got the rounded function that I

00:17:38.378 --> 00:17:39.790
showed, continuous, nonlinear.

00:17:40.600 --> 00:17:44.060
Giving it away but and then I've got a

00:17:44.060 --> 00:17:45.850
more non linear function that had like

00:17:45.850 --> 00:17:47.380
that little circle on the right side.

00:17:49.580 --> 00:17:51.750
Got display functions that I don't want

00:17:51.750 --> 00:17:54.455
to talk about because they're just for

00:17:54.455 --> 00:17:55.636
display and they're really complicated

00:17:55.636 --> 00:17:57.560
and I sort of like found it somewhere

00:17:57.560 --> 00:17:59.530
and modified it, but it's definitely

00:17:59.530 --> 00:17:59.980
not the point.

00:18:00.730 --> 00:18:02.650
Let me just see if this will run.

00:18:06.740 --> 00:18:08.060
All right, let's take for granted that

00:18:08.060 --> 00:18:09.130
it will and move on.

00:18:09.250 --> 00:18:09.870


00:18:11.440 --> 00:18:15.200
So then I've got so this is all display

00:18:15.200 --> 00:18:15.650
function.

00:18:16.260 --> 00:18:18.140
And then I've got the Perceptron down

00:18:18.140 --> 00:18:18.610
here.

00:18:18.610 --> 00:18:20.415
So just a second, let me make sure.

00:18:20.415 --> 00:18:22.430
OK, that's good, let me run my display

00:18:22.430 --> 00:18:23.850
functions, OK.

00:18:25.280 --> 00:18:27.460
So the Perceptron.

00:18:27.460 --> 00:18:29.800
OK, so I've got my prediction function

00:18:29.800 --> 00:18:33.746
that's just basically matmul X and

00:18:33.746 --> 00:18:33.993
West.

00:18:33.993 --> 00:18:36.050
So I just multiply my Weights by West.

00:18:37.050 --> 00:18:38.870
I've got an evaluation function to

00:18:38.870 --> 00:18:40.230
compute a loss.

00:18:40.230 --> 00:18:43.160
It's just one over 1 + E to the

00:18:43.160 --> 00:18:45.490
negative prediction times Y.

00:18:46.360 --> 00:18:48.650
The negative log of that just so it's

00:18:48.650 --> 00:18:49.520
the logistic loss.

00:18:51.210 --> 00:18:53.346
And I'm also computing an accuracy here

00:18:53.346 --> 00:18:56.430
which is just whether Y times the

00:18:56.430 --> 00:18:59.710
prediction which is greater than zero

00:18:59.710 --> 00:19:00.130
or not.

00:19:01.210 --> 00:19:02.160
The average of that?

00:19:03.080 --> 00:19:07.420
And then I've got my SGD Perceptron

00:19:07.420 --> 00:19:07.780
here.

00:19:08.540 --> 00:19:11.460
So I randomly initialized my Weights.

00:19:11.460 --> 00:19:13.480
Here I just did a uniform random, which

00:19:13.480 --> 00:19:14.530
is OK too.

00:19:14.670 --> 00:19:15.310


00:19:17.730 --> 00:19:18.900
And.

00:19:20.280 --> 00:19:22.040
So this is a uniform random

00:19:22.040 --> 00:19:26.040
initialization from -, .25 to .025.

00:19:27.020 --> 00:19:29.670
I added a one to my features as a way

00:19:29.670 --> 00:19:30.940
of dealing with the bias term.

00:19:32.500 --> 00:19:33.740
And then I've got some number of

00:19:33.740 --> 00:19:34.610
iterations set.

00:19:36.000 --> 00:19:37.920
And initializing something to keep

00:19:37.920 --> 00:19:39.770
track of their loss and the accuracy.

00:19:40.470 --> 00:19:42.940
I'm going to just Evaluate to start

00:19:42.940 --> 00:19:44.620
with my random Weights, so I'm not

00:19:44.620 --> 00:19:45.970
expecting anything to be good, but I

00:19:45.970 --> 00:19:46.840
want to start tracking it.

00:19:48.010 --> 00:19:50.410
Gotta batch size of 100 so I'm going to

00:19:50.410 --> 00:19:52.210
process 100 examples at a time.

00:19:53.660 --> 00:19:55.610
I start iterating through my data.

00:19:56.470 --> 00:19:58.002
I set my learning rate.

00:19:58.002 --> 00:20:00.440
I did the initial learning rate.

00:20:00.550 --> 00:20:01.200


00:20:02.210 --> 00:20:06.440
Divided by this thing, another number

00:20:06.440 --> 00:20:09.135
and then divide by the step size.

00:20:09.135 --> 00:20:11.910
This was based on the Pegasus learning

00:20:11.910 --> 00:20:12.490
rate schedule.

00:20:13.660 --> 00:20:15.210
Then I do.

00:20:15.300 --> 00:20:18.366
I've randomly permute my data order, so

00:20:18.366 --> 00:20:20.230
I randomly permute indices.

00:20:20.230 --> 00:20:22.300
So I've shuffled my data so that every

00:20:22.300 --> 00:20:23.856
time I pass through I'm going to pass

00:20:23.856 --> 00:20:24.920
through it in a different order.

00:20:26.730 --> 00:20:29.120
Then I step through and steps of batch

00:20:29.120 --> 00:20:29.360
size.

00:20:29.360 --> 00:20:30.928
I step through my data in steps of

00:20:30.928 --> 00:20:31.396
batch size.

00:20:31.396 --> 00:20:34.790
I get the indices of size batch size.

00:20:35.970 --> 00:20:37.840
I make a prediction for all those

00:20:37.840 --> 00:20:39.100
indices and like.

00:20:39.100 --> 00:20:40.770
These reshapes make the Code kind of

00:20:40.770 --> 00:20:42.690
ugly, but necessary.

00:20:42.690 --> 00:20:44.080
At least seem necessary.

00:20:45.260 --> 00:20:52.000
So I multiply my by my ex and I do the

00:20:52.000 --> 00:20:52.830
exponent of that.

00:20:52.830 --> 00:20:54.300
So this is 1 minus the.

00:20:54.300 --> 00:20:55.790
Since I don't have a negative here,

00:20:55.790 --> 00:20:57.940
this is 1 minus the probability of the

00:20:57.940 --> 00:20:58.390
True label.

00:20:59.980 --> 00:21:01.830
This whole pred is 1 minus the

00:21:01.830 --> 00:21:02.910
probability of the True label.

00:21:03.650 --> 00:21:05.009
And then I have my weight update.

00:21:05.010 --> 00:21:07.010
So my weight update is one over the

00:21:07.010 --> 00:21:09.255
batch size times the learning rate

00:21:09.255 --> 00:21:12.260
times X * Y.

00:21:12.970 --> 00:21:16.750
Times this error function evaluation

00:21:16.750 --> 00:21:17.390
which is pred.

00:21:18.690 --> 00:21:19.360
And.

00:21:20.000 --> 00:21:21.510
I'm going to sum it over all the

00:21:21.510 --> 00:21:22.220
examples.

00:21:23.050 --> 00:21:25.920
So this is my loss update.

00:21:25.920 --> 00:21:27.550
And then I also have an L2

00:21:27.550 --> 00:21:29.560
regularization, so I'm penalizing the

00:21:29.560 --> 00:21:30.550
square of Weights.

00:21:30.550 --> 00:21:32.027
When you penalize the square of

00:21:32.027 --> 00:21:33.420
Weights, take the derivative of West

00:21:33.420 --> 00:21:35.620
squared and you get 2 W so you subtract

00:21:35.620 --> 00:21:36.400
off 2 W.

00:21:37.870 --> 00:21:40.460
And so I take a step in that negative W

00:21:40.460 --> 00:21:40.950
direction.

00:21:43.170 --> 00:21:45.420
OK, so these are the same as the

00:21:45.420 --> 00:21:46.610
equations I showed, they're just

00:21:46.610 --> 00:21:48.487
vectorized so that I'm updating all the

00:21:48.487 --> 00:21:50.510
weights at the same time and processing

00:21:50.510 --> 00:21:52.462
all the data in the batch at the same

00:21:52.462 --> 00:21:54.362
time, rather than looping through the

00:21:54.362 --> 00:21:56.060
data and looping through the Weights.

00:21:57.820 --> 00:21:59.920
Then I do this.

00:22:00.750 --> 00:22:02.570
Until I finish get to the end of my

00:22:02.570 --> 00:22:06.120
data, I compute my accuracy and my loss

00:22:06.120 --> 00:22:07.870
just for plotting purposes.

00:22:08.720 --> 00:22:10.950
And then at the end I do an evaluation

00:22:10.950 --> 00:22:11.990
and I.

00:22:12.820 --> 00:22:15.860
And I print my error and my loss and my

00:22:15.860 --> 00:22:19.150
accuracy and plot plot things OK, so

00:22:19.150 --> 00:22:19.400
that's.

00:22:20.560 --> 00:22:22.680
That's SGD for Perceptron.

00:22:23.940 --> 00:22:25.466
And so now let's look at it at the

00:22:25.466 --> 00:22:26.640
linear for the linear problem.

00:22:27.740 --> 00:22:29.260
So I'm going to generate some random

00:22:29.260 --> 00:22:29.770
data.

00:22:30.610 --> 00:22:31.190


00:22:32.380 --> 00:22:34.865
So here's some like randomly generated

00:22:34.865 --> 00:22:37.190
data where like half the data is on one

00:22:37.190 --> 00:22:38.730
side of this diagonal and half on the

00:22:38.730 --> 00:22:39.250
other side.

00:22:40.900 --> 00:22:43.220
And I plot it and then I run this

00:22:43.220 --> 00:22:44.760
function that I just described.

00:22:46.290 --> 00:22:48.070
And so this is what happens to the

00:22:48.070 --> 00:22:48.800
loss.

00:22:48.800 --> 00:22:50.800
So first, the first, the learning rate

00:22:50.800 --> 00:22:53.120
is pretty high, so it's actually kind

00:22:53.120 --> 00:22:55.140
of a little wild, but then it settles

00:22:55.140 --> 00:22:57.430
down and it quickly descends and

00:22:57.430 --> 00:22:59.480
reaches a.

00:22:59.600 --> 00:23:00.000
The loss.

00:23:01.380 --> 00:23:02.890
And here's what happens to the

00:23:02.890 --> 00:23:03.930
accuracy.

00:23:04.340 --> 00:23:07.910
The accuracy goes up to pretty close to

00:23:07.910 --> 00:23:08.140
1.

00:23:09.950 --> 00:23:12.680
And I just ran it for 10 iterations.

00:23:12.680 --> 00:23:15.810
So if I decrease my learning rate and

00:23:15.810 --> 00:23:17.290
let it run more, I could probably get a

00:23:17.290 --> 00:23:18.490
little higher accuracy, but.

00:23:21.070 --> 00:23:22.720
So notice the loss is still like far

00:23:22.720 --> 00:23:25.270
from zero, even though here's my

00:23:25.270 --> 00:23:26.560
decision boundary.

00:23:27.800 --> 00:23:29.780
I'm going to have to zoom out.

00:23:29.780 --> 00:23:31.010
That's a big boundary.

00:23:31.900 --> 00:23:33.070
All right, so here's my decision

00:23:33.070 --> 00:23:35.450
boundary, and you can see it's

00:23:35.450 --> 00:23:37.880
classifying almost everything perfect.

00:23:37.880 --> 00:23:40.210
There's some red dots that ended up on

00:23:40.210 --> 00:23:41.450
the wrong side of the line.

00:23:42.990 --> 00:23:45.330
And but pretty good.

00:23:45.940 --> 00:23:47.880
But the loss is still fairly high

00:23:47.880 --> 00:23:49.430
because it's still paying a loss even

00:23:49.430 --> 00:23:51.370
for these correctly classified samples

00:23:51.370 --> 00:23:52.350
that are near the boundary.

00:23:52.350 --> 00:23:54.020
In fact, all the samples it's paying

00:23:54.020 --> 00:23:55.880
some loss, but here pretty much fit

00:23:55.880 --> 00:23:56.620
this function right.

00:23:58.160 --> 00:23:59.790
Alright, so now let's look at our non

00:23:59.790 --> 00:24:00.770
linear problem.

00:24:01.520 --> 00:24:04.910
With the rounded curve.

00:24:04.910 --> 00:24:06.560
So I just basically did like a circle

00:24:06.560 --> 00:24:08.040
that overlaps with the feature space.

00:24:11.370 --> 00:24:13.630
Here's what happened in loss.

00:24:13.630 --> 00:24:15.960
Nice descent leveled out.

00:24:17.390 --> 00:24:21.400
My accuracy went up, but it's topped

00:24:21.400 --> 00:24:22.210
out at 90%.

00:24:23.150 --> 00:24:25.000
And that's because I can't fit this

00:24:25.000 --> 00:24:26.380
perfectly with the linear function,

00:24:26.380 --> 00:24:26.620
right?

00:24:26.620 --> 00:24:28.518
The best I can do with the linear

00:24:28.518 --> 00:24:29.800
function it means that I'm drawing a

00:24:29.800 --> 00:24:31.070
line in this 2D space.

00:24:31.970 --> 00:24:34.610
And the True boundary is not a line,

00:24:34.610 --> 00:24:36.280
it's a semi circle.

00:24:36.960 --> 00:24:39.040
And so I get these points over here

00:24:39.040 --> 00:24:41.396
incorrect the red dots and I get.

00:24:41.396 --> 00:24:41.989
I get.

00:24:43.310 --> 00:24:47.429
It shows a line and then I get these

00:24:47.430 --> 00:24:49.056
red dots incorrect, and then I get

00:24:49.056 --> 00:24:49.960
these blue dots correct.

00:24:49.960 --> 00:24:52.240
So it's the best line it can find, but

00:24:52.240 --> 00:24:52.981
it can't fit.

00:24:52.981 --> 00:24:55.340
You can't fit a nonlinear shape with

00:24:55.340 --> 00:24:57.170
the line, just like you can't put a

00:24:57.170 --> 00:24:58.810
square in a round hole.

00:24:59.720 --> 00:25:00.453
Right.

00:25:00.453 --> 00:25:03.710
So not perfect, but not horrible.

00:25:04.710 --> 00:25:06.220
And then if we go to this.

00:25:06.330 --> 00:25:07.010
And.

00:25:07.860 --> 00:25:09.030
We go to this guy.

00:25:09.830 --> 00:25:11.400
And this has this big BLOB here.

00:25:11.400 --> 00:25:12.770
So obviously we're not going to fit

00:25:12.770 --> 00:25:14.100
this perfectly with a line like.

00:25:14.100 --> 00:25:15.470
I could do that, I could do that.

00:25:16.330 --> 00:25:20.270
But it does its best, minimizes the

00:25:20.270 --> 00:25:20.730
loss.

00:25:20.730 --> 00:25:23.140
Now it gets an error of 85% or an

00:25:23.140 --> 00:25:24.220
accuracy of 85%.

00:25:24.220 --> 00:25:25.420
This is accuracy that I've been

00:25:25.420 --> 00:25:25.700
plotting.

00:25:26.590 --> 00:25:28.580
So a little bit lower and what it does

00:25:28.580 --> 00:25:30.340
is it puts like a straight line, like

00:25:30.340 --> 00:25:31.330
straight through.

00:25:31.330 --> 00:25:32.820
It just moves it a little bit to the

00:25:32.820 --> 00:25:34.800
right so that these guys don't have

00:25:34.800 --> 00:25:36.010
quite as high of a loss.

00:25:36.990 --> 00:25:38.820
And it's still getting a lot of the

00:25:38.820 --> 00:25:40.475
same examples wrong.

00:25:40.475 --> 00:25:42.940
And it also gets this like BLOB over

00:25:42.940 --> 00:25:43.480
here wrong.

00:25:44.300 --> 00:25:46.610
So these I should have said, these

00:25:46.610 --> 00:25:49.890
boundaries are showing where the model

00:25:49.890 --> 00:25:50.563
predicts 0.

00:25:50.563 --> 00:25:52.170
So this is like the decision boundary.

00:25:53.140 --> 00:25:53.960
And then the.

00:25:54.700 --> 00:25:56.718
Faded background is showing like the

00:25:56.718 --> 00:25:59.007
probability of the blue class or the

00:25:59.007 --> 00:26:00.420
probability of the red class.

00:26:00.420 --> 00:26:01.570
So it's bigger if it's.

00:26:02.880 --> 00:26:04.200
Excuse me if it's more probable.

00:26:04.830 --> 00:26:07.240
And then the dark dots are the training

00:26:07.240 --> 00:26:08.980
examples question.

00:26:10.930 --> 00:26:11.280
Decision.

00:26:13.920 --> 00:26:15.120
It's a straight line.

00:26:15.120 --> 00:26:16.880
It's just that in order to plot, you

00:26:16.880 --> 00:26:18.810
have to discretize the space and take

00:26:18.810 --> 00:26:20.690
samples at different positions.

00:26:20.690 --> 00:26:22.860
So we need discretize it and fit a

00:26:22.860 --> 00:26:23.770
contour to it.

00:26:23.770 --> 00:26:25.826
It's like wiggling, but it's really a

00:26:25.826 --> 00:26:26.299
straight line.

00:26:27.170 --> 00:26:27.910
Yeah, question.

00:26:33.180 --> 00:26:35.320
So that's one thing you could do, but I

00:26:35.320 --> 00:26:37.550
would say in this case.

00:26:39.180 --> 00:26:42.890
Even polar coordinates I think would

00:26:42.890 --> 00:26:45.260
probably not be linear still, but it's

00:26:45.260 --> 00:26:46.580
true that you could project it into a

00:26:46.580 --> 00:26:48.520
higher dimension dimensionality and

00:26:48.520 --> 00:26:50.274
make it linear, and polar coordinates

00:26:50.274 --> 00:26:51.280
could be part of that.

00:26:52.030 --> 00:26:52.400
Question.

00:27:02.770 --> 00:27:05.630
So the question was, could layer lines

00:27:05.630 --> 00:27:07.089
on top of each other and use like a

00:27:07.090 --> 00:27:08.560
combination of lines to make a

00:27:08.560 --> 00:27:10.110
prediction like with the decision tree?

00:27:11.280 --> 00:27:12.130
So definitely.

00:27:12.130 --> 00:27:13.780
So you could just literally use a

00:27:13.780 --> 00:27:14.930
decision tree.

00:27:15.910 --> 00:27:16.870
And.

00:27:17.840 --> 00:27:19.870
Multi layer Perceptron, which is the

00:27:19.870 --> 00:27:21.070
next thing that we're going to talk

00:27:21.070 --> 00:27:22.742
about, is essentially doing just that.

00:27:22.742 --> 00:27:25.510
You make a bunch of linear predictions

00:27:25.510 --> 00:27:27.335
as your intermediate features and then

00:27:27.335 --> 00:27:29.480
you have some nonlinearity like a

00:27:29.480 --> 00:27:31.755
threshold and then you make linear

00:27:31.755 --> 00:27:32.945
predictions from those.

00:27:32.945 --> 00:27:34.800
And so that's how we're going to do it.

00:27:34.860 --> 00:27:35.430
Yep.

00:27:41.910 --> 00:27:42.880
So.

00:27:43.640 --> 00:27:44.690
There's here.

00:27:44.690 --> 00:27:46.820
It's not important because it's a

00:27:46.820 --> 00:27:48.510
convex function and it's a small

00:27:48.510 --> 00:27:51.195
function, but there's two purposes to a

00:27:51.195 --> 00:27:51.380
batch.

00:27:51.380 --> 00:27:53.550
Size 1 is that you can process the

00:27:53.550 --> 00:27:55.110
whole batch in parallel, especially if

00:27:55.110 --> 00:27:56.660
you're doing like GPU processing.

00:27:57.380 --> 00:27:59.440
The other is that it gives you a more

00:27:59.440 --> 00:28:00.756
stable estimate of the gradient.

00:28:00.756 --> 00:28:02.290
So we're computing the gradient for

00:28:02.290 --> 00:28:04.200
each of the examples, and then we're

00:28:04.200 --> 00:28:06.190
summing it and dividing by the number

00:28:06.190 --> 00:28:06.890
of samples.

00:28:06.890 --> 00:28:08.670
So I'm getting a more I'm getting like

00:28:08.670 --> 00:28:10.840
a better estimate of the mean gradient.

00:28:11.490 --> 00:28:13.760
So what I'm really doing is for each

00:28:13.760 --> 00:28:16.640
sample I'm getting an unexpected

00:28:16.640 --> 00:28:19.605
gradient function for all the data, but

00:28:19.605 --> 00:28:21.450
the expectation is based on just one

00:28:21.450 --> 00:28:22.143
small sample.

00:28:22.143 --> 00:28:24.430
So the bigger the sample, the better

00:28:24.430 --> 00:28:25.910
approximates the true gradient.

00:28:27.930 --> 00:28:31.620
In practice, usually bigger batch sizes

00:28:31.620 --> 00:28:32.440
are better.

00:28:32.590 --> 00:28:33.280


00:28:35.380 --> 00:28:37.440
And so usually people use the biggest

00:28:37.440 --> 00:28:39.240
batch size that can fit into their GPU

00:28:39.240 --> 00:28:41.290
memory when they're doing like deep

00:28:41.290 --> 00:28:41.890
learning.

00:28:42.090 --> 00:28:45.970
But you have to like tune different

00:28:45.970 --> 00:28:47.660
some parameters, like you might

00:28:47.660 --> 00:28:48.810
increase your learning rate, for

00:28:48.810 --> 00:28:50.460
example if you have a bigger batch size

00:28:50.460 --> 00:28:51.840
because you have a more stable estimate

00:28:51.840 --> 00:28:53.450
of your gradient, so you can take

00:28:53.450 --> 00:28:54.140
bigger steps.

00:28:54.140 --> 00:28:55.180
But there's.

00:28:55.850 --> 00:28:56.780
Yeah.

00:29:00.230 --> 00:29:00.870
Alright.

00:29:01.600 --> 00:29:03.225
So now I'm going to jump out of that.

00:29:03.225 --> 00:29:05.350
I'm going to come back to this Demo.

00:29:06.700 --> 00:29:07.560
In a bit.

00:29:13.580 --> 00:29:16.570
Right, so I can fit linear functions

00:29:16.570 --> 00:29:19.040
with this Perceptron, but sometimes I

00:29:19.040 --> 00:29:20.360
want a nonlinear function.

00:29:22.070 --> 00:29:23.830
So that's where the multilayer

00:29:23.830 --> 00:29:25.210
perceptron comes in.

00:29:25.950 --> 00:29:27.120
It's just a.

00:29:28.060 --> 00:29:28.990
Perceptron with.

00:29:29.770 --> 00:29:31.420
More layers of Perceptrons.

00:29:31.420 --> 00:29:33.760
So basically this guy.

00:29:33.760 --> 00:29:36.081
So you have in a multilayer perceptron,

00:29:36.081 --> 00:29:39.245
you have your, you have your output or

00:29:39.245 --> 00:29:41.010
outputs, and then you have what people

00:29:41.010 --> 00:29:42.880
call hidden layers, which are like

00:29:42.880 --> 00:29:44.500
intermediate outputs.

00:29:44.690 --> 00:29:45.390


00:29:46.180 --> 00:29:47.955
That you can think of as being some

00:29:47.955 --> 00:29:50.290
kind of latent feature, some kind of

00:29:50.290 --> 00:29:52.300
combination of the Input data that may

00:29:52.300 --> 00:29:54.510
be useful for making a prediction, but

00:29:54.510 --> 00:29:56.466
it's not like explicitly part of your

00:29:56.466 --> 00:29:58.100
data vector or part of your label

00:29:58.100 --> 00:29:58.570
vector.

00:30:00.050 --> 00:30:02.518
So for example, this is somebody else's

00:30:02.518 --> 00:30:05.340
Example, but if you wanted to predict

00:30:05.340 --> 00:30:07.530
whether somebody's going to survive the

00:30:07.530 --> 00:30:08.830
cancer, I think that's what this is

00:30:08.830 --> 00:30:09.010
from.

00:30:09.670 --> 00:30:11.900
Then you could take the age, the gender

00:30:11.900 --> 00:30:14.170
of the stage, and you could just try a

00:30:14.170 --> 00:30:14.930
linear prediction.

00:30:14.930 --> 00:30:16.030
But maybe that doesn't work well

00:30:16.030 --> 00:30:16.600
enough.

00:30:16.600 --> 00:30:18.880
So you create an MLP, a multilayer

00:30:18.880 --> 00:30:21.500
perceptron, and then this is

00:30:21.500 --> 00:30:23.029
essentially making a prediction, a

00:30:23.030 --> 00:30:24.885
weighted combination of these inputs.

00:30:24.885 --> 00:30:27.060
It goes through a Sigmoid, so it gets

00:30:27.060 --> 00:30:28.595
mapped from zero to one.

00:30:28.595 --> 00:30:30.510
You do the same for this node.

00:30:31.450 --> 00:30:34.150
And then you and then you make another

00:30:34.150 --> 00:30:35.770
prediction based on the outputs of

00:30:35.770 --> 00:30:37.410
these two nodes, and that gives you

00:30:37.410 --> 00:30:38.620
your final probability.

00:30:41.610 --> 00:30:44.510
So this becomes a nonlinear function

00:30:44.510 --> 00:30:47.597
because of these like nonlinearities in

00:30:47.597 --> 00:30:48.880
that in that activation.

00:30:48.880 --> 00:30:50.795
But I know I'm throwing out a lot of

00:30:50.795 --> 00:30:51.740
throwing around a lot of terms.

00:30:51.740 --> 00:30:53.720
I'm going to get through it all later,

00:30:53.720 --> 00:30:56.400
but that's just the basic idea, all

00:30:56.400 --> 00:30:56.580
right?

00:30:56.580 --> 00:30:59.586
So here's another example for Digits

00:30:59.586 --> 00:31:02.480
for MNIST digits, which is part of your

00:31:02.480 --> 00:31:03.140
homework too.

00:31:04.090 --> 00:31:05.180
So.

00:31:05.800 --> 00:31:07.590
So we have in the digit problem.

00:31:07.590 --> 00:31:11.830
We have 28 by 28 digit images and we

00:31:11.830 --> 00:31:14.430
then reshape it to a 784 dimensional

00:31:14.430 --> 00:31:16.650
vector so the inputs are the pixel

00:31:16.650 --> 00:31:17.380
intensities.

00:31:19.680 --> 00:31:20.500
That's here.

00:31:20.500 --> 00:31:24.650
So I have X0 which is 784 Values.

00:31:25.720 --> 00:31:27.650
I pass it through what's called a fully

00:31:27.650 --> 00:31:28.550
connected layer.

00:31:28.550 --> 00:31:32.520
It's a linear, it's just linear

00:31:32.520 --> 00:31:33.350
product.

00:31:34.490 --> 00:31:36.870
And now the thing here is that I've got

00:31:36.870 --> 00:31:40.110
I've got here 256 nodes in this layer,

00:31:40.110 --> 00:31:42.235
which means that I'm going to predict

00:31:42.235 --> 00:31:44.130
256 different Values.

00:31:44.790 --> 00:31:47.489
Each one has its own vector of weights

00:31:47.490 --> 00:31:50.735
and the vector of weights that size

00:31:50.735 --> 00:31:53.260
2784 plus one for the bias.

00:31:54.530 --> 00:31:57.330
So I've got 256 values that I'm going

00:31:57.330 --> 00:31:58.360
to produce here.

00:31:58.360 --> 00:32:00.550
Each of them is based on a linear

00:32:00.550 --> 00:32:02.210
combination of these inputs.

00:32:03.690 --> 00:32:05.830
And I can store that as a matrix.

00:32:07.730 --> 00:32:11.070
The matrix is W10 and it has a shape.

00:32:11.750 --> 00:32:15.985
256 by 784 so when I multiply this 256

00:32:15.985 --> 00:32:22.817
by 784 matrix by X0 then I get 256 by 1

00:32:22.817 --> 00:32:23.940
vector right?

00:32:23.940 --> 00:32:26.150
If this is a 784 by 1 vector?

00:32:29.000 --> 00:32:31.510
So now I've got 256 Values.

00:32:31.510 --> 00:32:34.380
I pass it through a nonlinearity and I

00:32:34.380 --> 00:32:36.030
am going to talk about these things

00:32:36.030 --> 00:32:36.380
more.

00:32:36.380 --> 00:32:36.680
But.

00:32:37.450 --> 00:32:38.820
Call it a veliu.

00:32:38.820 --> 00:32:40.605
So this just sets.

00:32:40.605 --> 00:32:42.490
If the Values would have been negative

00:32:42.490 --> 00:32:44.740
then they become zero and if they're

00:32:44.740 --> 00:32:48.100
positive then they stay the same.

00:32:48.100 --> 00:32:49.640
So this.

00:32:49.640 --> 00:32:52.629
I passed my X1 through this and it

00:32:52.630 --> 00:32:55.729
becomes a Max of X1 and zero and I

00:32:55.730 --> 00:32:58.060
still have 256 Values here but now it's

00:32:58.060 --> 00:32:59.440
either zero or positive.

00:33:01.070 --> 00:33:03.470
And then I pass it through another

00:33:03.470 --> 00:33:04.910
fully connected layer if.

00:33:04.910 --> 00:33:06.580
This is if I'm doing 2 hidden layers.

00:33:07.490 --> 00:33:10.780
And this maps it from 256 to 10 because

00:33:10.780 --> 00:33:12.250
I want to predict 10 digits.

00:33:13.370 --> 00:33:16.340
So I've got a 10 by 256 matrix.

00:33:16.340 --> 00:33:21.380
I do a linear mapping into 10 Values.

00:33:22.120 --> 00:33:25.300
And then these can be my scores, my

00:33:25.300 --> 00:33:26.115
logic scores.

00:33:26.115 --> 00:33:28.460
I could have a Sigmoid after this if I

00:33:28.460 --> 00:33:29.859
wanted to map it into zero to 1.

00:33:31.350 --> 00:33:33.020
So these are like the main components

00:33:33.020 --> 00:33:34.405
and again I'm going to talk through

00:33:34.405 --> 00:33:36.130
these a bit more and show you Code and

00:33:36.130 --> 00:33:36.650
stuff, but.

00:33:37.680 --> 00:33:38.750
I've got my Input.

00:33:38.750 --> 00:33:41.690
I've got usually like a series of fully

00:33:41.690 --> 00:33:43.130
connected layers, which are just

00:33:43.130 --> 00:33:45.460
matrices that are learnable matrices of

00:33:45.460 --> 00:33:45.910
Weights.

00:33:47.370 --> 00:33:49.480
Some kind of non linear activation?

00:33:49.480 --> 00:33:51.595
Because if I were to just stack a bunch

00:33:51.595 --> 00:33:54.205
of linear weight multiplications on top

00:33:54.205 --> 00:33:56.233
of each other, that just gives me a

00:33:56.233 --> 00:33:58.110
linear multiplication, so there's no

00:33:58.110 --> 00:33:58.836
point, right?

00:33:58.836 --> 00:34:00.750
If I do a bunch of linear operations,

00:34:00.750 --> 00:34:01.440
it's still linear.

00:34:02.510 --> 00:34:05.289
And one second, and then I have A and

00:34:05.290 --> 00:34:06.690
so I usually have a bunch of a couple

00:34:06.690 --> 00:34:08.192
of these stacked together, and then I

00:34:08.192 --> 00:34:08.800
have my output.

00:34:08.880 --> 00:34:09.050
Yeah.

00:34:14.250 --> 00:34:16.210
So this is the non linear thing this

00:34:16.210 --> 00:34:18.520
Relu this.

00:34:20.290 --> 00:34:23.845
So it's non linear because if I'll show

00:34:23.845 --> 00:34:27.040
you but if it's negative it maps to 0

00:34:27.040 --> 00:34:28.678
so that's pretty non linear and then

00:34:28.678 --> 00:34:30.490
you have this bend and then if it's

00:34:30.490 --> 00:34:32.250
positive it keeps its value.

00:34:37.820 --> 00:34:42.019
So when they lose so I mean so these

00:34:42.020 --> 00:34:44.600
networks, these multilayer perceptrons,

00:34:44.600 --> 00:34:46.610
they're a combination of linear

00:34:46.610 --> 00:34:48.369
functions and non linear functions.

00:34:49.140 --> 00:34:50.930
The linear functions you're taking the

00:34:50.930 --> 00:34:53.430
original Input, Values it by some

00:34:53.430 --> 00:34:55.590
Weights, summing it up, and then you

00:34:55.590 --> 00:34:56.970
get some new output value.

00:34:57.550 --> 00:34:59.670
And then you have usually a nonlinear

00:34:59.670 --> 00:35:01.440
function so that you can.

00:35:02.390 --> 00:35:03.900
So that when you stack a bunch of the

00:35:03.900 --> 00:35:05.340
linear functions together, you end up

00:35:05.340 --> 00:35:06.830
with a non linear function.

00:35:06.830 --> 00:35:08.734
Similar to decision trees and decision

00:35:08.734 --> 00:35:10.633
trees, you have a very simple linear

00:35:10.633 --> 00:35:11.089
function.

00:35:11.090 --> 00:35:13.412
Usually you pick a feature and then you

00:35:13.412 --> 00:35:13.969
threshold it.

00:35:13.970 --> 00:35:15.618
That's a nonlinearity, and then you

00:35:15.618 --> 00:35:17.185
pick a new feature and threshold it.

00:35:17.185 --> 00:35:19.230
And so you're stacking together simple

00:35:19.230 --> 00:35:21.780
linear and nonlinear functions by

00:35:21.780 --> 00:35:23.260
choosing a single variable and then

00:35:23.260 --> 00:35:23.820
thresholding.

00:35:25.770 --> 00:35:29.880
So the simplest activation is a linear

00:35:29.880 --> 00:35:31.560
activation, which is basically a number

00:35:31.560 --> 00:35:31.930
op.

00:35:31.930 --> 00:35:32.820
It doesn't do anything.

00:35:34.060 --> 00:35:37.140
So F of X = X, the derivative of it is

00:35:37.140 --> 00:35:37.863
equal to 1.

00:35:37.863 --> 00:35:39.350
And I'm going to keep on mentioning the

00:35:39.350 --> 00:35:41.866
derivatives because as we'll see, we're

00:35:41.866 --> 00:35:43.240
going to be doing like a Back

00:35:43.240 --> 00:35:44.050
propagation.

00:35:44.050 --> 00:35:46.180
So you flow the gradient back through

00:35:46.180 --> 00:35:48.330
the network, and so you need to know

00:35:48.330 --> 00:35:49.510
what the gradient is of these

00:35:49.510 --> 00:35:51.060
activation functions in order to

00:35:51.060 --> 00:35:51.550
compute that.

00:35:53.050 --> 00:35:55.420
And the size of this gradient is pretty

00:35:55.420 --> 00:35:56.080
important.

00:35:57.530 --> 00:36:00.220
So you could do you could use a linear

00:36:00.220 --> 00:36:01.820
layer if you for example want to

00:36:01.820 --> 00:36:02.358
compress data.

00:36:02.358 --> 00:36:06.050
If you want to map it from 784 Input

00:36:06.050 --> 00:36:09.501
pixels down to 100 Input Values down to

00:36:09.501 --> 00:36:10.289
100 Values.

00:36:10.290 --> 00:36:13.220
Maybe you think 784 is like too high of

00:36:13.220 --> 00:36:14.670
a dimension or some of those features

00:36:14.670 --> 00:36:15.105
are useless.

00:36:15.105 --> 00:36:17.250
So as a first step you just want to map

00:36:17.250 --> 00:36:18.967
it down and you don't need to, you

00:36:18.967 --> 00:36:20.720
don't need to apply any nonlinearity.

00:36:22.380 --> 00:36:24.030
But you would never really stack

00:36:24.030 --> 00:36:26.630
together multiple linear layers.

00:36:27.670 --> 00:36:29.980
Because without non linear activation

00:36:29.980 --> 00:36:31.420
because that's just equivalent to a

00:36:31.420 --> 00:36:32.390
single linear layer.

00:36:35.120 --> 00:36:37.770
Alright, so this Sigmoid.

00:36:38.960 --> 00:36:42.770
So the so the Sigmoid it maps.

00:36:42.870 --> 00:36:43.490


00:36:44.160 --> 00:36:46.060
It maps from an infinite range, from

00:36:46.060 --> 00:36:48.930
negative Infinity to Infinity to some.

00:36:50.690 --> 00:36:52.062
To some zero to 1.

00:36:52.062 --> 00:36:54.358
So basically it can turn anything into

00:36:54.358 --> 00:36:55.114
a probability.

00:36:55.114 --> 00:36:56.485
So it's part of the logistic.

00:36:56.485 --> 00:36:59.170
It's a logistic function, so it maps a

00:36:59.170 --> 00:37:00.890
continuous score into a probability.

00:37:04.020 --> 00:37:04.690
So.

00:37:06.100 --> 00:37:08.240
Sigmoid is actually.

00:37:09.410 --> 00:37:10.820
The.

00:37:11.050 --> 00:37:13.680
It's actually the reason that AI

00:37:13.680 --> 00:37:15.140
stalled for 10 years.

00:37:15.950 --> 00:37:18.560
So this and the reason is the gradient.

00:37:19.610 --> 00:37:20.510
So.

00:37:20.800 --> 00:37:21.560


00:37:24.180 --> 00:37:26.295
All right, so I'm going to try this.

00:37:26.295 --> 00:37:28.610
So rather than talking behind the

00:37:28.610 --> 00:37:31.330
Sigmoid's back, I am going to dramatize

00:37:31.330 --> 00:37:32.370
the Sigmoid.

00:37:32.620 --> 00:37:35.390
Right, Sigmoid.

00:37:36.720 --> 00:37:37.640
What is it?

00:37:38.680 --> 00:37:41.410
You say I Back for 10 years.

00:37:41.410 --> 00:37:42.470
How?

00:37:43.520 --> 00:37:46.120
One problem is your veins.

00:37:46.120 --> 00:37:48.523
You only map from zero to one or from

00:37:48.523 --> 00:37:49.359
zero to 1.

00:37:49.360 --> 00:37:50.980
Sometimes people want a little bit less

00:37:50.980 --> 00:37:52.130
or a little bit more.

00:37:52.130 --> 00:37:53.730
It's like, OK, I like things neat, but

00:37:53.730 --> 00:37:54.690
that doesn't seem too bad.

00:37:55.350 --> 00:37:58.715
Sigmoid, it's not just your range, it's

00:37:58.715 --> 00:37:59.760
your gradient.

00:37:59.760 --> 00:38:00.370
What?

00:38:00.370 --> 00:38:02.020
It's your curves?

00:38:02.020 --> 00:38:02.740
Your slope.

00:38:02.740 --> 00:38:03.640
Have you looked at it?

00:38:04.230 --> 00:38:05.490
It's like, So what?

00:38:05.490 --> 00:38:07.680
I like my lump Black Eyed Peas saying a

00:38:07.680 --> 00:38:08.395
song about it.

00:38:08.395 --> 00:38:08.870
It's good.

00:38:12.150 --> 00:38:16.670
But the problem is that if you get the

00:38:16.670 --> 00:38:19.000
lump may look good, but if you get out

00:38:19.000 --> 00:38:21.110
into the very high values or the very

00:38:21.110 --> 00:38:21.940
low Values.

00:38:22.570 --> 00:38:25.920
You end up with this flat slope.

00:38:25.920 --> 00:38:28.369
So what happens is that if you get on

00:38:28.369 --> 00:38:30.307
top of this hill, you slide down into

00:38:30.307 --> 00:38:32.400
the high Values or you slide down into

00:38:32.400 --> 00:38:34.440
low values and then you can't move

00:38:34.440 --> 00:38:34.910
anymore.

00:38:34.910 --> 00:38:36.180
It's like you're sitting on top of a

00:38:36.180 --> 00:38:37.677
nice till you slide down and you can't

00:38:37.677 --> 00:38:38.730
get back up the ice hill.

00:38:39.600 --> 00:38:41.535
And then if you negate it, then you

00:38:41.535 --> 00:38:43.030
just slide into the center.

00:38:43.030 --> 00:38:44.286
Here you still have a second derivative

00:38:44.286 --> 00:38:46.250
of 0 and you just sit in there.

00:38:46.250 --> 00:38:48.220
So basically you gum up the whole

00:38:48.220 --> 00:38:48.526
works.

00:38:48.526 --> 00:38:50.370
If you get a bunch of these stacked

00:38:50.370 --> 00:38:52.070
together, you end up with a low

00:38:52.070 --> 00:38:54.140
gradient somewhere and then you can't

00:38:54.140 --> 00:38:55.830
optimize it and nothing happens.

00:38:56.500 --> 00:39:00.690
And then Sigmoid is said, man I sorry

00:39:00.690 --> 00:39:02.150
man, I thought I was pretty cool.

00:39:02.150 --> 00:39:04.850
I people have been using me for years.

00:39:04.850 --> 00:39:05.920
It's like OK Sigmoid.

00:39:06.770 --> 00:39:07.500
It's OK.

00:39:07.500 --> 00:39:09.410
You're still a good closer.

00:39:09.410 --> 00:39:11.710
You're still good at getting the

00:39:11.710 --> 00:39:12.860
probability at the end.

00:39:12.860 --> 00:39:16.120
Just please don't go inside the MLP.

00:39:17.370 --> 00:39:19.280
So I hope, I hope he wasn't too sad

00:39:19.280 --> 00:39:20.800
about that.

00:39:20.800 --> 00:39:21.770
But I am pretty mad.

00:39:21.770 --> 00:39:22.130
What?

00:39:27.940 --> 00:39:30.206
The problem with this Sigmoid function

00:39:30.206 --> 00:39:33.160
is that stupid low gradient.

00:39:33.160 --> 00:39:34.880
So everywhere out here it gets a really

00:39:34.880 --> 00:39:35.440
low gradient.

00:39:35.440 --> 00:39:36.980
And the problem is that remember that

00:39:36.980 --> 00:39:38.570
we're going to be taking steps to try

00:39:38.570 --> 00:39:40.090
to improve our.

00:39:40.860 --> 00:39:42.590
Improve our error with respect to the

00:39:42.590 --> 00:39:42.990
gradient.

00:39:43.650 --> 00:39:45.780
And the great if the gradient is 0, it

00:39:45.780 --> 00:39:46.967
means that your steps are zero.

00:39:46.967 --> 00:39:49.226
And this is so close to zero that

00:39:49.226 --> 00:39:49.729
basically.

00:39:49.730 --> 00:39:51.810
I'll show you a demo later, but

00:39:51.810 --> 00:39:53.960
basically this means that you.

00:39:54.610 --> 00:39:56.521
You get unlucky, you get out into this.

00:39:56.521 --> 00:39:57.346
It's not even unlucky.

00:39:57.346 --> 00:39:58.600
It's trying to force you into this

00:39:58.600 --> 00:39:59.340
side.

00:39:59.340 --> 00:40:00.750
But then when you get out here you

00:40:00.750 --> 00:40:02.790
can't move anymore and so you're

00:40:02.790 --> 00:40:05.380
gradient based optimization just gets

00:40:05.380 --> 00:40:06.600
stuck, yeah.

00:40:09.560 --> 00:40:13.270
OK, so the lesson don't put sigmoids

00:40:13.270 --> 00:40:14.280
inside of your MLP.

00:40:15.820 --> 00:40:18.350
This guy Relu is pretty cool.

00:40:18.350 --> 00:40:22.070
He looks very unassuming and stupid,

00:40:22.070 --> 00:40:24.340
but it works.

00:40:24.340 --> 00:40:26.750
So you just have a.

00:40:26.750 --> 00:40:28.170
Anywhere it's negative, it's zero.

00:40:28.170 --> 00:40:30.470
Anywhere it's positive, you pass

00:40:30.470 --> 00:40:30.850
through.

00:40:31.470 --> 00:40:34.830
And is so good about this is that for

00:40:34.830 --> 00:40:37.457
all of these values, the gradient is 11

00:40:37.457 --> 00:40:39.466
is like a pretty high, pretty high

00:40:39.466 --> 00:40:39.759
gradient.

00:40:40.390 --> 00:40:42.590
So if you notice with the Sigmoid, the

00:40:42.590 --> 00:40:45.040
gradient function is the Sigmoid times

00:40:45.040 --> 00:40:46.530
1 minus the Sigmoid.

00:40:46.530 --> 00:40:50.240
This is maximized when F of X is equal

00:40:50.240 --> 00:40:53.035
to 5 and that leads to a 25.

00:40:53.035 --> 00:40:55.920
So it's at most .25 and then it quickly

00:40:55.920 --> 00:40:57.070
goes to zero everywhere.

00:40:58.090 --> 00:40:58.890
This guy.

00:40:59.570 --> 00:41:02.050
Has a gradient of 1 as long as X is

00:41:02.050 --> 00:41:03.120
greater than zero.

00:41:03.120 --> 00:41:04.720
And that means you've got like a lot

00:41:04.720 --> 00:41:06.130
more gradient flowing through your

00:41:06.130 --> 00:41:06.690
network.

00:41:06.690 --> 00:41:09.140
So you can do better optimization.

00:41:09.140 --> 00:41:10.813
And the range is not limited from zero

00:41:10.813 --> 00:41:12.429
to 1, the range can go from zero to

00:41:12.430 --> 00:41:12.900
Infinity.

00:41:15.800 --> 00:41:17.670
So.

00:41:17.740 --> 00:41:18.460


00:41:19.610 --> 00:41:21.840
So let's talk about MLP architectures.

00:41:21.840 --> 00:41:24.545
So the MLP architecture is that you've

00:41:24.545 --> 00:41:26.482
got your inputs, you've got a bunch of

00:41:26.482 --> 00:41:28.136
layers, each of those layers has a

00:41:28.136 --> 00:41:29.530
bunch of nodes, and then you've got

00:41:29.530 --> 00:41:30.830
Activations in between.

00:41:31.700 --> 00:41:33.340
So how do you choose the number of

00:41:33.340 --> 00:41:33.840
layers?

00:41:33.840 --> 00:41:35.290
How do you choose the number of nodes

00:41:35.290 --> 00:41:35.810
per layer?

00:41:35.810 --> 00:41:37.240
It's a little bit of a black art, but

00:41:37.240 --> 00:41:37.980
there is some.

00:41:39.100 --> 00:41:40.580
Reasoning behind it.

00:41:40.580 --> 00:41:42.640
So first, if you don't have any hidden

00:41:42.640 --> 00:41:43.920
layers, then you're stuck with the

00:41:43.920 --> 00:41:44.600
Perceptron.

00:41:45.200 --> 00:41:47.650
And you have a linear model, so you can

00:41:47.650 --> 00:41:48.860
only fit linear boundaries.

00:41:50.580 --> 00:41:52.692
If you only have enough, if you only

00:41:52.692 --> 00:41:54.600
have 1 hidden layer, you can actually

00:41:54.600 --> 00:41:56.500
fit any Boolean function, which means

00:41:56.500 --> 00:41:57.789
anything where you have.

00:41:58.420 --> 00:42:01.650
A bunch of 01 inputs and the output is

00:42:01.650 --> 00:42:03.160
01 like classification.

00:42:03.870 --> 00:42:05.780
You can fit any of those functions, but

00:42:05.780 --> 00:42:07.995
the catch is that you need that the

00:42:07.995 --> 00:42:09.480
number of nodes required grows

00:42:09.480 --> 00:42:10.972
exponentially in the number of inputs

00:42:10.972 --> 00:42:13.150
in the worst case, because essentially

00:42:13.150 --> 00:42:15.340
you just enumerating all the different

00:42:15.340 --> 00:42:16.760
combinations of inputs that are

00:42:16.760 --> 00:42:18.220
possible with your internal layer.

00:42:20.730 --> 00:42:26.070
So further, if you have a single

00:42:26.070 --> 00:42:29.090
Sigmoid layer, that's internal.

00:42:30.080 --> 00:42:32.490
Then, and it's big enough, you can

00:42:32.490 --> 00:42:34.840
model every single bounded continuous

00:42:34.840 --> 00:42:36.610
function, which means that if you have

00:42:36.610 --> 00:42:39.333
a bunch of inputs and your output is a

00:42:39.333 --> 00:42:40.610
single continuous value.

00:42:41.620 --> 00:42:43.340
Or even really Multiple continuous

00:42:43.340 --> 00:42:43.930
values.

00:42:43.930 --> 00:42:47.100
You can approximate it to arbitrary

00:42:47.100 --> 00:42:48.010
accuracy.

00:42:49.240 --> 00:42:50.610
With this single Sigmoid.

00:42:51.540 --> 00:42:53.610
So one layer MLP can fit like almost

00:42:53.610 --> 00:42:54.170
everything.

00:42:55.750 --> 00:42:58.620
And if you have a two layer MLP.

00:42:59.950 --> 00:43:01.450
With Sigmoid activation.

00:43:02.350 --> 00:43:03.260
Then.

00:43:04.150 --> 00:43:06.900
Then you can approximate any function

00:43:06.900 --> 00:43:09.700
with arbitrary accuracy, right?

00:43:09.700 --> 00:43:12.510
So this all sounds pretty good.

00:43:15.040 --> 00:43:16.330
So here's a question.

00:43:16.330 --> 00:43:18.170
Does it ever make sense to have more

00:43:18.170 --> 00:43:20.160
than two internal layers given this?

00:43:23.460 --> 00:43:24.430
Why?

00:43:26.170 --> 00:43:29.124
I just said that you can fit any

00:43:29.124 --> 00:43:30.570
function, or I didn't say you could fit

00:43:30.570 --> 00:43:30.680
it.

00:43:30.680 --> 00:43:33.470
I said you can approximate any function

00:43:33.470 --> 00:43:35.460
to arbitrary accuracy, which means

00:43:35.460 --> 00:43:36.350
infinite precision.

00:43:37.320 --> 00:43:38.110
With two layers.

00:43:45.400 --> 00:43:48.000
So one thing you could say is maybe

00:43:48.000 --> 00:43:50.010
like maybe it's possible to do it too

00:43:50.010 --> 00:43:51.140
layers, but you can't find the right

00:43:51.140 --> 00:43:52.810
two layers, so maybe add some more and

00:43:52.810 --> 00:43:53.500
then maybe you'll get.

00:43:54.380 --> 00:43:55.500
OK, that's reasonable.

00:43:55.500 --> 00:43:56.260
Any other answer?

00:43:56.900 --> 00:43:57.180
Yeah.

00:44:04.590 --> 00:44:07.290
Right, so that's an issue that these

00:44:07.290 --> 00:44:09.600
may require like a huge number of

00:44:09.600 --> 00:44:10.100
nodes.

00:44:10.910 --> 00:44:14.300
And so the reason to go deeper is

00:44:14.300 --> 00:44:15.470
compositionality.

00:44:16.980 --> 00:44:20.660
So you may be able to enumerate, for

00:44:20.660 --> 00:44:22.460
example, all the different Boolean

00:44:22.460 --> 00:44:24.220
things with a single layer.

00:44:24.220 --> 00:44:26.760
But if you had a stack of layers, then

00:44:26.760 --> 00:44:29.462
you can model, then one of them is

00:44:29.462 --> 00:44:29.915
like.

00:44:29.915 --> 00:44:32.570
Is like partitions the data, so it

00:44:32.570 --> 00:44:34.194
creates like a bunch of models, a bunch

00:44:34.194 --> 00:44:35.675
of functions, and then the next one

00:44:35.675 --> 00:44:37.103
models functions of functions and

00:44:37.103 --> 00:44:37.959
functions of functions.

00:44:39.370 --> 00:44:42.790
Functions of functions and functions.

00:44:42.790 --> 00:44:45.780
So compositionality is a more efficient

00:44:45.780 --> 00:44:46.570
representation.

00:44:46.570 --> 00:44:48.540
You can model model things, and then

00:44:48.540 --> 00:44:49.905
model combinations of those things.

00:44:49.905 --> 00:44:51.600
And you can do it with fewer nodes.

00:44:52.890 --> 00:44:54.060
Fewer nodes, OK.

00:44:54.830 --> 00:44:57.230
So it can make sense to make have more

00:44:57.230 --> 00:44:58.590
than two internal layers.

00:45:00.830 --> 00:45:02.745
And you can see the seductiveness of

00:45:02.745 --> 00:45:03.840
the Sigmoid here like.

00:45:04.650 --> 00:45:06.340
You can model anything with Sigmoid

00:45:06.340 --> 00:45:08.800
activation, so why not use it right?

00:45:08.800 --> 00:45:10.230
So that's why people used it.

00:45:11.270 --> 00:45:12.960
That's why it got stuck.

00:45:13.980 --> 00:45:14.880
So.

00:45:14.950 --> 00:45:15.730
And.

00:45:16.840 --> 00:45:18.770
You also have, like the number the

00:45:18.770 --> 00:45:20.440
other parameters, the number of nodes

00:45:20.440 --> 00:45:21.950
per hidden layer, called the width.

00:45:21.950 --> 00:45:23.800
If you have more nodes, it means more

00:45:23.800 --> 00:45:25.790
representational power and more

00:45:25.790 --> 00:45:26.230
parameters.

00:45:27.690 --> 00:45:30.460
So, and that's just a design decision.

00:45:31.600 --> 00:45:33.420
That you could use fit with cross

00:45:33.420 --> 00:45:34.820
validation or something.

00:45:35.650 --> 00:45:37.610
And then each layer has an activation

00:45:37.610 --> 00:45:39.145
function, and I talked about those

00:45:39.145 --> 00:45:40.080
activation functions.

00:45:41.820 --> 00:45:43.440
Here's one early example.

00:45:43.440 --> 00:45:45.082
It's not an early example, but here's

00:45:45.082 --> 00:45:47.700
an example of application of MLP.

00:45:48.860 --> 00:45:51.020
To backgammon, this is a famous case.

00:45:51.790 --> 00:45:53.480
From 1992.

00:45:54.400 --> 00:45:56.490
They for the first version.

00:45:57.620 --> 00:46:00.419
So first backgammon you one side is

00:46:00.419 --> 00:46:02.120
trying to move their pieces around the

00:46:02.120 --> 00:46:03.307
board one way to their home.

00:46:03.307 --> 00:46:04.903
The other side is trying to move the

00:46:04.903 --> 00:46:06.300
pieces around the other way to their

00:46:06.300 --> 00:46:06.499
home.

00:46:07.660 --> 00:46:09.060
And it's a dice based game.

00:46:10.130 --> 00:46:13.110
So one way that you can represent the

00:46:13.110 --> 00:46:14.900
game is just the number of pieces that

00:46:14.900 --> 00:46:16.876
are on each of these spaces.

00:46:16.876 --> 00:46:19.250
So the earliest version they just

00:46:19.250 --> 00:46:20.510
directly represented that.

00:46:21.460 --> 00:46:23.670
Then they have an MLP with one internal

00:46:23.670 --> 00:46:27.420
layer that just had 40 hidden units.

00:46:28.570 --> 00:46:32.270
And they played two hundred 200,000

00:46:32.270 --> 00:46:34.440
games against other programs using

00:46:34.440 --> 00:46:35.390
reinforcement learning.

00:46:35.390 --> 00:46:37.345
So the main idea of reinforcement

00:46:37.345 --> 00:46:40.160
learning is that you have some problem

00:46:40.160 --> 00:46:41.640
you want to solve, like winning the

00:46:41.640 --> 00:46:41.950
game.

00:46:42.740 --> 00:46:44.250
And you want to take actions that bring

00:46:44.250 --> 00:46:45.990
you closer to that goal, but you don't

00:46:45.990 --> 00:46:48.439
know if you won right away and so you

00:46:48.440 --> 00:46:50.883
need to use like a discounted reward.

00:46:50.883 --> 00:46:53.200
So usually I have like 2 reward

00:46:53.200 --> 00:46:53.710
functions.

00:46:53.710 --> 00:46:55.736
One is like how good is my game state?

00:46:55.736 --> 00:46:57.490
So moving your pieces closer to home

00:46:57.490 --> 00:46:58.985
might improve your score of the game

00:46:58.985 --> 00:46:59.260
state.

00:46:59.960 --> 00:47:01.760
And the other is like, did you win?

00:47:01.760 --> 00:47:05.010
And then you're going to score your

00:47:05.010 --> 00:47:09.060
decisions based on the reward of taking

00:47:09.060 --> 00:47:10.590
the step, as well as like future

00:47:10.590 --> 00:47:11.690
rewards that you receive.

00:47:11.690 --> 00:47:13.888
So at the end of the game you win, then

00:47:13.888 --> 00:47:15.526
that kind of flows back and tells you

00:47:15.526 --> 00:47:16.956
that the steps that you took during the

00:47:16.956 --> 00:47:17.560
game were good.

00:47:19.060 --> 00:47:20.400
There's a whole classes on

00:47:20.400 --> 00:47:22.320
reinforcement learning, but that's the

00:47:22.320 --> 00:47:23.770
basic idea and that's how they.

00:47:24.700 --> 00:47:26.620
Solve this problem.

00:47:28.420 --> 00:47:30.810
So even the first version, which had

00:47:30.810 --> 00:47:33.090
no, which was just like very simple

00:47:33.090 --> 00:47:35.360
inputs, was able to perform competitive

00:47:35.360 --> 00:47:37.205
competitively with world experts.

00:47:37.205 --> 00:47:39.250
And so that was an impressive

00:47:39.250 --> 00:47:43.100
demonstration that AI and machine

00:47:43.100 --> 00:47:45.300
learning can do amazing things.

00:47:45.300 --> 00:47:47.510
You can beat world experts in this game

00:47:47.510 --> 00:47:49.540
without any expertise just by setting

00:47:49.540 --> 00:47:50.760
up a machine learning problem and

00:47:50.760 --> 00:47:52.880
having a computer play other computers.

00:47:54.150 --> 00:47:56.050
Then they put some experts in it,

00:47:56.050 --> 00:47:57.620
designed better features, made the

00:47:57.620 --> 00:47:59.710
network a little bit bigger, trained,

00:47:59.710 --> 00:48:02.255
played more games, virtual games, and

00:48:02.255 --> 00:48:04.660
then they were able to again compete

00:48:04.660 --> 00:48:07.210
well with Grand Masters and experts.

00:48:08.280 --> 00:48:10.110
So this is kind of like the forerunner

00:48:10.110 --> 00:48:12.560
of deep blue or is it deep blue,

00:48:12.560 --> 00:48:13.100
Watson?

00:48:13.770 --> 00:48:15.635
Maybe Watson, I don't know the guy that

00:48:15.635 --> 00:48:17.060
the computer that played chess.

00:48:17.910 --> 00:48:19.210
As well as alpha go.

00:48:22.370 --> 00:48:26.070
So now I want to talk about how we

00:48:26.070 --> 00:48:27.080
optimize this thing.

00:48:27.770 --> 00:48:31.930
And the details are not too important,

00:48:31.930 --> 00:48:33.650
but the concept is really, really

00:48:33.650 --> 00:48:33.940
important.

00:48:35.150 --> 00:48:38.190
So we're going to optimize these MLP's

00:48:38.190 --> 00:48:40.150
using Back propagation.

00:48:40.580 --> 00:48:45.070
Back propagation is just an extension

00:48:45.070 --> 00:48:46.430
of.

00:48:46.570 --> 00:48:49.540
Of SGD of stochastic gradient descent.

00:48:50.460 --> 00:48:51.850
Where we just apply the chain rule a

00:48:51.850 --> 00:48:53.180
little bit more.

00:48:53.180 --> 00:48:54.442
So let's take this simple network.

00:48:54.442 --> 00:48:56.199
I've got two inputs, I've got 2

00:48:56.200 --> 00:48:57.210
intermediate nodes.

00:48:58.230 --> 00:48:59.956
Going to represent their outputs as F3

00:48:59.956 --> 00:49:00.840
and four.

00:49:00.840 --> 00:49:03.290
I've gotten output node which I'll call

00:49:03.290 --> 00:49:04.590
G5 and the Weights.

00:49:04.590 --> 00:49:06.910
I'm using a like weight and then two

00:49:06.910 --> 00:49:08.559
indices which are like where it's

00:49:08.560 --> 00:49:09.750
coming from and where it's going.

00:49:09.750 --> 00:49:11.920
So F3 to G5 is W 35.

00:49:13.420 --> 00:49:18.210
And so the output here is some function

00:49:18.210 --> 00:49:20.550
of the two intermediate nodes and each

00:49:20.550 --> 00:49:21.230
of those.

00:49:21.230 --> 00:49:24.140
So in particular W 3/5 times if three

00:49:24.140 --> 00:49:25.880
plus W four 5 * 4.

00:49:26.650 --> 00:49:28.420
And each of those intermediate nodes is

00:49:28.420 --> 00:49:29.955
a linear combination of the inputs.

00:49:29.955 --> 00:49:31.660
And to keep things simple, I'll just

00:49:31.660 --> 00:49:33.070
say linear activation for now.

00:49:33.990 --> 00:49:35.904
My error function is the squared

00:49:35.904 --> 00:49:37.970
function, the squared difference of the

00:49:37.970 --> 00:49:39.400
prediction and the output.

00:49:41.880 --> 00:49:44.320
So I just as before, if I want to

00:49:44.320 --> 00:49:46.210
optimize this, I compute the partial

00:49:46.210 --> 00:49:47.985
derivative of my error with respect to

00:49:47.985 --> 00:49:49.420
the Weights for a given sample.

00:49:50.600 --> 00:49:53.400
And I apply the chain rule again.

00:49:54.620 --> 00:49:57.130
And I get for this weight.

00:49:57.130 --> 00:50:02.400
Here it becomes again two times this

00:50:02.400 --> 00:50:04.320
derivative of the error function, the

00:50:04.320 --> 00:50:05.440
prediction minus Y.

00:50:06.200 --> 00:50:10.530
Times the derivative of the inside of

00:50:10.530 --> 00:50:12.550
this function with respect to my weight

00:50:12.550 --> 00:50:13.440
W 35.

00:50:13.440 --> 00:50:15.180
I'm optimizing it for W 35.

00:50:16.390 --> 00:50:16.800
Right.

00:50:16.800 --> 00:50:18.770
So the derivative of this guy with

00:50:18.770 --> 00:50:21.220
respect to the weight, if I look up at

00:50:21.220 --> 00:50:21.540
this.

00:50:24.490 --> 00:50:26.880
If I look at this function up here.

00:50:27.590 --> 00:50:31.278
The derivative of W-35 times F3 plus W

00:50:31.278 --> 00:50:33.670
Four 5 * 4 is just F3.

00:50:34.560 --> 00:50:36.530
Right, so that gives me that my

00:50:36.530 --> 00:50:41.050
derivative is 2 * g Five X -, y * F

00:50:41.050 --> 00:50:41.750
three of X.

00:50:42.480 --> 00:50:44.670
And then I take a step in that negative

00:50:44.670 --> 00:50:46.695
direction in order to do my update for

00:50:46.695 --> 00:50:47.190
this weight.

00:50:47.190 --> 00:50:48.760
So this is very similar to the

00:50:48.760 --> 00:50:50.574
Perceptron, except instead of the Input

00:50:50.574 --> 00:50:53.243
I have the previous node as part of

00:50:53.243 --> 00:50:54.106
this function here.

00:50:54.106 --> 00:50:55.610
So I have my error gradient and then

00:50:55.610 --> 00:50:56.490
the input to the.

00:50:57.100 --> 00:50:59.240
Being multiplied together and that

00:50:59.240 --> 00:51:01.830
gives me my direction of the gradient.

00:51:03.860 --> 00:51:06.250
For the internal nodes, I have to just

00:51:06.250 --> 00:51:08.160
apply the chain rule recursively.

00:51:08.870 --> 00:51:11.985
So if I want to solve for the update

00:51:11.985 --> 00:51:13.380
for W 113.

00:51:14.360 --> 00:51:17.626
Then I take the derivative.

00:51:17.626 --> 00:51:19.920
I do again, again, again get this

00:51:19.920 --> 00:51:21.410
derivative of the error.

00:51:21.410 --> 00:51:23.236
Then I take the derivative of the

00:51:23.236 --> 00:51:25.930
output with respect to West 1/3, which

00:51:25.930 --> 00:51:27.250
brings me into this.

00:51:27.250 --> 00:51:29.720
And then if I follow that through, I

00:51:29.720 --> 00:51:32.450
end up with the derivative of the

00:51:32.450 --> 00:51:36.610
output with respect to W13 is W-35

00:51:36.610 --> 00:51:37.830
times X1.

00:51:38.720 --> 00:51:40.540
And so I get this as my update.

00:51:42.270 --> 00:51:44.100
And so I end up with these three parts

00:51:44.100 --> 00:51:45.180
to the update.

00:51:45.180 --> 00:51:47.450
This product of three terms, that one

00:51:47.450 --> 00:51:49.111
term is the error gradient, the

00:51:49.111 --> 00:51:50.310
gradient error gradient in my

00:51:50.310 --> 00:51:50.870
prediction.

00:51:51.570 --> 00:51:54.030
The other is like the input into the

00:51:54.030 --> 00:51:56.890
function and the third is the

00:51:56.890 --> 00:51:59.400
contribution how this like contributed

00:51:59.400 --> 00:52:02.510
to the output which is through W 35

00:52:02.510 --> 00:52:06.300
because W 113 Help create F3 which then

00:52:06.300 --> 00:52:08.499
contributes to the output through W 35.

00:52:12.700 --> 00:52:15.080
And this was for a linear activation.

00:52:15.080 --> 00:52:18.759
But if I had a Relu all I would do is I

00:52:18.760 --> 00:52:19.920
modify this.

00:52:19.920 --> 00:52:22.677
Like if I have a Relu after F3 and F4

00:52:22.677 --> 00:52:27.970
that means that F3 is going to be W 1/3

00:52:27.970 --> 00:52:30.380
times Max of X10.

00:52:31.790 --> 00:52:33.690
And.

00:52:34.310 --> 00:52:35.620
Did I put that really in the right

00:52:35.620 --> 00:52:36.140
place?

00:52:36.140 --> 00:52:38.190
All right, let me go with it.

00:52:38.190 --> 00:52:38.980
So.

00:52:39.080 --> 00:52:42.890
FW13 times this is if I put a rally

00:52:42.890 --> 00:52:44.360
right here, which is a weird place.

00:52:44.360 --> 00:52:47.353
But let's just say I did it OK W 1/3

00:52:47.353 --> 00:52:50.737
times Max of X10 plus W 2/3 of Max X20.

00:52:50.737 --> 00:52:54.060
And then I just plug that into my.

00:52:54.060 --> 00:52:56.938
So then the Max of X10 just becomes.

00:52:56.938 --> 00:52:59.880
I mean the X1 becomes Max of X1 and 0.

00:53:01.190 --> 00:53:02.990
I think I put it value here where I

00:53:02.990 --> 00:53:04.780
meant to put it here, but the main

00:53:04.780 --> 00:53:06.658
point is that you then take the

00:53:06.658 --> 00:53:09.170
derivative, then you just follow the

00:53:09.170 --> 00:53:10.870
chain rule, take the derivative of the

00:53:10.870 --> 00:53:11.840
activation as well.

00:53:16.130 --> 00:53:20.219
So the general concept of the.

00:53:20.700 --> 00:53:23.480
Backprop is that each Weights gradient

00:53:23.480 --> 00:53:26.000
based on a single training sample is a

00:53:26.000 --> 00:53:27.540
product of the gradient of the loss

00:53:27.540 --> 00:53:28.070
function.

00:53:29.060 --> 00:53:30.981
And the gradient of the prediction with

00:53:30.981 --> 00:53:33.507
respect to the activation and the

00:53:33.507 --> 00:53:36.033
gradient of the activation with respect

00:53:36.033 --> 00:53:38.800
to the with respect to the weight.

00:53:39.460 --> 00:53:41.570
So it's like a gradient that says how I

00:53:41.570 --> 00:53:42.886
got for W13.

00:53:42.886 --> 00:53:45.670
It's like what was fed into me.

00:53:45.670 --> 00:53:47.990
How does how does the value that I'm

00:53:47.990 --> 00:53:49.859
producing depend on what's fed into me?

00:53:50.500 --> 00:53:51.630
What did I produce?

00:53:51.630 --> 00:53:53.920
How did I influence this W this F3

00:53:53.920 --> 00:53:57.360
function and how did that impact my

00:53:57.360 --> 00:53:58.880
gradient error gradient?

00:54:00.980 --> 00:54:03.380
And because you're applying chain rule

00:54:03.380 --> 00:54:05.495
recursively, you can save computation

00:54:05.495 --> 00:54:08.920
and each weight ends up being like a

00:54:08.920 --> 00:54:11.940
kind of a product of the gradient that

00:54:11.940 --> 00:54:13.890
was accumulated in the Weights after it

00:54:13.890 --> 00:54:16.100
with the Input that came before it.

00:54:19.910 --> 00:54:21.450
OK, so it's a little bit late for this,

00:54:21.450 --> 00:54:22.440
but let's do it anyway.

00:54:22.440 --> 00:54:25.330
So take a 2 minute break and you can

00:54:25.330 --> 00:54:26.610
think about this question.

00:54:26.610 --> 00:54:29.127
So if I want to fill in the blanks, if

00:54:29.127 --> 00:54:31.320
I want to get the gradient with respect

00:54:31.320 --> 00:54:34.290
to W 8 and the gradient with respect to

00:54:34.290 --> 00:54:34.950
W 2.

00:54:36.150 --> 00:54:37.960
How do I fill in those blanks?

00:54:38.920 --> 00:54:40.880
And let's say that it's all linear

00:54:40.880 --> 00:54:41.430
layers.

00:54:44.280 --> 00:54:45.690
I'll set a timer for 2 minutes.

00:55:12.550 --> 00:55:14.880
The input size and that output size.

00:55:17.260 --> 00:55:17.900
Yeah.

00:55:18.070 --> 00:55:20.310
Input size are we talking like the row

00:55:20.310 --> 00:55:20.590
of the?

00:55:22.870 --> 00:55:23.650
Yes.

00:55:23.650 --> 00:55:25.669
So it'll be like 784, right?

00:55:25.670 --> 00:55:28.670
And then output sizes colon, right,

00:55:28.670 --> 00:55:30.350
because we're talking about the number

00:55:30.350 --> 00:55:30.520
of.

00:55:32.050 --> 00:55:35.820
Out output size is the number of values

00:55:35.820 --> 00:55:36.795
that you're trying to predict.

00:55:36.795 --> 00:55:39.130
So for Digits it would be 10 all

00:55:39.130 --> 00:55:41.550
because that's the testing, that's the

00:55:41.550 --> 00:55:42.980
label side, the number of labels that

00:55:42.980 --> 00:55:43.400
you have.

00:55:43.400 --> 00:55:45.645
So it's a row of the test, right?

00:55:45.645 --> 00:55:46.580
That's would be my.

00:55:49.290 --> 00:55:51.140
But it's not the number of examples,

00:55:51.140 --> 00:55:52.560
it's a number of different labels that

00:55:52.560 --> 00:55:53.310
you can have.

00:55:53.310 --> 00:55:53.866
So doesn't.

00:55:53.866 --> 00:55:56.080
It's not really a row or a column,

00:55:56.080 --> 00:55:56.320
right?

00:55:57.500 --> 00:55:59.335
Because then you're data vectors you

00:55:59.335 --> 00:56:01.040
have like X which is number of examples

00:56:01.040 --> 00:56:02.742
by number of features, and then you

00:56:02.742 --> 00:56:04.328
have Y which is number of examples by

00:56:04.328 --> 00:56:04.549
1.

00:56:05.440 --> 00:56:07.580
But the out you have one output per

00:56:07.580 --> 00:56:10.410
label, so per class.

00:56:11.650 --> 00:56:12.460
There, it's 10.

00:56:13.080 --> 00:56:14.450
Because you have 10 digits.

00:56:14.450 --> 00:56:16.520
Alright, thank you.

00:56:16.520 --> 00:56:17.250
You're welcome.

00:56:29.150 --> 00:56:31.060
Alright, so let's try it.

00:56:31.160 --> 00:56:31.770


00:56:34.070 --> 00:56:37.195
So this is probably a hard question.

00:56:37.195 --> 00:56:40.160
You've just been exposed to Backprop,

00:56:40.160 --> 00:56:42.330
but I think solving it out loud will

00:56:42.330 --> 00:56:43.680
probably make this a little more clear.

00:56:43.680 --> 00:56:44.000
So.

00:56:44.730 --> 00:56:46.330
Gradient with respect to W.

00:56:46.330 --> 00:56:48.840
Does anyone have an idea what these

00:56:48.840 --> 00:56:49.810
blanks would be?

00:57:07.100 --> 00:57:08.815
It might be, I'm not sure.

00:57:08.815 --> 00:57:11.147
I'm not sure I can do it without the.

00:57:11.147 --> 00:57:13.710
I was not putting it in terms of

00:57:13.710 --> 00:57:16.000
derivatives though, just in terms of

00:57:16.000 --> 00:57:17.860
purely in terms of the X's.

00:57:17.860 --> 00:57:19.730
H is the G's and the W's.

00:57:21.200 --> 00:57:24.970
Alright, so part of it is that I would

00:57:24.970 --> 00:57:27.019
have how this.

00:57:27.020 --> 00:57:29.880
Here I have how this weight contributes

00:57:29.880 --> 00:57:30.560
to the output.

00:57:31.490 --> 00:57:34.052
So it's going to flow through these

00:57:34.052 --> 00:57:37.698
guys, right, goes through W7 and W3

00:57:37.698 --> 00:57:40.513
through G1 and it also flows through

00:57:40.513 --> 00:57:41.219
these guys.

00:57:42.790 --> 00:57:45.280
Right, so part of it will end up being

00:57:45.280 --> 00:57:48.427
W 0 times W 9 this path and part of it

00:57:48.427 --> 00:57:52.570
will be W 7 three times W 7 this path.

00:57:54.720 --> 00:57:57.500
So this is 1 portion like how it's

00:57:57.500 --> 00:57:58.755
influenced the output.

00:57:58.755 --> 00:58:00.610
This is my output gradient which I

00:58:00.610 --> 00:58:01.290
started with.

00:58:02.070 --> 00:58:04.486
My error gradient and then it's going

00:58:04.486 --> 00:58:07.100
to be multiplied by the input, which is

00:58:07.100 --> 00:58:09.220
like how the magnitude, how this

00:58:09.220 --> 00:58:11.610
Weights, whether it made a positive or

00:58:11.610 --> 00:58:13.050
negative number for example, and how

00:58:13.050 --> 00:58:15.900
big, and that's going to depend on X2.

00:58:16.940 --> 00:58:17.250
Right.

00:58:17.250 --> 00:58:18.230
So it's just the.

00:58:19.270 --> 00:58:21.670
The sum of the paths to the output

00:58:21.670 --> 00:58:23.250
times the Input, yeah.

00:58:27.530 --> 00:58:29.240
I'm computing the gradient with respect

00:58:29.240 --> 00:58:30.430
to weight here.

00:58:31.610 --> 00:58:32.030
Yeah.

00:58:33.290 --> 00:58:33.480
Yeah.

00:58:42.070 --> 00:58:45.172
Yeah, it's not like it's a.

00:58:45.172 --> 00:58:47.240
It's written as an undirected graph,

00:58:47.240 --> 00:58:49.390
but it's not like a.

00:58:49.390 --> 00:58:50.830
It doesn't imply a flow direction

00:58:50.830 --> 00:58:51.490
necessarily.

00:58:52.440 --> 00:58:54.790
But when you do, but we do think of it

00:58:54.790 --> 00:58:55.080
that way.

00:58:55.080 --> 00:58:56.880
So we think of forward as you're making

00:58:56.880 --> 00:58:59.480
a prediction and Backprop is your

00:58:59.480 --> 00:59:01.480
propagating the error gradients back to

00:59:01.480 --> 00:59:02.450
the Weights to update them.

00:59:04.440 --> 00:59:05.240
And then?

00:59:10.810 --> 00:59:13.260
Yeah, it doesn't imply causality or

00:59:13.260 --> 00:59:15.070
anything like that like a like a

00:59:15.070 --> 00:59:16.020
Bayesian network might.

00:59:19.570 --> 00:59:23.061
All right, and then with W 2, it'll be

00:59:23.061 --> 00:59:25.910
the connection of the output is through

00:59:25.910 --> 00:59:29.845
W 3, and the connection to the Input is

00:59:29.845 --> 00:59:32.400
H1, so it will be the output of H1

00:59:32.400 --> 00:59:34.240
times W 3.

00:59:39.320 --> 00:59:41.500
So that's for linear and then if you

00:59:41.500 --> 00:59:43.430
have non linear it will be.

00:59:43.510 --> 00:59:44.940
I like it.

00:59:44.940 --> 00:59:46.710
Will be longer, you'll have more.

00:59:46.710 --> 00:59:48.320
You'll have those nonlinearities like

00:59:48.320 --> 00:59:49.270
come into play, yeah?

00:59:58.440 --> 01:00:00.325
So it would end up being.

01:00:00.325 --> 01:00:03.420
So it's kind of like so I did it for a

01:00:03.420 --> 01:00:04.600
smaller function here.

01:00:05.290 --> 01:00:07.833
But if you take if you do the chain

01:00:07.833 --> 01:00:10.240
rule through, if you take the partial

01:00:10.240 --> 01:00:11.790
derivative and then you follow the

01:00:11.790 --> 01:00:13.430
chain rule or you expand your

01:00:13.430 --> 01:00:14.080
functions.

01:00:14.800 --> 01:00:15.930
Then you will.

01:00:16.740 --> 01:00:17.640
You'll get there.

01:00:18.930 --> 01:00:19.490
So.

01:00:21.900 --> 01:00:23.730
Mathematically, you would get there

01:00:23.730 --> 01:00:25.890
this way, and then in practice the way

01:00:25.890 --> 01:00:28.305
that it's implemented usually is that

01:00:28.305 --> 01:00:30.720
you would accumulate you can compute

01:00:30.720 --> 01:00:32.800
the contribution of the error.

01:00:33.680 --> 01:00:36.200
Each node like how this nodes output

01:00:36.200 --> 01:00:38.370
affected the error the error.

01:00:38.990 --> 01:00:41.489
And then you propagate and then you

01:00:41.490 --> 01:00:41.710
can.

01:00:42.380 --> 01:00:45.790
Can say that this Weights gradient is

01:00:45.790 --> 01:00:47.830
its error contribution on this node

01:00:47.830 --> 01:00:49.990
times the Input.

01:00:50.660 --> 01:00:52.460
And then you keep on like propagating

01:00:52.460 --> 01:00:54.110
that error contribution backwards

01:00:54.110 --> 01:00:56.220
recursively and then updating the

01:00:56.220 --> 01:00:57.650
previous layers we.

01:00:59.610 --> 01:01:01.980
So one thing I would like to clarify is

01:01:01.980 --> 01:01:04.190
that I'm not going to ask any questions

01:01:04.190 --> 01:01:07.016
about how you compute the.

01:01:07.016 --> 01:01:10.700
I'm not going to ask you guys in an

01:01:10.700 --> 01:01:13.130
exam like to compute the gradient or to

01:01:13.130 --> 01:01:13.980
perform Backprop.

01:01:14.840 --> 01:01:16.850
But I think it's important to

01:01:16.850 --> 01:01:20.279
understand this concept that the

01:01:20.280 --> 01:01:22.740
gradients are flowing back through the

01:01:22.740 --> 01:01:25.220
Weights and one consequence of that.

01:01:25.980 --> 01:01:27.640
Is that you can imagine if this layer

01:01:27.640 --> 01:01:29.930
were really deep, if any of these

01:01:29.930 --> 01:01:32.025
weights are zero, or if some fraction

01:01:32.025 --> 01:01:34.160
of them are zero, then it's pretty easy

01:01:34.160 --> 01:01:35.830
for this gradient to become zero, which

01:01:35.830 --> 01:01:36.950
means you don't get any update.

01:01:37.610 --> 01:01:39.240
And if you have Sigmoid adds, a lot of

01:01:39.240 --> 01:01:40.680
these weights are zero, which means

01:01:40.680 --> 01:01:42.260
that there's no updates flowing into

01:01:42.260 --> 01:01:43.870
the early layers, which is what

01:01:43.870 --> 01:01:44.720
cripples the learning.

01:01:45.520 --> 01:01:47.590
And even with raley's, if this gets

01:01:47.590 --> 01:01:50.020
really deep, then you end up with a lot

01:01:50.020 --> 01:01:52.790
of zeros and you end up also having the

01:01:52.790 --> 01:01:53.490
same problem.

01:01:54.880 --> 01:01:57.240
So that's going to foreshadowing some

01:01:57.240 --> 01:01:59.760
of the difficulties that neural

01:01:59.760 --> 01:02:00.500
networks will have.

01:02:02.140 --> 01:02:06.255
If I want to do optimization by SGD,

01:02:06.255 --> 01:02:09.250
then it's, then this is the basic

01:02:09.250 --> 01:02:09.525
algorithm.

01:02:09.525 --> 01:02:11.090
I split the data into batches.

01:02:11.090 --> 01:02:12.110
I set some learning rate.

01:02:13.170 --> 01:02:15.715
I go for each or for each epac POC.

01:02:15.715 --> 01:02:17.380
I do that so for each pass through the

01:02:17.380 --> 01:02:19.630
data for each batch I compute the

01:02:19.630 --> 01:02:20.120
output.

01:02:22.250 --> 01:02:23.010
My predictions.

01:02:23.010 --> 01:02:25.790
In other words, I Evaluate the loss, I

01:02:25.790 --> 01:02:27.160
compute the gradients with Back

01:02:27.160 --> 01:02:29.170
propagation, and then I update the

01:02:29.170 --> 01:02:29.660
weights.

01:02:29.660 --> 01:02:30.780
Those are the four steps.

01:02:31.910 --> 01:02:33.520
And I'll show you that how we do that

01:02:33.520 --> 01:02:36.700
in Code with torch in a minute, but

01:02:36.700 --> 01:02:37.110
first.

01:02:38.480 --> 01:02:40.550
Why go from Perceptrons to MLPS?

01:02:40.550 --> 01:02:43.310
So the big benefit is that we get a lot

01:02:43.310 --> 01:02:44.430
more expressivity.

01:02:44.430 --> 01:02:46.370
We can model potentially any function

01:02:46.370 --> 01:02:49.187
with MLPS, while with Perceptrons we

01:02:49.187 --> 01:02:50.910
can only model linear functions.

01:02:50.910 --> 01:02:52.357
So that's a big benefit.

01:02:52.357 --> 01:02:53.970
And of course like we could like

01:02:53.970 --> 01:02:55.670
manually project things into higher

01:02:55.670 --> 01:02:57.540
dimensions and use polar coordinates or

01:02:57.540 --> 01:02:58.790
squares or whatever.

01:02:58.790 --> 01:03:01.500
But the nice thing is that the MLP's

01:03:01.500 --> 01:03:03.650
you can optimize the features and your

01:03:03.650 --> 01:03:05.150
prediction at the same time to work

01:03:05.150 --> 01:03:06.050
well together.

01:03:06.050 --> 01:03:08.310
And so it takes the.

01:03:08.380 --> 01:03:10.719
Expert out of the loop a bit if you can

01:03:10.720 --> 01:03:12.320
do this really well, so you can just

01:03:12.320 --> 01:03:14.240
take your data and learn really good

01:03:14.240 --> 01:03:15.620
features and learn a really good

01:03:15.620 --> 01:03:16.230
prediction.

01:03:16.900 --> 01:03:19.570
Jointly, so that you can get a good

01:03:19.570 --> 01:03:22.220
predictor based on simple features.

01:03:24.090 --> 01:03:26.050
The problems are that the optimization

01:03:26.050 --> 01:03:29.640
is no longer convex, you can get stuck

01:03:29.640 --> 01:03:30.480
in local minima.

01:03:30.480 --> 01:03:31.930
You're no longer guaranteed to reach a

01:03:31.930 --> 01:03:33.440
globally optimum solution.

01:03:33.440 --> 01:03:34.560
I'm going to talk more about

01:03:34.560 --> 01:03:37.210
optimization and this issue next class.

01:03:37.840 --> 01:03:39.730
You also have a larger model, which

01:03:39.730 --> 01:03:41.265
means more training and inference time

01:03:41.265 --> 01:03:43.299
and also more data is required to get a

01:03:43.300 --> 01:03:43.828
good fit.

01:03:43.828 --> 01:03:45.870
You have higher, lower, in other words,

01:03:45.870 --> 01:03:47.580
the MLP has lower bias and higher

01:03:47.580 --> 01:03:48.270
variance.

01:03:48.270 --> 01:03:50.840
And also you get additional error due

01:03:50.840 --> 01:03:53.330
to the challenge of optimization.

01:03:53.330 --> 01:03:56.594
So even though the theory is that you

01:03:56.594 --> 01:03:59.316
can fit that, there is a function that

01:03:59.316 --> 01:04:01.396
the MLP, the MLP can represent any

01:04:01.396 --> 01:04:01.623
function.

01:04:01.623 --> 01:04:02.960
It doesn't mean you can find it.

01:04:03.840 --> 01:04:05.400
So it's not enough that it has

01:04:05.400 --> 01:04:07.010
essentially 0 bias.

01:04:07.010 --> 01:04:09.400
If you have a really huge network, you

01:04:09.400 --> 01:04:10.770
may still not be able to fit your

01:04:10.770 --> 01:04:12.826
training data because of the deficiency

01:04:12.826 --> 01:04:14.230
of your optimization.

01:04:16.960 --> 01:04:20.370
Alright, so now let's see.

01:04:20.370 --> 01:04:21.640
I don't need to open a new one.

01:04:23.140 --> 01:04:24.310
Go back to the old one.

01:04:24.310 --> 01:04:25.990
OK, so now let's see how this works.

01:04:25.990 --> 01:04:28.370
So now I've got torch torches or

01:04:28.370 --> 01:04:29.580
framework for deep learning.

01:04:30.710 --> 01:04:33.429
And I'm specifying a model.

01:04:33.430 --> 01:04:35.609
So in torch you specify a model and

01:04:35.610 --> 01:04:38.030
I've got two models specified here.

01:04:38.850 --> 01:04:41.170
One has a linear layer that goes from

01:04:41.170 --> 01:04:43.850
Input size to hidden size.

01:04:43.850 --> 01:04:45.230
In this example it's just from 2

01:04:45.230 --> 01:04:46.850
because I'm doing 2 dimensional problem

01:04:46.850 --> 01:04:49.270
for visualization and a hidden size

01:04:49.270 --> 01:04:51.180
which I'll set when I call the model.

01:04:52.460 --> 01:04:55.225
Then I've got a Relu so do the Max of

01:04:55.225 --> 01:04:57.620
the input and zero.

01:04:57.620 --> 01:05:00.470
Then I have a linear function.

01:05:00.660 --> 01:05:03.500
That then maps into my output size,

01:05:03.500 --> 01:05:04.940
which in this case is 1 because I'm

01:05:04.940 --> 01:05:06.550
just doing classification binary

01:05:06.550 --> 01:05:09.000
classification and then I do I put a

01:05:09.000 --> 01:05:10.789
Sigmoid here to map it from zero to 1.

01:05:12.820 --> 01:05:14.800
And then I also defined A2 layer

01:05:14.800 --> 01:05:17.459
network where I pass in a two-part

01:05:17.460 --> 01:05:20.400
hidden size and I have linear layer

01:05:20.400 --> 01:05:22.290
Velu, linear layer we're fully

01:05:22.290 --> 01:05:24.310
connected layer Relu.

01:05:25.490 --> 01:05:28.180
Then my output layer and then Sigmoid.

01:05:28.880 --> 01:05:30.800
So this defines my network structure

01:05:30.800 --> 01:05:31.110
here.

01:05:32.610 --> 01:05:36.820
And then my forward, because I'm using

01:05:36.820 --> 01:05:39.540
this sequential, if I just call self

01:05:39.540 --> 01:05:42.140
doubt layers it just does like step

01:05:42.140 --> 01:05:43.239
through the layers.

01:05:43.240 --> 01:05:46.040
So it means that it goes from the input

01:05:46.040 --> 01:05:47.464
to this layer, to this layer, to this

01:05:47.464 --> 01:05:49.060
layer to list layer, blah blah blah all

01:05:49.060 --> 01:05:49.985
the way through.

01:05:49.985 --> 01:05:52.230
You can also just define these layers

01:05:52.230 --> 01:05:53.904
separately outside of sequential and

01:05:53.904 --> 01:05:56.640
then you're forward will be like X

01:05:56.640 --> 01:05:57.715
equals.

01:05:57.715 --> 01:06:00.500
You name the layers and then you say

01:06:00.500 --> 01:06:02.645
like you call them one by one and

01:06:02.645 --> 01:06:03.190
you're forward.

01:06:03.750 --> 01:06:04.320
Step here.

01:06:06.460 --> 01:06:08.290
Here's the training code.

01:06:08.980 --> 01:06:10.410
I've got my.

01:06:11.000 --> 01:06:14.280
I've got my X training and my train and

01:06:14.280 --> 01:06:14.980
some model.

01:06:16.010 --> 01:06:19.009
And I need to make them into torch

01:06:19.010 --> 01:06:21.350
tensors, like a data structure that

01:06:21.350 --> 01:06:22.270
torch can use.

01:06:22.270 --> 01:06:24.946
So I call this torch tensor X and torch

01:06:24.946 --> 01:06:27.930
tensor reshaping Y into a column vector

01:06:27.930 --> 01:06:31.000
in case it was a north comma vector.

01:06:33.020 --> 01:06:34.110
And.

01:06:34.180 --> 01:06:37.027
And then I so that creates a train set

01:06:37.027 --> 01:06:38.847
and then I call my data loader.

01:06:38.847 --> 01:06:40.380
So the data loader is just something

01:06:40.380 --> 01:06:42.440
that deals with all that shuffling and

01:06:42.440 --> 01:06:43.890
loading and all of that stuff.

01:06:43.890 --> 01:06:47.105
For you can give it like your source of

01:06:47.105 --> 01:06:48.360
data, or you can give it the data

01:06:48.360 --> 01:06:50.795
directly and it will handle the

01:06:50.795 --> 01:06:52.210
shuffling and stepping.

01:06:52.210 --> 01:06:54.530
So I give it a batch size, told it to

01:06:54.530 --> 01:06:57.026
Shuffle, told it how many CPU threads

01:06:57.026 --> 01:06:57.760
it can use.

01:06:58.670 --> 01:06:59.780
And I gave it the data.

01:07:01.670 --> 01:07:04.240
I set my loss to binary cross entropy

01:07:04.240 --> 01:07:07.515
loss, which is just the log probability

01:07:07.515 --> 01:07:09.810
loss in the case of a binary

01:07:09.810 --> 01:07:10.500
classifier.

01:07:11.950 --> 01:07:15.920
And I'm using an atom optimizer because

01:07:15.920 --> 01:07:18.680
it's a little more friendly than SGD.

01:07:18.680 --> 01:07:20.310
I'll talk about Adam in the next class.

01:07:23.140 --> 01:07:25.320
Then I'm doing epoch, so I'm stepping

01:07:25.320 --> 01:07:27.282
through my data or cycling through my

01:07:27.282 --> 01:07:28.580
data number of epochs.

01:07:30.020 --> 01:07:32.370
Then I'm stepping through my batches,

01:07:32.370 --> 01:07:34.260
enumerating my train loader.

01:07:34.260 --> 01:07:35.830
It gets each batch.

01:07:37.120 --> 01:07:39.160
I split the data into the targets and

01:07:39.160 --> 01:07:40.190
the inputs.

01:07:40.190 --> 01:07:42.350
I zero out my gradients.

01:07:43.260 --> 01:07:44.790
I.

01:07:45.780 --> 01:07:48.280
Make my prediction which is just MLP

01:07:48.280 --> 01:07:48.860
inputs.

01:07:50.710 --> 01:07:53.040
Then I call my loss function.

01:07:53.040 --> 01:07:55.030
So I compute the loss based on my

01:07:55.030 --> 01:07:56.410
outputs and my targets.

01:07:57.610 --> 01:07:59.930
Then I do Back propagation loss dot

01:07:59.930 --> 01:08:01.450
backwards, backward.

01:08:02.740 --> 01:08:04.550
And then I tell the optimizer to step

01:08:04.550 --> 01:08:06.954
so it updates the Weights based on that

01:08:06.954 --> 01:08:08.440
based on that loss.

01:08:10.180 --> 01:08:11.090
And that's it.

01:08:12.100 --> 01:08:13.600
And then keep looping through the

01:08:13.600 --> 01:08:14.620
through the batches.

01:08:14.620 --> 01:08:16.800
So code wise is pretty simple.

01:08:16.800 --> 01:08:18.360
Computing partial derivatives of

01:08:18.360 --> 01:08:20.730
complex functions is not so simple, but

01:08:20.730 --> 01:08:22.250
implementing it in torch is simple.

01:08:23.540 --> 01:08:26.270
And then I'm just like doing some

01:08:26.270 --> 01:08:28.180
record keeping to compute accuracy and

01:08:28.180 --> 01:08:30.720
losses and then record it and plot it,

01:08:30.720 --> 01:08:31.200
all right.

01:08:31.200 --> 01:08:33.340
So let's go back to those same

01:08:33.340 --> 01:08:33.820
problems.

01:08:39.330 --> 01:08:41.710
So I've got some.

01:08:43.730 --> 01:08:45.480
And then here I just have like a

01:08:45.480 --> 01:08:47.040
prediction function that I'm using for

01:08:47.040 --> 01:08:47.540
display.

01:08:50.720 --> 01:08:52.800
Alright, so here's my loss.

01:08:52.800 --> 01:08:54.570
A nice descent.

01:08:55.890 --> 01:08:59.330
And my accuracy goes up to close to 1.

01:09:00.670 --> 01:09:03.660
And this is now on this like curved

01:09:03.660 --> 01:09:04.440
problem, right?

01:09:04.440 --> 01:09:07.020
So this is one that the Perceptron

01:09:07.020 --> 01:09:09.480
couldn't fit exactly, but here I get

01:09:09.480 --> 01:09:11.410
like a pretty good fit OK.

01:09:12.240 --> 01:09:14.000
Still not perfect, but if I add more

01:09:14.000 --> 01:09:16.190
nodes or optimize further, I can

01:09:16.190 --> 01:09:17.310
probably fit these guys too.

01:09:19.890 --> 01:09:20.830
So that's cool.

01:09:22.390 --> 01:09:24.660
Just for my own sanity checks, I tried

01:09:24.660 --> 01:09:29.265
using the MLP in SKLEARN and it gives

01:09:29.265 --> 01:09:30.210
the same result.

01:09:31.580 --> 01:09:33.170
Show you similar result.

01:09:33.170 --> 01:09:35.779
Anyway, so here I SET Max Iters, I set

01:09:35.780 --> 01:09:36.930
some network size.

01:09:37.720 --> 01:09:40.270
Here's using Sklearn and did like

01:09:40.270 --> 01:09:42.890
bigger optimization so better fit.

01:09:43.840 --> 01:09:44.910
But basically the same thing.

01:09:46.780 --> 01:09:51.090
And then here I can let's try the other

01:09:51.090 --> 01:09:51.770
One South.

01:09:51.770 --> 01:09:54.800
Let's do a one layer network with 100

01:09:54.800 --> 01:09:56.140
nodes hidden.

01:10:02.710 --> 01:10:03.760
It's optimizing.

01:10:03.760 --> 01:10:04.710
It'll take a little bit.

01:10:06.550 --> 01:10:10.550
I'm just using CPU so it did decrease

01:10:10.550 --> 01:10:11.300
the loss.

01:10:11.300 --> 01:10:13.790
It got pretty good error but not

01:10:13.790 --> 01:10:14.280
perfect.

01:10:14.280 --> 01:10:15.990
It didn't like fit that little circle

01:10:15.990 --> 01:10:16.470
in there.

01:10:17.460 --> 01:10:18.580
It kind of went around.

01:10:18.580 --> 01:10:20.150
It decided to.

01:10:21.030 --> 01:10:22.950
These guys are not important enough and

01:10:22.950 --> 01:10:24.880
justice fit everything in there.

01:10:25.880 --> 01:10:27.160
If I run it with different random

01:10:27.160 --> 01:10:29.145
seeds, sometimes it will fit that even

01:10:29.145 --> 01:10:31.980
with one layer, but let's go with two

01:10:31.980 --> 01:10:32.370
layers.

01:10:32.370 --> 01:10:33.779
So now I'm going to train the two layer

01:10:33.780 --> 01:10:35.550
network, each with the hidden size of

01:10:35.550 --> 01:10:36.040
50.

01:10:37.970 --> 01:10:39.090
And try it again.

01:10:44.940 --> 01:10:45.870
Executing.

01:10:48.470 --> 01:10:50.430
All right, so now here's my loss

01:10:50.430 --> 01:10:51.120
function.

01:10:52.940 --> 01:10:54.490
Still going down, if I trained it

01:10:54.490 --> 01:10:55.790
further I'd probably decrease the loss

01:10:55.790 --> 01:10:56.245
further.

01:10:56.245 --> 01:10:58.710
My error is like my accuracy is super

01:10:58.710 --> 01:10:59.440
close to 1.

01:11:00.180 --> 01:11:02.580
And you can see that it fit both these

01:11:02.580 --> 01:11:03.940
guys pretty well, right?

01:11:03.940 --> 01:11:05.696
So with the more layers I got like a

01:11:05.696 --> 01:11:07.270
more easier to get a more expressive

01:11:07.270 --> 01:11:07.710
function.

01:11:08.350 --> 01:11:10.020
That could deal with these different

01:11:10.020 --> 01:11:11.200
parts of the feature space.

01:11:18.170 --> 01:11:20.270
I also want to show you this demo.

01:11:20.270 --> 01:11:22.710
This is like so cool I think.

01:11:24.820 --> 01:11:26.190
I realized that this was here before.

01:11:26.190 --> 01:11:27.820
I might not have even made another

01:11:27.820 --> 01:11:28.340
demo, but.

01:11:29.010 --> 01:11:32.723
So this so here you get to choose your

01:11:32.723 --> 01:11:33.126
problem.

01:11:33.126 --> 01:11:34.910
So like let's say this problem.

01:11:35.590 --> 01:11:39.340
And you choose your number of layers,

01:11:39.340 --> 01:11:41.400
and you choose the number of neurons,

01:11:41.400 --> 01:11:43.072
and you choose your learning rate, and

01:11:43.072 --> 01:11:44.320
you choose your activation function.

01:11:44.940 --> 01:11:45.850
And then you can't play.

01:11:46.430 --> 01:11:50.490
And then it optimizes and it shows you

01:11:50.490 --> 01:11:52.100
like the function that's fitting.

01:11:53.140 --> 01:11:54.600
And this.

01:11:56.140 --> 01:11:57.690
Alright, I think, is it making

01:11:57.690 --> 01:11:58.065
progress?

01:11:58.065 --> 01:12:00.210
It's getting there, it's maybe doing

01:12:00.210 --> 01:12:00.890
things.

01:12:00.890 --> 01:12:03.380
So here I'm doing a Sigmoid with just

01:12:03.380 --> 01:12:04.760
these few neurons.

01:12:05.500 --> 01:12:09.279
And these two inputs so just X1 and X2.

01:12:09.970 --> 01:12:12.170
And then it's trying to predict two

01:12:12.170 --> 01:12:12.580
values.

01:12:12.580 --> 01:12:14.100
So it took a long time.

01:12:14.100 --> 01:12:16.520
It was started in a big plateau, but it

01:12:16.520 --> 01:12:18.103
eventually got there alright.

01:12:18.103 --> 01:12:20.710
So this Sigmoid did OK this time.

01:12:22.330 --> 01:12:25.270
And let's give it a harder problem.

01:12:25.270 --> 01:12:27.980
So this guy is really tough.

01:12:29.770 --> 01:12:31.770
Now it's not going to be able to do it,

01:12:31.770 --> 01:12:32.740
I don't think.

01:12:32.740 --> 01:12:33.720
Maybe.

01:12:35.540 --> 01:12:37.860
It's going somewhere.

01:12:37.860 --> 01:12:39.450
I don't think it has enough expressive

01:12:39.450 --> 01:12:41.630
power to fit this weird spiral.

01:12:42.800 --> 01:12:44.320
But I'll let it run for a little bit to

01:12:44.320 --> 01:12:44.890
see.

01:12:44.890 --> 01:12:46.180
So it's going to try to do some

01:12:46.180 --> 01:12:46.880
approximation.

01:12:46.880 --> 01:12:48.243
The loss over here is going.

01:12:48.243 --> 01:12:49.623
It's gone down a little bit.

01:12:49.623 --> 01:12:50.815
So it did something.

01:12:50.815 --> 01:12:53.090
It got better than chance, but still

01:12:53.090 --> 01:12:53.710
not great.

01:12:53.710 --> 01:12:54.410
Let me stop it.

01:12:55.120 --> 01:12:58.015
So let's add some more layers.

01:12:58.015 --> 01:13:00.530
Let's make it super powerful.

01:13:08.430 --> 01:13:10.200
And then let's run it.

01:13:13.620 --> 01:13:15.380
And it's like not doing anything.

01:13:16.770 --> 01:13:18.540
Yeah, you can't do anything.

01:13:20.290 --> 01:13:22.140
Because it's got all these, it's pretty

01:13:22.140 --> 01:13:25.240
slow too and it's sigmoids.

01:13:25.240 --> 01:13:26.500
I mean it looks like it's doing

01:13:26.500 --> 01:13:29.385
something but it's in like 6 digit or

01:13:29.385 --> 01:13:29.650
something.

01:13:30.550 --> 01:13:33.180
Alright, so now let's try Relu.

01:13:37.430 --> 01:13:38.340
Is it gonna work?

01:13:42.800 --> 01:13:43.650
Go in.

01:13:48.120 --> 01:13:49.100
It is really slow.

01:13:51.890 --> 01:13:52.910
It's getting there.

01:14:06.670 --> 01:14:08.420
And you can see what's so cool is like

01:14:08.420 --> 01:14:08.972
each of these.

01:14:08.972 --> 01:14:10.298
You can see what they're predicting,

01:14:10.298 --> 01:14:12.080
what each of these nodes is

01:14:12.080 --> 01:14:12.860
representing.

01:14:14.230 --> 01:14:16.340
It's slow because it's calculating all

01:14:16.340 --> 01:14:17.830
this stuff and you can see the gradient

01:14:17.830 --> 01:14:18.880
visualization.

01:14:18.880 --> 01:14:20.920
See all these gradients flowing through

01:14:20.920 --> 01:14:21.170
here.

01:14:22.710 --> 01:14:25.450
Though it did it like it's pretty good,

01:14:25.450 --> 01:14:26.970
the loss is really low.

01:14:30.590 --> 01:14:32.530
I mean it's getting all that data

01:14:32.530 --> 01:14:32.900
correct.

01:14:32.900 --> 01:14:34.460
It might be overfitting a little bit or

01:14:34.460 --> 01:14:35.740
not fitting perfectly but.

01:14:36.870 --> 01:14:39.140
Still optimizing and then if I want to

01:14:39.140 --> 01:14:40.710
lower my learning rate.

01:14:41.460 --> 01:14:41.890
Let's.

01:14:44.580 --> 01:14:46.060
Then it will like optimize a little

01:14:46.060 --> 01:14:46.480
more.

01:14:46.480 --> 01:14:48.610
OK, so basically though it did it and

01:14:48.610 --> 01:14:49.720
notice that there's like a lot of

01:14:49.720 --> 01:14:50.640
strong gradients here.

01:14:51.410 --> 01:14:54.430
We're with this Sigmoid the problem.

01:14:55.430 --> 01:14:58.060
Is that it's all like low gradients.

01:14:58.060 --> 01:15:00.120
There's no strong lines here because

01:15:00.120 --> 01:15:01.760
this Sigmoid has those low Values.

01:15:03.620 --> 01:15:04.130
All right.

01:15:04.820 --> 01:15:06.770
So you guys can play with that more.

01:15:06.770 --> 01:15:07.660
It's pretty fun.

01:15:08.820 --> 01:15:12.570
And then will, I am out of time.

01:15:12.570 --> 01:15:14.500
So I'm going to talk about these things

01:15:14.500 --> 01:15:15.655
at the start of the next class.

01:15:15.655 --> 01:15:17.180
You have everything that you need now

01:15:17.180 --> 01:15:18.120
to do homework 2.

01:15:19.250 --> 01:15:22.880
And so next class I'm going to talk

01:15:22.880 --> 01:15:24.800
about deep learning.

01:15:25.980 --> 01:15:28.270
And then I've got a review after that.

01:15:28.270 --> 01:15:29.430
Thank you.

01:15:31.290 --> 01:15:32.530
I got some questions.