WEBVTT

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

00:02.070 --> 00:05.910
在今天的教程中, 我们将使用共享模型进行同步｡ 

00:05.910 --> 00:13.950
所以我们要做的仍然是同样的函数, 然后初始化一集的长度｡

00:13.950 --> 00:19.740
所以我们把一个情节的长度叫做, 下划线长度｡ 

00:20.040 --> 00:20.910
我们走吧｡ 

00:20.910 --> 00:23.700
我们要把它初始化为零｡ 

00:23.700 --> 00:27.150
但随后这一集的长度将增加｡ 

00:27.300 --> 00:30.360
说到递增, 这正是我们要做的｡ 

00:30.390 --> 00:37.560
所以我们要用while循环, 用这个技巧来表示while为真｡ 

00:38.430 --> 00:43.680
卡伦重复接下来要发生的事情, 在这个循环中会发生什么｡ 

00:43.980 --> 00:49.950
在这个井循环中, 首先要做的是实现一个事件的长度｡

00:49.980 --> 00:53.640
所以我们要做的第一件事就是把它加1｡ 

00:53.640 --> 00:58.860
要做到这一点, 我们可以简单地把一集的长度和｡ 

00:59.720 --> 01:02.480
这里加一等于一｡ 

01:02.990 --> 01:06.330
现在, 我们将与共享模型同步｡ 

01:06.350 --> 01:15.280
这意味着现在代理将使用共享模型在一定数量的步骤上进行它的小探索｡

01:15.290 --> 01:18.620
模型如何获得共享模型？

01:18.650 --> 01:27.650
我们需要取我们的模型, 然后用点, 然后用load state

01:27.650 --> 01:34.140
dict方法, 因为我们要用它来获取共享模型的状态字典｡

01:34.160 --> 01:41.780
因此, 我们必须首先放置共享模型, 然后应用静态方法来获取该共享模型的参数｡

01:41.780 --> 01:46.970
这就是我们的模型将如何让共享模型进行它的小探索｡ 

01:48.430 --> 01:53.560
一旦模型得到了这个共享模型, 现在我们要区分两种情况｡ 

01:53.590 --> 01:59.940
第一个是if done, 意思是游戏是否结束｡ 

01:59.950 --> 02:03.240
如果博弈结束了, 会发生什么呢？

02:03.280 --> 02:09.660
我们必须重新初始化lshtm和模型的隐藏状态和单元状态｡ 

02:09.670 --> 02:17.440
这就是为什么现在我要取C, X, 单元状态, 还有h, x, 隐藏状态,

02:17.440 --> 02:18.960
我将重新初始化它们｡

02:18.970 --> 02:22.900
以及如何用0重新初始化它们｡ 

02:22.930 --> 02:31.600
将存在256个零的向量, 因为记住lshtm的输出具有维度1和256｡

02:31.600 --> 02:32.260
好了, 我们走吧｡ 

02:32.260 --> 02:36.070
我们将使用torch库初始化它们｡ 

02:36.070 --> 02:38.890
然后零点起作用｡ 

02:38.890 --> 02:46.270
因为我们需要一个256个零的向量, 我们在这里输入两个维度, 一个是向量,

02:46.270 --> 02:50.500
256个是零的元素数｡

02:50.500 --> 02:51.520
好了

02:51.520 --> 02:58.450
但是我们会把它转换成一个火炬变量, 因为这样会计算一些梯度｡ 

02:58.450 --> 03:01.390
所以我们需要把这个和梯度积分｡ 

03:01.870 --> 03:02.380
好吧, 我会的

03:02.380 --> 03:09.460
下面的隐藏状态也是一样的, 我们用同样的方法初始化它们｡ 

03:09.730 --> 03:10.570
我们走吧｡ 

03:10.570 --> 03:13.060
如果游戏结束的话｡ 

03:13.060 --> 03:20.740
现在我们可以用ls来访问的另一个案例是在那个案例中发生的事情｡ 

03:20.740 --> 03:28.810
我们将保留旧的单元格状态和隐藏状态, 我们可以很容易地通过输入来保留旧的状态｡

03:28.840 --> 03:36.610
请参阅x等于变量c x数据, 对于隐藏状态也是如此｡ 

03:36.610 --> 03:44.470
我们可以简单地把这里的hx等于变量hx加到数据中｡ 

03:44.890 --> 03:45.490
好吧, 我会的

03:45.490 --> 03:46.000
这是好事

03:46.000 --> 03:46.420
好了, 好了

03:46.420 --> 03:53.890
现在我们可以退出LS了因为不管博弈结束与否我们基本上都已经完成了这两种情况.

03:53.890 --> 04:00.250
但我们仍然处于疯狂的循环中, 因为现在我们要做更多的事情, 基本上都是训练过程｡

04:00.250 --> 04:07.930
所以我们现在要做的是初始化几个变量, 这些变量将是训练中计算的核心｡

04:07.930 --> 04:08.830
所以我们开始吧｡ 

04:08.830 --> 04:13.600
我们需要的价值观, 是评论家的输出｡ 

04:13.600 --> 04:18.610
这就是V函数, 我们用这种方法把它们初始化为一个空列表.

04:18.940 --> 04:22.450
然后我们需要对数概率｡ 

04:22.720 --> 04:27.040
因此, 记录probs, 我们也将它初始化为一个空列表｡ 

04:27.340 --> 04:33.160
当然我们也需要初始化为空列表的奖励｡ 

04:33.370 --> 04:43.060
最后, 我们需要熵是一个新的东西, 但这确实是训练计算的核心｡

04:43.060 --> 04:44.800
所以空名单也一样｡ 

04:44.890 --> 04:49.240
现在我们已经初始化了这四个变量, 我们可以开始一个新的for循环｡ 

04:49.240 --> 04:53.110
在这个新的for循环中, 我们将更新这四个变量的值｡ 

04:53.110 --> 05:01.300
所以这个新的for循环将是一个完整的循环, 遍历所有的步骤, 循环变量就是我们的步骤.

05:01.300 --> 05:12.070
因此对于step in range和inside我们可以直接输入params. num steps因为参数num

05:12.070 --> 05:14.680
steps就是探索的步数｡

05:14.950 --> 05:19.090
那么对于探索中的所有步骤, 我们该怎么做呢？

05:19.120 --> 05:24.490
我们将得到模型的预测值, 你知道, 模型返回的值｡ 

05:24.490 --> 05:29.740
为了得到这些预测, 我们可以简单地把模型应用到输入中｡ 

05:29.740 --> 05:31.240
这就是输入信号｡ 

05:31.240 --> 05:36.850
它会通过模型中的大脑, 得到输出, 但它会得到几个输出｡ 

05:36.850 --> 05:42.400
它会得到V函数的值, 这是评论家的输出, 然后是Q值, Q分析,

05:42.400 --> 05:45.790
这是演员的输出｡

05:45.970 --> 05:51.430
但也不要忘记, 它还将输出隐藏状态和单元状态的元组｡ 

05:51.430 --> 05:58.120
因为记住, 如果我们回到我们的模型,

05:58.120 --> 06:05.620
在正向函数中, 我们可以看到, 它确实返回了评论家的输出, 也就是v函数的值,

06:05.620 --> 06:14.410
然后是参与者的输出, 也就是Q值, 还有lshtm的输出, 也就是这个双十六进制, 可以看到隐藏状态和细胞状态｡

06:14.680 --> 06:16.810
所以我们必须小心｡ 

06:16.810 --> 06:22.270
这与之前发生的情况有很大不同, 因此, 我们现在要将模型应用于输入,

06:22.270 --> 06:24.280
即状态｡

06:24.280 --> 06:30.610
但现在有几件事要做, 这与酷刑有关, 但这当然给了我们正在做的事情力量｡

06:31.030 --> 06:34.210
我们要做的第一件事就是挤压｡ 

06:35.590 --> 06:40.600
要添加索引必须为零的伪维度的State｡ 

06:40.840 --> 06:47.020
这是因为模型只能接受一批输入, 而不能接受向量或张量本身的输入｡

06:47.050 --> 06:49.420
所以这是我们必须做的第一件事｡ 

06:49.420 --> 06:55.290
但是, 要将输入状态转换为torch变量, 这还不是全部｡ 

06:55.300 --> 06:58.450
所以我在这里加上变量｡ 

06:58.960 --> 07:01.720
所以现在我们对状态, 输入状态没问题了｡ 

07:01.720 --> 07:06.790
但请记住, 这四个函数的输入实际上是输入图像｡ 

07:06.830 --> 07:13.180
这就是我们刚才讲的, 也是隐藏态和细胞态的主要内容｡ 

07:13.510 --> 07:22.030
因此, 我们需要在这里加上第二部分的输入, 其中有一对H, x和c, x｡ 

07:23.090 --> 07:23.570
好吧, 我会的

07:23.570 --> 07:26.810
我们必须把我们去的括号｡ 

07:26.810 --> 07:28.300
我们有两个输入｡ 

07:28.310 --> 07:30.140
第一个是输入状态｡ 

07:30.140 --> 07:36.080
也就是说, 输入图像全部转换为火炬变量, 并进行压缩,

07:36.080 --> 07:40.160
以添加批次的模糊维度以及隐藏状态和单元状态的元组｡

07:40.160 --> 07:41.510
所以我们都准备好了｡ 

07:41.510 --> 07:43.670
我们已经准备好进行预测了｡ 

07:43.820 --> 07:49.820
现在, 因为这个返回, 我们的三个预测, 评论家的输出,

07:49.820 --> 07:54.350
参与者的输出, 隐藏状态的元组, 以及LCM的单元状态｡

07:54.350 --> 07:59.720
我们现在要引入三个新变量, 这三个变量就是输出｡ 

07:59.720 --> 08:00.380
好了, 我们走吧｡ 

08:00.380 --> 08:05.330
第一个输出是V函数的值, 它是评论器的输出｡ 

08:05.330 --> 08:07.490
所以我们称之为价值｡ 

08:08.330 --> 08:08.900
好了, 我们走吧｡ 

08:08.900 --> 08:10.130
这是第一个输出｡ 

08:10.130 --> 08:16.790
然后第二个输出是参与者的输出, 这就是Q值｡ 

08:16.910 --> 08:23.720
但是, 由于Q值与动作相关联, 我们也可以将其称为动作值｡ 

08:24.630 --> 08:25.440
好吧, 我会的

08:25.440 --> 08:28.700
然后由模型返回最终输出｡ 

08:28.710 --> 08:33.000
这是隐藏态的顶部, hx和单元态｡ 

08:33.030 --> 08:34.920
看到X, 我们走｡ 

08:34.920 --> 08:38.970
我们有三个由模型返回的输出｡ 

08:39.000 --> 08:39.930
好极了｡ 

08:39.930 --> 08:45.420
现在我们已经有了预测, 我们需要使用软最大值来进行正确的操作｡ 

08:45.420 --> 08:48.390
所以现在这将和我们之前做的完全一样｡ 

08:48.420 --> 08:53.730
下一步是求出概率, 我们称之为prob.｡ 

08:54.700 --> 09:01.450
这就是我们使用软最大值方法的地方, 我们从有捷径的函数模块中得到｡ 

09:01.450 --> 09:09.970
所以, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,

09:09.970 --> 09:14.050
, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,

09:14.050 --> 09:18.880
这就是Q值, 也就是模型中参与者的输出｡ 

09:19.030 --> 09:19.270
好吧, 我会的

09:19.390 --> 09:24.820
现在我们有了概率, 但是你们注意到了,

09:24.820 --> 09:32.770
我们要用熵来计算熵, 为了得到熵, 我们不仅需要概率, 还需要对数概率, 因为熵是乘积的和｡

09:32.770 --> 09:37.120
对数概率乘以所有这些乘以-1

09:37.120 --> 09:46.210
所以我们还需要得到log prob, 它同样是从log soft max中生成的｡ 

09:46.210 --> 09:54.250
所以我们不求概率的分布, 而是求对数概率的分布, 我们用log来计算.

09:55.060 --> 09:59.200
塞脖子, 最大的锁功能相同｡ 

09:59.200 --> 10:01.330
我们应用于cue值｡ 

10:02.280 --> 10:04.170
我们称之为动作值｡ 

10:04.320 --> 10:04.710
好吧, 我会的

10:04.710 --> 10:11.190
现在我们有了探针和探针, 我们就可以得到熵和熵了｡ 

10:12.030 --> 10:13.590
这个公式是什么？

10:13.620 --> 10:22.380
正如我刚才提到的, 我们取对数, 乘以探测器, 然后我们要取所有这些的和｡

10:22.860 --> 10:26.010
要做到这一点, 我们可以把这个和加起来｡ 

10:26.830 --> 10:27.520
一个｡ 

10:27.640 --> 10:29.830
实际上, 我们现在已经多次使用这个技巧了｡ 

10:29.980 --> 10:33.400
就像我们说的, 我们把这些乘以-1｡ 

10:33.490 --> 10:39.670
所以它是log prob乘以prob perfect的乘积之和的负数｡ 

10:39.670 --> 10:44.770
现在我们要把这个刚刚计算出来的熵, 存储在熵的列表中｡ 

10:45.340 --> 10:46.060
因为我们开始了｡ 

10:46.060 --> 10:48.400
最后一次计算熵｡ 

10:48.400 --> 10:51.370
所以我们需要把它存储在熵列表中｡ 

10:51.460 --> 10:55.720
要做到这一点, 再简单不过了, 我们要用append函数, 当然,

10:55.720 --> 10:57.250
因为熵是一个列表｡

10:57.250 --> 11:05.590
所以我们取熵列表, 然后点, 我们用append函数把刚刚计算的熵加起来｡

11:06.420 --> 11:06.780
好吧, 我会的

11:06.780 --> 11:08.300
所以我们现在要休息一下｡ 

11:08.310 --> 11:10.020
我们要一步一步来

11:10.020 --> 11:16.730
在下一个教程中, 我们将通过随机抽取生成的概率分布来玩这个游戏｡

11:16.740 --> 11:22.260
而在我们玩完这个动作之后, 我们将得到这个状态的值,

11:22.260 --> 11:25.230
我们将最终存储我们的新传输状态的奖励并这样做｡

11:25.230 --> 11:29.340
这将是一个新的一大步, 我们将在下一个教程中完成｡ 

11:29.340 --> 11:30.590
在那之前, 好好享受吧｡ 

11:30.600 --> 11:31.140
一､