WEBVTT

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

00:02.520 --> 00:07.530
现在我们要做一个正向函数, 它将把信号从输入图像开始,

00:07.530 --> 00:13.050
向前传播到整个大脑, 直到输出, 它将包含演员的线索值和V值,

00:13.050 --> 00:17.920
V值是V函数为评论家取的值｡

00:17.940 --> 00:23.720
所以这将是非常相似的, 我们做了什么毁灭战士, 但这一次有些事情要改变｡ 

00:23.730 --> 00:29.040
最主要的变化是, 现在我们在大脑中有了一个自动取款机, 所以我们都必须做更多的事情来传播信号,

00:29.040 --> 00:32.280
并小心处理｡

00:32.580 --> 00:38.220
另一件不太重要的事情, 但是和以前相比, 还是有变化的,

00:38.220 --> 00:43.800
那就是我们不会使用循环激活函数, 你知道, 非线性激活函数,

00:43.800 --> 00:48.770
但是我们会使用循环, 这是一种更复杂的函数｡

00:48.780 --> 00:51.210
我们将在Python文档中看到这一点｡ 

00:51.630 --> 00:52.770
所以我们开始吧｡ 

00:52.770 --> 00:54.180
让我们把这个函数｡ 

00:54.180 --> 00:55.800
我们从定义开始｡ 

00:55.890 --> 00:58.980
这实际上是这个活动类的最后一个函数｡ 

00:58.980 --> 01:02.400
所以我们要像上次一样向前调用它｡ 

01:02.400 --> 01:09.930
第四个函数是把self作为对象因为我们要使用对象和输入.

01:09.930 --> 01:13.320
了解这些输入是什么如此重要？

01:13.350 --> 01:20.810
这将不仅是输入图像, 这些输入还将包含隐藏节点和团队的单元节点｡

01:20.850 --> 01:24.300
所以这就是为什么我想强调一些事情将要改变｡ 

01:24.300 --> 01:30.720
现在, 基本上, 我们在转发函数中考虑STM的单元节点中的隐藏节点｡

01:30.930 --> 01:41.440
现在我们要做的就是把这两个输入分开, forward函数的输入, 我们怎么把它们分开呢？

01:41.460 --> 01:46.050
我们可以调用一个新的变量, 它将是输入图像｡ 

01:46.050 --> 01:55.110
这一次, 输入图像, 我们用元组H, X和Cx, 把它们分开,

01:55.110 --> 02:03.720
这是一对隐藏状态和lsg的单元状态, 所以hx是隐藏状态, cx是单元状态｡

02:04.440 --> 02:04.800
好吧, 我会的

02:04.800 --> 02:07.470
这将等于输入｡ 

02:07.470 --> 02:09.030
这就是这个论点｡ 

02:09.420 --> 02:15.000
所以现在我们做了这个分离, 因此我们可以开始在整个大脑中传播信号｡ 

02:15.000 --> 02:21.030
为了做到这一点, 我们要连续地得到不同的层,

02:21.030 --> 02:30.060
从第一层到最后一层, 通过使用一个连接, 也就是卷积, lshtm连接和这里的线性连接, 全连接｡

02:30.210 --> 02:31.650
所以我们现在就开始吧｡ 

02:31.650 --> 02:33.470
它会和以前一样｡ 

02:33.480 --> 02:39.060
我们将得到第一层,

02:39.060 --> 02:44.880
称为X, 为了得到第一层,

02:44.880 --> 02:51.660
我们需要将信号从输入传播到第一层, 因此我们需要使用第一次卷积, 因为正是第一次卷积将信号从输入图像传播到第一层｡

02:51.840 --> 02:58.020
我们现在要做的是复制它,

02:58.020 --> 03:04.710
因为这是我们粘贴在这里的第一个卷积, 我们将第一个卷积应用到我们的输入图像, 现在是正确的输入｡

03:04.710 --> 03:05.640
好了

03:05.640 --> 03:09.480
其将来自输入图像的信号传播到第一层｡ 

03:09.600 --> 03:16.170
但现在请记住, 我们必须使用非线性激活函数来打破线性,

03:16.170 --> 03:20.040
以便能够学习图像内部的非线性关系｡

03:20.040 --> 03:27.990
要做到这一点, 我们将使用ALU激活函数, 我们将在PyTorch文档中看到该函数｡

03:27.990 --> 03:29.940
但在那之前, 先把它弄到手｡ 

03:29.940 --> 03:36.450
为了得到它, 我们实际上取一个函数模块, 它有一个短的片段,

03:36.450 --> 03:45.750
F, 然后是点, 然后是Alu, 然后我们把这些都放在括号里, 因为我们想非线性地激活第一层的神经元,

03:45.750 --> 03:50.730
我们在输入上应用第一个卷积得到的｡

03:50.970 --> 03:55.050
现在让我们来看看PyTorch, Doug, 来了解ALU是什么｡ 

03:55.080 --> 04:02.130
在这里, 你可以访问它到pytorch点org斜线doug斜线rn点html｡ 

04:02.130 --> 04:04.860
然后你必须找到非线性激活｡ 

04:05.310 --> 04:10.470
在非线性激活函数中, 你会发现, 卢, 这是我们所知道的经典函数｡ 

04:10.470 --> 04:17.100
所以这只是一个0和x的最大值, 你已经有了这个图, 然后你有了版本6, 就是这个｡

04:17.100 --> 04:19.260
所以更复杂一点｡ 

04:19.260 --> 04:20.040
好了

04:20.040 --> 04:21.060
我们有一个卢｡ 

04:21.330 --> 04:26.400
正如你所看到的, 循环就是一个循环加上一个额外的元素｡ 

04:26.400 --> 04:29.130
所以它是一个更复杂的值｡ 

04:29.130 --> 04:33.960
这就是我们用来非线性激活不同层神经元的方法｡ 

04:33.960 --> 04:39.030
顺便说一下, 这个循环激活函数被称为指数线性单位｡ 

04:39.300 --> 04:40.170
好了, 我们走吧｡ 

04:40.170 --> 04:46.170
我们在第一个卷积层上应用了循环, 现在事情就简单了｡ 

04:46.170 --> 04:52.230
我们将继续进行信号的下一个第四传播,

04:52.230 --> 04:58.980
即从第一卷积层到第二卷积层, 我们将其称为X,

04:58.980 --> 05:09.060
因为基本上我们只是更新X, 现在x是第一卷积层, 通过将信号从第一卷积层传播到下一个卷积层, x将成为下一个卷积层｡

05:09.270 --> 05:15.120
因此, 要将信号从第一卷积层传播到第二卷积层, 我们可以简单地复制并粘贴到这里, 然后用conf

05:15.120 --> 05:20.310
2替换conf 1｡

05:20.310 --> 05:25.920
当然, 现在第二次卷积不是应用于输入图像, 而是应用于x｡ 

05:25.920 --> 05:29.400
这是第一个卷积层, 就在这里｡ 

05:29.670 --> 05:30.630
好吧, 完美｡ 

05:30.630 --> 05:37.950
现在, 我们得到第二卷积层, 现在让我们再次将信号从第二卷积层传播到第三卷积层｡

05:37.950 --> 05:45.660
因此, 我们可以直接复制这个和这个, 然后用三个来代替两个｡ 

05:45.810 --> 05:46.710
我们走吧｡ 

05:46.710 --> 05:52.740
最后一个是将信号从第三卷积层传播到第四卷积层, 也是最后一个, 我们可以再次复制,

05:52.740 --> 05:58.620
粘贴到这里, 并将3号营替换为4号营｡

05:58.650 --> 05:59.460
我们走吧｡ 

06:00.000 --> 06:01.560
让我们回顾一下｡ 

06:01.590 --> 06:03.240
我们从输入开始｡ 

06:03.240 --> 06:06.930
我们应用第一卷积以获得第一卷积层｡ 

06:07.080 --> 06:12.720
然后, 我们将第二卷积应用于第一卷积层以获得第二卷积层｡

06:12.720 --> 06:18.300
然后, 我们将第三卷积应用于第二卷积层以获得第三卷积层｡

06:18.300 --> 06:24.570
最后, 我们将第四个卷积应用到第三个卷积层, 得到第四个卷积层,

06:24.570 --> 06:29.700
这就是信号如何通过人工智能的眼睛传播的｡

06:29.820 --> 06:30.600
好了, 我们走吧｡ 

06:30.600 --> 06:35.550
我们现在有了四次卷积后的输出信号, 现在你知道该怎么做了｡ 

06:35.550 --> 06:40.710
我们需要将整个输出信号扩展为一维向量｡ 

06:40.710 --> 06:42.570
这是压平步骤｡ 

06:42.630 --> 06:45.060
所以我们要再次更新X｡ 

06:45.090 --> 06:48.690
X现在变成了这个平面化的一维向量｡ 

06:49.050 --> 06:57.180
要做到这一点, 我们需要取X, 这是目前为止的第四个卷积层｡

06:57.330 --> 07:03.720
然后我们使用Vue函数, 首先输入-1表示我们想要｡ 

07:03.800 --> 07:05.240
一维向量｡ 

07:05.240 --> 07:10.940
然后作为第二个参数, 我们需要输入这个向量中的元素个数, 记住,

07:10.940 --> 07:16.280
32乘以3乘以3, 所以我们在这里输入32｡

07:17.060 --> 07:19.670
乘以三乘以三｡ 

07:20.120 --> 07:20.650
我们走吧｡ 

07:20.660 --> 07:24.290
现在我们有了展平的向量, 展平步骤完成了｡ 

07:24.530 --> 07:25.290
好极了｡ 

07:25.310 --> 07:27.980
现在让我们来处理最后一部分｡ 

07:27.980 --> 07:31.610
正如你所理解的, Lshtm接受我们的输入｡ 

07:31.610 --> 07:36.830
展平的向量, 这个一维的向量, 由三, 二, 三, 三个元素组成｡ 

07:36.950 --> 07:40.250
所以它已经准备好了, 为Lshtm做好了充分的准备｡ 

07:40.250 --> 07:49.820
Lshtm现在已经准备好将这个展平的向量作为输入, 因此我们可以将lshtm和输入作为参数｡

07:49.820 --> 07:55.820
第一个X是展平的矢量, 就是我们刚刚用过的x射线｡ 

07:56.000 --> 08:00.620
但这也是这个双打发挥作用的地方｡ 

08:00.650 --> 08:08.660
我们需要输入H, X和C, x, 我们可以使用x, 这里看到x,

08:08.660 --> 08:12.230
因为我们把它和forward函数的原始输入参数分开了｡

08:12.740 --> 08:19.940
所以lshtm, x, 最多四个卷积的展平输出向量, 以及这个隐藏节点和单元节点的表｡

08:20.330 --> 08:21.230
好了, 我们走吧｡ 

08:21.230 --> 08:26.030
然后我们不能忘记自我, 因为lshtm是我们最终函数的一个变量｡ 

08:26.030 --> 08:33.560
所以变量会连接到对象上, 所以LCM会返回到输出, 一个包含两个输出的表,

08:33.560 --> 08:37.670
这两个输出是输出健康节点和输出单元节点｡

08:37.670 --> 08:48.920
所以它实际上是一个元组, 所以我们可以更新hx隐藏节点, 看到x单元节点, 因为这就是lshtm的输出｡

08:49.930 --> 08:50.380
好极了｡ 

08:50.380 --> 08:52.660
所以我们现在差不多完成了｡ 

08:52.660 --> 08:58.780
现在我们有了LLS小组的输出, 我们需要得到有用的输出,

08:58.780 --> 09:06.970
因为实际上只有印度音符是有用的, 所以我们要通过再次更新x得到它, x现在等于｡

09:07.270 --> 09:13.810
LSB x的输出对的第一个元素等于h x, 我们差不多完成了｡ 

09:14.020 --> 09:18.580
记住, 我们有两个大脑, 一个是演员的大脑, 一个是评论家的大脑｡ 

09:18.580 --> 09:25.150
因此我们必须输出信号, 以返回演员的输出信号和评论家的输出信号｡

09:25.330 --> 09:29.350
因此, 现在我们要做的是返回这两个输出信号｡ 

09:29.350 --> 09:30.640
我们怎么才能做到呢？

09:30.640 --> 09:31.870
这很简单

09:31.870 --> 09:35.230
我们只需要得到线性的全连接｡ 

09:35.230 --> 09:40.660
但是, 独立的, 有线性的, 完整的连接的批评家和线性的完整的连接的演员｡

09:40.960 --> 09:50.170
我们将这些连接中的每一个应用到输出x, 它是lshtm的有用输出, 也是输出信号的全部｡

09:50.170 --> 09:51.730
好了, 开始吧｡ 

09:51.730 --> 09:58.990
我们首先把self作为对象, 然后我们得到critic的线性脚连接,

09:59.140 --> 10:06.730
这是critic下划线线性, 我们把它应用到x, lshtm的输出信号, 然后我们再把self,

10:06.730 --> 10:16.090
然后, 然后我们得到actor的线性全连接, 这是actor下划线线性, 我们把它应用到x｡

10:16.090 --> 10:17.020
我们走吧｡ 

10:17.920 --> 10:19.520
所以这是我们需要的主要东西｡ 

10:19.540 --> 10:25.780
但我们也会返回所有隐藏的顶部音符, 并看到X来卖出音符,

10:25.780 --> 10:28.990
因为我们稍后会在LSB场景的复古循环中使用它们｡

10:29.350 --> 10:30.340
好吧, 完美｡ 

10:30.340 --> 10:37.950
所以现在我们已经完成了大脑或者我应该说大脑, 因为我们实际上做了两个大脑, 一个给演员, 一个给评论家｡

10:37.960 --> 10:41.900
所以恭喜你做了a3c大脑｡ 

10:41.920 --> 10:51.070
我希望这不是太压倒性的联合收割机CNN和LCM, 但至少好消息是, 我们真的是与最好的和最强大的模式｡

10:51.070 --> 10:52.810
好了, 我们走吧｡ 

10:52.840 --> 10:56.590
实际上, 我们已经完成了第一个文件模型, 即饼图｡ 

10:56.620 --> 11:03.010
在下一个教程中, 我们将讨论优化器, 因为我们将创建一个单独的优化器｡

11:03.040 --> 11:08.170
我们不打算编写每一行代码, 因为很多代码来自研究论文｡ 

11:08.170 --> 11:10.270
这是非常具体的｡ 

11:10.270 --> 11:16.450
如果我们深入了解这个优化器的详细情况, 对于接下来要发生的事情来说, 这可能有点太难了,

11:16.450 --> 11:22.360
因为我们还要创建train函数, 这将是一个巨大的函数,

11:22.360 --> 11:26.750
其中包含风险算法｡

11:26.800 --> 11:32.260
所以相信我, 你要保持一些精力, 因此我们不会花太多时间在这上面｡

11:32.260 --> 11:37.630
但是, 我仍然会解释代码, 您将理解这个优化器背后的整个思想｡ 

11:37.960 --> 11:44.470
再次祝贺你创建了这个活跃的创造性类, 我会在下一个教程中看到你创建优化器｡

11:44.500 --> 11:45.670
在那之前, 好好享受吧｡ 

11:45.670 --> 11:45.970
一､