WEBVTT

00:00.420 --> 00:01.260
你准备好了吗？

00:01.290 --> 00:02.300
我们开始吧

00:02.310 --> 00:05.970
让我们从安装智慧的所有系统依赖项开始｡ 

00:06.000 --> 00:12.510
让我们单击这个播放按钮, 现在它将安装所有依赖项, 如您所见, 如pillow或psi､

00:12.510 --> 00:18.150
pi, 以及成功运行此程序所需的其他一些依赖项｡

00:18.150 --> 00:22.140
但所有其他像pytorch, 健身房模块已经安装｡ 

00:22.140 --> 00:23.070
所以这真的很棒｡ 

00:23.070 --> 00:28.800
这就是Google CoLab的美妙之处, 也正是因为如此,

00:29.250 --> 00:32.040
你们在执行代码和可视化最终结果时不会有任何问题｡

00:32.430 --> 00:32.760
好吧, 我会的

00:32.760 --> 00:35.250
所以这实际上需要一两分钟｡ 

00:35.250 --> 00:41.430
我将快进到这里, 很快我们将在代码的其余执行部分见面｡

00:42.820 --> 00:43.420
好吧, 我会的

00:43.420 --> 00:46.240
我们似乎在系统的安装结束｡ 

00:46.240 --> 00:53.680
依赖项, 如您所见, 它是下载它们, 安装它们, 同时收集它们与所有正确的要求｡

00:53.680 --> 00:58.180
在几秒钟内, 它应该做得很好｡ 

00:58.180 --> 00:59.800
让我们看看｡ 

00:59.800 --> 01:01.360
三, 二｡ 

01:01.360 --> 01:02.140
我们走吧｡ 

01:02.140 --> 01:03.910
已成功安装所有项目｡ 

01:03.910 --> 01:05.260
不要担心这里的这些错误｡ 

01:05.260 --> 01:11.050
它们不会影响代码的执行, 但一切都按照我们的要求成功安装｡ 

01:11.050 --> 01:13.450
好了, 下一步.

01:13.450 --> 01:14.770
非常重要的｡ 

01:14.800 --> 01:16.600
看看这个重要的节点｡ 

01:16.600 --> 01:24.010
它说在安装完所有依赖项之后, 基本上在执行这里的第一个单元格之后, 你必须重新启动你的运行时｡

01:24.010 --> 01:26.560
否则, 您将在此处得到一些执行错误｡ 

01:26.560 --> 01:27.610
那我们就速战速决吧｡ 

01:27.610 --> 01:28.390
这很简单｡ 

01:28.390 --> 01:33.910
你只需要点击这里的运行时, 然后重新启动运行时, 然后是的, 好的｡ 

01:33.910 --> 01:35.500
这将还原您的运行时｡ 

01:35.500 --> 01:40.480
现在你可以通过点击播放按钮来执行所有这些单元格｡ 

01:40.480 --> 01:44.800
让我们开始吧, 从第一个文件图像预处理开始｡ 

01:44.830 --> 01:51.370
好了, 让我们首先导入库,

01:51.370 --> 01:58.570
然后用预处理图像类预处理图像, 现在我们已经转到体验回放实现, 也就是这个实现｡

01:58.570 --> 02:00.340
好吧, 我们开始吧｡ 

02:00.340 --> 02:05.140
我们首先导入库, 然后定义环境的一个步骤｡ 

02:05.170 --> 02:14.770
然后, 我们使用Step Progress类在几个步骤上创建进度, 这些步骤与文件夹中的进度完全相同｡

02:14.830 --> 02:20.500
然后我们通过构建这个回放内存类来实现体验回放｡ 

02:20.500 --> 02:21.940
好了, 一切顺利｡ 

02:21.940 --> 02:30.160
现在我们继续到第三个文件, 这个文件, 我们首先导入库｡ 

02:31.100 --> 02:31.940
那就这样吧

02:31.940 --> 02:32.240
好吧, 我会的

02:32.240 --> 02:38.820
这里需要一点时间, 因为我们导入了所有的torch模块, 然后导入了openai和doom的包｡

02:38.840 --> 02:41.990
健身房､ 智慧健身房和说唱歌手也是如此｡ 

02:42.320 --> 02:43.310
所以一切都好｡ 

02:43.310 --> 02:48.800
然后我们进入第一部分, 构建人工智能, 我们将在这里制造大脑, 然后是身体,

02:48.800 --> 02:51.380
然后组装所有的东西｡

02:51.380 --> 02:55.610
所以我们先用CNN的课程来让大脑正常｡ 

02:55.700 --> 03:04.580
然后让我们用一个soft max body类来制作body, 然后让我们用一个类来制作AI｡ 

03:04.730 --> 03:05.210
好吧, 我会的

03:05.210 --> 03:06.260
所以一切都好｡ 

03:06.260 --> 03:12.350
现在我们已经进入第二部分, 我们将用深度卷积学习来训练人工智能｡

03:12.590 --> 03:12.950
好吧, 我会的

03:12.950 --> 03:15.200
所以和我们这里的完全一样｡ 

03:15.380 --> 03:19.130
我们首先用我们的新模块和坟墓获得末日环境｡ 

03:19.130 --> 03:20.270
别担心这个｡ 

03:20.270 --> 03:21.560
这不是错误｡ 

03:21.650 --> 03:27.620
然后我们将通过创建不同的对象来构建人工智能, 大脑, CNN, max

03:27.620 --> 03:31.010
body的身体, 以及包含大脑和身体的整个人工智能｡

03:31.010 --> 03:31.430
好吧, 我会的

03:31.430 --> 03:32.300
我执行了吗？

03:32.300 --> 03:32.870
是的, 我知道

03:33.110 --> 03:39.800
然后我们设置经验､ 回放带和步骤, 并将记忆作为目标回放记忆,

03:39.800 --> 03:42.950
然后我们实现资格跟踪｡

03:43.220 --> 03:43.730
好吧, 我会的

03:43.730 --> 03:45.320
以提高性能｡ 

03:45.620 --> 03:50.120
然后, 我们用MA类在100步上做移动平均线｡ 

03:50.120 --> 03:52.490
最后, 我的朋友们, 你们准备好了吗？

03:52.490 --> 03:57.260
好了, 现在是时候了, 你知道, 非常令人兴奋的部分,

03:57.260 --> 03:58.520
我们将训练人工智能超过20个纪元｡

03:58.520 --> 04:01.430
好的, 你们会看到这已经有点长了｡ 

04:01.430 --> 04:05.780
你知道, 这可能需要一个或两个小时, 因为我增加了维度｡ 

04:05.780 --> 04:09.770
如果发现尺寸太长, 可以将尺寸减小到80 × 80｡ 

04:09.770 --> 04:13.100
但相信我, 你会有更好的视频与这些尺寸｡ 

04:13.910 --> 04:15.620
你准备好了吗？

04:15.620 --> 04:20.450
倒数三二一开始｡ 

04:20.450 --> 04:24.140
好的, 这将执行培训的代码｡ 

04:24.140 --> 04:30.020
再过几秒钟, 我们就能看到第一个纪元了, 当然, 它会有一个负的奖励｡

04:30.020 --> 04:36.380
但是你会看到, 在各纪元中, 奖励会一点一点地增加, 直到达到正奖励,

04:36.380 --> 04:40.220
然后直到达到数百奖励｡

04:40.220 --> 04:42.230
好吧, 让我们瞄准那个, 实际上｡ 

04:42.230 --> 04:48.920
让我们希望在20个纪元中, 我们会有一些最终的奖励, 比如100, 200或300,

04:48.920 --> 04:53.240
因为这些奖励, 我实际上是用它们做实验的｡

04:53.240 --> 04:53.450
是的, 我知道

04:53.450 --> 04:56.990
第一纪元, 负奖励, -98｡ 

04:56.990 --> 05:02.960
所以我是说, 奖励在100, 203百左右, 我们已经得到一些伟大的结果｡ 

05:02.960 --> 05:07.920
你知道, 我们会看到人工智能设法要么杀死一些怪物, 要么避开它们, 或者, 你知道,

05:07.970 --> 05:10.010
向背心移动｡

05:10.700 --> 05:14.360
这是第一个纪元, 纪元1-98｡ 

05:14.360 --> 05:18.740
然后, 你知道, 我们我们会看到第二个纪元, 也许已经有了更好的奖励｡ 

05:18.740 --> 05:21.620
但是, 你知道, 在开始的时候, 当然, 人工智能是没有经过训练的｡ 

05:21.620 --> 05:23.510
它正在探索环境｡ 

05:23.510 --> 05:23.750
好吧, 我知道了

05:23.750 --> 05:28.610
还记得强化学习､ 探索与利用之间的权衡吗？

05:28.610 --> 05:33.170
一开始, 人工智能只是单纯的探索,

05:33.170 --> 05:37.850
然后它会训练, 然后它会变得越来越聪明, 这就是它会达到一些高回报的时候｡

05:37.850 --> 05:41.000
所以一开始就有负面的奖励是完全可以的｡ 

05:41.000 --> 05:46.700
也许我们会在3/1时期得到这个数字, 但是你会看到,

05:46.700 --> 05:54.380
在第四､ 五或六个时期之后, 我们可能会开始获得正面的奖励, 然后希望在10200或300左右获得奖励｡

05:55.040 --> 05:57.560
所以就像我说的, 这需要一点时间｡ 

05:57.560 --> 06:02.510
所以我们不打算在这里呆2个小时, 否则我会无话可说｡ 

06:02.510 --> 06:08.030
所以我现在要做的就是放一段有趣或者很酷的音乐｡ 

06:08.030 --> 06:10.790
好了, 第二个纪元, -62｡ 

06:10.820 --> 06:12.200
所以已经有了一些改善｡ 

06:12.200 --> 06:12.620
那就好｡ 

06:12.620 --> 06:18.380
但是你会看到, 随着我们在时代中的进步, 会有一些更好的改善｡ 

06:18.980 --> 06:20.030
我刚才说到哪了？

06:20.030 --> 06:25.460
是的, 我现在要放一些很酷的音乐, 并以加速模式播放训练｡ 

06:25.460 --> 06:30.350
当然, 我会在训练结束时看到你们的最终结果｡ 

06:30.350 --> 06:30.980
好吧, 我会的

06:30.980 --> 06:32.030
好了, 我们走吧｡ 

06:32.030 --> 06:35.060
三二一开始｡ 

07:20.030 --> 07:20.810
好吧, 我会的

07:20.810 --> 07:22.610
现在我们已经到了培训的最后阶段｡ 

07:22.610 --> 07:23.600
恭喜你啊

07:23.600 --> 07:30.170
您将在一个非常具有挑战性的应用程序上训练深度卷积学习模型, 即玩末日游戏｡

07:30.570 --> 07:32.130
那先说什么好呢？

07:32.130 --> 07:37.290
正如我们所希望的那样, 我们的平均奖金超过了100英镑｡ 

07:37.470 --> 07:43.340
当然, 重要的是, 随着时代的增加, 你会得到更高的回报｡ 

07:43.350 --> 07:49.470
所以如果你准备好了, 比如说, 训练这个模型更多的纪元, 比如100个纪元, 甚至更多,

07:49.470 --> 07:54.600
以达到更多的奖励, 大约30400和500, 甚至1000｡

07:54.600 --> 07:55.980
好吧, 随便你｡ 

07:55.980 --> 08:00.570
例如, 你可以让这个在你睡觉的时候运行一夜, 当你早上醒来的时候,

08:00.570 --> 08:02.220
你会得到你更好的结果｡

08:02.250 --> 08:05.550
请注意, 您也可以在运行时使用GPU, 对吗？

08:05.550 --> 08:10.500
如果你改变了运行时类型, 我不应该这样做, 因为否则它会重新启动笔记本电脑｡ 

08:10.500 --> 08:16.440
但在硬件加速器中, 您可以选择GPU甚至CPU, 但前提是您希望优化性能,

08:16.830 --> 08:20.280
并进行一些超级艰苦的训练｡

08:20.280 --> 08:25.200
但在这里我用的是经典的方法因为我只想向你们展示如何执行这一切｡ 

08:25.200 --> 08:26.220
好了

08:26.220 --> 08:32.860
现在, 我们将使用专门针对这本内核书的额外代码来执行工作簿的其余部分, 当然,

08:32.880 --> 08:36.210
我们将在其中可视化人工智能的运行｡

08:36.480 --> 08:37.440
好吧, 我们开始吧｡ 

08:37.440 --> 08:39.810
让我们首先导入库｡ 

08:39.810 --> 08:40.380
好吧, 我知道了

08:40.380 --> 08:41.250
一切都好｡ 

08:41.430 --> 08:46.110
然后, 我们将打印输入的形状和一些可能的操作｡ 

08:46.110 --> 08:46.470
好吧, 我会的

08:46.470 --> 08:52.800
在这里我们将得到在末日走廊环境中我们有七种可能的行动｡ 

08:52.800 --> 08:57.840
所以这些是向前, 向后, 向左, 向右, 射击｡ 

08:57.840 --> 09:00.420
然后也许保护你自己什么的｡ 

09:00.420 --> 09:03.570
我不知道最后一个动作是什么, 但大概是这样｡ 

09:03.570 --> 09:07.470
那么这些就是输入帧的尺寸｡ 

09:07.470 --> 09:09.420
这对应于框架的高度｡ 

09:09.420 --> 09:11.580
它有240像素的高度｡ 

09:11.610 --> 09:14.550
这对应于框架的宽度, 对吗？

09:14.550 --> 09:17.010
它是320大｡ 

09:17.010 --> 09:25.580
这与我们处理彩色图像的事实相对应, 这里的三个对应于我们通道的三个元素｡

09:25.860 --> 09:32.040
好了, 让我们执行下一个单元格, 显示一个环境的框架, 看看它是什么样子的｡

09:32.040 --> 09:37.170
事实上, 请记住, 这对了解您的工作环境非常有用, 对吗？

09:37.170 --> 09:43.200
这里我们看到我们在末日走廊, 但如果你想在这里尝试更多的环境, 实际上,

09:43.200 --> 09:48.510
请记住, 它们也在这里的主页｡

09:48.510 --> 09:48.960
就在这里｡ 

09:48.960 --> 09:49.200
是的, 我知道

09:49.200 --> 09:53.280
你有所有的环境清单, 你知道, 我建议尝试｡ 

09:53.280 --> 09:56.430
所以如果你想再看一个｡ 

09:56.430 --> 09:58.230
我可以给你看｡ 

09:58.230 --> 10:02.760
我们先拿下这个然后我再回到这条死亡走廊｡ 

10:02.790 --> 10:03.240
好吧, 我知道了

10:03.240 --> 10:06.810
所以如果我用这个来代替那个｡ 

10:07.500 --> 10:10.290
好的, 我会很好的执行这个｡ 

10:10.290 --> 10:12.290
这次我们将得到三个动作｡ 

10:12.300 --> 10:17.610
当然这是一个更简单的例子, 如果我们很好地执行这个单元, 我们会看到这个环境, 对吗？

10:17.610 --> 10:26.190
所以这只是一种快速查看你正在使用的东西的方法, 基本上, 它可以预览人工智能在环境中会做什么｡

10:26.400 --> 10:26.760
好吧, 我会的

10:26.760 --> 10:29.220
那么, 让我们回到智慧长廊｡ 

10:29.250 --> 10:34.080
现在让我们重新执行此操作, 以备下一个单元格需要它｡ 

10:34.110 --> 10:37.230
好吧, 完美毁灭走廊｡ 

10:37.260 --> 10:39.720
现在我们来看看最后一个细胞｡ 

10:39.720 --> 10:43.620
这是一个用于可视化的辅助函数｡ 

10:43.620 --> 10:48.090
让我们执行这个单元, 现在让我们在一个事件上运行人工智能｡ 

10:48.090 --> 10:53.160
在这里, 你将能够理解代码,

10:53.550 --> 10:59.670
因为, 你知道, 基本上它是在一个完整的情节上运行空气的过程, 在每一步它都处于一个特定的状态,

10:59.670 --> 11:04.950
它将在该状态中播放一个动作, 然后它将获得奖励, 然后到达下一个状态, 对吗？

11:04.950 --> 11:07.440
这就是经典的MDP流程, 对吧？

11:07.440 --> 11:09.000
马尔可夫决策过程｡ 

11:09.000 --> 11:09.960
所以我们开始了｡ 

11:09.960 --> 11:11.580
一集就这样了｡ 

11:11.580 --> 11:19.620
最后, 我们要得到我们的AI的游戏视频, 谁是训练20巴克斯, 能够达到100多奖励,

11:19.620 --> 11:26.040
这将给我们一些相当不错的结果, 但也许没有达到背心.

11:26.040 --> 11:26.880
但没关系｡ 

11:26.880 --> 11:28.680
你可以自己去尝试｡ 

11:28.680 --> 11:35.340
现在, 我希望您单击此处的“完全”按钮, 因为我将向您展示视频是如何填充的｡

11:35.340 --> 11:42.720
这些文件夹包含了一些元素, 比如帧, 结果的帧, 或者一些JS和文件｡

11:42.720 --> 11:45.600
但我们真正感兴趣的是最后的视频｡ 

11:45.600 --> 11:52.110
要获取该文件, 只需单击此处的“播放”按钮, 您将看到它将填充到此处的主文件夹中｡

11:52.110 --> 11:53.670
别错过了, 没事的｡ 

11:53.670 --> 11:57.420
你知道, 看起来像细胞已经被执行, 这是事实｡ 

11:57.420 --> 11:59.220
但几秒钟后你就会看到｡ 

11:59.220 --> 12:03.840
我们将看到一个AVI文件, 这是一个视频文件被填充在这里｡ 

12:03.840 --> 12:05.640
它会在10秒内出现｡ 

12:05.640 --> 12:08.010
如果你想的话我甚至可以倒计时｡ 

12:08.010 --> 12:09.150
所以我们开始吧｡ 

12:09.150 --> 12:20.970
十, 九, 八, 七, 六, 五, 四, 三, 二, 一, 开始.

12:21.710 --> 12:24.050
而现在它真的应该在几秒钟内出现｡ 

12:24.050 --> 12:24.890
好了, 我们走｡ 

12:25.040 --> 12:25.460
好吧, 我会的

12:25.460 --> 12:26.570
所以, 特工游戏｡ 

12:26.570 --> 12:27.500
弹那个阿维｡ 

12:27.500 --> 12:28.400
这是你的视频

12:28.400 --> 12:36.740
我们来下载它, 它会被下载到你的电脑上, 我可以在这里找到｡ 

12:36.740 --> 12:37.030
好吧, 我知道了

12:37.040 --> 12:38.810
这就是视频特工游戏｡ 

12:38.810 --> 12:39.800
扮演FBI｡ 

12:39.830 --> 12:44.060
请确保使用具有VLC等编解码器的视频播放器打开它｡ 

12:44.090 --> 12:44.450
好吧, 我知道了

12:44.450 --> 12:49.070
如果你在mac上, 它不会与quicktime播放器一起工作, 但它肯定会与VLC一起工作｡ 

12:49.100 --> 12:52.190
让我们来看看这段视频｡ 

12:52.190 --> 12:52.550
好吧, 我会的

12:52.550 --> 12:55.040
让我按下暂停键｡ 

12:55.250 --> 12:55.520
好吧, 我会的

12:55.520 --> 12:56.210
这是视频｡ 

12:56.210 --> 13:01.460
正如你所看到的, 这是256乘256的框架｡ 

13:01.460 --> 13:03.050
所以你可以看到, 它不是很大｡ 

13:03.050 --> 13:03.320
好吧, 我知道了

13:03.320 --> 13:08.210
所以这就是为什么我真的想用这些尺寸来工作, 而不是80乘80｡ 

13:08.630 --> 13:10.070
现在我们来看看视频｡ 

13:10.070 --> 13:15.920
所以这是人工智能在一集里玩末日游戏, 它必须避开怪物, 而不是被杀死｡ 

13:15.920 --> 13:17.990
它必须向前移动才能够到背心｡ 

13:17.990 --> 13:19.400
让我们来看看它的表现｡ 

13:19.400 --> 13:22.280
三比一｡ 

13:23.920 --> 13:24.460
好吧, 我会的

13:24.460 --> 13:27.850
所以它先被击中, 然后向前移动, 好吗？

13:27.940 --> 13:29.920
然后它被怪物杀死了｡ 

13:29.920 --> 13:31.510
但那还是相当不错的｡ 

13:31.510 --> 13:37.870
你知道, 它明白它必须向前移动到背心, 因为最高的奖励是通过达到背心｡

13:38.080 --> 13:42.730
当然,

13:42.730 --> 13:48.790
你知道, 如果你真的想看到你的眼睛到达背心并赢得这场比赛的视频, 基本上你将不得不训练你的眼睛更多的时间,

13:48.790 --> 13:55.090
也许做一些其他类型的改善, 像调整你的眼睛的大脑或做一些参数调整, 像调整学习率｡

13:55.090 --> 14:01.060
好吧, 如果你们中的任何一个得到了一个惊人的视频, 或者, 你知道, 一个人工智能的视频已经达到了1000以上的奖励,

14:01.060 --> 14:03.820
例如, 你有很多选择｡

14:03.820 --> 14:06.490
好吧, 欢迎在问答环节分享｡ 

14:06.490 --> 14:09.490
我相信其他学生会非常高兴得到它｡ 

14:09.850 --> 14:10.420
好吧, 我会的

14:10.420 --> 14:14.890
所以我希望你喜欢实施深度卷积学习模型｡ 

14:14.890 --> 14:19.330
现在我们将进入下一部分, 这将是关于实施A三个关键模型,

14:19.330 --> 14:25.000
甚至更好, 更强大的模型, 将实施玩游戏的突破｡

14:25.000 --> 14:26.800
所以我们下一部分再见｡ 

14:26.800 --> 14:28.180
在那之前, 好好享受吧｡ 

14:28.180 --> 14:28.780
一､