WEBVTT

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

00:03.360 --> 00:06.300
在今天的教程中, 我们将讨论它的一个附加功能｡ 

00:06.300 --> 00:08.610
我们将实现我们的3C算法｡ 

00:08.610 --> 00:12.690
它被称为长时短时记忆或简称为长时记忆｡ 

00:12.690 --> 00:21.000
让我们先看看目前为止的情况, 然后讨论为什么需要LST以及什么是LSM｡

00:21.000 --> 00:24.480
到目前为止, 我们已经讨论了三个C算法｡ 

00:24.480 --> 00:29.910
我们已经讨论了A3C中的所有三个字母A, 当然, 我们已经看到它实际上要复杂一些,

00:29.910 --> 00:33.300
比我们在这张图上看到的复杂得多｡

00:33.300 --> 00:39.570
实际上, 我们有三个或更多的多个代理在环境中运行, 它们相互之间进行通信, 依此类推｡

00:39.570 --> 00:45.570
但为了简单起见, 今天的故事, 我们将用一个代理来说明一切｡

00:45.570 --> 00:47.520
最后, 我们有这个演员部分, 评论家部分｡ 

00:47.520 --> 00:52.770
所以基本上, 一旦我们有了一个状态, 这个状态到这个图像要经过一个卷积层, 然后它要经过一个池化层,

00:52.770 --> 00:55.290
到一个平面化层｡

00:55.290 --> 01:03.960
在这一点上, 我们有值或数字, 然后通过网络传播, 他们进入隐藏层｡

01:03.960 --> 01:10.350
然后作为输出, 我们得到政策或行动者部分, 他们得到国家的价值,

01:10.350 --> 01:12.600
我们得到批评者部分｡

01:12.600 --> 01:16.530
我们今天要做的就是讨论这个隐藏的部分｡ 

01:16.530 --> 01:21.600
所以在隐藏层中, 我们可以将其提升到下一个级别, 并进行修改｡ 

01:21.600 --> 01:25.560
我们已经看到, 算法存在多个修改｡ 

01:25.560 --> 01:26.250
我们见过其中一个｡ 

01:26.250 --> 01:32.430
我们已经看到, 在某些情况下, 您可以拥有网络的这一主要部分, 这一部分对于每个代理都是独立的,

01:32.430 --> 01:35.700
或者您可以拥有网络的这一主要部分, 这一部分是共享的｡

01:35.700 --> 01:42.000
这就是我们在之前的直觉实验中看到的, 我们有一个共享的网络部分｡ 

01:42.000 --> 01:44.100
此网络在代理之间共享｡ 

01:44.100 --> 01:50.580
正如阿德隆将在实践教程中告诉你的更多, 这真的有助于突破的挑战｡

01:50.580 --> 01:59.670
还有很多很多其他的方法可以修改算法, 很多其他的附加功能可以实现｡

01:59.670 --> 02:03.120
我们要讨论其中一个,

02:03.120 --> 02:09.720
因为我们实际上会在一组实用的教程中介绍它, 在你进入层之前, 你可以添加一个lshtm层,

02:09.720 --> 02:18.810
一个神经网络层, 它允许你的算法, 它允许算法有记忆, 它允许算法记住以前发生的事情｡

02:18.810 --> 02:20.940
我们现在会更详细地讨论Lshtm｡ 

02:20.940 --> 02:26.040
但基本上, 您可以在此处添加一个额外的层, 这是一个列表层,

02:26.040 --> 02:27.870
并通过为另一个功能添加一些额外的内存来增强您的算法｡

02:27.870 --> 02:32.610
在分形材质中, 你会看到, 在最后一层之后,

02:32.610 --> 02:36.030
我们甚至不需要任何隐藏层, 所以你会在预先实现中看到｡

02:36.030 --> 02:38.760
他马上就有了平整层｡ 

02:38.760 --> 02:40.350
之后, 他就有了系统层｡ 

02:40.350 --> 02:43.380
基本上, 这个框代表lshtm层｡ 

02:43.380 --> 02:45.960
然后马上就可以得到输出｡ 

02:45.960 --> 02:53.160
因此, 他甚至不需要任何其他隐藏层, 因为这是lshtm层为算法增加的能力｡

02:53.160 --> 02:58.980
同样, 神经网络的算法或架构, 也是一个非常个体化的东西｡ 

02:58.980 --> 03:01.320
这是个人的喜好, 是个很有创意的东西｡ 

03:01.320 --> 03:08.730
因此, 您可能希望有两个图层, 一个分析师图层, 然后列表中有五个隐藏图层｡

03:08.910 --> 03:11.670
这完全取决于你自己, 也取决于你的实验和探索｡ 

03:11.670 --> 03:16.290
但这是我们在实践教程中得出的结论｡ 

03:16.290 --> 03:24.240
因此, 您会看到我们有一个平面化层, 然后是lsd1层, 最后是输出｡

03:24.240 --> 03:28.590
现在我们已经讨论了这么多关于这个层的内容, 这个列表层是什么？

03:28.590 --> 03:34.650
好吧, lshtm层增加了记忆, 提供了一个特性,

03:34.650 --> 03:36.810
比如允许神经网络拥有关于之前迭代中发生的事情的记忆｡

03:36.810 --> 03:43.170
它经常被象征或用一个像这样的符号来表示｡ 

03:43.170 --> 03:46.050
这是我们刚刚开始, 我只是把它放在这里｡ 

03:46.050 --> 03:52.830
我知道它看起来很弯曲, 但我把它放在这里, 这样你就可以看到, 当我们进一步讨论这张图片时, 你就可以看到发生了什么｡

03:52.830 --> 04:01.500
这是这一层的输出, 这是我们的, 这是一个完整的层｡ 

04:01.500 --> 04:02.970
所以这是一个价值向量｡ 

04:02.970 --> 04:04.920
X是一个向量值, 它会进入三明治｡ 

04:04.920 --> 04:09.510
我们现在讨论一下, 然后作为输出, 你会得到另一个向量, 它是这些商店的连接,

04:09.510 --> 04:12.150
或者它以某种方式与网络联系在一起｡

04:12.150 --> 04:14.820
在我们的例子中, 作为一个输出, 你得到这个, 你得到这个｡ 

04:14.820 --> 04:17.280
让我们更详细地了解一下｡ 

04:17.280 --> 04:18.810
所以我们只关注这一部分｡ 

04:18.940 --> 04:22.830
事实上, 你们可能注意到了, 字母的大小,

04:22.830 --> 04:24.270
我们要把它翻到一边.

04:24.270 --> 04:31.590
所以像这样的混乱只是为了重申一个事实, 即使它看起来像这样, 实际上发生的是一层价值观,

04:31.590 --> 04:37.410
一个完整的价值观向量｡

04:37.410 --> 04:39.780
有些事情正在发生, 我们会时不时地讨论一下｡ 

04:39.780 --> 04:41.390
一整个矢谷都是在这里发生的｡ 

04:41.400 --> 04:43.170
这就是那一层｡ 

04:43.170 --> 04:47.190
这不仅仅是一个元素, 这是层本身｡ 

04:47.190 --> 04:49.320
所以我们再回过头来｡ 

04:49.320 --> 04:53.550
再重申一遍, 这一层归这一层｡ 

04:53.550 --> 04:55.530
发生了一些事情, 层出来了｡ 

04:55.530 --> 04:58.560
所以这就是这个系统只是在它的一边｡ 

04:58.560 --> 05:00.020
所以讨论起来容易些｡ 

05:00.490 --> 05:02.050
这是常见的表示法｡ 

05:02.170 --> 05:02.580
好吧, 我会的

05:02.590 --> 05:07.770
现在我们已经同意为什么这张图片是在它的一边, 我们将如何进行这一点？

05:07.780 --> 05:11.430
让我们开始深入研究这种情况｡ 

05:11.440 --> 05:14.010
那么蒸汽层内部会发生什么呢？

05:14.020 --> 05:15.330
这就是它的样子｡ 

05:15.340 --> 05:17.920
当然, 这看起来很复杂｡ 

05:17.920 --> 05:24.010
我们现在肯定不会讨论所有这些, 因为有很多东西需要讨论｡

05:24.100 --> 05:32.050
重点是, 运营是一个层次的运营, 只是有很多正在进行的事情或很多复杂的细节, 我们不打算讨论,

05:32.050 --> 05:37.300
因为否则会使本课程泡汤｡

05:37.300 --> 05:40.480
而这并不是目的, 也不是要在这里谈梗｡ 

05:40.480 --> 05:42.230
我们只需要利用每种弹性体｡ 

05:42.340 --> 05:49.960
如果你想了解更多关于Tams的信息, 你可以去克里斯托弗·奥拉斯的博客｡ 

05:50.410 --> 05:56.560
他很好地描述了所有的词干, 我们也在深度学习时代谈论LCMS｡ 

05:56.560 --> 05:57.970
当然, 您可以在那里查看｡ 

05:57.970 --> 06:01.300
我们还有一整节是关于递归神经网络和神经干的｡ 

06:01.300 --> 06:09.160
基本上, 这是LCM的内部部分, 所发生的事情就像是层进入｡ 

06:09.160 --> 06:13.450
所以我们将从直觉的层面, 从一个非常基本的内在层面来讨论这个问题｡ 

06:13.450 --> 06:18.310
仅仅, 仅仅,

06:18.310 --> 06:23.260
仅仅什么, 什么就足以让我们理解发生了什么, 为什么会有记忆, 这样你也可以更好地理解艾伦在实现这个的时候所说的｡

06:23.260 --> 06:28.390
所以在所有这些东西里面都有一层东西｡ 

06:28.420 --> 06:29.260
层熄灭｡ 

06:29.530 --> 06:37.390
我们需要实际看到的是, 这些部分, 实际上有额外的输入到这一层｡

06:37.390 --> 06:43.480
请记住, 通常您有来自上一层的输入, 然后是此层, 最后是输出｡

06:43.480 --> 06:49.540
如果你想想我们之前看到的图像, 正常的网络, 不是, 不是在它的一边, 而是从左到右,

06:49.540 --> 06:55.120
不是从上到下到上, 而是香草茎, 你实际上有更多的输入｡

06:55.120 --> 06:59.290
所以我知道这变得更加复杂, 但这些事情至少我们可以理解它们｡ 

06:59.290 --> 07:06.640
这是你的记忆细胞, 这是钥匙, 这就是你会听到阿德隆谈论的｡ 

07:06.640 --> 07:11.810
因此, 存储单元是保存在系统中的东西｡ 

07:11.830 --> 07:15.730
因此, 这些输入和输出实际上都在这里｡ 

07:15.730 --> 07:18.130
你现在看到的是时间轴｡ 

07:18.130 --> 07:20.200
所以这是在时间中解开的｡ 

07:20.200 --> 07:28.780
在一个特定的迭代中, 会发生这种情况, 但是这个值是从过去的值中取出来的, 这个值被传递到这些值中｡

07:28.780 --> 07:35.350
这些价值观取自过去, 并传递给未来, 以及它们如何通过LHS团队的工作方式顺利传递｡

07:35.350 --> 07:41.320
所以不用太担心这里发生了什么, 我们只需要知道,

07:41.350 --> 07:48.990
这个层已经存在了, 这里我们已经有了一个来自过去的值, 它存储在lshtm中｡

07:49.000 --> 07:51.550
在长､ 短期记忆中｡ 

07:51.880 --> 07:59.560
我们有一个记忆单元, 不管之前的值是什么, 它都在这里.

07:59.560 --> 08:00.010
你也看到了｡ 

08:00.010 --> 08:07.090
它只是自由地流过, 除了这些点操作, 它可以被关闭或添加一些东西｡

08:07.090 --> 08:11.380
但不管怎样, 它只是一些自由流动的价值｡ 

08:11.380 --> 08:14.860
所以基本上它被传递到下一个时间点, 下一个时间点｡ 

08:14.860 --> 08:21.310
所以你可以把它想象成一个像闪存驱动器之类的内存, 或者这个细胞拥有的东西｡

08:21.310 --> 08:24.280
它只会记住之前的值.

08:24.280 --> 08:29.860
然后它可以使用这个值来做加法或者从这个值中读取等等｡ 

08:30.160 --> 08:38.110
这个值是隐藏状态, 它是这样的, 因此H和隐藏状态基本上是另一个来自过去的值,

08:38.110 --> 08:41.950
然后在系统内部使用｡

08:41.950 --> 08:49.240
最后你可以看到, 在这一切发生之后, 你得到的是一个层, 它出来了｡

08:49.240 --> 08:52.930
所以你得到的这个值和向前传递的值是一样的｡ 

08:52.930 --> 08:55.690
所以LLS团队记住了两件事｡ 

08:55.690 --> 09:01.370
在lshtm中有一个常量值, 就像stays一样, 可以像这样改变｡ 

09:01.420 --> 09:04.660
有一个闪存驱动器, 像一个常量值｡ 

09:04.660 --> 09:10.540
所以记忆细胞, 你可以, 你可以在那个空间里, 在那个记忆里, 储存一些东西,

09:10.540 --> 09:13.330
这些东西将被传递到未来｡

09:13.330 --> 09:20.470
所以在下一次迭代中, 就像算法在一个环境中, 它看到了什么, 做了什么, 等等｡

09:20.470 --> 09:26.740
在团队中, 您可以存储某个值, 即使处于下一个状态, 它也会记住该值｡

09:27.190 --> 09:33.640
另一个值也会记住它之前的输出, 它会自动记住之前的输出.

09:33.640 --> 09:35.290
输出在这里输出在这里｡ 

09:35.290 --> 09:42.070
这基本上就是LSM中发生的非常非常高的水平｡ 

09:42.070 --> 09:46.060
同样, 如果您想了解更多详细信息, 您可以找到大量资源｡ 

09:46.060 --> 09:50.920
在这个阶段, 我们不需要对所有这些事情进行太多的详细介绍｡ 

09:50.920 --> 09:56.950
我们只需要了解什么是记忆单元, 什么是隐藏的记忆单元, 什么是隐藏的状态,

09:56.950 --> 09:59.950
以及它们如何促进｡

10:00.490 --> 10:01.810
列表的内存｡ 

10:02.110 --> 10:09.520
现在的问题是, 既然我们已经对所有这些有了一个大致的了解,

10:09.520 --> 10:19.090
来巩固或巩固这些知识, 或者给予这些知识一个理由, 让我们问一个问题, 为什么我们需要记忆？

10:19.090 --> 10:22.960
为什么我们的a3c或其他算法需要内存？

10:22.960 --> 10:26.890
好吧, 让我们看看我们的例子, 我们在这一节要面对的挑战｡ 

10:26.890 --> 10:28.360
所以挑战是突围｡ 

10:28.360 --> 10:29.860
在突围中会发生什么？

10:29.860 --> 10:35.710
好吧, 在突破中, 你有这样的环境, 这些小块, 你需要用这个小球摧毁｡

10:35.710 --> 10:40.900
你需要确保这是你喜欢的球拍或平台, 这是移动｡ 

10:40.900 --> 10:46.060
当球飞起来的时候, 它必须接住球, 然后从平台上弹回来, 打到球上, 或者从墙上弹回来,

10:46.060 --> 10:49.480
打到拦网上, 然后回来.

10:49.870 --> 10:54.100
所以这就是你需要完成的事情的本质｡ 

10:54.100 --> 11:02.260
但是现在让我们看看这个球, 就像想象你是一个an, an, a3c算法, 或者是一个在a3c里面的代理,

11:02.260 --> 11:05.260
你看到这张图了吗？

11:05.260 --> 11:07.480
你从这里提取了什么？

11:07.480 --> 11:09.070
你在这里会采取什么行动？

11:09.070 --> 11:09.490
从这里？

11:09.490 --> 11:11.740
所以你能看到球在飞, 对吧？

11:11.740 --> 11:13.540
它飞起来了, 对吧｡ 

11:13.540 --> 11:15.880
所以它要去某个地方, 也许它正朝你飞过来｡ 

11:15.880 --> 11:16.120
好吧, 我知道了

11:16.120 --> 11:17.740
你能不能做出这个结论？

11:17.740 --> 11:20.050
你能预料到它朝你走来吗？

11:20.080 --> 11:21.160
你也许可以｡ 

11:21.160 --> 11:23.680
也许你是在正确的位置接球｡ 

11:23.680 --> 11:26.590
但如果球实际上不是朝那个方向飞呢？

11:26.590 --> 11:27.310
那飞的是什么？

11:27.310 --> 11:28.480
如果它朝那边飞呢？

11:28.750 --> 11:36.340
问题是, 你不能从这张图像中分辨出它的飞行方向, 因为你不知道它在前一刻的位置｡

11:36.340 --> 11:39.060
所以如果它在这里, 那么它就在飞这个｡ 

11:39.150 --> 11:43.690
所以如果你有, 如果你知道时间上的前一刻, 如果你知道它在这里, 那么, 现在你知道,

11:43.690 --> 11:45.400
这里是作为一个人｡

11:45.400 --> 11:48.640
你只要把这两个画一条线, 你就会说, 哦, 酷, 所以它是这样的｡ 

11:48.640 --> 11:52.270
但是如果你知道它在这里, 你就画一条线到这些看台去｡ 

11:52.270 --> 11:54.250
而且, 看看这个｡ 

11:54.250 --> 11:57.010
它可能就在这里｡ 

11:57.010 --> 11:59.500
也许它在往上走, 也许它真的往那个方向走｡ 

11:59.500 --> 12:01.030
所以也许它就在这里, 而我正往上走｡ 

12:01.240 --> 12:04.540
所以仅仅从那一个形象来看是很难的｡ 

12:04.540 --> 12:05.860
这实际上是不可能的｡ 

12:05.860 --> 12:10.450
这就像几何学上不可能知道球是朝哪个方向飞的｡ 

12:10.450 --> 12:17.830
所以这就是为什么上次记忆真的, 真的帮助算法, 没有记忆, 它仍然可以做得很好,

12:17.830 --> 12:22.450
但它可能会像猜测, 或者,

12:22.450 --> 12:27.640
你知道, 找到其他方式来理解去哪里, 但只是尊重一个记忆｡

12:27.640 --> 12:33.790
因此, 如果我们使用该值返回, 那么, 这有点像上一个值的输出,

12:34.150 --> 12:40.270
或者, 您可以将其存储在此处, 或者基于该值, 例如,

12:40.270 --> 12:43.180
基于从上一个时间点获得的信息｡

12:43.180 --> 12:47.980
从这里发生的事情来看, 这就是你的球之前所在的位置｡ 

12:47.980 --> 12:54.100
因此, 您可以通过这里传递上一时间点的环境信息, 现在您就拥有了这些信息｡

12:54.100 --> 13:02.740
现在你不仅从图像中得到信息, 如果我们再往前看, 你会从图像中记住信息｡

13:02.740 --> 13:07.060
好吧, 这是厄运, 但我们实际上是在处理图像中的突破信息, 这里,

13:07.060 --> 13:09.910
这里, 变成了这些扁平的值｡

13:09.910 --> 13:13.240
这就是进入系统的图像信息｡ 

13:13.240 --> 13:21.220
现在突然间, 就像你记得的那样, 不是从某个地方来的, 而是从以前的时间点来的｡

13:21.220 --> 13:24.490
所以这就是为什么你根本不能证明它是从哪里来的, 而是从球和从左到右｡

13:24.490 --> 13:28.300
它实际上只是停留在lshtm层｡ 

13:28.300 --> 13:31.540
您只需通过系统的体系结构就可以获得这些信息｡ 

13:31.540 --> 13:33.790
你有关于之前发生的事情的信息｡ 

13:33.880 --> 13:41.920
所以我们回到这里, 这里的信息帮助你现在做一个决定, 做什么, 帮助算法做一个决定, 现在突然之间, 它知道了,

13:41.920 --> 13:45.420
哦, 好吧｡

13:45.430 --> 13:51.040
所以球实际上要么是朝这个方向飞, 要么是朝这个方向飞.

13:51.040 --> 13:53.170
所以我来对地方了, 我应该留在这里｡ 

13:53.170 --> 13:54.610
球朝我的方向来了｡ 

13:54.610 --> 13:58.510
或者如果它意识到球飞到了那里, 它应该开始向左移动, 因为如果它再等一段时间,

13:58.510 --> 14:01.690
就太晚了, 它会错过球.

14:01.690 --> 14:12.200
这就是lshtm层在这个算法中的作用, 这也正是我们在学习Adland的实践教程时会看到的｡

14:12.220 --> 14:12.940
好了, 我们走吧｡ 

14:12.970 --> 14:14.260
这就是这个团队的工作方式｡ 

14:14.260 --> 14:20.680
还有一个额外的注意事项, 正如我们在开始时提到的, 埃利斯时报不是100%必要的｡ 

14:20.680 --> 14:25.330
它们不是一个完整的, 就像它们没有完全依附于这个算法一样｡ 

14:25.330 --> 14:27.910
你可能会想把它们放进去, a3c算法｡ 

14:27.910 --> 14:31.030
您可能不想拥有它们, 具体取决于具体情况和您选择的体系结构｡ 

14:31.030 --> 14:37.270
有很多的增加, 我们已经讨论过, 增加或修改, 神经网络在参与者之间共享,

14:37.270 --> 14:40.750
在代理之间不共享, 或者不共享｡

14:40.750 --> 14:41.860
现在尽管如此｡ 

14:41.860 --> 14:47.830
在实践教程中, 你们会看到另一个例子, 我们加入了熵, 它是在保单损失中计算的,

14:47.830 --> 14:51.010
阿德隆会带你们去的｡

14:51.010 --> 14:56.920
所以基本上, 在一个算法中可以有很多不同的修改｡ 

14:57.250 --> 14:59.230
只要记住这要看情况｡ 

14:59.380 --> 15:00.460
你想要达到的目标｡ 

15:00.460 --> 15:08.140
如果你要实现很多这样的算法, 尝试不同的算法, 这也会鼓励你去探索｡

15:08.890 --> 15:15.310
我们已经讨论了几个, 也许你可以找到一些额外的修改, 可能会感兴趣的｡

15:15.460 --> 15:21.250
或者当你在看这些教程的时候, 也许到那时更多的修改已经出来了, 这很有趣｡

15:21.250 --> 15:27.310
所以这绝对是你可以研究的东西, 它可以进一步增强你对人工智能的知识,

15:27.310 --> 15:30.460
以及如何创建这些算法｡

15:30.490 --> 15:34.030
在这一点上, 我希望你喜欢今天的教程, 我期待着你下一次｡ 

15:34.060 --> 15:35.250
在那之前, 好好享受吧｡ 

15:35.250 --> 15:35.650
一､