WEBVTT

00:00.150 --> 00:02.310
大家好, 欢迎学习本教程｡ 

00:02.340 --> 00:07.320
我非常兴奋因为我们即将制造出A3大脑也就是我们眼睛的大脑｡ 

00:07.350 --> 00:10.640
说到大脑, 我想强调一些东西｡ 

00:10.650 --> 00:15.450
还记得在第一个模块中, 我们做了一个简单的大脑, 只有完全连接的层｡ 

00:15.600 --> 00:21.900
然后在《毁灭战士》的第二个模块中, 我们制作了一个大脑, 它不仅有完全连接的层,

00:21.900 --> 00:28.830
还有眼睛, 因为我们添加了卷积层, 这给了眼睛眼睛, 因为它可以观察图像,

00:28.830 --> 00:31.490
理解里面发生了什么｡

00:31.500 --> 00:37.530
现在我们甚至要在更高的层次上进行研究, 因为我们要制造一个不仅有眼睛和完全连接各层的大脑,

00:37.530 --> 00:41.220
而且还有记忆的大脑｡

00:41.220 --> 00:46.470
因为正如我在上一节课中所说的,

00:46.470 --> 00:56.730
我们将在这个大大脑中添加一个神经网络的记录, 这将给予我们的大脑一个长时间的记忆, 这样它就可以理解时间关系, 输入图像的时间属性｡

00:56.850 --> 00:57.840
好了, 我们走吧｡ 

00:57.840 --> 01:04.410
更强大的大脑, 我可以告诉你, 我们现在要实现的模型真的, 真的很强大｡

01:04.710 --> 01:14.650
我们可以看到如何建造眼睛和做深度学习, 做深度强化学习是为了越来越接近人类大脑的工作方式｡

01:14.750 --> 01:19.350
你知道, 我们从大脑的基本关系开始, 从线性食物连接开始｡ 

01:19.350 --> 01:21.990
然后我们加了眼睛, 然后我们加了记忆｡ 

01:22.020 --> 01:24.830
谁知道我们会在未来的模型中添加什么？

01:24.840 --> 01:31.350
你知道, 在2018年, 也许他们会添加一些东西, 使大脑看起来更像一个人的大脑｡

01:31.350 --> 01:38.100
但是已经有了完全连接的层, 眼睛和记忆, 我们已经有了一个真正好的和功能性的大脑｡

01:38.520 --> 01:39.600
那就开始吧｡ 

01:39.600 --> 01:41.110
让我们把这个大脑｡ 

01:41.130 --> 01:48.600
像往常一样, 我们要为它创建一个类, 因为它有很多关于卷积和LCMS的性质｡

01:48.600 --> 01:54.930
所以我们要用init函数初始化所有这些, 创建所有这些连接,

01:54.930 --> 02:02.160
然后当然我们会有forward函数, 它会在大脑内部传播信号, 这样我们就可以最终得到输出｡

02:02.370 --> 02:03.950
好了, 准备好了吗？

02:03.960 --> 02:05.110
我们开始吧

02:05.130 --> 02:11.310
所以, 我们引入了一个新的课程, 我们称之为演员评论家｡ 

02:11.310 --> 02:13.650
因为, 当然, 我说的是大脑｡ 

02:13.650 --> 02:21.900
但我们不要忘记我们正在制作a3c模型, 它是基于主动批评原则, 演员和批评者是分开的｡

02:21.900 --> 02:27.600
所以我们实际上会为演员和评论家建立一个线性的, 完整的联系｡

02:27.600 --> 02:28.860
你会看到我们是如何做到的｡ 

02:28.860 --> 02:30.600
其实很简单｡ 

02:30.600 --> 02:40.650
演员评论家, 这个演员评论家类继承自尾注模块, 这样我们就可以使用所有的PyTorch工具了｡

02:40.650 --> 02:44.010
因此, 让我们这样做以从节点模块继承｡ 

02:44.010 --> 02:49.080
好吧, 我们得先拿下火炬图书馆, 然后再拿下那个｡ 

02:49.080 --> 02:49.830
然后就｡ 

02:49.830 --> 02:51.900
还有那个和模块｡ 

02:52.980 --> 02:53.640
好吧, 我会的

02:53.940 --> 02:55.560
这样我们就能继承它｡ 

02:56.870 --> 02:57.200
好吧, 我会的

02:57.200 --> 03:01.430
这就是我们的第一个函数, 当然, 也就是init函数｡ 

03:01.430 --> 03:09.800
所以我们从双下划线开始, 然后这个init函数将把self和对象作为参数,

03:09.800 --> 03:17.060
然后是输入形状,

03:17.060 --> 03:25.640
也就是我们输入图像的维度, 我们称之为输入和动作空间, 基本上是包含所有动作的空间｡

03:25.880 --> 03:30.410
我们也可以, 从这个动作空间, 我们可以得到动作的数量,

03:30.410 --> 03:33.740
也就是可能的动作的数量, 我们很快就会得到｡

03:33.740 --> 03:35.690
所以我们也需要它｡ 

03:36.140 --> 03:39.320
这就是我们需要的论据｡ 

03:39.320 --> 03:45.230
然后让我们进入函数内部, 创建所有适合我们大脑的变量｡ 

03:45.590 --> 03:51.350
但是在我们这么做之前, 记住我们要做什么来激活继承,

03:51.350 --> 03:54.740
我们可以使用输入模块中的所有工具｡

03:54.740 --> 04:01.100
我们必须以这种方式使用超级函数, 在其中输入actor｡ 

04:01.770 --> 04:07.470
批判者认为是我们的类然后自我为对象上来的｡ 

04:07.980 --> 04:09.850
好吧, 那么, 圆圆｡ 

04:09.960 --> 04:12.900
我们再次使用init｡ 

04:13.940 --> 04:14.710
功能｡ 

04:14.720 --> 04:15.420
我们走吧｡ 

04:15.440 --> 04:19.880
这给了我们所有的工具, 我们将需要从火炬建立我们的大脑｡ 

04:20.210 --> 04:21.920
好吧, 那么｡ 

04:21.920 --> 04:24.590
好了, 是时候让眼睛的眼睛｡ 

04:24.620 --> 04:26.170
这就是回旋｡ 

04:26.180 --> 04:34.040
所以我们会很快地做, 因为我们已经详细解释过了, 因为记住末日之眼是有眼睛的｡

04:34.040 --> 04:35.300
所以完全一样｡ 

04:35.300 --> 04:41.360
我们要做一些卷积, 我们将使用一个非常简单的架构, 有32个大小为3 × 3的特征检测器,

04:41.360 --> 04:45.130
步长为2, 填充为1｡

04:45.140 --> 04:53.510
这是一个非常经典的架构, 但这实际上足以确保眼睛了解在突破游戏中发生了什么｡

04:54.290 --> 04:54.620
好吧, 我会的

04:54.620 --> 04:56.540
让我们来做这些回旋｡ 

04:56.540 --> 05:01.610
所以我们从self开始因为卷积是对象的变量｡ 

05:01.610 --> 05:06.680
所以self, 我们可以称之为conf, 这里有四个卷积｡ 

05:06.680 --> 05:15.260
所以我把这个叫做conf 1, 我们取GN模块点, 然后取conf 2,

05:15.290 --> 05:20.630
d类因为实际上con 1是这个类的一个对象.

05:21.350 --> 05:25.790
然后在里面首先输入图像的形状｡ 

05:25.790 --> 05:32.450
这就是我们现在所拥有的, 我们可以复制它, 并将其作为第一个输入｡ 

05:32.810 --> 05:38.450
那么第二个参数是特征检测器的数量或者也是内核的数量｡ 

05:38.450 --> 05:42.590
所以我们要选32个, 就像我们刚才说的, 经典的选择｡ 

05:42.590 --> 05:45.020
然后我们需要选择内核的大小｡ 

05:45.020 --> 05:49.970
这是将在输入图像上滑动的单元格的数量｡ 

05:49.970 --> 05:52.700
所以, 记住, 我们可以选择三个, 四个或五个｡ 

05:52.700 --> 05:54.050
这是常见的选择｡ 

05:54.050 --> 05:55.730
现在我们选三个｡ 

05:56.590 --> 06:01.930
然后我们将选择步幅2和｡ 

06:02.640 --> 06:04.740
填充值为1｡ 

06:05.010 --> 06:05.790
我们走吧｡ 

06:05.970 --> 06:16.110
这是从输入图像到由32个卷积图像组成的第一个卷积层的第一个卷积｡

06:16.110 --> 06:18.780
现在我们准备进行第二次卷积｡ 

06:18.780 --> 06:21.390
所以实际上几乎是一样的｡ 

06:21.390 --> 06:29.430
所以我复制这条线, 粘贴到下面, 但是再粘贴到下面, 最后一次粘贴,

06:29.430 --> 06:34.140
因为我们有四个卷积, 几乎没有什么要改变的｡

06:34.440 --> 06:42.480
所以我们已经可以把这里的, 一个一个数转换成一个一个三, 然后一个一个四｡ 

06:42.510 --> 06:44.880
这将是我们的四个回旋｡ 

06:44.880 --> 06:49.320
现在我们当然需要做一些改变, 但不会太多, 因为我们将保留一个字符串, 每个字符串为2,

06:49.320 --> 06:51.780
填充为1｡

06:52.200 --> 06:54.930
它们都有32个特征探测器｡ 

06:54.930 --> 06:58.530
这是32个输出卷积图像｡ 

06:58.530 --> 07:04.020
但是这里, 记住这对应于卷积的左边部分｡ 

07:04.020 --> 07:08.520
所以实际上, 这对应于前面卷积的右边部分｡ 

07:08.520 --> 07:10.200
你知道, 记住, 这就像多米诺骨牌｡ 

07:10.200 --> 07:11.280
所以这真的很简单｡ 

07:11.280 --> 07:16.080
因此这里我们必须输入32, 这里也是｡ 

07:17.070 --> 07:21.870
我们很容易看到32和32｡ 

07:22.170 --> 07:22.500
好吧, 我会的

07:22.500 --> 07:28.680
总而言之, 我们从输入维数为num的输入图像开始｡ 

07:29.190 --> 07:35.520
通过第一次卷积, 我们得到32个卷积图像, 每个图像检测一个特定特征｡ 

07:35.550 --> 07:43.170
然后, 从这32个卷积图像中, 我们应用第二次卷积以得到32个新的卷积图像｡ 

07:43.170 --> 07:46.290
这32张新的图像也是一样｡ 

07:46.290 --> 07:50.880
我们应用第三次卷积再次得到32个新的卷积图像｡ 

07:50.880 --> 07:57.060
最后, 从这32个卷积图像中, 我们应用第四个卷积来得到图像｡ 

07:57.300 --> 07:57.780
好吧, 我会的

07:57.780 --> 08:01.440
这就够了, 不然我就有监护人了｡ 

08:01.440 --> 08:02.970
它会很好地探测到球｡ 

08:03.510 --> 08:03.870
好吧, 我会的

08:03.870 --> 08:05.580
这就是卷积｡ 

08:05.580 --> 08:07.130
眼睛就这样了｡ 

08:07.140 --> 08:09.440
现在让我们来处理一下记忆｡ 

08:09.450 --> 08:14.220
我们正在实现的这个大脑的新功能与之前的tune相反｡ 

08:14.490 --> 08:20.220
它不仅会有一个监督,

08:20.220 --> 08:26.010
而且它会有一个超级记忆, 一个长记忆, 因为我们要实现一个STM长短期记忆,

08:26.010 --> 08:33.810
这是一种常规的神经网络, 它给你的模型某种长记忆, 这样它就可以从过去学习一些长时间的关系｡

08:34.230 --> 08:37.560
同样我们也要创建一个新变量｡ 

08:37.560 --> 08:43.440
我从self和这个新变量开始, 我们将把它简称为lshtm,

08:43.440 --> 08:46.950
因为它对应于大脑中的Lshtm网络.

08:47.040 --> 08:48.360
所以Lshtm｡ 

08:48.690 --> 08:56.220
现在在我们写STM的代码之前, 让我们确保我们理解了大脑的lshtm部分将做什么｡

08:56.220 --> 09:03.900
因此, 正如我们所理解的, lshtm被用于学习输入图像的输入的时间属性｡

09:03.900 --> 09:09.330
例如, 如果球击中砖块, lshtm会对反弹进行编码｡ 

09:09.540 --> 09:11.250
所以这是首先要了解的｡ 

09:11.250 --> 09:14.790
它会对游戏中发生的事情进行编码｡ 

09:14.790 --> 09:20.280
然后, 当我们实现LSHTM时, 需要理解的下一件重要事情是,

09:20.280 --> 09:22.560
我们需要选择时态依赖关系的顺序｡

09:22.680 --> 09:28.590
在这里, 因为我们要给我们的神经网络输入一个四幅图像的序列,

09:28.590 --> 09:32.700
那么这意味着我们已经可以学习一些顺序的时间依赖性｡

09:32.700 --> 09:39.720
因为这是一些时间依赖关系, 在90加1发生的事情取决于在时间发生的事情｡

09:39.720 --> 09:42.960
倒数一, 倒数二, 倒数三.

09:42.960 --> 09:45.420
所以我们绝对可以做到｡ 

09:45.420 --> 09:51.360
但好消息是, 我们将使用lshtm, 因此,

09:51.360 --> 09:53.850
我们将能够学习一些更复杂的时间关系｡

09:54.270 --> 09:59.160
也就是说, 例如, 我们可以学习一些时间属性, 在时间t加1发生的事情,

09:59.160 --> 10:00.690
将取决于在时间t发生的事情｡

10:00.690 --> 10:05.520
减一, 减二, 减三, 减到, 减n.

10:05.700 --> 10:10.380
这是lshtm中的长时间部分, 长时间, 短时间记忆｡ 

10:10.380 --> 10:14.610
通过Lshtm团队, 我们可以了解一些非常复杂的时间关系｡ 

10:15.360 --> 10:17.580
好吧, 我们把名单加起来｡ 

10:17.970 --> 10:25.200
为此, 我们将使用RN模块, 然后添加Class Lshtm单元格,

10:25.320 --> 10:31.290
这将创建此Lshtm对象, 它将表示新网络的Lshtm部分｡

10:31.290 --> 10:37.130
因为现在还有一个重要的事情需要理解, 那就是我们正在做一个C, R和n, 你知道,

10:37.170 --> 10:39.480
一个卷积神经网络｡

10:39.480 --> 10:42.780
雅顿的部分在CNN之后｡ 

10:42.780 --> 10:51.150
因此, 现在, 我们需要在Lshtm单元中输入的是卷积后输出的大小｡

10:51.150 --> 10:55.980
所以是32次, 3乘3｡ 

10:55.980 --> 11:02.610
所以这32乘以3乘以3实际上是四次卷积后的输出｡ 

11:02.610 --> 11:07.500
但这变成了R和Lshtm网络的输入｡ 

11:07.590 --> 11:13.620
现在为什么四个卷积的输出是32倍, 3乘以3？

11:13.620 --> 11:15.900
别担心, 没那么直接｡ 

11:15.900 --> 11:17.790
这实际上不是一个简单的公式｡ 

11:17.790 --> 11:26.460
但是, 有一个公式可以在将卷积的合并图像和卷积图像展平后计算输出神经元的数量｡

11:26.460 --> 11:31.920
但是如果我们把这个大公式的项集合起来, 我们得到32次, 三乘三｡ 

11:31.950 --> 11:36.000
我不想在这上面花太多时间, 因为我们还有很多事情要做｡ 

11:36.000 --> 11:39.330
另外, 我们已经做了一个函数来计算这个数｡ 

11:39.330 --> 11:42.360
记住, 这是为了极速

11:42.360 --> 11:46.710
神经元的功能是让你可以重复使用它, 如果你想, 如果你不相信｡ 

11:46.710 --> 11:53.250
但这只是我们在收集了这个大公式计算的项后得到的结果, 输出的数量｡

11:53.250 --> 11:55.530
这是第一个论点｡ 

11:55.530 --> 12:03.570
第二个参数是lshtm的输出神经元的数量我们取256个.

12:04.510 --> 12:04.890
好吧, 我会的

12:05.050 --> 12:06.920
那么现在这意味着什么呢？

12:06.940 --> 12:15.640
这意味着现在我们有了一个向量来编码博弈中的每个事件, 换句话说, 我们有了一个编码状态.

12:15.640 --> 12:21.430
所以现在我们可以把演员和评论家分开了, 因为, 你知道, 我们要做两个独立的神经网络,

12:21.430 --> 12:27.070
一个给演员, 一个给评论家｡

12:27.070 --> 12:33.760
但是, 这两个神经网络的图像编码和时间关系是相同的｡

12:33.760 --> 12:37.660
这是我们为这两个神经网络做的共同部分｡ 

12:37.660 --> 12:41.260
这将是两个神经网络的相同开始｡ 

12:41.260 --> 12:46.120
但是现在演员和评论家的关系要改变了因为我们要为演员建立一个线性的,

12:46.120 --> 12:51.820
完整的联系, 为评论家建立一个不同的线性的, 完整的联系｡

12:52.000 --> 12:56.160
我们先休息一下, 在下一个教程中再讲｡ 

12:56.170 --> 12:57.400
在那之前, 好好享受吧｡ 

12:57.400 --> 12:57.880
一､