WEBVTT

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

00:02.250 --> 00:08.910
好的, 在我们做了这四个卷积和lshtm之后, 我们现在有了一个编码的状态,

00:08.910 --> 00:14.310
它将成为这两个神经网络的输入, 我们将为演员和评论家做这两个网络｡

00:14.490 --> 00:20.550
说到它们, 我们现在唯一要做的就是创建两个线性的, 完整的连接, 一个给演员,

00:20.550 --> 00:22.770
一个给评论家｡

00:22.980 --> 00:27.120
但在此之前, 我们需要得到可能的动作数｡ 

00:27.120 --> 00:32.310
所以我要在这里调用一个新的变量它不是对象的变量.

00:32.310 --> 00:38.790
所以这里我不会用self, 但我会创建变量num, 输出,

00:38.790 --> 00:44.100
它代表可能的动作数, 并把它从动作空间中取出来.

00:44.310 --> 00:46.800
所以我们采取行动的空间｡ 

00:47.600 --> 00:54.020
这将是init函数的输入, 当我们创建对象时,

00:54.020 --> 01:01.010
然后我们加上点n, 得到可能的动作数, 现在演员和评论家将分别得到相同的输入｡

01:01.010 --> 01:06.230
这是整个过程的输出, 包括卷积和LCM｡ 

01:06.230 --> 01:12.860
所以它会接受相同的输入, 也就是一个编码状态, 但是它们会有两个不同的线性食物连接, 这样我们最终得到两个神经网络,

01:12.860 --> 01:18.800
一个是演员的, 一个是丙烯酸的｡

01:18.800 --> 01:20.870
所以让我们做两个独立的神经网络｡ 

01:20.870 --> 01:27.020
但既然我们已经在这里做了大量的编码工作, 那么,

01:27.020 --> 01:33.440
我们只需要创建两个对象, 一个是演员的线性全连接, 另一个是评论家的线性全连接｡

01:33.440 --> 01:35.240
这正是我要做的｡ 

01:35.240 --> 01:42.080
我现在要创建两个对象, 第一个对象是评论家的线性食物连接,

01:42.080 --> 01:46.040
我把它命名为评论家下划线线性｡

01:46.310 --> 01:50.210
为了创造这种线性食物连接, 你知道怎么做｡ 

01:50.210 --> 01:56.090
我们只需要取RN模块, 然后是我们要输入的线性类,

01:56.090 --> 02:04.940
这里的输入神经元, 是所有这些编码的输出, 这里有卷积和LCM, 也就是256个神经元｡

02:04.940 --> 02:13.430
这里输入256, 然后我们会有一个输出, 因为记住, 神经网络的输出, 对于评论家来说,

02:13.430 --> 02:20.810
是V函数的值, 应用于输入状态, 我们在这里做的输入编码状态｡

02:20.930 --> 02:25.850
如果我们把输入状态称为se, 它就是所有这些的输出｡ 

02:25.850 --> 02:33.620
批评家的神经网络的输出是s, 因此它只有一个维度, 它只是一个值｡

02:33.620 --> 02:36.020
这里我们输入一个｡ 

02:36.260 --> 02:42.950
请记住, VSE是参与者之间共享的内容, 这样他们就可以获得一些共同的信息,

02:42.950 --> 02:46.340
以便以更相关的方式执行他们的操作｡

02:47.180 --> 02:50.330
这就是批评者的神经网络｡ 

02:50.330 --> 03:00.500
现在让我们建立一个新的参与者网络, 因此我在这里加入了self, 点参与者, 线性和same｡

03:00.500 --> 03:05.720
我们已经有了输入编码状态, 所以现在我们只需要添加一个线性全连接,

03:05.720 --> 03:11.150
因此我们取RN模块, 然后是线性类, 现在是相同的｡

03:11.150 --> 03:17.390
行动者的这个神经网络将采用大小为256的编码状态｡ 

03:17.390 --> 03:19.820
这里是256

03:19.820 --> 03:25.940
但是输出会有所不同, 因为你当然知道,

03:25.940 --> 03:33.560
神经网络对演员的输出是Q值, 输入状态的Q值, 我们在这里编码的那个, 还有动作板｡

03:33.560 --> 03:40.640
如果我们称之为编码状态, 我们可能会听到SW, 这个神经网络主动线性的输出,

03:40.640 --> 03:44.150
将是Q｡

03:44.660 --> 03:49.910
因为你知道, 我们有一个值为每个行动, 所以我们没有输出｡ 

03:49.940 --> 03:53.870
Q值, 因此这里的输出将为无｡ 

03:54.710 --> 03:59.090
因为没有输出, 所以实际上输出的是Q值的个数｡ 

03:59.690 --> 04:00.850
好的, 很好｡ 

04:00.860 --> 04:03.920
所以如果你想的话, 我可以帮你写｡ 

04:03.920 --> 04:17.210
对于评论家来说, 这里的输出是s, 其中s是编码状态, 而对于演员来说, 输出是Q, 作为a｡

04:17.960 --> 04:18.290
好吧, 我会的

04:18.290 --> 04:23.780
所以理解这种区别是非常重要的, 并且理解我们因此有两个独立的神经网络, 一个用于评论家,

04:23.780 --> 04:27.320
一个用于演员｡

04:28.200 --> 04:29.220
好的, 很好｡ 

04:29.220 --> 04:31.900
在这个函数中, 我们几乎已经完成了｡ 

04:31.920 --> 04:33.890
现在最重要的事情已经完成了｡ 

04:33.900 --> 04:40.710
剩下我们要做的就是初始化这两个神经网络的所有权值和所有偏差｡

04:40.710 --> 04:45.240
当然, 要做到这一点, 我们将使用前面创建的两个函数,

04:45.240 --> 04:48.030
即规范化列初始化和其中的权重｡

04:48.270 --> 04:49.680
所以让我们快速完成｡ 

04:49.680 --> 04:51.780
这将是相当容易和相当快｡ 

04:51.930 --> 04:58.170
首先我们要初始化一些随机权重, 为了做到这一点, 我们要把权重初始化函数应用到我们的对象上｡

04:58.170 --> 05:06.120
所以这里我们必须用self来得到我们的对象, 我们给我们的对象应用了, init函数中的权值｡ 

05:06.300 --> 05:13.140
所以在里面我们只需要输入初始化函数的权重就可以了｡ 

05:13.140 --> 05:15.690
将此函数应用于我们的对象｡ 

05:15.690 --> 05:21.720
通过这样做, 我们只是初始化一些随机权重, 以获得这些权重的未来最优学习｡

05:21.720 --> 05:27.420
现在我们要做的是为演员和评论家做一个特殊的规范化｡ 

05:27.420 --> 05:35.040
但请记住, 我想我在前面的教程中已经讲过了, 我们不会为评论家中的演员设置相同的方差｡

05:35.160 --> 05:40.350
演员会得到一个小的标准差, 一个小的方差, 而评论家会得到一个大的｡ 

05:40.680 --> 05:41.730
我们为什么要这么做？

05:41.730 --> 05:49.260
给演员权重一个小的标准差, 给评论家权重一个大的标准差, 目的是什么？

05:49.260 --> 05:53.640
这样就可以管理交易探索与剥削｡ 

05:53.640 --> 05:55.740
这正是我们这么做的目的｡ 

05:55.740 --> 06:04.110
通过给演员一个小的变化, 给批评家一个大的变化, 我们将有一个很好的管理探索与利用｡

06:04.410 --> 06:05.550
所以我们开始吧｡ 

06:05.580 --> 06:09.960
让我们先来看看行动者, 这样我们就把自我或对象｡ 

06:09.960 --> 06:14.730
然后我们将取演员的神经网络, 它是演员线性的｡ 

06:14.880 --> 06:21.300
然后我们要访问演员的神经网络的权重, 记住要访问权重的数据｡

06:21.300 --> 06:22.860
我们需要添加这些数据｡ 

06:23.250 --> 06:24.060
好吧, 我会的

06:24.060 --> 06:30.390
这样, 我们就得到了权重, 现在我们要使用函数normalized columns initialize｡ 

06:31.200 --> 06:33.870
所以我在这个基础上复制这个｡ 

06:34.080 --> 06:38.760
我们要输入自变量, 我们希望这些权重的标准差｡ 

06:38.970 --> 06:41.940
但首先, 请记住, 这个函数有两个参数｡ 

06:41.940 --> 06:44.970
首先是我们要初始化的权重｡ 

06:44.970 --> 06:49.650
所以我们只需要再把它粘贴到这里｡ 

06:49.650 --> 06:54.390
第二个参数是我们希望这些权重具有的标准差｡ 

06:54.390 --> 07:02.730
正如我们所说的, 我们想要一个小的标准差, 这个小的标准差是0｡  好极了｡

07:02.730 --> 07:05.640
这是演员神经网络的权重｡ 

07:05.640 --> 07:09.450
现在, 我们来看看演员的神经网络的偏差｡ 

07:09.600 --> 07:11.970
因此, 我们在这里要做几乎相同的事情｡ 

07:11.970 --> 07:20.070
我们将在下面的基础上复制, 将权重替换为偏倚, 以评估偏倚｡ 

07:20.070 --> 07:30.930
在数据之后, 我们只需要在输入零中添加填充和记忆, 因为我们希望所有的偏差都初始化为零｡

07:31.260 --> 07:37.800
所以实际上我认为这一行是不必要的, 因为你们还记得, 偏置已经被初始化为零了,

07:37.800 --> 07:41.340
这个填充函数在权重初始化函数中｡

07:41.340 --> 07:49.440
我们这样做只是为了确保偏置实际上被初始化为零, 但我认为这里已经完成了｡

07:49.440 --> 07:52.530
但不管怎样, 现在我们100%确定了｡ 

07:52.860 --> 07:53.280
好吧, 我会的

07:53.280 --> 07:55.920
现在我们要对评论家做同样的事情｡ 

07:55.920 --> 07:58.980
所以让我们高效地复制这两行｡ 

08:00.030 --> 08:02.430
我们把它们贴在这里和这里｡ 

08:02.430 --> 08:06.540
我们只是用评论家来代替演员｡ 

08:07.050 --> 08:08.850
现在也一样｡ 

08:08.850 --> 08:12.300
我们唯一需要改变的就是标准差｡ 

08:12.300 --> 08:15.690
我们想让评论家拥有新网络的权重｡ 

08:15.690 --> 08:23.430
大家还记得, 我们这次要一个大的标准差, 而不是｡  01, 我们将输入一个｡

08:23.580 --> 08:24.360
好了, 我们走吧｡ 

08:24.360 --> 08:33.120
演员的新网络权重的标准差很小, 而评论家的神经网络权重的标准差很大｡

08:33.150 --> 08:37.320
当然, 我们不要忘记用创造来代替演员｡ 

08:37.830 --> 08:38.190
好吧, 我会的

08:38.190 --> 08:39.030
现在我们没事了｡ 

08:39.630 --> 08:40.320
好的, 谢谢

08:40.320 --> 08:42.330
所以现在我们还有两件事要做｡ 

08:42.330 --> 08:45.750
首先, 也初始化STM的偏置｡ 

08:45.750 --> 08:50.610
为了做到这一点, 我们需要我们的对象自我, 因为LCM属于我们的对象｡ 

08:50.610 --> 08:57.930
然后, 我们采用STM, 然后是DOT, 然后我们将得到STM中的两种偏置｡

08:57.930 --> 09:04.430
这是斜线下划线i, h, 另一个是斜线下划线h, h｡ 

09:04.440 --> 09:09.810
这就是LCM中的两种偏置, 它们将被初始化为零｡ 

09:09.810 --> 09:19.620
所以首先我们访问数据, 然后我们使用填充下划线函数, 用零填充所有这些偏差｡

09:19.620 --> 09:21.180
将它们初始化为零｡ 

09:21.780 --> 09:22.200
好吧, 我会的

09:22.200 --> 09:27.150
而现在对于第二组偏见, 我们在这里补充一下｡ 

09:27.700 --> 09:30.880
同样的位我们用hh替换了ih｡ 

09:31.390 --> 09:35.770
好的, 这就是用零初始化LSB组的偏置｡ 

09:36.190 --> 09:43.000
现在, 我们需要做的最后一件事是使用从NAT模块继承的方法, 即train方法｡

09:43.000 --> 09:47.290
基本上, 这只是一种将模块置于训练模式的方法｡ 

09:47.290 --> 09:48.670
那它有什么用呢？

09:48.670 --> 09:55.390
其用途是, 如果存在任何退出和批量标准化, 则允许激活｡ 

09:55.390 --> 10:03.010
因此, 要使用它, 我们只需添加self dot train, 这样就可以使模块处于完美的train模式｡ 

10:03.010 --> 10:05.440
这样我们就完成了init函数｡ 

10:05.440 --> 10:10.960
我们有卷积, 我们有lshtm, 我们有两个独立的神经网络,

10:10.960 --> 10:15.340
分别用于评论家和演员, 所有的权重和偏差都是初始化好的｡

10:15.340 --> 10:16.630
所以这一切都很好｡ 

10:16.630 --> 10:21.490
我们已经准备好进行下一步了, 那就是建立正向函数,

10:21.490 --> 10:28.450
它将从最初的输入图像开始, 把信号正向传播到整个大脑, 直到我们得到输出｡

10:28.780 --> 10:30.670
所以我们在下一个教程中做这个｡ 

10:30.670 --> 10:32.410
在那之前, 好好享受我｡