WEBVTT

00:00.150 --> 00:05.400
朋友们, 大家好, 欢迎来到这个新的部分,

00:05.400 --> 00:07.470
我们将讨论深度卷积学习模型的结果可视化｡

00:07.710 --> 00:15.830
首先, 我真的要对完成了深度卷积神经模型的整个实现表示热烈的祝贺｡

00:15.840 --> 00:22.560
现在, 我们来到了有趣的部分, 我们将可视化我们创建的人工智能的结果｡ 

00:22.680 --> 00:27.630
就像我在上一个教程的结尾说的, 你知道, 最后一个实现教程,

00:27.630 --> 00:29.940
我说我有一个惊喜给你｡

00:29.940 --> 00:32.610
惊喜就在这里｡ 

00:32.610 --> 00:36.090
我们将在Google CoLab上显示结果｡ 

00:36.090 --> 00:38.110
为什么这是个好惊喜？

00:38.130 --> 00:46.890
这是一个很好的惊喜, 因为基本上你将完全没有麻烦运行代码, 运行代码和可视化的结果｡

00:47.040 --> 00:49.620
的确, 这是课程的一个新特点｡ 

00:49.920 --> 00:56.430
在此之前, 我们实际上使用Python在Spider上运行代码, 但是安装所有的包､

00:56.430 --> 01:02.730
pytorch､ gym依赖项和所有不同的依赖项是非常困难的｡

01:02.850 --> 01:08.460
实际上, 很多学生在安装所有程序时遇到了很多问题, 最后,

01:08.460 --> 01:12.480
他们中的大多数人都不能很好地运行整个代码, 而且大多数人看不到最终结果｡

01:12.480 --> 01:15.030
所以我非常想解决这个问题｡ 

01:15.030 --> 01:19.830
我想到的最好的解决方案是包含整个代码｡ 

01:19.830 --> 01:24.180
因此, 您将拥有与我们在本部分中实现的代码完全相同的代码｡ 

01:24.180 --> 01:30.300
但是我已经将整个代码包含在了Google CoLab笔记本上, 在这里,

01:30.300 --> 01:35.160
你要运行代码并可视化结果, 唯一需要做的就是点击这里的播放按钮｡

01:35.160 --> 01:42.120
这是您唯一需要做的事情, 因为Google CoLab的美妙之处在于大多数库和包都已经安装好了｡

01:42.120 --> 01:47.400
例如, TensorFlow已经安装, PyTorch已经安装在所有火炬模块中,

01:47.400 --> 01:51.690
函数和类已经安装, 因此您不必安装它们｡

01:51.690 --> 01:56.970
然而,

01:56.970 --> 02:04.620
我们仍然有一些小的依赖项需要安装, 以确保一切都连接良好, 但我们不必像在自动驾驶汽车中那样通过终端或通过Anaconda提示符来安装它们｡

02:04.620 --> 02:10.830
我们只需要在第一个单元格中单击播放按钮, 安装系统依赖项即可｡

02:11.070 --> 02:13.770
我知道你们有些人可能在想什么｡ 

02:13.770 --> 02:16.700
为什么我们没有为自动驾驶汽车做同样的事情呢？

02:16.710 --> 02:22.950
不幸的是, 我们不能做同样的事情, 因为在自动驾驶汽车模块中, 我们有用户交互｡

02:22.950 --> 02:28.230
你知道, 当我们在地图上绘制一些感觉,

02:28.230 --> 02:35.730
你知道, 设计道路和放置一些障碍物, 嗯, 不幸的是, 谷歌合作实验室还没有允许用户与一些地图进行交互的功能｡

02:35.730 --> 02:38.340
所以我无法为自动驾驶汽车做到这一点｡ 

02:38.340 --> 02:44.010
我为此道歉, 但这就是为什么我给你我的书的整个章节的速成班, 其中包含了所有的说明,

02:44.010 --> 02:46.860
自动驾驶汽车｡

02:46.860 --> 02:49.440
我希望你无论如何都能把所有东西都安装好｡ 

02:49.440 --> 02:53.940
与Doom相比, 没有太多需要安装的东西, 所以我希望自动驾驶汽车一切顺利｡

02:53.940 --> 02:55.530
但对于劫数在这里｡ 

02:55.530 --> 02:56.580
现在你有保障了｡ 

02:56.580 --> 03:00.750
运行代码和可视化结果不会有任何问题｡ 

03:00.750 --> 03:01.890
这就是惊喜

03:01.890 --> 03:03.030
我希望你会喜欢｡ 

03:03.030 --> 03:08.040
现在, 我将向您介绍整个实现过程,

03:08.040 --> 03:11.610
以向您展示我们的代码与第二部分中实现的代码完全相同｡

03:11.610 --> 03:14.610
唯一的问题是我合并了三个代码｡ 

03:14.610 --> 03:20.370
这是我们在文件夹中的代码, 由图像预处理p文件､

03:20.370 --> 03:28.230
体验回放p文件和AI p文件组成, 其中包括两个部分：第一部分构建AI, 第二部分训练AI｡

03:28.260 --> 03:35.460
我只是把这三个文件合并起来先把图像预处理, 然后把p文件.

03:35.460 --> 03:37.020
我会在练习册上给你们看的｡ 

03:37.020 --> 03:39.090
其次是体验｡ 

03:39.090 --> 03:42.020
重放P文件和第三个, AI｡ 

03:42.050 --> 03:46.290
P在这里的顺序是一个在另一个下面｡ 

03:46.920 --> 03:48.240
所以我给你们看这个｡ 

03:48.240 --> 03:53.670
然后我在整个代码中修改了两三处地方, 我会给你们看具体的修改,

03:53.670 --> 03:56.700
这样你们就能发现其中的不同之处｡

03:56.700 --> 04:02.010
基本上, 在该文件中, 一切都是相同的, 而该文件中, 一切也是相同的｡ 

04:02.010 --> 04:04.920
但是, 那份文件绝对没有任何变化｡ 

04:04.920 --> 04:13.410
在这里, 当我们导入Openai和Zoom的包时, 我们没有使用P包doom包装器的操作空间来导入到离散｡

04:13.410 --> 04:14.940
我们已经不用了｡ 

04:14.940 --> 04:16.560
我们会用别的东西, 你会看到的｡ 

04:16.560 --> 04:25.230
我还把框架的尺寸改成了80乘80我把它改成了256乘256.

04:25.230 --> 04:30.960
这样你就可以有更好的可视化效果, 因为你会有更大的视频来观看｡ 

04:31.260 --> 04:32.460
这就是我改变的地方｡ 

04:32.460 --> 04:32.940
我带你去看

04:32.940 --> 04:39.420
现在, 让我们从图像处理开始, 因为事实上, 正如我告诉你的, 我刚刚把三个文件合并在一起｡

04:39.420 --> 04:43.350
所以我们从按下“y”键开始｡ 

04:43.350 --> 04:45.870
如你所见, 这是完全一样的｡ 

04:45.870 --> 04:49.470
我们从导入库开始, 与此处的库完全相同｡ 

04:49.470 --> 04:56.580
然后用初始化方法和观察方法组成的预处理图像类对图像进行预处理｡

04:56.580 --> 04:59.670
正如你所看到的, 这是完全相同的预处理图像｡ 

05:00.130 --> 05:02.470
在它里面, 方法和观察方法｡ 

05:02.500 --> 05:07.480
好的, 我们继续体验重播, 我们有完全相同的｡ 

05:07.480 --> 05:11.350
实际上, 我们首先在这里使用了两个库, 但都没有命名｡ 

05:11.370 --> 05:13.060
轻按右侧｡ 

05:13.060 --> 05:17.260
然后我们定义一个和这里完全一样的步骤｡ 

05:17.260 --> 05:24.280
然后, 我们使用Step Progress类在几个步骤上取得进展,

05:24.280 --> 05:26.770
这与工作簿中的情况完全相同｡

05:26.770 --> 05:27.130
好吧, 我知道了

05:27.130 --> 05:29.200
我只是在这里做了一些复制粘贴｡ 

05:29.200 --> 05:31.300
我们有完全相同的init方法｡ 

05:31.300 --> 05:34.780
这是一个方法和奖励步骤的方法｡ 

05:34.780 --> 05:40.540
好了, 我们用replay memory类实现了体验回放.

05:40.540 --> 05:44.140
如您所见, 我们在Google协作实验室中拥有完全相同的内容｡ 

05:44.140 --> 05:48.660
另外, 你可能会更好地欣赏结构, 因为我添加了一些文本单元格｡ 

05:48.670 --> 05:52.720
这就是你知道的, 在这本练习册上可视化会更好｡ 

05:52.720 --> 05:53.140
好吧, 我会的

05:53.140 --> 05:58.840
所以重放内存类init方法示例的批量运行步骤, 基本上完全相同的代码｡ 

05:58.840 --> 05:59.500
好吧, 我会的

05:59.500 --> 06:06.340
然后我们进入第三个文件API, 自由API, 这个API包含两个部分, 第一部分, 构建人工智能,

06:06.340 --> 06:09.190
第二部分, 训练API｡

06:09.220 --> 06:12.670
让我向大家展示一下, 我们在这本练习册上有完全相同的内容｡ 

06:12.670 --> 06:17.950
因此, 我Freedom API首先导入库, 完全相同的库｡ 

06:17.950 --> 06:19.210
对, 如你所见｡ 

06:19.210 --> 06:25.030
在这里, 这就是我在导入Openai和Dhoom的包时已经强调的区别｡ 

06:25.030 --> 06:31.960
我们不必导入gem包装器, 然后跳过包装器并将其打包以导入到脚本中, 我们只需实际导入gem,

06:31.960 --> 06:37.510
这是相同的, 然后导入这个注定要失败的gem, 这基本上是新的注定要失败的环境,

06:37.510 --> 06:41.770
实际上得到了很好的改进｡

06:41.770 --> 06:44.980
最后是宝石图书馆的包装纸｡ 

06:44.980 --> 06:45.310
好吧, 我会的

06:45.310 --> 06:51.220
所以这里的区别, 这将使这个东西在谷歌CoLab上工作, 如果你想运行它, 也可以在Python上工作｡

06:51.220 --> 06:55.960
当然, 在这里, 我不需要在Google collapse中包含这些代码,

06:55.960 --> 06:59.410
因为我们在这里导入了其他文件, 因为它们是分开的｡

06:59.410 --> 07:04.360
由于我在Google CoLab上合并了三个文件, 因此, 我不需要进行导入｡ 

07:04.360 --> 07:10.510
这里我们直接转到端口1, 构建API, 这里, 正如我告诉过你的, 我们有完全相同的代码,

07:10.510 --> 07:13.150
除了这里的尺寸｡

07:13.150 --> 07:13.750
好吧, 我知道了

07:13.750 --> 07:20.950
如果我们看一下这里的一号端口, 一号端口二号楼, 我们从C和class开始制作大脑.

07:20.950 --> 07:25.870
正如你所看到的, 我们有完全相同的代码, 除了这里输入帧的尺寸,

07:25.870 --> 07:29.110
这是当我们实现代码80乘80｡

07:29.110 --> 07:36.940
但我在谷歌CoLab中将其改为256乘256, 这样你就可以有更好的帧, 因此更好的视频观看,

07:36.940 --> 07:40.450
但所有其他的都是完全一样的｡

07:40.450 --> 07:46.450
所以这里我们用CNN类来做大脑, 然后用最大软伙伴类来做伙伴｡ 

07:46.450 --> 07:49.000
所以和我们这里的完全一样｡ 

07:49.000 --> 07:58.090
最后, 我们把整个东西和包含大脑和身体的类放在一起, 还有一些执行动作的方法｡

07:58.090 --> 07:59.980
对, 完全一样｡ 

08:00.040 --> 08:05.350
类组成的大脑在体内, 然后以同样的方法来执行动作｡ 

08:05.350 --> 08:05.980
好吧, 我会的

08:05.980 --> 08:07.120
所以完全一样｡ 

08:07.120 --> 08:09.670
只是输入帧的尺寸发生了变化｡ 

08:09.670 --> 08:13.690
现在让我们进入第二部分, 也是完全一样的｡ 

08:13.690 --> 08:16.630
首先, 我们要把末日环境做好｡ 

08:16.630 --> 08:18.610
让我给你们看第二部分｡ 

08:18.880 --> 08:27.940
我们首先得到doom环境, 这里请记住, 因为我们不再使用数据包导入环境, 而是使用此doom｡

08:27.940 --> 08:31.480
唯一改变的代码就是这里

08:31.480 --> 08:35.680
的确我们得到智慧走廊, 但这里的环境完全一样｡ 

08:35.860 --> 08:36.280
好吧, 我会的

08:36.280 --> 08:40.600
然后, 当然, 我改变了这些新的尺寸, 这样你就可以在这里有更大的视频｡ 

08:40.600 --> 08:46.240
所以我们不再是80乘80, 而是256乘256｡ 

08:46.240 --> 08:52.750
然后我们得到了完全相同的结果, 你会看到的动作数是7｡

08:53.230 --> 08:58.840
然后我们通过创建大脑对象来构建人工智能, 你知道, CNN, 然后是身体对象,

08:58.870 --> 09:05.470
soft max body, 然后是整个人工智能, 由大脑和身体组成, 与我们一起实现的完全相同｡

09:05.710 --> 09:06.100
好吧, 我会的

09:06.100 --> 09:07.870
然后我们设置体验回放｡ 

09:07.870 --> 09:09.820
所以这里也是一样的｡ 

09:09.820 --> 09:14.080
然后我们实现的资格跟踪仍然完全相同｡ 

09:14.080 --> 09:15.550
然后我们怎么办？

09:15.550 --> 09:19.840
我们用100步的平均数来计算高管｡ 

09:19.840 --> 09:20.320
我也是

09:20.320 --> 09:22.030
所以这是完全相同的代码｡ 

09:22.030 --> 09:28.000
基本上只有框架的尺寸和导入环境的方式发生了变化｡ 

09:28.510 --> 09:33.160
最后我们用完全相同的代码训练人工智能｡ 

09:33.730 --> 09:41.260
到这里为止, 我们已经有了你下载时在文件夹中看到的完整代码, 代码中的数据集｡

09:41.560 --> 09:45.250
基本上, 我们也有我们一起实现的完整代码｡ 

09:45.340 --> 09:53.560
然而, 为了使可视化在Google Lab上工作, 我添加了这个额外的代码,

09:53.560 --> 09:59.530
但因为它实际上只针对这个CoLab笔记本电脑, 也只针对可视化｡

09:59.740 --> 10:03.490
A. 一､  在末日环境中的行动将请｡ 

10:03.490 --> 10:08.350
你不必担心理解这里的所有代码,

10:08.350 --> 10:13.400
因为你知道, 你一生中只会看到一次, 当你想建立和训练一些人工智能在厄运环境中发挥作用｡

10:13.420 --> 10:19.750
我的意思是, 在构建和训练人工智能时, 您不必将此代码用于其他应用程序｡

10:19.780 --> 10:21.960
所以不要太担心这个代码｡ 

10:21.970 --> 10:26.010
我只是为了让它能在Google CoLab上工作而添加了这一点, 但让我们看看我做了什么｡ 

10:26.260 --> 10:28.060
首先, 当然是导入库｡ 

10:28.060 --> 10:34.030
然后我在这里添加了一些实用的代码, 这样你就可以很快地看到你在环境中所做的动作的数量, 以及环境框架的显示,

10:34.030 --> 10:39.310
看看它是什么样子的｡

10:39.310 --> 10:46.870
我之所以这么说, 是因为我还将向你们展示如何处理其他厄运环境, 因为你们实际上有很多这样的环境｡

10:46.870 --> 10:54.070
所以你要做的就是用其他环境的名字来代替智慧走廊｡

10:54.070 --> 10:57.400
我会给予你这个页面的链接, 直到这个教程｡ 

10:57.430 --> 11:01.540
但在这里, 正如你所看到的, 你有很多厄运环境, 你可以玩｡ 

11:01.540 --> 11:06.250
你知道, 智慧基础, 智慧走廊,

11:06.250 --> 11:11.800
这是我们现在要玩的, 智慧防御中心和其他, 甚至有一些室内迷宫, 只要按照这里的指示｡

11:11.800 --> 11:15.760
您可以在这个init方法中的这个文件夹中找到它们｡ 

11:15.760 --> 11:17.740
你可以在这里找到名字｡ 

11:17.740 --> 11:20.710
智慧基础､ 智慧长廊､ 智慧保卫中心｡ 

11:20.710 --> 11:22.600
而且你有很多很多, 你看｡ 

11:22.600 --> 11:26.020
所以如果你想玩其他的末日环境, 请随意｡ 

11:26.020 --> 11:29.830
您只需要更改环境的名称｡ 

11:29.830 --> 11:34.150
任何时候你在这本练习册上看到这个末日走廊, 你只要用这个名字代替它就行了｡ 

11:34.150 --> 11:39.580
多亏了这段代码和这段代码, 你很快就能看到动作的数量,

11:39.580 --> 11:45.790
输入形状的尺寸, 还有一个框架的显示, 可以看到环境的样子｡

11:45.790 --> 11:47.410
所以这将是相当实用的｡ 

11:47.530 --> 11:50.920
然后我为可视化创建了这个辅助函数｡ 

11:50.920 --> 11:55.540
然后, 我运行人工智能的一个插曲, 当然后, 它是训练｡ 

11:55.540 --> 11:57.760
所以我们先在这里训练它｡ 

11:57.760 --> 12:02.460
正如你们所见, 顺便说一下, 我忘了告诉你们, 我也改变了历元的数量, 从100到20,

12:02.460 --> 12:06.730
这仅仅是因为, 你们知道, 我增加了框架的维度｡

12:06.730 --> 12:12.820
因为我增加了框架的尺寸, 训练会花更长的时间, 因为训练起来更难｡

12:12.820 --> 12:17.700
因此, 我将100个历元的数量减少到20个OC｡ 

12:17.740 --> 12:20.950
不用担心, 我们已经得到了很好的, 积极的回报｡ 

12:20.950 --> 12:26.680
当然, 如果您希望最终提高性能和结果, 可以随意增加历元的数量｡

12:26.680 --> 12:32.350
你会得到更好的结果, 但你会看到, 已经有20个纪元, 训练将需要相当长的时间｡

12:33.160 --> 12:35.380
好吧, 我说到哪了？

12:35.380 --> 12:37.540
是的, 这有助于实现可视化功能｡ 

12:37.540 --> 12:41.560
然后我在一集里运行人工智能, 当然, 在它被训练之后｡ 

12:41.560 --> 12:48.550
最后, 这段代码将输出游戏的视频, 你知道, 在这一集里,

12:48.550 --> 12:54.490
你会看到人工智能在这一集里的表现, 视频将被输出, 你可以在这里下载,

12:54.490 --> 12:59.920
你知道, 当我们执行这段代码的时候｡

13:00.670 --> 13:01.300
好吧, 我会的

13:01.300 --> 13:03.130
现在是行刑的时候了｡ 

13:03.130 --> 13:06.370
是时候好好坐在椅子上了｡ 

13:06.370 --> 13:08.470
我希望你有一个好咖啡或好茶｡ 

13:08.480 --> 13:13.990
现在我们只需按下每个单元格中的不同播放按钮, 即可运行最终结果｡ 

13:14.000 --> 13:14.920
所以我们开始吧｡ 

13:14.920 --> 13:17.420
但首先, 这是非常重要的理解｡ 

13:17.420 --> 13:18.460
还有谷歌合作实验室｡ 

13:18.460 --> 13:24.760
这是一个Google CoLab工作簿的链接, 你们都可以访问它, 因此, 当然,

13:24.760 --> 13:30.100
你们不能修改其中的任何内容, 因为如果你们中的一个修改得很好, 其他人会看到修改｡

13:30.100 --> 13:34.750
这是一个只读模式, 因此,

13:34.750 --> 13:38.920
如果您要更改环境名称或增加纪元数,

13:38.920 --> 13:47.170
甚至调整您的人工智能, 那么, 您必须创建一份该工作簿的副本, 并将其保存在您自己的Google云端硬盘中｡

13:47.170 --> 13:52.930
这就是为什么要做到这一点, 你需要一个Gmail地址, 以便你有一个谷歌驱动器｡

13:53.500 --> 13:55.450
所以一定要有一个｡ 

13:55.450 --> 14:01.150
一旦出现这种情况, 您只需单击此处得文件, 然后保存一个副本并驱动.

14:01.150 --> 14:08.620
这将在您自己的Google云端硬盘中创建此工作簿的副本, 您可以在该副本上进行一些修改｡

14:08.620 --> 14:09.310
好吧, 我会的

14:09.310 --> 14:12.910
现在我们开始执行死刑｡ 

14:12.910 --> 14:18.640
所以现在我们只需要播放所有的单元格我们会越来越接近最终的结果｡