WEBVTT

00:00.240 --> 00:03.640
大家好, 欢迎再次来到我们的自动驾驶汽车模块｡ 

00:03.660 --> 00:10.200
所以在这个教程中, 我将解释我们将实现人工智能的环境, 当然,

00:10.200 --> 00:16.020
这将包括我们将训练汽车自动驾驶和避开障碍物, 我们将在上面画一些道路和一些障碍物,

00:16.020 --> 00:20.820
让我们的汽车绕着它们行驶｡

00:20.970 --> 00:28.680
所以我们以后会建造这个人工智能来训练这辆车, 在路上行驶而不越过限制,

00:28.680 --> 00:33.630
避开一些我们会放在路上的障碍物｡

00:33.900 --> 00:35.730
所以这是一个相当令人兴奋的挑战｡ 

00:35.730 --> 00:37.920
实际上有两个独立的文件｡ 

00:37.920 --> 00:40.560
如您所见, 这是AI python文件｡ 

00:40.590 --> 00:46.980
这是我们的人工智能, 它会做所有的训练来训练汽车, 如何自动驾驶, 驾驶｡

00:46.980 --> 00:51.840
我们有地图, 这个p文件是创建这个环境的代码｡ 

00:51.840 --> 00:56.820
这段代码实际上有200多行代码｡ 

00:56.820 --> 01:03.150
所以这段代码并不是典型的和AI有关, 它只是一段代码, 让环境去做地图｡

01:03.150 --> 01:08.340
所以我会一个一个地讲解每一部分, 但是我们不会一行一行地从头开始实现这个代码,

01:08.340 --> 01:13.470
因为我们想把重点放在人工智能上｡

01:13.470 --> 01:17.040
但是, 我们还是要一个接一个地浏览这些部分, 以了解发生了什么｡ 

01:17.130 --> 01:20.430
因此, 首先, 我们导入基本库｡ 

01:20.430 --> 01:21.870
这适用于任何代码｡ 

01:21.870 --> 01:28.680
我们需要一些库来更有效地执行一些任务, 然后导入所有的归档包｡ 

01:28.680 --> 01:33.000
这并不重要, 因为这都是归档特有的｡ 

01:33.030 --> 01:39.030
我们使用KB来制作地图, 所以我们导入了很多类和对象, 以便能够制作地图,

01:39.030 --> 01:41.580
并在地图中添加一些工具｡

01:42.030 --> 01:44.250
好吧, 那这条线很重要｡ 

01:44.250 --> 01:52.440
这条线与人工智能有关, 因为基本上这是我们导入大脑的地方, 汽车的大脑,

01:52.440 --> 01:56.160
它将是这个沙丘类的一个对象｡

01:56.160 --> 02:00.300
而沙丘类就是我们的人工智能本身｡ 

02:00.300 --> 02:04.410
在下面的教程中, 您将看到我们将在课堂上实现VQ｡ 

02:04.410 --> 02:09.390
正如你可能已经猜到的, DCN代表深Q网络｡ 

02:09.390 --> 02:14.910
所以我们将实现一个深度Q学习网络, 一旦它准备好了, 我们将把它导入到这里,

02:14.910 --> 02:18.210
从人工智能的这行代码中｡

02:18.210 --> 02:21.240
AI当然是我们的AI python文件｡ 

02:21.810 --> 02:22.230
好吗？

02:22.230 --> 02:24.300
所以迫不及待地要实现这一点｡ 

02:24.300 --> 02:29.430
这将是一个相当长的旅程, 但你会看到这将是非常令人兴奋的, 因为感谢人工智能,

02:29.430 --> 02:32.730
汽车将能够自己驾驶｡

02:33.090 --> 02:33.660
好吧, 我会的

02:33.660 --> 02:38.790
在我进入下一节之前, 我们必须解释一下我们将如何训练这辆车｡ 

02:38.820 --> 02:47.850
我现在不打算解释神经网络, 但我会解释我们如何训练汽车自动驾驶和避开障碍物的想法｡

02:48.150 --> 02:54.060
所以, 你知道, 在真实的生活中, 如果你想训练一辆真正的车避开一些墙或障碍物, 那么,

02:54.060 --> 02:55.530
你会怎么做？

02:55.560 --> 03:00.960
你绝对不会采取真实的墙壁或真正的大障碍, 并粉碎你的车到他们｡ 

03:00.960 --> 03:02.640
那会花你很多钱的｡ 

03:02.640 --> 03:12.540
相反, 一个更聪明的想法是惩罚你的车, 不是当它撞到墙或障碍物, 而是当它撞到沙子上｡

03:12.540 --> 03:14.040
就像你有一个领域｡ 

03:14.040 --> 03:19.620
这片田地有一些道路, 汽车必须停留在上面, 道路被一些沙子划界｡ 

03:19.620 --> 03:25.410
每一次赛车进入沙地, 就像是遇到了障碍物, 因为一旦赛车进入沙地,

03:25.440 --> 03:30.330
它就会减速, 我们会确保赛车受到处罚｡

03:30.330 --> 03:31.590
它会因此受到惩罚｡ 

03:31.590 --> 03:35.070
这是人工智能的一个基本点｡ 

03:35.070 --> 03:39.690
每当汽车进入沙地并减速时, 坏的奖励就会出现｡ 

03:40.050 --> 03:40.590
好吧, 我会的

03:40.590 --> 03:47.610
因此, 我在这里引入了最后一个X和最后一个Y, 它们是我们在地图上画沙子时,

03:47.610 --> 03:50.190
记忆中最后一个点的坐标｡

03:50.550 --> 03:51.030
好吧, 我会的

03:51.030 --> 03:57.750
然后我们得到了人工智能, 我们称之为大脑, 它包含了我们的神经网络｡ 

03:57.750 --> 04:03.690
我们称之为大脑, 因为这实际上是汽车的大脑, 它包含了我们的神经网络｡

04:04.170 --> 04:04.620
好吧, 我会的

04:04.620 --> 04:10.080
所以在这行代码中, 正如你所看到的, 我创建了一个dune类的对象｡ 

04:10.080 --> 04:14.280
我会提醒类和对象是什么, 但大脑是对象｡ 

04:14.280 --> 04:19.470
DCN是类和五和三和0｡  9是类的输入｡ 

04:19.470 --> 04:20.790
所以这很简单｡ 

04:20.790 --> 04:26.700
五对应于作为五个维度的编码向量的状态｡ 

04:26.700 --> 04:31.500
我们将看到他们完美地描述了什么, 在地图上的环境中发生了什么｡ 

04:31.500 --> 04:34.980
那么三个就是将要进行的动作的数目｡ 

04:34.980 --> 04:43.710
三种可能的动作是向左､ 直行或向右, 以及0｡  9是深度学习算法中的伽马参数｡

04:44.070 --> 04:44.430
好吧, 我会的

04:44.430 --> 04:46.770
然后是动作二的旋转｡ 

04:46.770 --> 04:52.920
所以动作2的旋转是一个三元素的矢量, 0, 20和-20｡ 

04:53.010 --> 04:59.940
所以我们必须这么做, 因为这些动作是由三个数字编码的｡ 

05:00.060 --> 05:04.650
两个, 并且, 对应于该动作的索引的两个旋转向量｡ 

05:04.650 --> 05:13.680
例如, 如果在时间T选择的动作是零, 那么零对应于这个动作对旋转向量的索引,

05:13.680 --> 05:21.210
索引零的值是零, 因此我们将直线前进｡

05:21.240 --> 05:28.740
然后, 如果所选择的动作是1, 则1对应于该动作对旋转向量的索引,

05:28.740 --> 05:32.550
并且具有索引1的该向量的值是20｡

05:32.550 --> 05:38.760
所以20对应于20度的旋转, 这意味着核心会向右旋转20度｡ 

05:39.030 --> 05:45.780
如果选择的动作是2, 那么2对应于索引, 这个动作的2对应于旋转向量,

05:45.780 --> 05:52.260
因此内核会旋转-20度, 所以它会向左｡

05:52.350 --> 06:00.000
好了, 我们引入最后一个奖励变量, 因为在每一个状态下我们都会得到最后一个奖励.

06:00.000 --> 06:04.920
所以记住, 如果卡没有进入沙子, 那么奖励将是积极的｡ 

06:04.920 --> 06:09.390
如果这张牌走上了某种意义上的道路, 那么, 它将得到一个糟糕的奖励｡ 

06:09.390 --> 06:14.580
在每一次这个变量都包含了它在每一次得到的奖励｡ 

06:14.580 --> 06:21.570
然后我们初始化这个过程, 这是一个包含奖励的向量, 不是所有的,

06:21.570 --> 06:28.920
但是奖励在一个滑动窗口上, 这样, 你知道, 我们就可以做一个奖励的平均分数关于时间的曲线｡

06:29.250 --> 06:35.940
好了, 在这段代码中, 我们初始化了map, 比如说, 初始化了cen变量.

06:35.940 --> 06:37.050
所以这很重要｡ 

06:37.050 --> 06:42.870
这个变量实际上是一个数组, 其中的单元格是地图的像素｡ 

06:42.990 --> 06:52.050
在每一个格子里, 如果有意义的话, 我们就会有一个1, 如果一开始没有美分, 我们就不会画任何东西｡

06:52.050 --> 06:57.660
因此, 将根本没有读出, 并且因此发送阵列的所有单元将具有零｡ 

06:57.660 --> 06:59.220
所以到处都是零｡ 

06:59.220 --> 07:05.340
一旦我们画了一些沙子, 那么我们画了意义的单元格会得到一个1, 我们用所有的0来初始化数组,

07:05.340 --> 07:09.840
沙子等于和p个0｡

07:10.110 --> 07:13.290
然后我们有一个重要的事情, 那就是目标｡ 

07:13.290 --> 07:17.430
所以目标就是地图上的点, 我们要训练赛车到达这个点｡ 

07:17.430 --> 07:19.410
所以它就像一个目的地｡ 

07:19.650 --> 07:21.360
那么这个目标是什么呢？

07:21.360 --> 07:24.840
这是地图的左上角｡ 

07:24.840 --> 07:28.320
于是我们将火车车开到地图的左上角｡ 

07:28.320 --> 07:34.230
然后一旦它到达地图的左上角, 我们就训练它去地图的右下角｡

07:34.230 --> 07:36.450
所以我们可以想象下面的场景｡ 

07:36.450 --> 07:44.280
地图的左上角是一个城市的机场, 地图的右下角是这个城市的市中心｡

07:44.280 --> 07:50.040
我们将求助于出租车或优步在机场和市中心之间做一些往返｡ 

07:50.040 --> 07:55.530
当然, 我们会给这辆出租车增加测试难度,

07:55.530 --> 08:02.700
画一些越来越难走的路, 在街道上增加越来越多的障碍物, 看看这辆出租车是否还能从机场到市区｡

08:02.700 --> 08:04.050
所以这会很有趣的｡ 

08:04.050 --> 08:08.940
这就是为什么我要设定第一个目标的坐标｡ 

08:08.940 --> 08:12.480
那是机场, 在屏幕的左上方｡ 

08:12.690 --> 08:16.140
所以地图会像这样一个正方形｡ 

08:16.620 --> 08:21.780
而原点的坐标, 也就是零零的坐标, 就在这里｡ 

08:22.080 --> 08:25.110
这个距离更大｡ 

08:25.110 --> 08:32.010
所以坐标, 20和更大的, -20就在这里, 地图的左上角｡

08:32.570 --> 08:35.510
为什么我选了20而不是0？

08:35.540 --> 08:40.180
那是因为我们要训练赛车, 而不是冲到墙上｡ 

08:40.190 --> 08:42.530
我们也想训练它避开墙壁｡ 

08:42.530 --> 08:46.530
因此, 目标不能为零, 因为我们不想让车碰到墙｡ 

08:46.550 --> 08:47.960
我们要摸到目标｡ 

08:47.960 --> 08:49.370
所以我们必须把它放在这里｡ 

08:50.000 --> 08:55.160
然后我引入最后一个距离变量, 它给出了从汽车到目标的当前距离,

08:55.160 --> 08:58.190
我把它初始化为零｡

08:58.890 --> 08:59.400
好吧, 我会的

08:59.400 --> 09:02.160
现在是时候做车和游戏了｡ 

09:02.160 --> 09:06.540
所以我们要设置两个类, 一个类是赛车, 一个类是游戏.

09:06.540 --> 09:10.800
在这些课程中, 我们已经和眼睛建立了一些联系｡ 

09:10.890 --> 09:13.020
我们将在下一个教程中进行此操作｡ 

09:13.020 --> 09:14.490
在那之前, 好好享受吧｡ 

09:14.490 --> 09:14.940
一､