WEBVTT

00:00.930 --> 00:03.840
大家好, 欢迎回到人工智能课程｡ 

00:03.840 --> 00:09.780
今天我们将继续我们的旅程, 进入83 C的世界, 我们将讨论C的异步端, 这样我们就有了我们的缩写,

00:09.780 --> 00:14.190
同步优势, 积极的批评家｡

00:14.190 --> 00:18.900
今天, 我们将了解这里的同步表示什么, 它意味着什么｡ 

00:18.900 --> 00:20.940
让我们退一步｡ 

00:20.940 --> 00:23.730
让我们来看看这门课的开头部分｡ 

00:23.730 --> 00:28.890
我们从强化学习开始, 它是关于主体处于某种状态的｡ 

00:29.160 --> 00:34.260
他们观察状态, 他们做出某些决定, 他们在那个状态下采取行动｡ 

00:34.260 --> 00:36.660
然后状态就改变了｡ 

00:36.660 --> 00:38.910
所以他们进入了一个新的状态, 而且他们得到了奖励｡ 

00:38.910 --> 00:45.570
所以他们会因为采取行动而得到奖励或者某种奖励, 也可能是惩罚｡ 

00:45.840 --> 00:47.670
他们最终会进入一个新的状态｡ 

00:47.670 --> 00:52.350
在此基础上, 他们又采取了另一个行动, 他们得到了奖励, 最终进入了一个新的状态, 他们又采取了另一个行动,

00:52.350 --> 00:53.910
依此类推｡

00:54.390 --> 00:59.580
这就是强化学习的基础｡ 

00:59.580 --> 01:05.820
这就是我们一直在学习中使用的东西, 在深度学习和深度卷积学习中｡ 

01:05.820 --> 01:10.560
这使得我们的特工能够逐渐战胜越来越复杂的环境｡ 

01:10.560 --> 01:16.340
但现在我们要进一步介绍一个更好的概念｡ 

01:16.350 --> 01:23.130
更进一步说, a3c通过这个同步元素引入了一个代理,

01:23.130 --> 01:31.080
而不是一个代理来攻击环境, 他们有三个代理, 或者其他数量的代理｡

01:31.080 --> 01:34.110
所以几个特工攻击同一个环境｡ 

01:34.110 --> 01:39.300
这里的关键是, 之所以称之为同步是因为它们的初始化方式不同｡ 

01:39.300 --> 01:40.860
所以他们的出发点不同｡ 

01:40.860 --> 01:47.790
比如说, 从实际情况来看, 你设置了一个随机的种子, 然后对每个代理人都进行不同的设置.

01:47.790 --> 01:53.100
这样, 因为他们的出发点不同, 他们首先会以不同的方式穿越环境,

01:53.100 --> 01:55.710
然后他们会以不同的方式探索｡

01:55.710 --> 01:58.530
然后在下一次迭代中, 它也将以不同的方式进行探索｡ 

01:58.530 --> 02:03.540
比如说,

02:03.540 --> 02:12.330
如果你有三个代理, 你会突然获得三倍的经验, 而不是只有一个代理去探索环境, 并试图了解如何在该环境中操作｡

02:12.330 --> 02:17.670
你现在有三个或无论他们中有多少人经历了这一点, 并获得了这种经验｡ 

02:17.670 --> 02:21.690
所以他们中的每一个人都在通过这个更大的体验学习｡ 

02:21.690 --> 02:31.260
除了提供更广泛的经验外, 它还减少了一个代理陷入局部最大值的机会｡

02:31.260 --> 02:37.470
例如, 如果一个代理找到了一种方法来战胜环境, 但这并不是最优的,

02:37.470 --> 02:43.380
因为如果它向左或向右偏离了它找到的解决方案, 它总是会受到更多的惩罚｡

02:43.380 --> 02:45.450
它可能会卡在局部最大值上｡ 

02:45.460 --> 02:49.440
它可能会一直这样做, 认为这是最优的解决方案, 而实际上不是｡

02:49.440 --> 02:59.640
好吧, 几个代理人陷入同一个局部最大值的可能性随着代理人的数量而减少｡

02:59.640 --> 03:07.920
因此, 一个代理陷入某个局部最大值的概率可能很高, 但也可能是某个值｡

03:07.920 --> 03:12.600
但是当你有三个这样的函数时, 它们都陷入局部最大值的概率要低得多｡

03:12.690 --> 03:17.850
而且只要他们彼此分享经验, 他们就能互相帮助｡ 

03:17.850 --> 03:20.970
所以如果其中一个被卡住了, 比如说, 它就卡在了局部最大值上｡ 

03:20.970 --> 03:24.960
只要简单地认为这是最好的一个, 这是最好的, 这是最好的解决方案, 一直都是最好的,

03:24.960 --> 03:28.020
只要它与其他代理相互作用, 就能保持良好的状态｡

03:28.020 --> 03:32.670
假设这家伙陷入了局部最大值只要它和其他代理通过我们构建整个算法的方式进行交互,

03:32.670 --> 03:37.530
通过算法, 他们就会帮助他.

03:37.530 --> 03:42.930
他们会给予他真正知道的知识, 嘿, 你应该探索这个, 否则他很可能,

03:42.930 --> 03:44.550
更有可能摆脱那个｡

03:44.550 --> 03:49.740
而且总体而言, 环境会知道, 嘿,

03:49.740 --> 03:54.990
即使这是一个很好的最大值, 这些其他代理已经看到了更好的选择, 我们应该继续探索, 因为他们看起来是更好的选择｡

03:54.990 --> 04:00.690
因此, 在一个非常简短的粗略的, 直观的理解, 这些是一些优势,

04:00.690 --> 04:02.430
有这些异步代理｡

04:02.430 --> 04:05.910
首先, 你有更多的经验可供选择和学习｡ 

04:06.000 --> 04:08.070
您可以更快地找到解决方案｡ 

04:08.130 --> 04:16.410
一般来说, 陷入局部最大值的可能性更小｡ 

04:16.410 --> 04:20.670
让我们来看看这一切在我们目前建立的模型中是如何发挥作用的｡ 

04:20.670 --> 04:24.930
你们应该还记得, 这是我们通过额外的评论员得到的结果｡ 

04:24.930 --> 04:26.670
这就是一切联系的地方｡ 

04:26.670 --> 04:31.230
这是你们还记得的, 在上一个教程中我们介绍过的, 我们在深度卷积Q学习中已经有了,

04:31.230 --> 04:35.100
所以我们现在把它命名为extra｡

04:35.460 --> 04:38.670
但现在我们已经引入了批评, 但到目前为止, 它还没有真正意义｡ 

04:38.670 --> 04:43.770
用同样的神经网络, 同样的方法来衡量或预测国家的价值,

04:43.770 --> 04:48.060
有什么意义呢？

04:48.330 --> 04:51.870
但现在, 这是这是一个部分, 它将开始变得更有意义｡ 

04:52.260 --> 04:56.820
我们要做的是复制这个, 因为现在我们有多个代理｡ 

04:56.820 --> 04:58.320
因此, 对于多个代理, 这是｡ 

04:58.320 --> 04:59.310
这就是它的样子｡ 

04:59.310 --> 04:59.910
是这样｡ 

05:00.530 --> 05:05.120
第一种想象方式是现在我们有了这三样东西｡ 

05:05.120 --> 05:09.170
好吧, 还记得我们说过的关于他们彼此分享经验的话吗？

05:09.170 --> 05:11.000
所以这其实是对的｡ 

05:11.000 --> 05:12.200
现在他们都是独立的｡ 

05:12.200 --> 05:15.350
你有一个在玩游戏, 另一个在玩游戏, 另一个在玩游戏｡ 

05:15.350 --> 05:19.400
这就像是在三台不同的计算机上启动您的代理｡ 

05:19.400 --> 05:21.740
你把三台不同的电脑放在一起, 然后启动它们｡ 

05:21.740 --> 05:22.970
你知道, 这很好｡ 

05:22.970 --> 05:27.260
喜欢, 的确, 你喜欢你就会得到你就会得到更多的经验｡ 

05:27.290 --> 05:29.750
你会得到更多的变化, 特别是如果它们被初始化为不同的｡ 

05:29.750 --> 05:32.840
所以我们从这里开始假设它们都是初始的, 初始化总是不同的｡ 

05:32.990 --> 05:37.820
尽管我们在这里看到了相同的图片, 但我们知道它们实际上是以不同的方式初始化的｡ 

05:37.820 --> 05:43.220
所以它不会像相同的训练, 从这个游戏中学习一样｡ 

05:43.670 --> 05:47.540
所以, 即使你把三台电脑并排放在一起,

05:47.540 --> 05:55.610
然后启动它们, 是的, 你会有更多的经验, 因为你会有三个代理人在玩,

05:55.610 --> 05:58.490
而且你会有更多的可能的解决方案｡

05:58.490 --> 06:00.020
原来如此｡ 

06:00.020 --> 06:02.540
但问题是, 他们没有在我们中间分享这种经验｡ 

06:02.570 --> 06:04.010
他们没有互相学习｡ 

06:04.010 --> 06:06.740
所以他们没有协同效应｡ 

06:06.740 --> 06:11.390
他们没有优势或额外的权力, 他们会得到如果他们合作｡ 

06:11.390 --> 06:17.840
你知道, 如果你有如果你有一个团队的人, 他们一起工作更好, 然后他们每个人分开｡

06:17.840 --> 06:21.140
就像在一个团队里, 你有一加一加一, 就是三｡ 

06:21.140 --> 06:23.120
但在一个团队中, 一加一加一不是三｡ 

06:23.120 --> 06:28.220
这就像33, 因为他们利用对方的优势, 减轻对方的弱点｡ 

06:28.220 --> 06:29.180
这里也一样｡ 

06:29.180 --> 06:33.260
所以如果你把这三台电脑放在一起, 是的, 你会有更多的经验,

06:33.260 --> 06:36.080
更多的变化, 也许有人会得到一个比另一个更好的解决方案｡

06:36.080 --> 06:39.500
这很好, 但如果他们开始分享这一经验, 那就更好了｡ 

06:39.500 --> 06:41.030
他们是怎么做到的？

06:41.030 --> 06:43.880
我们就是通过这个V来计算它的｡ 

06:43.880 --> 06:49.310
这个V值是我们网络的输出, 实际上是这样的｡ 

06:49.310 --> 06:57.980
所以他们有相同的V所以每次所有这些代理, 他们都贡献给相同的评论家｡ 

06:57.980 --> 06:59.870
他们没有单独的批评家｡ 

06:59.870 --> 07:01.190
他们有一个共同的批评家｡ 

07:01.190 --> 07:06.020
这就是演员评论家如何与同步联系的关键｡ 

07:06.020 --> 07:09.650
所以有一个评论家在观察他们获得的经验｡ 

07:09.650 --> 07:17.510
那么我们如何计算V, 我们通过你们记得的, 我们通过得到的值来计算V｡

07:17.510 --> 07:20.660
所以我们通过环境得到的回报｡ 

07:20.660 --> 07:30.620
所以当代理人探索他们的环境时, 他们在计算, 他们在预测V加上他们可以计算的V｡

07:30.630 --> 07:35.390
这是所有这些都与我们在本课程前几节中讨论过的内容有关｡

07:35.600 --> 07:43.100
所以他们已经有了一个V, 他们可以通过这个迷宫中存在的奖励来预测和期待,

07:43.100 --> 07:47.090
他们已经探索过了｡

07:47.090 --> 07:51.860
随着他们的探索, 当然, 这个值是可以改变的, 但是他们也有V,

07:51.860 --> 07:53.390
这个V是神经网络的输出｡

07:53.390 --> 08:01.340
所以当他们经历这些的时候, 他们会调整他们的神经网络, 以便更好地匹配预期｡

08:01.340 --> 08:11.120
V基本上这是共享的, 关键部分是在代理之间共享, 这就是他们如何在彼此之间共享信息｡

08:11.120 --> 08:16.250
这就是他们如何能够看到彼此共享的环境中正在发生的事情, 然后利用这一点,

08:16.250 --> 08:20.840
我们将在下一部分中进一步了解这一点｡

08:21.200 --> 08:25.280
利用它来优化他们在那个环境中的行为｡ 

08:25.460 --> 08:32.690
另外一件需要注意的事情是, 这是a3c, 这是a3c的核心｡ 

08:32.990 --> 08:39.800
这是a3c的一个版本, 但实际上有一个更好的实现, a3c,

08:40.250 --> 08:46.640
你们会在Adland的第一个实用教程中听到它｡

08:46.640 --> 08:58.310
他会讲的是PyTorch的创建者是如何对GitHub上共享的代码进行调整的｡

08:58.310 --> 09:01.880
就像你现在看到的, 他们有独立的神经网络, 只有他们共享V｡ 

09:02.060 --> 09:09.260
这个调整实际上是把所有这些神经网络放到一起, 把它们放在一起｡

09:09.260 --> 09:14.990
所以最终, 这里只有一个神经网络在代理之间共享｡ 

09:14.990 --> 09:21.620
在此之前, 他们每个人都有一个神经网络, 演员和评论家共享这个网络｡

09:21.620 --> 09:25.340
一个神经网络为关键角色共享, 一个神经网络为角色图共享;

09:25.490 --> 09:31.340
现在他们都有一个神经网络, 这个神经网络是演员, 评论家, 演员, 评论家, 演员, 评论家共享的｡

09:31.790 --> 09:35.030
然后批评家在这里是共同的｡ 

09:35.030 --> 09:38.390
让我们看看, 让我们把这些图片移到左边.

09:38.390 --> 09:39.350
所以腾出点空间｡ 

09:39.800 --> 09:48.050
这基本上就是我们在实践教程中要用到的架构或结构｡

09:48.050 --> 09:53.570
我知道, 像这样, 这可能听起来有点压倒性的在这个阶段, 但我们有我们还有一个要谈,

09:53.570 --> 09:55.730
这是优势｡

09:55.730 --> 10:00.260
在那里, 我们将看到更好的行动是如何进行的｡ 

10:00.260 --> 10:00.380
是这样｡ 

10:00.480 --> 10:02.670
我们将讨论直觉在其中的作用｡ 

10:02.670 --> 10:05.570
但总的来说, 这就是它是什么｡ 

10:05.580 --> 10:10.560
每个代理都使用一个网络, 因此它们共享｡ 

10:10.560 --> 10:13.020
基本上这意味着它们分担了重量｡ 

10:13.020 --> 10:16.080
网络的权重在代理之间共享｡ 

10:16.080 --> 10:19.590
当它们更新时, 它们会更新整个网络, 而不仅仅是它们自己的网络｡ 

10:20.250 --> 10:21.600
然后他们有输出｡ 

10:21.600 --> 10:27.630
每个代理都有类似的操作, 然后他们有一个共享的批评者, 这将是监视｡

10:27.630 --> 10:35.460
所以我知道这一切有点像现在有很多东西, 但希望它慢慢走到一起｡

10:35.460 --> 10:42.000
至少这里的主要收获是, 批评者, 因为它是共享的,

10:42.000 --> 10:48.540
这是代理人能够确保他们合作在一起, 以便更快地得到结果的方式｡

10:48.540 --> 10:53.610
在下一个教程中, 我们将进一步了解所有这些是如何叠加在一起的, 所有这些是如何组合在一起的｡

10:53.610 --> 11:01.140
现在, 我想推荐或者我们想推荐你们一本, 一本阅读｡

11:01.140 --> 11:06.690
这是Jaromir Jaenisch写的博客｡ 

11:06.720 --> 11:08.560
它叫做“让我们做一个A三键实现”｡ 

11:08.560 --> 11:11.280
实际上有两部分实现和理论

11:11.670 --> 11:12.450
这就是链接｡ 

11:12.450 --> 11:19.320
这与Alan在本教程的实践部分将实现的内容非常相似｡ 

11:19.320 --> 11:24.810
所以它不是专门针对这篇教程的, 不仅仅是针对这篇教程的,

11:24.810 --> 11:30.840
而是为了这一节的鼓励, 一些额外的信息, 一些额外的见解｡

11:30.840 --> 11:33.120
所以这就是为什么我们把它带到这里来｡ 

11:33.120 --> 11:38.940
但不管怎样, 在下一个教程中, 我们将开始把所有这些, 我们之前讨论过的所有东西, 都集中起来｡

11:39.000 --> 11:40.440
我期待着下次见到你｡ 

11:40.440 --> 11:41.760
在那之前, 好好享受吧｡ 

11:41.760 --> 11:42.300
一､