WEBVTT

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

00:02.280 --> 00:08.400
这个特别的教程将会非常令人兴奋, 因为我们离a3c算法越来越近了｡ 

00:08.430 --> 00:13.890
您将看到, 我们即将实现的称为资格跟踪或源代码的功能实际上是异步活动批评､

00:14.280 --> 00:19.830
代理和算法的算法, 但我们不能将其视为A3

00:19.830 --> 00:24.900
C,

00:24.900 --> 00:33.690
因为我们仍将使用一个代理, 但您仍将看到, 我们即将实现的功能实际上摘自以下文章, 本文将其作为深度强化学习的同步方法｡

00:33.690 --> 00:40.770
在本文中, 您将看到我们将实现的三个关键算法, 这是本课程的最后一个收获｡

00:40.770 --> 00:47.760
但正如我所说的, 我们离它越来越近了, 因为我们现在要实现的模型实际上就是这个,

00:48.210 --> 00:50.850
异步和单步｡

00:50.850 --> 00:51.600
Q学习｡ 

00:51.600 --> 00:52.620
就是这个｡ 

00:52.620 --> 00:57.930
这差不多就是三把钥匙了, 也就是后面的一把, 但是只有一个代理｡ 

00:57.930 --> 01:04.020
这一步的强大之处在于Q步学习, 我们将学习累积奖励和累积目标,

01:04.020 --> 01:09.420
而不是像之前那样一步完成.

01:09.420 --> 01:14.940
这将使训练更有表现力, 因此我们的人工智能也更强大｡ 

01:15.000 --> 01:18.750
所以我们有了这个算法的伪代码｡ 

01:18.750 --> 01:20.970
这是一个算法｡ 

01:20.970 --> 01:23.130
单击它, 就可以了｡ 

01:23.130 --> 01:25.680
这就是我们将要实现的算法｡ 

01:25.680 --> 01:32.310
但请记住, 在只有一个代理的情况下, 不同之处在于, 在这里,

01:32.310 --> 01:37.950
他们根据Epsilon贪婪策略采取行动, 该策略基于当前状态的Q值和所采取的行动｡

01:37.950 --> 01:41.820
但在所有情况下, 我们都没有实施一个ε贪婪策略｡ 

01:41.820 --> 01:45.030
我们实现了一个软最大化, 但其余部分是相同的｡ 

01:45.030 --> 01:50.700
如你所见, 我们要计算最后一步的累积奖励, 实际上是十步, 请记住.

01:50.700 --> 01:52.170
而步数等于十｡ 

01:52.170 --> 01:57.930
所以我们将在我们的算法中实现这行代码, 我们现在就要实现｡ 

01:57.930 --> 02:01.920
我们会得到这个, 而且我们也会实现这个｡ 

02:01.920 --> 02:07.530
您将看到, 我们将获得当前状态和当前操作的最大Q值｡ 

02:07.530 --> 02:10.950
这里的θ就是目标参数｡ 

02:11.160 --> 02:15.180
让我们来做这个, 来攻击这个算法｡ 

02:15.180 --> 02:21.420
这一个叫做异步和步着色, 但就我们而言我们无权说异步,

02:21.420 --> 02:29.220
因为我们只有一个代理, 但因此我们可以称之为N步Q学习的资格､ 迹甚至源｡

02:30.090 --> 02:31.620
好吧, 我们开始吧｡ 

02:31.620 --> 02:32.880
会很有趣的｡ 

02:32.880 --> 02:37.230
我们基本上可以遵循这里的伪代码, 这就是我们要做的｡ 

02:37.230 --> 02:43.980
如你所见, 我们需要的一个参数是gamma, gamma参数是衰变参数｡

02:43.980 --> 02:50.190
因此, 我们将首先为该gamma参数引入一个变量, 并选择一个值｡ 

02:50.550 --> 02:51.690
所以我们开始吧｡ 

02:51.690 --> 02:53.910
我们实际上不需要一个类来实现它｡ 

02:53.910 --> 03:00.720
我们可以简单地用一个函数来实现它, 因为您知道, 我们实际上并不需要为这个资格跟踪模型创建对象｡

03:00.720 --> 03:06.690
一个函数就足够了,

03:06.690 --> 03:13.170
因为基本上我们要做的是返回输入和目标, 这样在训练人工智能时, 我们就可以最小化预测和目标之间的距离｡

03:13.170 --> 03:19.530
为了得到预测, 我们需要输入, 因为我们要用大脑处理输入, 得到输出信号｡

03:19.530 --> 03:21.060
这将是我们的预测｡ 

03:21.060 --> 03:26.700
然后, 一旦我们有了预测和目标,

03:26.700 --> 03:30.420
我们就可以通过尽量减小预测和目标之间的平方距离来训练人工智能｡

03:30.420 --> 03:32.070
所以这就是我们要做的｡ 

03:32.070 --> 03:32.610
现在就去

03:32.610 --> 03:37.950
我们实现此函数是为了能够在这些目标中返回这些输入, 以便我们可以准备好进行训练,

03:37.950 --> 03:42.600
以最小化距离预测值减去目标值的平方｡

03:42.840 --> 03:44.100
好吧, 我们开始吧｡ 

03:44.100 --> 03:46.320
正如我们所说的, 我们要实现一个函数｡ 

03:46.320 --> 03:47.430
我们从def开始｡ 

03:47.430 --> 03:52.680
这个函数, 我们称之为易读性下划线跟踪.

03:52.680 --> 03:54.000
您也可以称之为源｡ 

03:54.150 --> 03:59.670
你也可以称之为coloring, 但我们称之为qualibility trace｡ 

03:59.670 --> 04:06.030
这个函数有一个参数, 它是一个批处理, 以及为什么要批处理.

04:06.060 --> 04:13.320
这是因为我们将获得一些输入和一些目标, 因为我们将在批处理上训练人工智能｡

04:13.320 --> 04:17.190
因此输入和目标将进入一些批处理｡ 

04:17.190 --> 04:24.840
因此, 这里的输入参数是这个批处理, 它将包含几个输入, 然后是我们要计算的几个目标｡

04:25.260 --> 04:26.670
好了, 我们走吧｡ 

04:26.670 --> 04:28.230
这是我们唯一需要的论据｡ 

04:28.260 --> 04:31.860
现在, 让我们进入函数内部, 定义需要执行的操作｡ 

04:32.130 --> 04:37.350
因此, 正如我们在论文的伪代码中看到的, 我们需要一个gamma参数｡ 

04:37.350 --> 04:44.490
正如我们所说的, 我们首先引入gamma参数, 所以gamma等于, 我们已经可以决定值了,

04:44.490 --> 04:48.150
我们将选择4｡ 99.

04:48.180 --> 04:50.370
这是一个典型的好价值的伽玛｡ 

04:50.370 --> 04:54.930
而且不用担心, 我检查了一下, 这对我们的人工智能来说是一个很好的价值｡ 

04:55.500 --> 04:56.970
好吧, 那下一步｡ 

04:56.970 --> 04:59.670
下一步是准备我们的意见｡ 

05:00.740 --> 05:04.950
我们的目标因为那正是我们想要的回报｡ 

05:04.970 --> 05:08.300
我们希望返回输入和目标以准备培训｡ 

05:08.750 --> 05:12.860
所以我们可以用一个空列表初始化它们｡ 

05:12.860 --> 05:18.320
因为, 当然, 在批处理中的这些输入中, 我们将有几个输入都放到一个列表中｡

05:18.320 --> 05:23.660
这就是为什么我把输入初始化为一个列表和目标｡ 

05:24.080 --> 05:24.830
我们走吧｡ 

05:24.830 --> 05:27.320
因此, 我们在目标中初始化输入｡ 

05:27.320 --> 05:31.430
最后, 这个资格跟踪函数将返回｡ 

05:31.430 --> 05:32.240
-没错—没错

05:32.240 --> 05:35.480
当然, 这些投入和目标都是填写好的｡ 

05:36.110 --> 05:41.360
在函数返回的内容中, 我们将有几个输入和关联的几个目标｡ 

05:42.140 --> 05:42.470
好吧, 我会的

05:42.470 --> 05:43.130
下一步｡ 

05:43.130 --> 05:45.650
下一步是存储for循环｡ 

05:45.650 --> 05:51.320
这正是因为我们遵循了论文中的伪代码, 这组代码｡ 

05:51.320 --> 05:57.290
正如你所看到的, 这是一个重复代码部分, 重复一个完整的循环｡ 

05:57.440 --> 06:03.710
我们要计算的累积奖励的代码是在十步中累积的.

06:03.710 --> 06:05.090
它是如何计算的？

06:05.090 --> 06:07.880
嗯, 每一步, 那都不是最后一步｡ 

06:07.880 --> 06:12.980
我们将在此和步骤运行期间获得当前状态的最大Q值｡ 

06:12.980 --> 06:17.720
如果我们走到最后一组十步, 那么, 这将等于零｡ 

06:17.720 --> 06:19.490
也就是说, 我们不想再更新它｡ 

06:19.820 --> 06:23.210
然后是for循环, 这是另一个for循环｡ 

06:23.210 --> 06:25.490
这里没有重复, 但那是一样的｡ 

06:25.490 --> 06:28.310
这将是我们算法中的第二个for循环｡ 

06:28.310 --> 06:35.480
我们用这种方法更新奖励, 乘以衰减参数gamma, 再加上奖励.

06:35.720 --> 06:36.830
所以我们开始吧｡ 

06:36.830 --> 06:40.250
让我们回到Python, 开始for循环｡ 

06:40.490 --> 06:44.840
那么四, 迭代变量是什么？

06:44.840 --> 06:50.180
这就是我们的十步系列, 我们的十个转变系列｡ 

06:50.180 --> 06:58.610
所以我们把这个变量序列叫做, 它代表了一个十个跃迁的序列, 就像一个十个跃迁的序列｡

06:58.610 --> 07:00.830
所以四个系列｡ 

07:00.920 --> 07:02.330
然后你怎么想？

07:02.330 --> 07:07.970
好吧, 我们的系列将属于我们的批次, 也就是我们将训练人工智能的批次｡ 

07:08.000 --> 07:14.390
所以对于批处理中的序列, 也就是对于输入批处理中的所有10个跃迁的序列｡ 

07:14.570 --> 07:16.460
那我们该怎么办｡ 

07:16.940 --> 07:21.890
为了得到累积的奖励, 你会在伪代码中看到, 我们需要序列的第一个跃迁的状态,

07:21.890 --> 07:26.480
也需要序列的最后一个跃迁的状态｡

07:26.480 --> 07:29.840
所以我们现在要做的就是得到这些输入状态｡ 

07:29.840 --> 07:36.590
我们将把这两个输入状态放入一个变量中, 我们称之为input,

07:36.590 --> 07:45.260
我们将得到这两个输入状态, 第一个输入状态和最后一个输入状态, 我们将把它们放入一个非bios数组中｡

07:45.590 --> 07:48.310
不过不用担心, 我们不会一直守着这个数阵｡ 

07:48.320 --> 07:50.900
我们当然会把它转换成一个总变量｡ 

07:50.900 --> 07:56.660
但第一步是把这些状态输入到第一个状态中, 把最后一个输入到一个数组中｡ 

07:57.050 --> 08:03.260
在这个numpy数组中, 我们加入了第一个输入, 它是序列的第一个跃迁的输入状态,

08:03.260 --> 08:06.380
这就是序列｡

08:07.780 --> 08:11.340
第一次跃迁, 我们取数列的指数0｡ 

08:11.350 --> 08:12.820
这是第一个转变｡ 

08:13.090 --> 08:17.830
然后我们可以通过获取它的属性来访问它, 也就是state｡ 

08:18.040 --> 08:24.220
这是因为在我们的经验回放文件中, 我们为每个转变定义了一个特殊的结构, 你知道, 这个结构,

08:24.220 --> 08:29.350
每个转变都由一个状态, 一个动作, 一个奖励组成｡

08:29.350 --> 08:31.840
但最后一个元素也完成了｡ 

08:31.840 --> 08:38.830
所以我们现在可以使用的这个特殊结构来自于我们在经验回放中定义转换的方式｡

08:39.160 --> 08:39.490
好吧, 我会的

08:39.490 --> 08:48.490
这样, 我们就得到了第一个跃迁的输入状态, 现在我们也得到了这个序列的最后一个跃迁的输入状态｡

08:48.490 --> 08:49.930
而要做到这一点, 那是一样的｡ 

08:49.930 --> 08:51.910
我们可以复制这个｡ 

08:53.320 --> 09:00.310
以这个序列的最后一个指数为基, 用这个指数来代替0,

09:00.310 --> 09:07.420
我们可以用这个技巧减去一个序列, 减去一个状态, 得到序列最后一个跃迁的输入状态｡

09:08.140 --> 09:14.410
好的, 然后我们需要把这两个元素放在方括号里｡ 

09:15.130 --> 09:18.310
因为这是裁判所期望的｡ 

09:18.700 --> 09:26.020
接下来要做的一件很重要的事情, 因为我们要把它转换成火炬张量和火炬变量｡

09:26.020 --> 09:31.680
好吧, 记住, 火炬张量的定义是一个特殊的数组, 包含一个单一的类型｡ 

09:31.690 --> 09:34.510
所以我们需要强制拥有一种类型｡ 

09:34.510 --> 09:37.540
像往常一样, 我们选择浮点型｡ 

09:37.540 --> 09:48.520
所以我在这里加上这个参数, D, type, equals, P, dot, float, 32,

09:48.520 --> 09:52.300
可以取这个, 现在我们可以把它转换成火炬张量和火炬变量｡

09:52.300 --> 09:57.340
为了做好这一点, 首先, 我们将其转换为手电筒传感器｡ 

09:57.340 --> 10:02.590
记住, 我们可以用NumPy火炬

10:03.700 --> 10:12.220
然后我们把所有两个输入态的数组, 放入火炬张量中, 火炬张量是从它们的函数中得到的｡

10:12.340 --> 10:13.120
好极了｡ 

10:13.120 --> 10:18.060
因此, 这将把该阵列的输入状态转换为焊炬传感器｡ 

10:18.070 --> 10:24.250
现在我们把这个火炬张量放到火炬变量中, 用变量类｡ 

10:25.350 --> 10:28.220
所以input将是变量类的一个对象｡ 

10:28.230 --> 10:35.970
事实上, 正如你所理解的, 这个变量类把所有这些都作为一个参数, 这样就创建了这个对象｡

10:36.510 --> 10:38.270
好了, 现在我们应该没事了｡ 

10:38.280 --> 10:40.770
我们有我们需要的两个输入｡ 

10:40.770 --> 10:45.120
即第一个转换的输入状态和最后一个转换的输入状态｡ 

10:45.580 --> 10:48.840
现在, 既然我们有了输入, 那么, 我们能得到什么呢？

10:48.870 --> 10:52.440
我们可以得到眼睛大脑的输出信号｡ 

10:52.470 --> 10:53.790
这就是预言｡ 

10:53.790 --> 10:55.710
但我们称之为输出｡ 

10:56.520 --> 10:59.120
这是输出信号, 并得到输出｡ 

10:59.130 --> 11:05.280
这很简单, 因为我们已经创造了一个大脑, 这就是我们的卷积神经网络｡

11:05.280 --> 11:16.590
所以我们可以简单地把我们的大脑扫描应用到输入上, 它会返回预测, 也就是输出, 就这么简单｡

11:16.590 --> 11:19.500
现在我们已经准备好进入下一步｡ 

11:20.510 --> 11:24.810
下一步就是开始计算这个累积奖励｡ 

11:24.830 --> 11:31.040
所以现在我们要做的和我们的SE 2算法完全一样, 源代码, 或者我们应该称之为和步骤｡

11:31.040 --> 11:31.820
Q学习｡ 

11:32.000 --> 11:38.670
我们将引入累积奖励变量, 即累积奖励｡ 

11:38.690 --> 11:41.000
让我们回到报纸上｡ 

11:41.030 --> 11:45.860
正如你现在所看到的, 我们要做的就是得到这个累积的奖励, 也就是我们在这里｡ 

11:45.860 --> 11:53.640
在十步中的每一步, 我们都需要在这个累积奖励上加一个零｡

11:53.660 --> 12:00.020
如果我们达到了系列的最后一个日期或Q值的最大值, 如果我们还没有达到系列的最后一个状态,

12:00.020 --> 12:03.290
那就是说对于除最后一步以外的所有步骤｡

12:03.530 --> 12:05.720
让我们简单地实现它｡ 

12:05.910 --> 12:07.130
让我们回到Python｡ 

12:07.370 --> 12:13.580
所以这个累积奖励, 就像我们刚才看到的, 将等于0｡  0.

12:13.970 --> 12:14.660
如果｡ 

12:15.020 --> 12:18.920
我们到了最后一个日期, 我们可以骑这种情况下这样做｡ 

12:19.250 --> 12:28.460
如果索引序列减一, 这是该序列的最后一次传输, 那么我们加上done, 因为done实际上是我们定义的,

12:28.460 --> 12:35.510
体验重放, 体验重放文件的过渡结构的一个属性.

12:35.510 --> 12:42.140
这些都是从露天建筑中完成的, 因为如果我们去开放式健身房网站, 就在这里,

12:42.320 --> 12:44.990
我准备了它｡

12:44.990 --> 12:47.050
这就是零的平方根｡ 

12:47.060 --> 12:53.090
如果我们去看文档, 然后如果我们这样, 这就是教程｡ 

12:53.090 --> 12:55.070
我真的鼓励你去看看｡ 

12:55.190 --> 13:01.730
你可以运行一个环境, 但你可以看到我们的观察, 也就是我们的转变是由一个观察,

13:01.730 --> 13:05.390
一个奖励来定义的｡

13:05.390 --> 13:11.780
在这里完成了这个, 这个完成了, 意味着一个过渡或步骤结束了｡ 

13:11.840 --> 13:15.380
所以我们要把这里的结果作为if条件｡ 

13:15.380 --> 13:23.120
因此, 如果系列减去一个点, 则表示如果系列的最后一个过渡结束, 则它已完成｡ 

13:23.540 --> 13:32.810
所以这个累积奖励将等于零如果序列的最后一个跃迁完成了或者如果我们还没有到达最后一个跃迁.

13:32.810 --> 13:40.910
正如我们所说的, 累积奖励将根据Q值的最大值进行更新｡ 

13:40.910 --> 13:47.330
因为这里的输出是大脑的输出, 那就是神经网络的预测｡ 

13:47.330 --> 13:51.350
如您所知, 神经网络的预测就是预测的队列值｡ 

13:51.350 --> 13:54.830
这个输出包含Q值｡ 

13:54.830 --> 14:01.100
因为我们需要取Q值的最大值,

14:01.110 --> 14:09.320
所以我们需要先添加这个索引, 因为这个结构包含索引1中的Q值, 然后我们需要添加数据来访问这个输出结构的数据｡

14:09.320 --> 14:11.930
你知道, 它有着火炬变量的特殊结构｡ 

14:12.020 --> 14:16.940
这样, 我们就得到了Q值, 然后我们想取Q值的最大值｡ 

14:16.940 --> 14:29.990
所以我们简单地加上最大值, 现在我们得到了我们在论文中想要的, 这个非终结态的Q值的最大值｡

14:29.990 --> 14:36.020
现在我们要做的是, 创建第二个for循环, 它是这个序列的十个步骤｡ 

14:36.020 --> 14:43.340
我们将更新累积奖励, 首先乘以衰减参数, 我们已经有了,

14:43.340 --> 14:46.130
然后再加上奖励｡

14:46.130 --> 14:47.360
所以我们开始吧｡ 

14:47.360 --> 14:50.840
我们实际上要做的和伪代码中的完全一样｡ 

14:50.840 --> 14:56.510
正如你所注意到的, 他们从右边开始, 所以他们不是从第一步开始, 然后走到最后一步｡

14:56.510 --> 15:02.150
他们从最后一步开始, t减一向上到第一步开始｡ 

15:02.150 --> 15:06.110
这正是我们要做的,

15:06.110 --> 15:15.590
因为我们想在最后得到, 累积奖励等于, 等于, 一加, 平方或二加,

15:15.590 --> 15:24.980
点加, 十的幂次, 其中的一, 二或十是在这个系列的最后一步得到的奖励｡

15:25.370 --> 15:29.810
在进行第二个循环之前, 让我们稍作休息, 我们将在下一个教程中再见｡ 

15:29.810 --> 15:31.070
在那之前, 好好享受吧｡ 

15:31.070 --> 15:31.610
一､