WEBVTT

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

00:02.300 --> 00:07.180
现在我们要做一个完整的循环来计算保单损失和价值损失｡ 

00:07.190 --> 00:12.380
一旦我们有这两个损失, 我们将能够使用我们的优化器, 以应用随机梯度下降,

00:12.380 --> 00:14.270
以减少损失｡

00:14.660 --> 00:14.960
好吧, 我会的

00:14.960 --> 00:15.780
好了, 我们走吧｡ 

00:15.800 --> 00:17.480
我们从这里开始

00:17.480 --> 00:23.240
顺便说一下, 在上一个教程中, 我们实现了这一节, 我忘记删除缩进｡ 

00:23.240 --> 00:24.200
对不起, 我很抱歉

00:24.200 --> 00:30.350
所以从r开始, 这里不是for循环, 现在我们开始一个新的for循环.

00:30.350 --> 00:35.810
我从四个开始, 现在我们要做的是, 从过期期间完成的最后一步开始,

00:35.810 --> 00:40.220
我们要在时间上向后移动｡

00:40.220 --> 00:51.050
这就是为什么我在这里做了四个I, 在反向范围内, 因为奖励是一个列表｡ 

00:51.050 --> 00:57.050
因为探索的每一步都有奖励, 因为每一步我们都有奖励,

00:57.050 --> 01:03.970
当Len的奖励是这个步数时, 这里使用了相反的方法, 这样我们就可以回到过去｡

01:03.980 --> 01:04.970
好了, 我们走吧｡ 

01:04.970 --> 01:11.510
现在我们要做的是更新累积奖励R我们要这样更新它.

01:11.510 --> 01:13.790
这实际上和我们为Doom做的一样｡ 

01:13.940 --> 01:18.290
它将等于gamma, 我们从参数中得到｡ 

01:18.290 --> 01:31.220
我先取参数gamma乘以R, 再加上步骤的奖励, 我们可以通过取列表奖励和取高索引来得到.

01:31.250 --> 01:35.930
首先, 这将是最后一步的奖励, 然后是前一步的奖励,

01:35.930 --> 01:43.250
等等｡ 每次我们更新的时候, 都是把它乘以gamma, 然后在这一步加上这个奖励｡

01:43.340 --> 01:47.000
记住, 通过这样做, 我们最终会得到｡ 

01:47.000 --> 01:48.860
所以我打算把它写成评论｡ 

01:48.890 --> 01:56.510
在循环结束时,

01:56.510 --> 02:08.450
我们得到的累积奖励等于r 0, 第0步的奖励加上γ乘以r

02:08.450 --> 02:25.880
1, 第一步的奖励加上γ的平方乘以R, 第二步的奖励加上γ的n次幂减去1乘以在第一步得到的奖励, 再减去1其中n是步数｡

02:25.880 --> 02:27.290
但以后要小心｡ 

02:27.290 --> 02:32.210
最后, 我们会得到步数的幂｡ 

02:33.460 --> 02:39.640
将该值乘以应用于最后一个状态的V函数的值｡ 

02:39.970 --> 02:47.410
这是我们在最后应该得到的, 这是我们得到的, 因为这里我们得到了最后一步的值,

02:47.410 --> 02:50.740
因为这是在for循环的最后完成的｡

02:50.920 --> 02:56.050
所以我们得到了这个值, 并把我们的设为等于这个值｡ 

02:56.140 --> 03:03.310
所以现在在第二个for循环开始的时候, 这里等于这个状态的值｡

03:03.310 --> 03:10.150
但是这样做的话, 我们最后得到的是等于或者零加上γ

03:10.150 --> 03:16.570
r, 一加上γ的平方或者二加上γ的n次幂减一乘以步骤n的奖励减一加上γ的步数的幂,

03:16.570 --> 03:20.700
乘以这个较小的状态的值｡

03:20.710 --> 03:25.840
所以这是在计算累积奖励时要理解的主要事情｡ 

03:25.840 --> 03:32.740
这就是为什么从这里开始, 用这里的值初始化我们的, 然后执行这个反向的for循环,

03:32.740 --> 03:37.270
以使最后的方程完美｡

03:37.270 --> 03:43.570
现在我们有了累积奖励的正确值, 我们来计算一下优势.

03:43.600 --> 03:48.940
这里的优势就是获得奖励的优势与价值相比｡ 

03:48.940 --> 04:01.390
所以我将引入一个新的可变优势它等于这个累积奖励减去在第二步得到的V函数的值.

04:01.390 --> 04:07.570
因此, 这是误差减去值, 即完美｡ 

04:07.570 --> 04:13.010
而既然我们有了累积奖励和优势, 那么我们就可以得到价值损失｡ 

04:13.030 --> 04:20.830
这是我们现在能得到的第一个类, 我们将得到价值损失变量, 它将按照下面的方式更新.

04:20.830 --> 04:35.320
记住到目前为止, 值损失被初始化为0所以我们要再次取值损失并加0.

04:35.320 --> 04:35.320
5倍于优势的平方根所以我们可以这样得到｡ 

04:35.320 --> 04:39.190
优势点战俘二号｡ 

04:39.220 --> 04:43.120
所以这只意味着平方的优势, 优势在2的幂｡ 

04:43.210 --> 04:52.390
而这正是价值损失, 即批评者对V函数输出的价值的预测所产生的损失｡

04:52.870 --> 04:59.710
所以这是价值损失是有道理的, 因为记住, 在状态状态中,

04:59.710 --> 05:04.600
行动A的优势, 是Q值和V函数值的差｡

05:04.600 --> 05:11.140
所以当我们很好地发挥最优作用时, 我们得到的定态为｡ 

05:11.170 --> 05:17.530
Q优的最优动作是一个明星在状态中扮演的角色｡ 

05:18.330 --> 05:21.960
等于我们存储的状态的最佳值｡ 

05:21.960 --> 05:28.230
所以很容易理解当优势不等于零时, 两者之间会有差别,

05:28.230 --> 05:32.700
这就是损失的衡量方法.

05:33.870 --> 05:37.200
所以价值损失少算了一个下来｡ 

05:37.200 --> 05:38.850
我们现在还有一个要去｡ 

05:38.850 --> 05:42.690
这就是保单损失, 这就是我们现在要计算的.

05:42.690 --> 05:49.530
为了计算它, 我们需要再次考虑广义收益估计, 因为要计算策略损失,

05:49.530 --> 05:55.500
我们需要广义收益估计, 而要得到广义收益估计,

05:55.500 --> 05:59.610
我们首先需要状态值的时间差｡

05:59.610 --> 06:02.940
所以我们有很多东西要计算｡ 

06:02.940 --> 06:05.640
我们从这个时间差开始｡ 

06:05.640 --> 06:10.290
一旦我们得到时间差, 我们将得到广义优势估计｡ 

06:10.290 --> 06:14.700
而一旦我们得到了广义收益估计, 我们就会得到保单损失｡ 

06:14.700 --> 06:15.390
好吧, 我会的

06:15.390 --> 06:18.510
让我们从时间差异开始｡ 

06:18.570 --> 06:31.620
所以t等于第二步的奖励加上gamma, 这要归功于我们的参数列表｡ 

06:31.620 --> 06:45.900
所以参数γ乘以第二步的值加1, 然后加上这个数据, 减去第一步的值.

06:46.740 --> 06:49.380
同样, 我们添加这些数据

06:50.150 --> 06:50.480
好吧, 我会的

06:50.480 --> 06:53.880
这就是状态值的时间差的公式｡ 

06:53.900 --> 06:58.310
现在我们可以更新到广义优势估计｡ 

06:58.310 --> 07:10.760
它是如何更新的, 我们把气体乘以伽马参数, 伽马乘以单元格, 我们也用参数访问单元格｡

07:10.760 --> 07:18.320
所以我们取params单元格, 加上状态值的时间差｡ 

07:18.320 --> 07:19.670
所以要小心｡ 

07:19.670 --> 07:26.930
我们在一个for循环中, 每次我们把气体乘以gamma和tau, 然后加上时间差｡ 

07:26.930 --> 07:33.800
所以重要的是要明白,

07:33.950 --> 07:41.630
在这个循环的最后, 这个广义的优势估计将等于太阳在所有步骤上的gamma倍｡

07:41.630 --> 07:44.810
Tau的威力是AI的两倍｡ 

07:44.990 --> 07:47.390
步进时的时间差｡ 

07:48.110 --> 07:48.440
好吧, 我会的

07:48.440 --> 07:50.300
记住这一点非常重要｡ 

07:50.390 --> 07:58.810
现在我们有了广义优势, 估计和时间差, 我们可以最终计算保单损失｡

07:58.820 --> 07:59.990
所以我们开始吧｡ 

08:00.020 --> 08:10.070
我们将用下面的方法更新保单损失, 取旧的保单损失,

08:10.070 --> 08:23.870
减去第二步得到的对数概率, 再乘以广义收益估计, 然后我们要输入一个变量, 因为我们要计算梯度.

08:23.870 --> 08:26.930
因此, 它必须附加到动态图中的梯度｡ 

08:26.930 --> 08:36.470
然后再加上负0｡  01乘以熵, 即在for循环的步骤II中获得的熵｡ 

08:37.040 --> 08:39.200
再说一遍, 现在要小心｡ 

08:39.290 --> 08:45.110
这是for循环中的计算, 这意味着在for循环结束时,

08:45.110 --> 08:48.140
我们将得到的是策略丢失｡

08:50.100 --> 08:54.180
等于步骤的负和｡ 

08:55.060 --> 09:06.130
第二步的策略的乘积log乘以广义收益估计加上这个0｡

09:06.130 --> 09:06.130
01.

09:07.010 --> 09:09.890
有时熵在台阶高处｡ 

09:09.920 --> 09:10.640
好了, 我们走吧｡ 

09:10.640 --> 09:12.890
现在的政策是什么？

09:12.890 --> 09:18.200
这是动作的软最大概率和步骤的熵｡ 

09:18.200 --> 09:22.760
你们知道它是什么, 它是我们之前计算的, 我们附加到列表中的｡ 

09:22.760 --> 09:24.050
所以我们已经有了｡ 

09:24.050 --> 09:29.420
但这个饼图是这些动作的软最大概率｡ 

09:29.960 --> 09:31.990
我们为什么要在这里加减号呢？

09:32.000 --> 09:36.980
这是因为概率的对数和熵都是负值｡ 

09:36.980 --> 09:44.180
既然我们想最小化它们的绝对值, 我们就必须把最后一个看作是对数似然, 而不是距离｡

09:44.180 --> 09:51.230
你知道, 我们想最大化的概率采取行动, 将最大化的优势｡ 

09:51.260 --> 09:52.940
这就是它背后的全部想法｡ 

09:52.940 --> 09:57.950
我们希望最大化采取行动的概率, 从而使优势最大化｡ 

09:57.980 --> 10:05.630
你们可能想知道, 熵系数的作用是什么, 也就是这个系数｡

10:05.630 --> 10:05.630
在这儿吗？

10:05.660 --> 10:13.370
它的目的只是为了防止太快落入一个陷阱, 在这个陷阱中, 除了一个概率为1的行为外,

10:13.370 --> 10:19.280
所有行为的概率分布都为零｡

10:19.280 --> 10:22.310
如果发生这种情况, 熵就会最小化｡ 

10:22.310 --> 10:29.990
这就是为什么我们要加上这个系数｡  01在这里这将使熵在梯度下降中增加｡

10:30.910 --> 10:31.320
好吧, 我会的

10:31.420 --> 10:35.220
所以现在好消息是最困难的部分已经完成了｡ 

10:35.230 --> 10:40.990
我们有两个损失, 因此我们现在只需要做的, 我们已经知道怎么做, 就是执行随机梯度下降,

10:40.990 --> 10:44.560
以减少这两个损失｡

10:44.950 --> 10:53.110
我们现在要做的是退出这个循环, 使用我们单独创建的优化器｡

10:53.290 --> 10:58.420
然后记住, 我们要做的第一件事是把所有梯度参数初始化为零｡ 

10:58.420 --> 11:04.210
为了做到这一点, 我们添加点, 然后零下划线网格方法｡ 

11:04.690 --> 11:06.790
好吧, 那就这样吧｡ 

11:06.790 --> 11:11.680
现在我们要执行反向传播, 但我们要给予保单的重要性是损失价值的两倍,

11:11.680 --> 11:15.490
因为保单损失更小.

11:15.730 --> 11:25.630
所以为了做到这一点, 我们要在括号里加上一个策略, 在loss加0下面划线｡  5.价值损失｡ 

11:26.620 --> 11:30.160
所以4. 5倍的价值损失｡ 

11:30.430 --> 11:38.260
我们在这里加上一个点, 然后用向后的方法来执行向后传播｡ 

11:38.260 --> 11:46.870
多亏了这个技巧, 保单损失加上一半的价值损失, 我们对保单的重视程度是损失价值的两倍.

11:47.680 --> 11:53.560
然后我们要使用另一个技巧, 就是防止梯度取非常大的值,

11:53.560 --> 11:56.770
从而生成算法｡

11:56.770 --> 12:03.700
要做到这一点, 首先要得到我们的torch库, 然后是torch库的内部模块,

12:03.970 --> 12:07.210
最后是utils子模块｡

12:07.210 --> 12:14.080
现在我们要使用函数clip, 在score范数上用下划线格拉德, 我们要输入模型参数,

12:14.080 --> 12:20.740
第二个输入值是40｡

12:20.980 --> 12:27.850
这个技巧基本上可以确保梯度不会取非常大的值, 然后生成算法｡

12:28.000 --> 12:31.480
对于那些可能想知道这40年到底是什么的人｡ 

12:31.570 --> 12:38.410
这就意味着我们使用这个值, 使得梯度的范数保持在0和40之间｡

12:38.410 --> 12:42.220
因此, 这就是我们如何防止梯度取太大的值｡ 

12:43.660 --> 12:44.980
现在我们差不多完成了｡ 

12:44.980 --> 12:52.750
请记住,

12:52.750 --> 13:00.610
我们在文件的开头创建了这个确保共享函数, 这是为了确保代理和共享模型共享相同的梯度, 并且这样做是为了确保我们可以在这里应用这个函数｡

13:01.030 --> 13:14.290
因此, 我们将添加“确保共享梯度”, 以确保模型和共享模型共享相同的梯度｡

13:14.500 --> 13:14.830
好吧, 我会的

13:14.830 --> 13:16.450
那只是预防措施｡ 

13:16.450 --> 13:21.310
我不确定这是否有必要, 但是, 你知道, 至少我们在这里不会有任何问题｡ 

13:22.440 --> 13:29.730
最后, 最后一行代码, 当然, 我们将执行优化步骤以减少损失,

13:29.730 --> 13:32.040
您知道如何执行｡

13:32.070 --> 13:40.310
当然, 我们使用优化器, 并在括号中添加该步骤, 这样就可以了｡ 

13:40.320 --> 13:43.210
我们大脑的训练结束了｡ 

13:43.260 --> 13:44.670
所以恭喜你

13:44.670 --> 13:46.820
我希望这不是太沉重｡ 

13:46.830 --> 13:49.410
别担心, 我会提供代码和所有注释｡ 

13:49.410 --> 13:53.190
所以如果你错过了任何细节, 你可以看看评论｡ 

13:53.190 --> 13:55.860
如果你还不明白什么也不用担心｡ 

13:55.860 --> 13:57.180
这是非常先进的｡ 

13:57.180 --> 14:00.600
不过放心, 这也是最强大的｡ 

14:00.600 --> 14:03.930
记住, 它是由谁创造出来的PyTorch｡ 

14:03.930 --> 14:07.800
所以我们真的是在用最好的东西, 最先进的东西｡ 

14:07.800 --> 14:13.560
所以, 如果你第一次没有得到所有的东西, 这是完全正常的, 但是通过多次的努力,

14:13.560 --> 14:15.840
你肯定会越来越舒服｡

14:16.260 --> 14:18.960
现在我们完成了训练｡ 

14:18.960 --> 14:22.770
所以基本上我们做了所有最重要的东西｡ 

14:22.770 --> 14:28.080
你知道, 我们通过构建神经网络的结构来制造大脑, 神经网络有回旋结构,

14:28.080 --> 14:30.360
LSHTM和完全连接的层｡

14:30.360 --> 14:34.290
我们通过编写训练代码来训练大脑｡ 

14:34.290 --> 14:37.080
所以基本上算法的核心已经完成了｡ 

14:37.080 --> 14:39.510
你成功了, 恭喜你.

14:39.510 --> 14:43.830
现在我们还有几件事要做, 但那只是为了得到有趣的部分｡ 

14:43.830 --> 14:53.970
你知道, 我们需要做这个测试, 人们失败, 这将测试代理人, 并提供视频的人工智能发挥突破｡

14:53.970 --> 14:55.980
所以这将是非常有趣的观看｡ 

14:56.010 --> 15:02.700
我们不会在PI文件中对该测试的所有行进行编码, 因为正如我们所说, 我们做了最重要的事情｡

15:02.700 --> 15:06.870
我将把它与a3c联系起来, 但我当然会解释代码｡ 

15:06.870 --> 15:11.670
最后我们有了这个主要的da pi文件, 它将执行代码｡ 

15:11.670 --> 15:15.840
从我们执行这段代码的那一刻起, 所有的代码都会生成｡ 

15:15.840 --> 15:23.790
所以大脑会被制造出来, 训练会发生, 人工智能会玩新的突破游戏, 我们会得到所有的视频｡

15:23.790 --> 15:26.370
所以我迫不及待地想最终看他们｡ 

15:26.370 --> 15:29.720
我们要看看人工智能是否足够聪明, 能接住球｡ 

15:29.730 --> 15:36.390
所以现在我将在下一个教程中看到你对PI的测试, 这样我们就可以在一些新的游戏中测试AI, 在那之前,

15:36.390 --> 15:39.000
享受AI｡