WEBVTT

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

00:04.020 --> 00:04.380
好吧, 我会的

00:04.380 --> 00:06.960
所以我希望到目前为止你喜欢这些教程｡ 

00:06.960 --> 00:08.460
我们的直觉已经接近尾声了｡ 

00:08.460 --> 00:09.000
你很快就来了｡ 

00:09.000 --> 00:09.340
很快的｡ 

00:09.360 --> 00:10.470
从实际出发｡ 

00:10.470 --> 00:13.290
我们只是有些小事需要掩盖｡ 

00:13.290 --> 00:20.220
好的, 之前我们讨论了如何将神经网络加入到关键学习的整个等式中, 并将你的学习带入下一步,

00:20.310 --> 00:25.140
将其转化为深度学习｡

00:25.380 --> 00:33.330
今天我们将添加一个额外的重要特性, 您将在实用方面对它进行编码｡

00:33.330 --> 00:39.450
所以我和Hudlin决定, 我们应该在直觉方面把它掩盖起来, 这样当涉及到编码方面的时候,

00:39.450 --> 00:42.120
你就有了更多的准备｡

00:42.120 --> 00:46.410
正如我们所讨论的, 我们已经在那里建立了网络｡ 

00:46.410 --> 00:47.880
有两个部分发生｡ 

00:47.880 --> 00:49.080
首先, 这是学习｡ 

00:49.080 --> 00:52.860
所以网络实际上会随着每一个新状态而学习｡ 

00:53.190 --> 00:58.590
它慢慢地更新它的权重, 以变得越来越好, 越来越好地处理这种环境｡ 

00:58.590 --> 01:01.890
然后是国家内部的行动｡ 

01:01.890 --> 01:07.980
因此, 在该状态中已经计数了Q值之后, 然后选择一个键值｡ 

01:07.980 --> 01:11.700
所以今天我们还是要讲学习的部分｡ 

01:11.700 --> 01:17.370
我们会提出一个有趣的特性,

01:17.370 --> 01:25.860
我们不会自己提出这个特性, 但我们会讨论一个对深度学习非常重要的特性｡

01:25.860 --> 01:29.310
这个功能叫做体验回放｡ 

01:29.520 --> 01:31.770
好了, 这是我们的网络｡ 

01:31.770 --> 01:34.500
所以我们把它复制到这里｡ 

01:34.500 --> 01:38.820
我们已经得到了在底部计算的损失通过我们的网络反向传播｡ 

01:38.820 --> 01:45.390
让我们来看看一个例子, 它能让我们更好地理解我们正在处理的问题｡

01:45.390 --> 01:49.050
这是本课程中的一个例子｡ 

01:49.050 --> 01:53.010
这是本课程的屏幕截图｡ 

01:53.010 --> 01:54.600
这就是你要编写的程序｡ 

01:54.750 --> 02:03.600
这是一辆自动驾驶汽车, 它沿着这条路行驶, 它必须学会如何在这条路上导航｡

02:03.600 --> 02:09.180
那么, 正如我们之前讨论的, 在这种状态下, 这是什么呢？

02:09.180 --> 02:12.030
当然, 状态不只是x1和x2｡ 

02:12.030 --> 02:18.450
Alan将更详细地描述状态是什么,

02:18.750 --> 02:26.400
这将是与汽车角度相关的几个参数和一些相关参数, 以及传感器正在读取的数据等｡

02:26.400 --> 02:31.530
所以会有更多的参数来描述状态, 但不管怎样, 它是一个值的向量｡

02:31.530 --> 02:33.690
它将通过一个神经网络｡ 

02:33.690 --> 02:36.390
在输出端, 您将得到一些Q值｡ 

02:36.390 --> 02:44.280
同样, 会有不同的视环境而定, 会有不同数量的动作, 可能的动作｡

02:44.280 --> 02:50.550
但是为了简单起见, 我们还是把它放在这里, 这样我们就能更好地理解这里发生的事情了｡

02:50.550 --> 02:58.470
那么在这种情况下, 到目前为止的问题是, 这个输入到这个神经网络中的是什么？

02:58.470 --> 03:03.450
或者更具体地说, 我们多久触发一次这个神经网络？

03:03.450 --> 03:05.070
这个神经网络多久一次？

03:05.070 --> 03:10.620
好吧, 每次汽车最终进入一个新的状态, 所以汽车移动, 它最终进入一个新的状态｡ 

03:10.620 --> 03:12.600
然后一切都结束了｡ 

03:12.600 --> 03:17.910
所有的数据, 所有的关于国家的信息通过网络是一个计算错误｡ 

03:17.910 --> 03:22.380
此误差是根据我们在前面的教程中讨论的内容计算的｡ 

03:22.800 --> 03:25.260
此错误通过网络反向传播｡ 

03:25.260 --> 03:31.530
权重被更新, 然后汽车选择要采取的行动, 使移动结束在一个新的状态｡

03:31.530 --> 03:34.050
在新的状态下, 一切都重新开始｡ 

03:34.230 --> 03:38.040
基本上, 每次汽车处于新状态时都会发生这种情况｡ 

03:38.160 --> 03:39.780
好吧, 看看这个例子｡ 

03:39.780 --> 03:48.960
我特意截取了这个截图, 因为它看起来很好地说明了通过经验､ 重播和经验解决的问题｡

03:48.960 --> 03:52.590
重放不仅仅是我们在这门课或这个具体问题中使用的东西｡ 

03:52.590 --> 04:00.330
你会看到它在整个过程中被使用, 就像在人工智能算法中被一遍又一遍地使用, 因为它是如此的强大,

04:00.330 --> 04:05.010
如此的重要｡

04:05.010 --> 04:09.540
看看这辆车, 这辆车在这个问题中或者在这个环境中｡ 

04:09.540 --> 04:12.330
它的目标是从这里到这里再回来｡ 

04:12.330 --> 04:17.400
它的目标是在这里导航, 在这里而不穿过这些沙墙｡ 

04:17.610 --> 04:25.050
汽车从这里开始, 然后下降就像它的奖励是基于它离目标的距离.

04:25.050 --> 04:26.910
所以车就从这里开过去了｡ 

04:26.910 --> 04:29.400
它一直往下, 一直这样, 这样, 这样, 这样｡ 

04:29.450 --> 04:31.320
沿着这堵墙, 沿着这堵墙｡ 

04:31.320 --> 04:32.580
接下来它会做什么？

04:32.580 --> 04:34.830
它会转向, 而且会继续前进｡ 

04:34.830 --> 04:37.410
我们要它一直走下去｡ 

04:37.410 --> 04:39.330
但让我们想一想｡ 

04:39.330 --> 04:44.160
一旦它到了这面墙, 每次它向前移动, 它向前移动｡ 

04:44.160 --> 04:47.640
它向前移动, 向前移动, 向前移动, 向前移动, 向前移动, 如此等等,

04:47.640 --> 04:48.360
向前移动｡

04:48.360 --> 04:54.540
因此, 根据结构环境的不同, 可能需要100步或50步｡

04:54.840 --> 04:57.510
他们只是不停地往前走, 往前走, 往前走, 往前走了四步｡ 

04:57.510 --> 04:58.920
什么都没变｡ 

04:58.920 --> 04:59.520
什么都没有

04:59.620 --> 05:00.310
真的变化了｡ 

05:00.310 --> 05:03.280
是的, 它离这个目标更远, 更近｡ 

05:03.280 --> 05:03.970
真可爱｡ 

05:03.970 --> 05:08.350
但就周边环境而言, 变化并不多｡ 

05:08.350 --> 05:09.870
还是那堵墙｡ 

05:09.880 --> 05:15.220
如果你坐在车里, 你可能见过这种情况,

05:15.220 --> 05:21.760
当你在开车的时候, 你所看到的环境是如此单调, 你只是看到一种相同的东西, 就像只是路过｡

05:21.760 --> 05:26.080
但是, 想象一下, 你开车穿过沙漠, 你看到的只是同样的事情｡ 

05:26.080 --> 05:27.670
都是一样的声音, 都是一样的声音｡ 

05:27.670 --> 05:30.250
什么都没发生, 什么都没改变｡ 

05:30.250 --> 05:37.450
所以基本上, 每次我们把那个状态, 那个新的状态放进这里, 是的, 当然,

05:37.450 --> 05:38.890
有些东西可能会改变｡

05:38.890 --> 05:43.330
例如, 你正在开车, 你的GPS显示你离目的地更近了｡ 

05:43.330 --> 05:45.910
其中一个输入就是变化｡ 

05:45.910 --> 05:51.820
但是很多其他的输入, 比如车上的传感器, 它们都没有改变｡ 

05:51.820 --> 05:53.260
因此, 当你开车的时候｡ 

05:53.260 --> 05:56.530
在这种状态下, 你把输入输入到你的神经网络中｡ 

05:56.530 --> 06:00.430
这里, 这里, 这里, 这里, 这里, 这里, 这里, 这里, 还有这里｡ 

06:00.730 --> 06:03.040
所有时间的输入都几乎相同｡ 

06:03.040 --> 06:10.390
所以如果你不断地输入相同的输入, 相同的值, 相同的向量或者非常相似的向量到你的网络中,

06:10.390 --> 06:16.570
因为没有变化, 汽车会学习得很好｡

06:16.570 --> 06:21.490
有一件事你会学得很好, 那就是如何沿着这堵墙开车, 就在它的右边｡ 

06:21.490 --> 06:24.870
所以这就是网络将如何更新, 它将得到回报｡ 

06:24.870 --> 06:27.370
它会慢慢地开始因为驾驶而得到奖励｡ 

06:27.370 --> 06:32.140
所以, 这就像, 好吧, 从这里开始学习, 哦, 我做得很好｡ 

06:32.140 --> 06:32.950
我做得更好了｡ 

06:32.950 --> 06:33.760
我做得更好了｡ 

06:33.760 --> 06:43.270
它会有一种错误的感觉, 认为自己做得很好, 尽管它只学会了如何沿着这堵墙开车.

06:43.270 --> 06:47.470
所以神经网络会变得非常适应沿着这堵墙行驶｡ 

06:47.470 --> 06:55.180
然后突然出现了一个曲线, 汽车不知道该怎么做, 它完全不符合这个神经网络｡

06:55.180 --> 07:03.130
即使它能以某种方式进行调整, 假设它通过了这一部分, 然后落在了这面墙上, 同样事情也会发生

07:03.130 --> 07:05.170
它会从这里, 这里, 这里｡ 

07:05.500 --> 07:10.780
现在, 神经网络正在自我重组以适应这堵墙然后, 砰, 这件事发生了｡ 

07:10.780 --> 07:14.590
即使它能越过那个, 它也会越过这个东西｡ 

07:14.590 --> 07:16.180
然后沿着这条线做同样事情

07:16.180 --> 07:22.120
所以基本上这就像是一个非常生动的例子, 说明了我们所面临的问题｡ 

07:22.120 --> 07:28.150
是因为我们使用神经网络的方式, 用每一个状态更新它, 一旦我们有很多连续的步骤,

07:28.150 --> 07:30.790
它们甚至不需要是相同的｡

07:30.790 --> 07:40.720
但是在环境中, 连续的状态是相互关联或相互依赖的, 这是很正常的｡ 

07:40.720 --> 07:45.490
我们不希望这种相互依赖性使我们的网络产生偏见｡ 

07:45.490 --> 07:52.830
我们不希望汽车只是学习如何沿着直线或长曲线行驶, 或者像你认为你能想到的任何东西,

07:54.000 --> 08:01.330
在生活中, 一个代理人将在一个环境中航行,

08:01.330 --> 08:07.810
无论你能想到的是相互关联或相互依赖的状态,

08:07.810 --> 08:15.190
一个接一个, 如果你只是让代理人从中学习, 这真的会扰乱你的神经网络｡

08:15.190 --> 08:17.560
这就是体验回放的用武之地｡ 

08:17.560 --> 08:21.790
在体验回放中所发生的就是这些体验｡ 

08:21.790 --> 08:30.760
所以这些州在1到3个州, 不管这里有多少个州, 它们都不会马上通过网络｡

08:31.330 --> 08:34.990
它们实际上保存在代理的内存中｡ 

08:35.920 --> 08:40.990
例如, 它会保存所有这些信息, 并在某个时间点保存所有这些信息,

08:40.990 --> 08:45.940
一旦达到某个阈值, 您将能够编写代码, 而Atlan将向您展示如何在达到某个阈值时执行此操作,

08:45.940 --> 08:50.290
然后代理将自行决定｡

08:50.290 --> 08:51.220
好吧, 是时候学习了｡ 

08:51.220 --> 08:56.500
我有我有这一批经验, 现在我要向那一批学习｡ 

08:56.500 --> 09:05.860
所以它随机选择一个均匀分布的密钥, 这一点很重要, 因为我们会在下一张幻灯片上讨论这个问题｡

09:06.670 --> 09:08.050
我们会我们会提到的｡ 

09:08.050 --> 09:11.650
但它需要一个均匀分布的样本｡ 

09:12.280 --> 09:15.520
所以基本上所有的经验都被认为是平等的｡ 

09:15.520 --> 09:20.050
它从它拥有的那批体验中取一个均匀分布的样本｡ 

09:20.320 --> 09:24.640
然后它通过他们, 从他们那里学习｡ 

09:24.640 --> 09:26.710
所以这不需要所有的经验｡ 

09:26.710 --> 09:28.270
它只需要一个均匀分布的样本｡ 

09:28.270 --> 09:31.180
所以从这里开始可能需要几个, 从这里开始几个, 从这里开始几个｡ 

09:31.180 --> 09:34.840
而每一个经验都表现为状态｡ 

09:34.840 --> 09:44.740
而是在于它采取的行动, 它最终所处的状态, 以及它在特定状态下通过行动所获得的回报｡

09:44.740 --> 09:49.750
因此在每一经验状态中对于要素的一个行动状态都要加奖励｡ 

09:49.870 --> 09:54.580
所以它把所有这些经验通过网络传递, 然后学习｡ 

09:54.580 --> 09:59.170
这样一来, 就打破了这种模式｡ 

09:59.210 --> 10:07.970
Elias, 这来自于经验的连续性, 如果你把它们一个接一个地通过网络｡

10:08.060 --> 10:11.820
所以这就是体验回放的重点｡ 

10:11.840 --> 10:14.300
这就是问题所在｡ 

10:14.300 --> 10:20.090
体验回放的另一个好处是, 有时候在这样的环境中, 你可能会有非常宝贵的､

10:20.090 --> 10:22.160
罕见的体验｡

10:22.160 --> 10:25.940
举个例子, 我不知道, 让我们看看这个角落｡ 

10:25.940 --> 10:26.270
对不对？

10:26.270 --> 10:28.280
这是这是一个右角｡ 

10:28.310 --> 10:28.550
好吧, 我知道了

10:28.640 --> 10:29.690
而且非常锋利｡ 

10:29.690 --> 10:30.770
有多少是锋利的？

10:30.770 --> 10:34.970
所以它会从这里来, 假设它会拥抱这个角落｡ 

10:35.450 --> 10:39.190
那么在这整个房间里我们有多少个尖锐的右角呢？

10:39.230 --> 10:42.260
我们这里只有一个右角这里也只有一个右角｡ 

10:43.580 --> 10:43.850
对不对？

10:43.850 --> 10:46.130
所以当它朝这边来的时候, 那是右角｡ 

10:46.130 --> 10:48.530
当它往回走的时候, 它是这里的锐角｡ 

10:48.530 --> 10:49.610
所以这个不锋利｡ 

10:49.610 --> 10:50.120
这个很锋利｡ 

10:50.120 --> 10:56.450
所以在整个环境中只有一个机会可以从一个尖锐的右角学习｡ 

10:56.660 --> 11:02.720
这是一个很重要的经验, 因为它可能会得到真正的好沿着直线驾驶, 得到真正的好做像软弯, 像这样,

11:02.720 --> 11:06.350
像这样｡

11:06.350 --> 11:15.470
但是它会继续把这个尖锐的右角弄得一团糟, 仅仅是因为它没有太多的机会从中学习｡

11:15.470 --> 11:20.000
所以它很快就能学会其他的东西, 但学会这个右角要花很长时间.

11:20.030 --> 11:21.830
这是一个非常简单的例子｡ 

11:21.830 --> 11:29.990
这是一个非常简单的解释, 但它说明了一个概念, 有时他们是罕见的经验, 这可能是有价值的｡

11:29.990 --> 11:35.930
如果你只是在做一个简单的神经网络, 你把你的值放在这里, 它们会通过,

11:35.930 --> 11:40.970
你知道,

11:40.970 --> 11:46.250
即使我们忘记了经验的顺序性问题, 以及它们是如何相互依赖和/或相互关联的, 甚至忘记了一秒钟,

11:46.640 --> 11:53.270
发生的是一旦你把一个经验, 它通过更新的网络, 然后你立刻忘记了它, 忘掉那些经历吧｡

11:53.270 --> 11:54.320
你去找下一个｡ 

11:54.320 --> 11:56.000
这就是神经网络的工作原理｡ 

11:56.000 --> 11:59.150
然后你进入下一个状态, 下一个状态, 下一个状态, 下一个体验, 下一个体验,

11:59.150 --> 12:00.980
下一个体验, 等等｡

12:00.980 --> 12:05.690
所以这个右边的角落, 一旦它通过了网络, 它就消失了,

12:05.690 --> 12:07.340
你对那个宝贵的经历没有任何记忆｡

12:07.340 --> 12:15.590
而对于体验回放, 由于您将这些体验放入批处理中, 因此可以将批处理组织为滚动窗口｡

12:15.590 --> 12:20.270
比如说, 你可以有100个批次, 也就是100次体验｡ 

12:20.270 --> 12:26.900
所以当它从这里回来的时候, 它在它的批次中记录了这段经历.

12:27.110 --> 12:35.000
然后就像在某个点上运行一样, 它从它的一批经验中获得一个均匀分布, 然后有一个滚动窗口｡

12:35.000 --> 12:39.560
所以它会忘记这些经验, 但它会保留这些经验, 然后它会再次学习, 一旦它在这里,

12:39.560 --> 12:42.200
它会从这一批中学习｡

12:42.320 --> 12:47.930
一旦它到了这里, 如果它一直到这里, 它就会有一系列这样的经历｡

12:47.930 --> 12:50.450
所以现在它从这些经验中学习｡ 

12:50.450 --> 12:58.670
这样的话, 你会得到这个右手边的角在学习过程中可能会出现几次, 因为它在那一批中,

12:58.670 --> 13:02.990
当那一批是这样的时候｡

13:02.990 --> 13:05.090
然后是在这一批, 在这一批｡ 

13:05.090 --> 13:11.390
所以它分几批出现, 因为批处理可能会作为一个滚动的体验窗口进行更新｡ 

13:11.390 --> 13:16.150
所以旧的经验被踢出去, 新的经验被加入, 然后旧的经验又踢了起来｡

13:16.160 --> 13:23.990
所以一个经验, 它停留在一批相当长的一段时间和汽车或代理人可以从经验中学习几次｡

13:23.990 --> 13:27.320
这是体验回放的另一个优势｡ 

13:27.320 --> 13:29.750
当然最后的优势是经验丰富｡ 

13:29.750 --> 13:35.510
与一次只学习一个经验相比, 重放为您提供了从更多经验中学习的机会, 因为您有该批,

13:35.510 --> 13:40.040
因此它是一个滚动窗口｡

13:40.040 --> 13:49.130
因此, 即使你的环境局限于经验, 你的经验回放方法也可以帮助你更快地学习｡

13:49.130 --> 13:55.640
而且, 您不必重复环境, 因为您不必重复, 所以可以更快地学习｡

13:55.640 --> 13:57.230
你保存了那些经历｡ 

13:57.590 --> 13:59.510
这些就是经验的主要优势｡ 

13:59.510 --> 13:59.840
重播｡ 

13:59.840 --> 14:00.560
让我们回顾一下｡ 

14:00.560 --> 14:03.860
我们已经得到了我们正在打破独立和｡ 

14:04.770 --> 14:07.230
连续经验的相关性｡ 

14:07.680 --> 14:12.540
我们保存了可能很重要的罕见经历, 因此我们可以更经常地从中学习｡ 

14:12.870 --> 14:16.770
我们可以在环境中学习｡ 

14:16.770 --> 14:24.900
我们可以学习有经验的寄养环境, 这些环境缺乏经验, 没有代理人经历过的那么多经验,

14:24.900 --> 14:29.100
但我们仍然可以学习｡

14:29.100 --> 14:31.740
所以这就是体验回放的意义所在｡ 

14:32.310 --> 14:38.900
如果你想读更多的东西, DeepMind在2016年发表了一篇有趣的文章｡

14:38.910 --> 14:44.300
这叫做“优先体验回放”, 它讲述了为什么｡ 

14:44.310 --> 14:50.420
为什么我们要使用均匀分布从体验批次中选择体验？

14:50.430 --> 14:56.640
为什么我们不找到一个更好的方法来选择我们的经历, 并优先考虑一些我们认为重要的经历呢？

14:56.880 --> 14:58.110
这是一件很有趣的事情｡ 

14:58.110 --> 15:07.650
所以在这种情况下, 你将不仅能够加强, 不仅加强你的经验重放知识,

15:07.650 --> 15:12.570
但你实际上将能够与最前沿的技术｡

15:12.570 --> 15:14.970
这是2016年, 由Deep Mind出版｡ 

15:14.970 --> 15:17.460
所以这是一篇很新的, 很有影响力的论文｡ 

15:17.460 --> 15:24.330
因此, 您将能够真正探索极限, 或者进一步探索此算法, 并将其提升到下一个级别｡

15:24.330 --> 15:30.810
因此, 如果您愿意, 我将让您来了解为什么以及如何将均匀分布更改为一种不同的方法,

15:30.810 --> 15:35.580
以体验本文中的重放, 我希望您喜欢今天的教程｡

15:35.580 --> 15:41.160
现在我们知道了什么是体验回放, 我们可以自信地在我们的实践教程中使用它｡ 

15:41.160 --> 15:42.810
我期待着下次见到你｡ 

15:42.810 --> 15:44.130
在那之前, 好好享受吧｡ 

15:44.130 --> 15:44.670
一､