WEBVTT

00:00.420 --> 00:02.850
-: Hello and welcome to this tutorial.

00:02.850 --> 00:05.820
In the previous tutorial, we initialized the map.

00:05.820 --> 00:07.830
And now, time for the exciting stuff.

00:07.830 --> 00:09.900
We create the car.

00:09.900 --> 00:12.060
And we do that with a class of course.

00:12.060 --> 00:14.580
You will see that the class is very practical

00:14.580 --> 00:18.360
to create some things that have a lot of properties,

00:18.360 --> 00:19.560
because as you can see,

00:19.560 --> 00:22.470
not only I'm defining some variables for my car,

00:22.470 --> 00:24.570
but also some functions,

00:24.570 --> 00:27.150
which of course is the function that will make the car

00:27.150 --> 00:30.660
move to the left, to the right, or going straight.

00:30.660 --> 00:32.400
So we have a couple of variables

00:32.400 --> 00:35.190
that are important to describe the environment.

00:35.190 --> 00:36.870
We have, for example, the angle,

00:36.870 --> 00:39.120
which is the angle between the X-axis

00:39.120 --> 00:42.600
and the axis of the direction of the car.

00:42.600 --> 00:46.230
Then we have the rotation, which is its last rotation,

00:46.230 --> 00:48.930
which remembers either zero degree,

00:48.930 --> 00:51.540
20 degrees, or minus 20 degrees.

00:51.540 --> 00:53.430
Then we have the velocity,

00:53.430 --> 00:55.890
the X-coordinate of the velocity vector

00:55.890 --> 00:58.440
and the Y-coordinate of the velocity vector,

00:58.440 --> 00:59.730
and then the vector

00:59.730 --> 01:03.390
of coordinates velocity X and velocity Y.

01:03.390 --> 01:05.790
Then we have the sensors and the signals,

01:05.790 --> 01:07.380
and that's very important.

01:07.380 --> 01:10.470
The car that we're making will have three sensors,

01:10.470 --> 01:13.470
sensor one, sensor two, and sensor three.

01:13.470 --> 01:15.870
Sensor one will be detecting

01:15.870 --> 01:18.420
if there is any sand in front of the car.

01:18.420 --> 01:21.540
Then sensor two is the sensor that will detect

01:21.540 --> 01:24.420
if there is any sand at the left of the car.

01:24.420 --> 01:27.000
And sensor three is the sensor that will detect

01:27.000 --> 01:29.910
if there is any sand at the right of the car.

01:29.910 --> 01:33.930
And then from these three sensors, we get the signals,

01:33.930 --> 01:37.290
that is the signals received by each of the sensors.

01:37.290 --> 01:40.350
So signal one is the signal received by sensor one.

01:40.350 --> 01:43.110
Signal two is the signal received by sensor two,

01:43.110 --> 01:46.410
and signal three is the signal received by sensor three.

01:46.410 --> 01:47.760
And so how does it work?

01:47.760 --> 01:51.900
Signal one is the density of sand around sensor one,

01:51.900 --> 01:54.660
signal two is the density of sand around sensor two,

01:54.660 --> 01:58.260
and signal three is the density of sand around sensor three.

01:58.260 --> 02:00.660
And how do we compute this density of sand?

02:00.660 --> 02:01.710
Well, that's very simple.

02:01.710 --> 02:06.120
We take some big squares around each of the sensors.

02:06.120 --> 02:09.030
These are actually squares of 200 by 200.

02:09.030 --> 02:10.500
And for each of the squares,

02:10.500 --> 02:13.170
we divide the number of ones in the square

02:13.170 --> 02:15.360
by the total number of cells in the square.

02:15.360 --> 02:18.030
That is, 20 times 20 equals 400.

02:18.030 --> 02:20.220
And that gives us the density of sand

02:20.220 --> 02:22.590
because the ones correspond to the sand.

02:22.590 --> 02:24.390
We do this for each sensor,

02:24.390 --> 02:26.580
and that gives us the density of sand

02:26.580 --> 02:29.610
around each sensor, that is, the signals.

02:29.610 --> 02:31.950
All right, so now we have everything to detect the sand

02:31.950 --> 02:35.460
and then we have the move function.

02:35.460 --> 02:38.100
And of course, the move function is what will allow the car

02:38.100 --> 02:41.880
to go to the left, going straight, or going to the right.

02:41.880 --> 02:43.350
So let's go through it quickly.

02:43.350 --> 02:46.890
We have here the update of the position of the car

02:46.890 --> 02:50.700
with its last position, which is self.pos here,

02:50.700 --> 02:52.530
and the velocity vector.

02:52.530 --> 02:54.900
So thanks to the velocity vector,

02:54.900 --> 02:56.520
the position will be updated

02:56.520 --> 02:58.890
in the direction of the velocity vector.

02:58.890 --> 03:01.200
Then we get the rotation,

03:01.200 --> 03:05.280
which we will get further down in the code right here.

03:05.280 --> 03:08.040
Rotation equals action-to-rotation action.

03:08.040 --> 03:09.480
Here we will select the action

03:09.480 --> 03:11.400
and then getting the rotation.

03:11.400 --> 03:15.600
And so, this self-rotation equals rotation here

03:15.600 --> 03:17.580
is this rotation that we get

03:17.580 --> 03:19.740
to know how we need to rotate the car

03:19.740 --> 03:22.410
that is going to the left or to the right.

03:22.410 --> 03:24.540
Then we update the angle,

03:24.540 --> 03:27.240
which I remind is the angle between the X-axis

03:27.240 --> 03:29.580
and the axis of the direction of the car.

03:29.580 --> 03:31.350
And then once the car has moved,

03:31.350 --> 03:34.650
then we have to update the sensors and the signal.

03:34.650 --> 03:37.560
Because of course, when the car has just rotated,

03:37.560 --> 03:39.900
well, the sensors have rotated as well,

03:39.900 --> 03:41.910
and therefore we need to rotate them

03:41.910 --> 03:43.590
by using the rotate function

03:43.590 --> 03:45.720
and to which we add the new position.

03:45.720 --> 03:49.080
And why do we have this vector of 30,0?

03:49.080 --> 03:51.930
Well, that's simply because 30 is the distance

03:51.930 --> 03:54.090
between the car and the sensor.

03:54.090 --> 03:56.220
You know it is the distance between the car

03:56.220 --> 03:59.160
and what the car detects.

03:59.160 --> 04:01.890
And then once the sensors are updated,

04:01.890 --> 04:04.230
well, then it's time to update the signals.

04:04.230 --> 04:05.910
And so here we do exactly what I explained

04:05.910 --> 04:07.200
to compute the signals.

04:07.200 --> 04:09.570
We get the X-coordinate of our sensor.

04:09.570 --> 04:13.350
Then we take all the cells from minus 10 to plus 10.

04:13.350 --> 04:15.420
Then we do the same for the Y-coordinate,

04:15.420 --> 04:19.080
taking all the cells from minus 10 to plus 10.

04:19.080 --> 04:23.250
So therefore, we get the square of 20 by 20 pixels

04:23.250 --> 04:24.990
surrounding the sensor.

04:24.990 --> 04:28.260
And inside this square, we sum all the ones.

04:28.260 --> 04:29.880
So basically, we sum all the cells,

04:29.880 --> 04:33.120
because the cells contain either zero or one.

04:33.120 --> 04:33.953
And since

04:33.953 --> 04:38.160
in a 20-by-20 square, there is 20 times 20 equals 400 cells,

04:38.160 --> 04:40.200
well, we divided by 400

04:40.200 --> 04:43.500
to get the density of ones inside the square.

04:43.500 --> 04:45.720
And that's how we get the signal

04:45.720 --> 04:48.570
of the density of sand around the sensor.

04:48.570 --> 04:51.060
And we do the same for the second sensor

04:51.060 --> 04:52.350
and the third sensor

04:52.350 --> 04:55.110
to get the second signal and the third signal.

04:55.110 --> 04:56.940
Okay, so that's to detect the sand.

04:56.940 --> 05:00.210
And then the three lines of code here are very important.

05:00.210 --> 05:03.270
It's another bad reward that we want to give to our car

05:03.270 --> 05:06.450
when it is reaching one of the edges of the map.

05:06.450 --> 05:09.420
We don't want the car to rush into some walls

05:09.420 --> 05:11.220
and therefore we want to penalize it,

05:11.220 --> 05:14.610
to punish it when it's getting too close to a wall.

05:14.610 --> 05:16.590
And therefore, that's what we do here.

05:16.590 --> 05:20.460
If the first sensor is larger than longer minus 10,

05:20.460 --> 05:23.160
that is, larger than here,

05:23.160 --> 05:25.200
because longer is this distance here.

05:25.200 --> 05:27.570
So longer minus 10 is right here.

05:27.570 --> 05:31.080
So if sensor one X larger than longer minus 10

05:31.080 --> 05:33.540
concerns all the points that are here,

05:33.540 --> 05:35.700
that is, if the car is getting closer

05:35.700 --> 05:37.740
to the right edge of the map.

05:37.740 --> 05:42.480
Or if cell sensor one X lower than 10, that's right here,

05:42.480 --> 05:45.900
if the car is getting closer to the left edge of the map.

05:45.900 --> 05:49.680
Or if sensor y is larger than larger minus 10,

05:49.680 --> 05:52.140
that's the upper edge of the map.

05:52.140 --> 05:55.680
And or if self-sensor y is lower than 10,

05:55.680 --> 05:58.680
that is, the lower edge of the map.

05:58.680 --> 06:01.590
And so if the sensor one is reaching

06:01.590 --> 06:03.180
any of these four edges,

06:03.180 --> 06:06.480
well, we will put the signal of the sensor,

06:06.480 --> 06:08.790
signal one is the signal of sensor one,

06:08.790 --> 06:10.500
we will set it to be one.

06:10.500 --> 06:11.610
And what does that mean?

06:11.610 --> 06:15.540
That means full sand, like the full density of sand.

06:15.540 --> 06:17.280
It's like the worst sand you could get.

06:17.280 --> 06:19.650
There is so much sand that it's going to stop your car.

06:19.650 --> 06:21.120
So signal will be one,

06:21.120 --> 06:24.450
and therefore the car will get a terribly bad reward.

06:24.450 --> 06:26.550
All right, and then we do the same for signal two

06:26.550 --> 06:29.553
and signal three from sensor two and sensor three.

06:30.390 --> 06:33.030
All right. And then we create the Game class.

06:33.030 --> 06:35.640
So that's basically the class to create the game

06:35.640 --> 06:38.460
because so far we have only created the car.

06:38.460 --> 06:40.770
And now of course, we have to create the map.

06:40.770 --> 06:42.360
We have to create the game itself.

06:42.360 --> 06:44.520
So we will not be playing the game.

06:44.520 --> 06:46.920
It's our AI that will be playing the game.

06:46.920 --> 06:48.900
And the game is actually to avoid the obstacles

06:48.900 --> 06:52.500
and to go from the airport to downtown and vice versa.

06:52.500 --> 06:54.360
So in this Game class,

06:54.360 --> 06:57.570
we need to create some objects, like the car.

06:57.570 --> 07:00.570
Then we need to define the update function.

07:00.570 --> 07:01.770
That is the most important

07:01.770 --> 07:03.870
and actually we will focus on that right now,

07:03.870 --> 07:05.730
because that's in this update function

07:05.730 --> 07:09.570
that we will select the action that the car has to do

07:09.570 --> 07:12.330
at each time to accomplish its goal.

07:12.330 --> 07:16.830
And this action is exactly the output of our neural network,

07:16.830 --> 07:18.960
the neural network that will be at the heart

07:18.960 --> 07:20.760
of our artificial intelligence.

07:20.760 --> 07:24.240
And so this action is returned by the brain of the car,

07:24.240 --> 07:27.420
which I remind is the object of our DQN class

07:27.420 --> 07:29.880
that we'll be making in our AI file.

07:29.880 --> 07:33.420
And this object has a method that is called update,

07:33.420 --> 07:37.590
and it takes as input the last reward and the last signal.

07:37.590 --> 07:40.140
So the last reward is of course the last reward obtained

07:40.140 --> 07:41.220
by the car.

07:41.220 --> 07:44.430
And the last signal is of course the last signal

07:44.430 --> 07:45.630
of the three sensors.

07:45.630 --> 07:47.580
Signal one from sensor one.

07:47.580 --> 07:49.350
Signal two from sensor two.

07:49.350 --> 07:51.420
Signal three from sensor three.

07:51.420 --> 07:53.490
But then I'm adding two other inputs,

07:53.490 --> 07:55.200
which is the orientation of the car

07:55.200 --> 07:56.880
with respect to the goal.

07:56.880 --> 07:59.490
So for example, if the car is heading towards the goal,

07:59.490 --> 08:01.680
then the orientation will be equal to zero.

08:01.680 --> 08:03.840
If it goes slightly to the right,

08:03.840 --> 08:06.900
then the orientation will be close to 45 degrees.

08:06.900 --> 08:08.520
And if it goes slightly to the left,

08:08.520 --> 08:11.880
the orientation will be close to minus 45 degrees.

08:11.880 --> 08:15.390
So that's the fourth input of our input state.

08:15.390 --> 08:18.990
And then there's a last input, which is minus orientation.

08:18.990 --> 08:22.590
So usually, the inputs of a neural network are independent.

08:22.590 --> 08:24.750
There is no multicollinearity.

08:24.750 --> 08:26.340
But it doesn't really matter if we add this

08:26.340 --> 08:28.470
because the neural network will just fix that

08:28.470 --> 08:29.460
with the weights.

08:29.460 --> 08:33.570
But still, I noticed that by adding this minus orientation,

08:33.570 --> 08:34.860
well, that allows the car,

08:34.860 --> 08:38.190
the training of the car, to stabilize the exploration.

08:38.190 --> 08:41.370
We're doing this so that the AI doesn't always explore

08:41.370 --> 08:42.780
in the same direction.

08:42.780 --> 08:44.400
By adding this minus orientation,

08:44.400 --> 08:47.820
we make sure that it explores in both directions,

08:47.820 --> 08:48.900
right or left.

08:48.900 --> 08:49.800
And so this,

08:49.800 --> 08:53.670
the three signals plus the orientation and minus orientation

08:53.670 --> 08:57.060
are the five inputs of our encoded vector,

08:57.060 --> 08:59.040
which will go into the network.

08:59.040 --> 09:02.880
That's our input vector that will go into the network.

09:02.880 --> 09:04.920
And after it goes into the network,

09:04.920 --> 09:07.830
well, the network returns the output,

09:07.830 --> 09:10.740
which is the action to play at each time.

09:10.740 --> 09:13.560
And the output is returned by this update function

09:13.560 --> 09:15.150
that contents the network itself

09:15.150 --> 09:16.770
and the output of the network.

09:16.770 --> 09:19.770
And therefore, that's why we have to input the last signal,

09:19.770 --> 09:21.240
that is, the input state,

09:21.240 --> 09:22.530
and also the last reward

09:22.530 --> 09:26.910
because the action to play also depends on the last reward.

09:26.910 --> 09:30.330
All right. And then we update the mean score of the rewards.

09:30.330 --> 09:32.370
We update the rotation.

09:32.370 --> 09:35.220
We use the move function to rotate the car

09:35.220 --> 09:37.440
according to the action that was selected.

09:37.440 --> 09:40.860
We update the distance of the car to the goal.

09:40.860 --> 09:43.560
And we update the positions of the sensors.

09:43.560 --> 09:46.350
Ball one, ball two, and ball three correspond to the balls

09:46.350 --> 09:48.480
that will represent the sensors on the map.

09:48.480 --> 09:50.520
You will see that very quickly.

09:50.520 --> 09:53.040
And then here, that part is very important

09:53.040 --> 09:55.020
because that's where we penalize the car

09:55.020 --> 09:57.000
if it goes onto some sand.

09:57.000 --> 09:59.310
Because as you can see, this means

09:59.310 --> 10:04.140
if the car is onto some sand, well, it will be slowed down.

10:04.140 --> 10:06.810
So that's where we reduce its velocity.

10:06.810 --> 10:10.110
Its velocity is usually six, as you can see here.

10:10.110 --> 10:12.690
And if it goes onto some sand, it will be one.

10:12.690 --> 10:14.400
So it will be slowed down to one.

10:14.400 --> 10:16.170
You'll see how the car will be slowed down

10:16.170 --> 10:18.060
once it goes onto some sand.

10:18.060 --> 10:19.200
So it is slowed down,

10:19.200 --> 10:21.840
and besides, it gets a bad reward.

10:21.840 --> 10:23.910
It gets a minus one reward.

10:23.910 --> 10:26.100
And that's actually the worst reward you could get.

10:26.100 --> 10:29.520
The best reward is one, the worst reward is minus one,

10:29.520 --> 10:32.550
and the reward is between minus one and plus one.

10:32.550 --> 10:35.970
And then otherwise, if the car isn't onto some sand,

10:35.970 --> 10:39.540
well, it keeps its usual speed, speed of six.

10:39.540 --> 10:41.040
And then we add something else.

10:41.040 --> 10:43.170
If it's getting closer to the goal,

10:43.170 --> 10:45.870
then it will get a slightly positive reward.

10:45.870 --> 10:48.150
And if it's getting further away from the goal,

10:48.150 --> 10:52.023
well, it gets a slightly negative reward, minus 0.2.

10:53.550 --> 10:57.420
And then last conditions that are related to the reward.

10:57.420 --> 11:00.180
Well, that's if the car is getting too close

11:00.180 --> 11:02.880
to one of the edges, as we spoke of earlier.

11:02.880 --> 11:05.160
Remember when we talked about full sand?

11:05.160 --> 11:07.410
Well, if the car is getting too close

11:07.410 --> 11:11.220
to the left edge of the map, it gets minus one reward.

11:11.220 --> 11:13.620
If it gets too close to the right edge of the map,

11:13.620 --> 11:15.690
it gets reward minus one.

11:15.690 --> 11:18.630
And if it gets too close to the bottom edge of the map,

11:18.630 --> 11:20.340
it gets reward minus one.

11:20.340 --> 11:23.760
And if it gets too close to the upper left of the map,

11:23.760 --> 11:25.230
it gets reward minus one.

11:25.230 --> 11:27.600
So that's a terrible punishment.

11:27.600 --> 11:29.670
And so you will see how it will learn fast

11:29.670 --> 11:31.890
not to rush into some walls.

11:31.890 --> 11:35.250
All right, and then this is to update the goal

11:35.250 --> 11:36.600
when the goal is reached.

11:36.600 --> 11:39.120
So when the car reaches the airport,

11:39.120 --> 11:40.230
which is the first goal,

11:40.230 --> 11:41.940
that is the upper-left corner of the map,

11:41.940 --> 11:43.350
well, the goal changes

11:43.350 --> 11:46.200
to the bottom-right corner of the map, which is downtown.

11:46.200 --> 11:47.550
And that's exactly what we do here.

11:47.550 --> 11:50.070
We update the X-coordinate of the goal

11:50.070 --> 11:51.840
and the Y-coordinate of the goal,

11:51.840 --> 11:55.860
and then we update the distance from the car to the goal.

11:55.860 --> 11:58.320
All right. And then that's less important.

11:58.320 --> 12:01.710
That's just a class that will add the painting tools

12:01.710 --> 12:04.140
for us to be able to paint some roads

12:04.140 --> 12:06.390
or some obstacles on the map.

12:06.390 --> 12:08.070
That's more related to SkyV.

12:08.070 --> 12:09.600
You can have a look if you want.

12:09.600 --> 12:12.690
I'll provide the commented version of this code

12:12.690 --> 12:14.220
and I'll provide some reference

12:14.220 --> 12:17.580
if you want to go deeper on how to do that with SkyV.

12:17.580 --> 12:20.250
But we're getting further from artificial intelligence,

12:20.250 --> 12:22.860
so I'm not gonna go into the details of it.

12:22.860 --> 12:25.320
And that's the same for the last code section here

12:25.320 --> 12:27.060
with the Car app class.

12:27.060 --> 12:31.500
That is just to add the API buttons, clear, save, and load.

12:31.500 --> 12:34.920
So that's what we do here, clear canvas, save.

12:34.920 --> 12:36.150
And that's actually very important.

12:36.150 --> 12:39.240
That's for us to be able to save the AI,

12:39.240 --> 12:42.480
to save the brain so that you can reuse it later

12:42.480 --> 12:44.490
by taking the load function,

12:44.490 --> 12:46.410
which is another tool we add on the map,

12:46.410 --> 12:47.790
to load the brain of the car,

12:47.790 --> 12:49.500
that is, to load the memory of the car,

12:49.500 --> 12:52.230
how to navigate in the map.

12:52.230 --> 12:55.440
And then finally, we have the last of the last code section,

12:55.440 --> 12:56.880
which runs the whole thing,

12:56.880 --> 13:00.900
that is, which runs the map and the AI itself.

13:00.900 --> 13:03.570
And actually, that's what we're gonna do right now.

13:03.570 --> 13:07.020
Let's have a look at everything we make in this code.

13:07.020 --> 13:10.500
So right now, the AI is not implemented

13:10.500 --> 13:13.920
so the car will have a very random movement.

13:13.920 --> 13:16.020
It will actually look like an insect.

13:16.020 --> 13:17.760
But don't worry. We will fix that.

13:17.760 --> 13:21.030
Not only we will train it to move like a real car

13:21.030 --> 13:23.610
and train it to navigate,

13:23.610 --> 13:26.610
following some roads and avoiding some obstacles.

13:26.610 --> 13:27.690
So let's do this.

13:27.690 --> 13:32.520
I'm going to select everything and execute.

13:32.520 --> 13:35.670
And here's the map and here's the car.

13:35.670 --> 13:39.000
All right, so that little thing here that you see

13:39.000 --> 13:41.580
that looks like an insect is our car.

13:41.580 --> 13:46.170
So as I told you, the actions are totally random.

13:46.170 --> 13:50.280
So at each time, the car selects randomly an action

13:50.280 --> 13:53.910
whether to go straight to the left or to the right.

13:53.910 --> 13:57.060
So that's why it is making some nonsense movement

13:57.060 --> 13:59.400
and that's why it's looking like an insect.

13:59.400 --> 14:01.710
So we will fix that, of course.

14:01.710 --> 14:05.640
And of course, since the AI is deactivated,

14:05.640 --> 14:07.290
well, it is not going to the goal,

14:07.290 --> 14:09.240
which is the airport here,

14:09.240 --> 14:13.710
or to downtown at the bottom right of the map.

14:13.710 --> 14:16.020
And we will fix all this by making the AI.

14:16.020 --> 14:21.020
So we will implement the AI into this car or this insect.

14:21.750 --> 14:23.910
So you can see the three balls here,

14:23.910 --> 14:26.580
the yellow one, the red one, and the white one,

14:26.580 --> 14:28.200
that's our three sensors.

14:28.200 --> 14:32.790
So that's what will detect if there is some sand around it.

14:32.790 --> 14:35.700
And speaking of sand, well, let's draw some.

14:35.700 --> 14:40.700
So to do so, I just need to do a click left here.

14:40.950 --> 14:45.480
And drawing some sand by still clicking left.

14:45.480 --> 14:47.970
So right now, I'm adding some sand.

14:47.970 --> 14:50.220
We can add some more.

14:50.220 --> 14:52.740
So each time I'm adding sand, as you can see,

14:52.740 --> 14:55.530
that's putting ones in the sand array.

14:55.530 --> 14:57.090
That's the sand array.

14:57.090 --> 15:00.150
That's the zero, zero coordinates of the origin.

15:00.150 --> 15:02.040
And here there are a lot of ones.

15:02.040 --> 15:04.890
And as you can see, well, that's good to see the car

15:04.890 --> 15:07.590
just went onto the sand and was slowed down.

15:07.590 --> 15:09.480
So as you can see right now,

15:09.480 --> 15:12.480
it is really slowed down because it's going onto the sand

15:12.480 --> 15:14.943
and right now it's trying to escape.

15:16.290 --> 15:19.380
And so what we'll do is we will draw some roads

15:19.380 --> 15:24.180
and we will draw some roads from the airport to downtown

15:24.180 --> 15:26.340
and we will train the car to stay in the road

15:26.340 --> 15:28.440
and to avoid the obstacles.

15:28.440 --> 15:30.840
All right, and as you can see, there is the clear button

15:30.840 --> 15:32.220
to clear the sand.

15:32.220 --> 15:37.220
There is the save button to save the brain of the car.

15:37.290 --> 15:40.230
And actually, there is the score curve that we spoke of.

15:40.230 --> 15:41.430
So that saves the AI,

15:41.430 --> 15:45.030
that saves your model actually, the brain of your car.

15:45.030 --> 15:48.720
And then you can, when you leave your code

15:48.720 --> 15:50.100
or turn off your computer

15:50.100 --> 15:51.870
and you want to go back to it again,

15:51.870 --> 15:54.480
you can use the load button to load your model,

15:54.480 --> 15:56.010
that is, to load the brain,

15:56.010 --> 16:01.010
and that will get the trained AI of your car.

16:01.740 --> 16:06.060
All right, so now I can't wait to start making the AI.

16:06.060 --> 16:07.470
This will be a lot of fun.

16:07.470 --> 16:09.390
We will make our neural network

16:09.390 --> 16:11.340
and we will punish the car

16:11.340 --> 16:14.100
as soon as it doesn't do what we want.

16:14.100 --> 16:16.380
So let's do that from the next tutorial.

16:16.380 --> 16:18.543
And until then, enjoy AI.
