WEBVTT

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

00:02.610 --> 00:08.160
好了, 今天我们要做一个更新函数, 当眼睛达到一个新的状态时,

00:08.160 --> 00:12.210
它会更新所有需要更新的东西｡

00:12.210 --> 00:15.940
所以当它达到新的状态时, 你知道, 我们需要更新动作｡ 

00:15.960 --> 00:22.470
最后一个动作会成为显示的新动作, 但最后一个状态也会成为新状态｡

00:22.470 --> 00:24.030
最后, 最后的奖励｡ 

00:24.030 --> 00:27.180
这就成为了我们在玩游戏时得到的新奖励｡ 

00:27.180 --> 00:33.060
这就是选择一个操作后立即发生的逻辑路径, 我们需要更新转换的所有元素, 当然,

00:33.060 --> 00:37.230
我们将获得一个新的转换｡

00:37.230 --> 00:40.080
因此, 我们必须将这个新的转换附加到内存中｡ 

00:40.080 --> 00:45.750
最后, 我们也会更新我们的奖励窗口, 你知道,

00:45.750 --> 00:49.380
以保持对培训的进展是如何进行和探索是如何进行的眼睛｡

00:49.380 --> 00:55.380
但对你们来说最重要的是现在我们终于可以把我们正在实现的AI和我们的地图联系起来了,

00:55.380 --> 01:06.090
因为如果我们回到我们的地图, 记住游戏类中有一个很大的更新函数｡

01:06.090 --> 01:12.930
这就是我们用赛车来做游戏的地方, 定义赛车犯错时该如何惩罚.

01:12.930 --> 01:19.230
但在这个博弈课上, 我们注意到了这个更新函数在这个更新函数中我们注意到这条线的动作等于大脑点的更新, 奖励少,

01:19.260 --> 01:24.600
信号少.

01:24.600 --> 01:28.200
这正是我们要做的｡ 

01:28.200 --> 01:37.590
我们即将使这个更新函数, 将采取最后的奖励和最后的信号, 以获得下一个行动发挥｡

01:37.590 --> 01:44.340
因此, 我们不仅要更新过渡的所有不同元素,

01:44.340 --> 01:48.990
而且主要是我们将扮演我们在获得最后一个奖励和最后一个信号时应该扮演的动作｡

01:49.140 --> 01:56.970
当然, 在这个更新函数中, 我们将使用之前实现的选择操作函数｡

01:56.970 --> 02:07.650
我们将在未来的更新功能中集成选择动作功能, 我们将在进行所有更新的同时选择正确的动作｡

02:07.650 --> 02:10.350
所以这一点非常重要, 要把它和地图联系起来｡ 

02:10.350 --> 02:19.470
现在, 我们要做的是最终把人工智能和游戏联系起来, 我们在这门课上做的游戏.

02:19.470 --> 02:26.400
我们现在要做的就是直接把这个更新取到最后, 我们是最后一个信号,

02:26.400 --> 02:30.300
因为这正是我们要用这两个参数来构造的函数｡

02:30.450 --> 02:34.320
提醒一下, 大脑是我们的视觉对象｡ 

02:34.320 --> 02:37.950
也就是说, 它是类的对象｡ 

02:38.280 --> 02:45.480
我们现在要做的就是复制这个更新, 减少奖励, 减少信号, 这将是我们要做的下一个函数,

02:45.480 --> 02:50.220
所以我把它粘贴在这里｡

02:50.250 --> 02:56.010
为了谨慎起见, 我想给予一些与我们这里的名称不同的名称｡ 

02:56.010 --> 02:57.390
你知道, 我们这里的奖励少｡ 

02:57.390 --> 03:00.660
我不想把最后一个奖励和这个混淆｡ 

03:00.660 --> 03:01.950
这可能很危险｡ 

03:01.950 --> 03:06.090
所以我要用奖励来代替最后一个词｡ 

03:06.090 --> 03:08.850
顺便说一句, 信号也是这样｡ 

03:08.850 --> 03:18.690
让我们输入信号或新信号, 以指定我们希望在达到新状态时进行更新, 从而获得新信号｡

03:18.690 --> 03:26.480
当然, 这个奖励是我们在这里得到的最后一个奖励, 你知道, 当我们进入一些沙子或者更糟的时候,

03:26.490 --> 03:31.320
太接近地图的一边｡

03:31.320 --> 03:33.960
这就是我们定义最后奖励的地方｡ 

03:33.960 --> 03:37.290
最后一个奖励将作为更新函数的输入｡ 

03:37.290 --> 03:39.330
这就是为什么我们这里的奖励较少｡ 

03:39.330 --> 03:45.810
但在这里我只是给论证奖励换了个名字, 以免混淆.

03:45.810 --> 03:46.920
最后一句话｡ 

03:47.460 --> 03:47.850
好吧, 我会的

03:47.850 --> 03:50.040
这就是更新函数｡ 

03:50.040 --> 03:53.880
现在让我们进去做这两件事｡ 

03:53.880 --> 03:58.770
也就是说, 更新过渡的所有元素, 当然, 还要选择操作｡ 

03:59.130 --> 03:59.420
好吧, 我会的

03:59.490 --> 04:01.530
那么, 我们首先需要更新什么？

04:01.740 --> 04:06.600
正如您所理解的, 我们希望在达到新状态时进行更新｡ 

04:06.600 --> 04:10.590
因此, 我们首先要更新的显然是这个新状态｡ 

04:10.590 --> 04:12.390
这就是我们正在达到的新境界｡ 

04:12.540 --> 04:17.160
所以我把这个新状态称为, 新状态然后等于.

04:17.160 --> 04:19.770
那么我们怎样才能得到这个新的状态呢？

04:19.800 --> 04:25.350
当然, 这取决于信号, 传感器刚刚检测到的新信号｡ 

04:25.620 --> 04:32.700
提醒一下, 状态是信号本身, 由传感器的三个信号组成, 信号一,

04:32.700 --> 04:37.260
信号二和信号三, 正方向和负方向｡

04:37.260 --> 04:38.400
那是我们的州｡ 

04:38.400 --> 04:42.420
所以一定要明白, 信号就是状态｡ 

04:42.420 --> 04:45.990
但现在它是一个简单的五元素列表｡ 

04:45.990 --> 04:52.170
因为这将是神经网络的输入, 记住我们要把它转换成火炬张量｡

04:52.200 --> 04:54.630
所以这正是我们现在要做的｡ 

04:54.660 --> 04:59.640
我们要把我们的火炬库再拿过来｡ 

04:59.930 --> 05:01.410
张量类｡ 

05:01.430 --> 05:02.330
我们走吧｡ 

05:02.330 --> 05:08.660
它会把我们的新信号转换成火炬张量｡ 

05:08.990 --> 05:13.970
那么最好确保火炬张量的所有元素都是浮点数｡ 

05:13.970 --> 05:21.350
所以我会做一个类型转换, 把它们转换成浮点数, 就像这样,

05:21.350 --> 05:24.260
然后最后试着得到我们下一步要做什么的反射｡

05:24.260 --> 05:29.000
当然, 这是为了创建假维度, 添加与批次对应的维度｡ 

05:29.000 --> 05:36.650
当然, 我们用压缩函数来实现这个过程, 我们必须输入这个假维度的索引, 这个索引是我们想要的,

05:36.710 --> 05:40.040
也就是零｡

05:40.610 --> 05:41.150
好吧, 我会的

05:41.150 --> 05:47.960
现在我们有了新的状态, 由三个传感器的三个信号加上方向减去方向组成｡

05:48.110 --> 05:55.400
当然, 这将取决于我们在这一行通过更新函数获得的新信号｡

05:55.400 --> 05:59.570
最后一个信号, 我们得到三个信号加上方向减去方向｡ 

05:59.570 --> 06:05.870
提醒一下, 这三个信号是传感器周围探测到的气味密度｡ 

06:06.290 --> 06:06.830
好吧, 我会的

06:06.830 --> 06:13.460
我们刚刚得到了新的状态, 这意味着我们到达了新的状态, 现在我们必须进行下一次更新｡

06:13.460 --> 06:16.370
那么根据你的说法, 我们现在需要更新什么？

06:16.400 --> 06:22.160
在达到这种新状态后, 现在更新什么才是合乎逻辑的？

06:22.370 --> 06:25.700
我们现在需要更新的是记忆｡ 

06:25.700 --> 06:26.750
为什么会这样呢？

06:26.750 --> 06:34.130
这是因为在每一个时刻t, 一个转移是由当前状态t, 下一个状态t, 加1, 奖励r,

06:34.130 --> 06:37.550
t和动作a, t组成的｡

06:37.550 --> 06:44.420
现在我们已经有了, 我们已经有了, 我们已经有了, 我们刚刚得到了, 转变的最后一个元素,

06:44.420 --> 06:47.150
T加1｡

06:47.330 --> 06:55.280
所以通过得到这个新的状态, T加1, 我们得到了一个全新的记忆转变｡ 

06:55.280 --> 07:01.490
因此我们必须把这个全新的过渡添加到内存中, 因为这只是我们的下一个过渡｡

07:01.700 --> 07:03.890
所以我们必须马上更新记忆｡ 

07:03.890 --> 07:13.040
因此, 我要做的是从replay内存类中创建内存对象, 因此我要用self｡

07:13.850 --> 07:16.880
引用该对象的内存｡ 

07:16.880 --> 07:22.220
但是因为我使用了self, 所以我必须在update函数中包含self｡ 

07:22.700 --> 07:25.270
所以现在你可以真正看到自我的作用了｡ 

07:25.280 --> 07:30.830
每当你使用一个你在init函数中创建并初始化的变量时｡ 

07:31.400 --> 07:33.890
所以self dot内存现在我们需要更新它｡ 

07:33.890 --> 07:36.830
根据你的说法, 我们要如何更新它？

07:36.920 --> 07:41.090
好消息是我们已经做了一个函数来做这个｡ 

07:41.090 --> 07:46.940
它是将事件或转换附加到内存的推送函数｡ 

07:46.940 --> 07:48.920
这正是我们现在要用到的｡ 

07:48.920 --> 07:54.470
我们将使用push函数将我们刚刚进行的新转换附加到内存中｡ 

07:54.470 --> 08:03.860
所以这里我不取等号因为我们要用一个方法所以我们可以直接用点推.

08:04.010 --> 08:09.770
首先, 我将加入这个跃迁, 这个新的跃迁, 我们刚刚得到的, 它是最后一个状态, 所以,

08:09.770 --> 08:13.910
self, 那么, lessstate｡

08:14.000 --> 08:18.410
这就是S-T, 这就是已经存在的｡ 

08:18.410 --> 08:23.540
然后这个转变的下一个元素当然是我们刚刚达到的新状态｡ 

08:23.540 --> 08:31.340
因此, 因为它不是我们在init函数中创建和初始化的对象的变量, 所以我们不在这里放置self｡

08:31.340 --> 08:33.590
我们直接把新的状态｡ 

08:35.190 --> 08:41.010
然后, 过渡的下一个元素是动作, 我们已经有了最后一个动作,

08:41.010 --> 08:43.580
也就是这个自我的最后一个动作｡

08:43.590 --> 08:49.950
所以它当然等于零, 但是它当然会被select action函数更新｡ 

08:49.950 --> 08:51.030
但这是这一个｡ 

08:51.030 --> 08:55.440
那么接下来就是自我打点的最后一个动作了｡ 

08:55.620 --> 08:56.970
但现在要小心｡ 

08:57.000 --> 09:01.470
我们在这个过渡中包括的元素都应该是火炬舞者｡ 

09:01.590 --> 09:03.720
如你所见, 这就是最后一次约会的情况｡ 

09:03.720 --> 09:05.100
是个火炬舞者｡ 

09:05.130 --> 09:07.500
新立也是火炬舞者｡ 

09:07.620 --> 09:10.440
所以这对动作来说一定是一样的｡ 

09:10.440 --> 09:11.940
当然, 还有奖励｡ 

09:11.940 --> 09:17.220
但现在你会想, 它怎么可能是一个火炬舞者, 考虑到它只是一个数字, 你知道,

09:17.220 --> 09:22.200
动作是01或2, 但事实上, 这不是一个问题｡

09:22.200 --> 09:28.410
我们仍然可以把这个01或02变量转换成火炬舞者｡ 

09:28.440 --> 09:31.320
这就是我们所说的长张量｡ 

09:31.320 --> 09:35.670
长整型是一种类型, 它是包含整数的张量｡ 

09:35.670 --> 09:39.240
因为最后一部分是整数, 所以它是零一或二｡ 

09:39.420 --> 09:43.290
我们现在要拿的是图书馆火炬｡ 

09:43.950 --> 09:53.460
然后我们用长张量类来创建一个新的对象, 这个对象就是长张量本身｡

09:53.460 --> 10:00.330
而通过把自我最后的作用函数作为输入, 它会创造出这个长项主体,

10:00.330 --> 10:04.650
但它仍然会把零一或二包含进一个长的张量客体中｡

10:04.650 --> 10:08.640
这只是为了与过渡保持一致｡ 

10:08.640 --> 10:13.980
它应该只包含传感器因为我们使用的是PyTorch和神经网络

10:13.980 --> 10:18.360
所以我们必须使用传感器, 这样我们就可以使用长张量｡ 

10:18.360 --> 10:25.560
还有最后一个转换, 我们必须确保这个长答案里面的是整数, 为了确保这一点,

10:25.560 --> 10:30.660
即使我们已经知道最后一部分是0,

10:30.660 --> 10:38.760
1或2, 为了确保我们要再次进行这个int类型的转换, 我们把我们自己的最后一个操作转换成整数｡

10:39.060 --> 10:39.720
我们走吧｡ 

10:39.720 --> 10:47.460
然后我们必须把整数自最后作用量放进括号里, 这样我们就得到了一个长张量, 它是最后作用量, 01,

10:47.460 --> 10:52.560
2本身｡

10:52.560 --> 10:59.160
所以关键点是, 这就是你如何通过触摸, 把一个简单的数字, 01或2, 转换成一个张量｡

10:59.930 --> 11:00.290
好吧, 我会的

11:00.290 --> 11:06.620
最后, 过渡的最后一个元素, 当然, 这也是我们得到的最后一个奖励｡

11:06.650 --> 11:12.890
这就是我们在init函数中创建的最后一个奖励变量, 它初始化为零,

11:12.890 --> 11:19.640
然后在这里更新, 当我们进入负奖励状态, 或者我们离目标更远时,

11:19.640 --> 11:23.960
它也是负奖励状态.

11:23.960 --> 11:26.870
如果我们离目标更近了, 那就是积极的奖励｡ 

11:26.870 --> 11:34.010
如果我们太靠近地图的一边, 最糟糕的惩罚是, 那是一个可怕的负奖励, 减一｡

11:34.010 --> 11:34.970
仅此而已｡ 

11:36.100 --> 11:40.690
所以让我们把这个转变自我的最后一个元素——奖赏加进去｡ 

11:40.810 --> 11:49.510
所以我复制了这个粘贴, 现在我们要做另一个转换, 当然和这个完全一样｡

11:49.540 --> 11:57.310
只不过既然奖励不是整数而是一个浮点数, 我们就简单地作一个火炬张量的换算｡

11:57.310 --> 12:01.450
但是如果没有整型数, 我们会保留括号,

12:01.450 --> 12:06.790
因为, 首先我们要把这个数放入一个列表中, 然后这个列表会作为火炬张量类的输入｡

12:06.790 --> 12:11.250
但我们不需要在转换中做这个因为最后的奖励是一个浮点数｡ 

12:11.260 --> 12:21.310
所以我们要做的就是简单的把火炬点张量加到张量上, 然后加上括号｡

12:21.400 --> 12:27.070
我们要把括号和圆括号合起来｡ 

12:27.280 --> 12:28.150
我们走吧｡ 

12:28.630 --> 12:37.060
总结一下我们刚刚达到的新状态和奖励, 我们观察到一个新的转变事件, 我们添加到记忆中｡

12:37.330 --> 12:41.650
并且该转换包含关于新状态的最后状态｡ 

12:41.650 --> 12:46.480
SD加一, 最后一个动作打了80和最后一个奖励｡ 

12:46.480 --> 12:47.190
好的, 我会的

12:47.830 --> 12:48.310
好吧, 我会的

12:48.310 --> 12:51.130
现在我们的记忆更新已经完成了｡ 

12:51.130 --> 12:55.570
所以, 让我们休息一下, 我们将在下一个教程中处理下一个更新｡ 

12:55.810 --> 12:56.950
在那之前, 好好享受吧｡ 

12:56.980 --> 12:57.300
一､