WEBVTT

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

00:02.290 --> 00:06.060
好的, 我们计算了熵, 并把它加到熵列表中｡ 

00:06.060 --> 00:12.660
现在我们要做的是根据集合max的概率分布随机抽取一个动作.

00:12.990 --> 00:14.460
所以我们开始吧｡ 

00:14.460 --> 00:15.590
这就是下一步｡ 

00:15.600 --> 00:19.840
我们仍然在循环中, 因为我们仍然在这里的步骤上运行｡ 

00:19.860 --> 00:22.370
所以你现在知道怎么玩动作了｡ 

00:22.380 --> 00:28.560
我们首先会引入一个变量来表示这个动作,

00:28.560 --> 00:38.340
然后我们会得到概率分布, 我们会用多重正态函数从这个概率分布中随机抽取.

00:39.030 --> 00:41.210
然后我们将这些数据相加｡ 

00:41.220 --> 00:47.610
所以需要注意的是, 作用量实际上是一个只有一个值的张量｡ 

00:47.610 --> 00:50.820
但您不应将其视为一个简单的值｡ 

00:50.820 --> 00:56.940
你应该把它看作是一个维度张量, 一个接一个地包含这个动作的值｡ 

00:56.940 --> 00:59.010
因为它没有被挤压｡ 

00:59.550 --> 01:09.720
现在仍然在同一个for循环中, 我们要得到与刚才执行的动作相关的对数概率｡

01:09.990 --> 01:18.000
所以我在这里更新我的对数概率, 用上一个, 我们在这里计算的上一个对数问题｡

01:18.000 --> 01:25.710
然后我将使用gather方法, 我将向其中输入一个和显示的动作,

01:25.710 --> 01:31.290
因为我们想得到与这个动作相关的对数概率｡

01:31.290 --> 01:38.940
作为第二个参数, 我将输入我的操作, 但它必须是getter函数所要求的变量,

01:38.940 --> 01:43.980
而gather函数只使用张量整数作为索引｡

01:44.340 --> 01:44.700
好吧, 我会的

01:44.700 --> 01:48.780
现在, 我们得到了与所显示的操作关联的日志属性｡ 

01:48.780 --> 01:53.610
现在下一步是把我们得到的附加到这个列表上｡ 

01:53.610 --> 01:55.500
所以我们得到了这个值｡ 

01:55.500 --> 01:58.560
这就是我们在这里得到的模型输出｡ 

01:58.560 --> 02:00.720
然后我们还得到了原木道具｡ 

02:00.720 --> 02:03.900
因此, 我们要将日志属性添加到日志属性列表中｡ 

02:03.900 --> 02:06.810
我们已经把熵添加到熵列表中了｡ 

02:06.810 --> 02:09.480
所以我们是好的, 奖励, 我们会得到它之后｡ 

02:09.480 --> 02:15.060
因此, 我们现在将把值和日志属性附加到值列表和日志属性列表中｡ 

02:15.270 --> 02:16.110
我们开始吧

02:16.110 --> 02:17.910
我们拿着我们的价值清单｡ 

02:17.910 --> 02:24.690
我们添加了append函数, 并添加了模型刚刚返回的值｡ 

02:24.780 --> 02:25.620
好极了｡ 

02:25.800 --> 02:28.470
然后对log probs进行相同操作｡ 

02:28.560 --> 02:35.700
我们刚刚得到了新的日志问题, 我们将把它附加到日志问题列表中｡ 

02:36.000 --> 02:42.570
所以在这个append函数中, 我们输入log prop我们刚才计算的log prop｡ 

02:43.870 --> 02:44.200
好吧, 我会的

02:44.200 --> 02:46.960
所以我们的名单现在已经更新了｡ 

02:46.990 --> 02:52.690
现在我们要做的就是玩这个动作, 因为实际上就在这里,

02:52.690 --> 02:56.440
我们是从概率分布中随机抽取的.

02:56.440 --> 03:02.530
但实际上我们还没有播放它, 我们现在要播放它, 这样我们就可以达到新的状态, 从而获得新的传输,

03:02.530 --> 03:05.980
并播放它｡

03:05.980 --> 03:10.270
我们将以我们的环境为例, 因为我们在我们的环境中进行动作｡ 

03:10.270 --> 03:17.980
然后我们将使用step方法, 并在其中指定要播放的动作｡ 

03:17.980 --> 03:25.060
为了做到这一点, 我们采取行动, 我们把这个numpy加上, 因为这是阶跃函数所期望的｡

03:25.930 --> 03:27.610
但这个回报｡ 

03:28.770 --> 03:37.380
实际上是新的状态和新的奖励, 因为达到新的状态, 我们得到了新的奖励,

03:37.650 --> 03:42.990
也得到了新的完成值来知道游戏是否完成.

03:43.350 --> 03:43.710
好吧, 我会的

03:43.710 --> 03:48.300
所以有了这个, 我们玩动作, 我们达到了新的状态, 我们得到了新的奖励｡ 

03:48.300 --> 03:50.070
我们知道我们是否完成了游戏｡ 

03:50.250 --> 03:55.590
说到游戏结束, 我们在这里加一些东西,

03:55.590 --> 03:59.100
确保代理不会陷入某种状态.

03:59.100 --> 04:03.780
要做到这一点, 我们要用下面的方法更新这个变量｡ 

04:04.650 --> 04:13.890
这等于完成了, 或者我们要加上一个条件, 游戏的情节不能持续太长时间.

04:14.190 --> 04:21.900
您将在主函数中看到, 最大事件长度参数将等于10, 000｡

04:21.900 --> 04:25.620
我们不希望一集的时长超过10,000个单位｡ 

04:25.620 --> 04:33.480
所以我们要在这里加上一集的长度, 也就是一集的长度,

04:33.480 --> 04:37.470
我们要把这个条件写成大于最大值｡

04:38.200 --> 04:39.940
单集长度｡ 

04:40.420 --> 04:40.840
我们走吧｡ 

04:40.840 --> 04:45.880
实际上最大剧集长度, 我们是从参数中得到的｡ 

04:45.880 --> 04:50.320
因此, 我在这里添加params点params点最大集长度｡ 

04:50.320 --> 04:59.260
这就意味着如果游戏结束或者情节长度大于设定的最大情节长度, 也就是10,000, 那么游戏就结束了,

04:59.260 --> 05:04.780
我们将开始一个新的游戏.

05:06.150 --> 05:07.950
那只是预防措施｡ 

05:07.950 --> 05:11.550
说到预防措施, 我们要增加一个预防措施｡ 

05:11.580 --> 05:15.160
这是为了把奖励限制在负1和正1之间｡ 

05:15.180 --> 05:20.820
我们已经得到了奖励, 但我们要确保奖励在负1和正1之间｡

05:20.850 --> 05:29.220
要做到这一点, 我们只需要更新奖励这样做, 采取最大, 然后采取奖励的人｡

05:29.310 --> 05:30.780
还有一个

05:30.960 --> 05:35.670
这里我们取最小奖励的最大值和一减一｡ 

05:35.970 --> 05:39.300
我们会确保奖励在负1和正1之间｡ 

05:40.030 --> 05:40.720
好吧, 我会的

05:40.720 --> 05:42.160
所以另一个预防措施｡ 

05:42.160 --> 05:49.000
而现在我们只想检查游戏是否完成, 在这种情况下, 我们将重新启动环境｡ 

05:49.000 --> 05:50.500
我们为什么要现在检查呢？

05:50.500 --> 05:52.870
因为我们刚进入了一个新的境界｡ 

05:52.900 --> 05:54.700
我们刚刚通过了一个新的传输｡ 

05:54.700 --> 05:59.410
所以我们需要检查, 通过这个新的传输后, 而游戏还没有完成｡ 

05:59.650 --> 06:09.730
因此, 如果再次进行, 如果进行, 那么在这种情况下,

06:10.720 --> 06:19.150
我们将通过将事件长度设置为零来重新启动环境, 并且状态也将被初始化并重新初始化｡

06:19.150 --> 06:23.350
我们使用环境和重置功能｡ 

06:24.460 --> 06:24.770
噢

06:25.060 --> 06:27.360
现在我们摆脱这种状况｡ 

06:27.370 --> 06:28.750
那只是检查｡ 

06:29.020 --> 06:34.420
现在我们要做的是, 因为我们达到了一个新的状态, 这个新的状态是现在, 然后,

06:34.420 --> 06:40.330
由, 雷, 因为记住, 状态是输入图像, 最初是由数组完成的｡

06:40.330 --> 06:44.350
所以现在我们要做的就是把新的状态转换成火炬张量｡ 

06:44.350 --> 06:52.540
所以我们要更新我们的状态, 我们要使用torch库,

06:52.690 --> 07:01.420
当然还有from numpy函数, 来转换这个numpy数组, 把输入图像状态转换成torch张量｡

07:02.020 --> 07:02.860
好极了｡ 

07:02.980 --> 07:08.560
在结束for循环之前, 我们要做的最后一件事, 就是steps上的循环.

07:08.560 --> 07:12.790
当然, 这是为了把奖励添加到奖励列表中｡ 

07:12.790 --> 07:15.100
这是最不需要更新的东西｡ 

07:15.100 --> 07:18.130
我们更新了这里所有的名单除了奖励｡ 

07:18.130 --> 07:19.450
所以我们现在就去做｡ 

07:19.450 --> 07:26.830
我们得到我们的奖励, 然后用append函数把刚收到的最后一个奖励加进去.

07:27.310 --> 07:28.060
好极了｡ 

07:28.060 --> 07:35.230
在我们结束循环之前, 我们只需要做最后一次检查｡ 

07:35.230 --> 07:39.250
如果它完成了, 那么我们要停止探索｡ 

07:39.250 --> 07:45.940
所以我们在这里添加一个break, 这意味着如果完成了, 我们就停止探索,

07:45.940 --> 07:50.890
直接进入下一步, 更新共享模型｡

07:51.370 --> 07:54.130
现在我们已经完成了for循环｡ 

07:54.310 --> 08:03.250
现在代理已经完成了它的探索, 它将更新共享模型, 我们将在下一个教程中处理这个问题｡

08:03.250 --> 08:04.480
在那之前, 好好享受吧｡ 

08:04.480 --> 08:04.990
一､