WEBVTT

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

00:02.730 --> 00:08.370
所以下一步就是让这些神经元发挥作用, 这将给予我们带来我们想要的｡ 

00:08.370 --> 00:14.040
这是在这个巨大的向量中的神经元数量, 在卷积之后｡ 

00:14.070 --> 00:19.260
这是我们现在唯一缺少的信息, 我们将通过函数得到它｡ 

00:19.410 --> 00:21.570
让我们把这个函数｡ 

00:21.570 --> 00:27.390
我们称之为计数, 简单地用下划线标出神经元｡ 

00:27.540 --> 00:29.550
这算什么？

00:29.580 --> 00:32.070
神经元的功能会以什么作为参数呢？

00:32.220 --> 00:38.340
好吧, 它会取物体本身, 但它会取其他东西,

00:38.340 --> 00:44.350
因为展平层中输出神经元的数量实际上只取决于一件事｡

00:44.370 --> 00:51.750
它取决于原始输入图像的维度, 即神经网络最开始的维度｡

00:51.930 --> 00:57.930
所以我们现在唯一需要的论据就是这些尺寸, 输入图像的尺寸｡

00:58.170 --> 01:03.540
因此, 让我们给予这个表示输入图像尺寸的参数命名, 我们将它命名为image

01:03.540 --> 01:06.590
dim｡

01:07.050 --> 01:07.620
好吧, 我会的

01:07.620 --> 01:16.500
我现在可以告诉你, 来自末日的输入图像的实际尺寸将是80 × 80｡

01:16.590 --> 01:25.970
我们要把原始图像的大小缩小到80乘80, 这就是进入神经网络的图像格式｡

01:25.980 --> 01:32.400
因此, 图像STEM实际上将为188, 这与我们处理白色图像的事实相对应,

01:32.400 --> 01:35.220
即只有一个通道｡

01:35.220 --> 01:40.440
所以把它们映射成元组1, 80和80｡ 

01:41.160 --> 01:41.460
好吧, 我会的

01:41.460 --> 01:43.470
所以这是我们唯一需要的论据｡ 

01:43.470 --> 01:45.620
现在让我们来数一下神经元｡ 

01:45.630 --> 01:47.220
那我们要怎么做呢？

01:47.250 --> 01:51.030
首先, 我们现在没有任何输入损伤｡ 

01:51.030 --> 01:53.910
我们没有任何可以导入的末日图像｡ 

01:53.910 --> 01:55.220
我们稍后再做｡ 

01:55.230 --> 02:00.210
所以我们要做的第一件事是创建一个假图像, 但它的维数是80｡ 

02:00.210 --> 02:05.700
到了80, 我们会用假像素来创建假图像,

02:05.700 --> 02:13.050
而这最终还是给予我们想要的数字, 因为这个数字只取决于尺寸, 而不是图像内部的像素｡

02:13.050 --> 02:18.120
我们先创建一个假的图像然后计算出我们需要的神经元的数量.

02:18.300 --> 02:25.230
创建假图像的技巧是, 首先我们将其命名为X, 然后我们将使用渲染的火炬,

02:25.230 --> 02:32.010
因为, 你知道, 我们将在图像中放置一些随机像素,

02:32.010 --> 02:36.810
因为我们使用火炬中的随机函数, 即run函数｡

02:36.930 --> 02:44.300
然后在里面我们要输入, 如你所见, 图像的尺寸是188｡ 

02:44.340 --> 02:50.130
但是因为我们要把这个图像输入到神经网络中, 你们还记得, 神经网络只能接受一批批的输入状态,

02:50.130 --> 02:55.110
一批批的输入图像｡

02:55.110 --> 03:00.420
我们将创建一个伪维度, 可以直接在run函数中创建｡ 

03:00.420 --> 03:05.270
实际上,

03:05.280 --> 03:10.860
我们只需要从与批次对应的一个开始, 然后我们可以将其放入与输入图像的尺寸对应的Apple 188｡

03:10.860 --> 03:16.950
正如你们所理解的, 这些维度包含在这个image dim参数中,

03:16.950 --> 03:26.640
它代表了表188, 所以, 现在我们只需要添加image dim, 但是为了传递temple的元素, 因为现在image

03:26.640 --> 03:34.140
them是一个元组, 作为一个函数的参数列表, 我们需要在image them之前, 也就是在表之前,

03:34.140 --> 03:36.260
添加｡

03:36.330 --> 03:43.920
一种存储, 该存储将允许将图像模糊元组的元素作为函数的参数列表传递｡

03:43.920 --> 03:49.380
正如你所看到的, 这正是这里所指定的, 星星和维度｡ 

03:49.740 --> 03:50.130
好吧, 我会的

03:50.130 --> 03:53.940
这样就产生了一个假像素的图像｡ 

03:54.000 --> 03:56.550
所以这和末日影像无关｡ 

03:56.550 --> 04:00.000
但同样, 我们仍然能够得到神经元的最终数量｡ 

04:00.300 --> 04:07.770
现在我们需要记住的最后一件事是, 把这个输入批处理向量转换成火炬变量,

04:07.950 --> 04:12.270
因为这将进入神经网络｡

04:12.870 --> 04:13.320
好吧, 我会的

04:13.320 --> 04:20.070
这代表了一个由随机像素组成的输入图像, 它刚刚被转换成了一个torch变量｡ 

04:20.070 --> 04:26.490
现在我们将把它引入到神经网络中, 更具体地说, 神经网络的卷积层｡

04:26.490 --> 04:33.990
因为我们只需要卷积后的神经元数目, 我们只需要卷积3｡

04:33.990 --> 04:39.390
在第三个卷积层之后, 我们就不讨论到全连接了｡ 

04:39.600 --> 04:44.970
这是因为我们需要的神经元数量介于卷积3和FC 1之间｡ 

04:45.360 --> 04:45.660
好吧, 我会的

04:45.660 --> 04:52.710
现在, 我们有了一个具有正确维度的输入图像, 那么, 是时候将该图像传播到神经网络中,

04:52.710 --> 04:55.980
以到达展平层｡

04:56.070 --> 05:01.650
然后我们将得到扁平层中的神经元, 我们将得到我们想要的信息｡

05:01.650 --> 05:04.710
这是这个扁平层中神经元的数量｡ 

05:04.710 --> 05:08.670
所以现在我们要做的就是我们在forward函数中所做的｡ 

05:08.670 --> 05:16.050
我们需要将信号传播到神经网络中, 但只在卷积层中传播, 直到到达展平层｡

05:16.050 --> 05:17.130
所以我们开始吧｡ 

05:17.130 --> 05:19.680
我们将更新x｡ 

05:19.680 --> 05:26.850
现在, x是输入图像, 并且对于第二个x, 这里x将完全变成第一卷积层｡ 

05:27.030 --> 05:29.970
现在我们要做的是一个三步的过程｡ 

05:29.970 --> 05:33.600
第一步, 我们将卷积应用于输入图像｡ 

05:33.600 --> 05:38.370
然后第二步, 我们对获得的卷积图像进行最大修剪｡ 

05:38.370 --> 05:44.250
然后第三步我们激活这些聚集在一起的卷曲图像中的神经元｡ 

05:44.250 --> 05:50.370
所以X将成为第一个卷积层, 由所有这些池, 卷积图像组成｡ 

05:50.790 --> 05:56.760
我们来做第一步, 对输入图像进行第一次卷积｡ 

05:56.760 --> 06:04.380
所以我们要做的就是取卷积1自点卷积1｡ 

06:04.380 --> 06:05.250
我们走吧｡ 

06:05.280 --> 06:11.130
我们将其应用于到目前为止由X表示的输入图像｡ 

06:11.250 --> 06:12.480
这是第一步｡ 

06:12.480 --> 06:13.590
第一步完成｡ 

06:13.590 --> 06:23.550
现在第二步, 我们将把最大池应用到由卷积一个X返回卷积图像上, 并应用最大池

06:23.550 --> 06:29.850
我们要从函数模块中取一个函数, 所以我们取F, 快捷方式, 然后点,

06:29.850 --> 06:38.250
然后我们要用函数max pool到D, 就是我们把自卷积1, X, 放在max

06:38.250 --> 06:40.410
pool的括号中定义的｡

06:41.660 --> 06:45.080
因为我们对卷积图像应用了最大合并｡ 

06:45.500 --> 06:53.020
但是这个最大池函数需要额外的参数, 首先是内核大小｡ 

06:53.030 --> 07:00.650
同样, 这是在图像中滑动的窗口的大小, 它将占用每张幻灯片中的最大像素｡

07:00.690 --> 07:09.530
这仍然可以检测到这些特征, 因为这些特征与数组中像素的高值相关联, 就像你在直觉课上看到的那样｡

07:09.530 --> 07:15.500
我们需要输入的第一个参数是内核大小, 我们取3｡ 

07:15.500 --> 07:17.630
这是内核大小的常见选择｡ 

07:17.630 --> 07:27.170
然后我们需要输入步幅, 即它在图像中滑动的像素数, 我们将步幅设为2｡

07:27.320 --> 07:29.120
同样, 这是一个常见的选择｡ 

07:29.630 --> 07:30.500
好了, 我们走吧｡ 

07:30.500 --> 07:32.390
现在第二步完成了｡ 

07:32.390 --> 07:41.210
现在让我们进入第三步, 激活第一层卷积图像中的所有神经元｡

07:41.240 --> 07:45.920
我们再做一次, 我们要对所有这些应用一个函数｡ 

07:45.920 --> 07:51.500
这里我再次取F, 因为我们要取另一个函数,

07:51.500 --> 07:58.430
你们可能已经猜到了, 它是一个激活函数, 但它通常是一个整流激活函数｡

07:58.610 --> 08:02.120
也许你还记得它的名字叫Réélu｡ 

08:02.570 --> 08:03.320
我们走吧｡ 

08:03.320 --> 08:04.130
就是这个｡ 

08:04.130 --> 08:10.190
所以我们把值应用到我们的集合卷积图像上｡ 

08:10.190 --> 08:11.630
这就是全部｡ 

08:12.380 --> 08:12.860
好吧, 我会的

08:12.860 --> 08:14.180
就是这样｡ 

08:14.180 --> 08:15.200
三个步骤完成｡ 

08:15.200 --> 08:16.280
这是非常快的｡ 

08:16.280 --> 08:22.880
请记住, 我们必须首先对输入图像应用卷积,

08:22.910 --> 08:28.640
然后对通过卷积获得的卷积图像应用最大池｡

08:28.640 --> 08:36.260
然后我们用整流器激活函数激活所有这些卷积层中的神经元｡

08:37.030 --> 08:37.980
太完美了｡ 

08:37.990 --> 08:45.990
我们得到了第一个卷积层, 在这个卷积层上应用了最大池, 并且现在激活了神经元｡

08:46.000 --> 08:52.390
所以基本上它所做的就是把信号从第一个卷积层传播到下一个卷积层｡

08:52.390 --> 08:56.260
说到下一个, 这正是我们现在要处理的｡ 

08:56.290 --> 09:01.630
我们要做的事情和我们刚才在第一卷积层上做的一样,

09:01.630 --> 09:09.610
到第二卷积层, 通过激活第二卷积层的神经元, 再次将信号进一步传播到神经网络｡

09:09.610 --> 09:12.820
但在此之前, 我们需要得到这个卷积层｡ 

09:12.820 --> 09:16.330
所以我们要对x进行卷积｡ 

09:16.330 --> 09:21.610
这是第一个卷积层, 我们将对X进行卷积,

09:21.610 --> 09:27.400
得到第二个卷积层, 然后我们将对其进行最大拉伸, 最后激活它的神经元｡

09:27.760 --> 09:28.930
所以我们开始吧｡ 

09:28.930 --> 09:30.010
其实很简单｡ 

09:30.010 --> 09:35.170
我们只需要复制并粘贴到下面｡ 

09:35.200 --> 09:39.100
当然, 现在我们需要用卷积二来代替卷积一｡ 

09:39.220 --> 09:40.360
好了

09:40.360 --> 09:41.830
已经准备好了｡ 

09:41.830 --> 09:43.390
C很容易｡ 

09:43.660 --> 09:49.780
现在, 通过这条线路, 我们将信号从第二个卷积层传播到下一个卷积层,

09:49.780 --> 09:52.450
也就是第三个卷积层｡

09:52.450 --> 09:56.830
为了得到第三个卷积层, 我们需要再次应用它｡ 

09:57.010 --> 10:03.460
所以我把它复制粘贴到下面, 用卷积三代替卷积二｡ 

10:03.700 --> 10:04.690
就这样了｡ 

10:04.720 --> 10:06.130
是不是太实用了？

10:06.130 --> 10:13.060
我们在三个卷积层和一个闪光灯中传播信号, 这要归功于这个令人敬畏的结构｡ 

10:13.860 --> 10:14.220
好吧, 我会的

10:14.220 --> 10:15.190
太完美了｡ 

10:15.210 --> 10:22.230
现在, 信号向上传播到第三个卷积层, 说到之后, 这会引导我们找到我们要找的,

10:22.230 --> 10:25.890
我们感兴趣的｡

10:25.890 --> 10:27.900
这就是展平层｡ 

10:28.290 --> 10:28.710
好吧, 我会的

10:28.710 --> 10:36.170
现在我们有了第三个卷积层, 也就是最后一个X, 现在是时候得到平坦层了｡

10:36.180 --> 10:38.250
这正是我们现在要做的｡ 

10:38.250 --> 10:42.990
我们要把第三个卷积层的所有像素都变平｡ 

10:42.990 --> 10:48.330
也就是说, 我们要取第三卷积层所有通道的所有像素｡ 

10:48.360 --> 10:51.840
我们要把它们一个接一个地放到一个巨大的向量中｡ 

10:51.840 --> 10:55.920
当然, 这个巨大的矢量就是展平层｡ 

10:55.980 --> 11:01.890
同时, 我们会用一个技巧来得到这个扁平层中的神经元数量｡ 

11:01.890 --> 11:03.510
这正是我们要找的｡ 

11:03.540 --> 11:05.520
这就是我们缺失的神经元数量｡ 

11:05.520 --> 11:08.580
因此, 让我们直接返回我们想要的｡ 

11:08.580 --> 11:14.070
在这个过程中, 我们要把第三个卷积层变平, 同时,

11:14.070 --> 11:16.200
在这个变平层中的神经元数量｡

11:16.350 --> 11:19.920
我们取X, 这是第三个卷积层｡ 

11:20.070 --> 11:25.080
我们将取第三卷积层的所有通道,

11:25.080 --> 11:31.830
我们将使用一个函数, 即大小函数, 将所有这些通道的所有像素展平到一个相同的巨大矢量中｡

11:31.950 --> 11:35.850
你可以在PyTorch教程中找到诀窍｡ 

11:35.850 --> 11:42.090
首先我们取X的数据, 因为X是一个特殊的结构, 它是一个火炬变量｡ 

11:42.090 --> 11:44.100
所以它的结构相当复杂｡ 

11:44.100 --> 11:51.840
但首先我们需要访问这里的数据, 然后我们需要查看它里面的内容｡ 

11:51.840 --> 11:57.630
所以我们使用这个视图函数, 现在我们需要访问我们要找的东西,

11:57.630 --> 12:01.800
这是用参数1和-1给出的｡

12:02.010 --> 12:08.790
你不需要了解这个结构里面有什么, 但你可以理解这就是我们要得到这个数量的神经元的方法｡

12:08.790 --> 12:15.360
最后, 我们需要添加size, 然后是括号, 在里面输入1｡ 

12:15.600 --> 12:21.570
所以基本上我们在这里所做的, 我们所做的是我们把所有通道的所有像素, 一个接一个地放在这个巨大的向量中,

12:21.570 --> 12:26.610
这将是全连接网络的输入｡

12:26.940 --> 12:29.190
这基本上就是一号的作用｡ 

12:29.190 --> 12:33.480
有了这个, 我们就可以得到我们要找的神经元的数量｡ 

12:33.870 --> 12:34.260
好吧, 我会的

12:34.260 --> 12:36.270
所以现在我们得到我们想要的了｡ 

12:36.270 --> 12:43.830
最后, 我们可以用这个函数返回的值来代替神经元的数目, 当这个函数应用于末日图像的格式时, 也就是1 *

12:43.830 --> 12:49.920
80 * 80｡

12:49.920 --> 12:57.180
所以我们现在要做的就是用计数神经元来代替数字神经元｡ 

12:57.790 --> 13:05.830
我们应用于缩放图像格式的函数, 该缩放图像将是元组｡ 

13:06.840 --> 13:08.820
80岁和80岁｡ 

13:09.240 --> 13:10.340
好了

13:10.350 --> 13:17.040
当然, 我们不会忘记self, 因为count neuron实际上是CNN类的一个方法｡ 

13:17.040 --> 13:20.700
所以我们需要添加自我, 现在警告应该消失了｡ 

13:20.970 --> 13:22.020
好了

13:22.290 --> 13:23.720
现在一切都好了｡ 

13:23.730 --> 13:27.900
我们得到了神经网络的结构, 没有任何遗漏｡ 

13:27.900 --> 13:29.060
我们有这个计数｡ 

13:29.070 --> 13:36.120
如果你想尝试其他架构, 而不想手动计算神经元的数量, 那么神经元就可以发挥作用｡

13:36.150 --> 13:42.000
你只要使用这个函数, 你把它应用到你的图像格式, 这将直接得到你想要的｡

13:42.000 --> 13:47.730
这是洪泛层中的神经元数量, 而不需要做任何事情, 也不管架构是什么｡

13:48.240 --> 13:49.350
所以这很酷｡ 

13:49.350 --> 13:55.950
现在我们已经完成了我们正在制造的大脑的第一个重要步骤｡ 

13:55.950 --> 14:02.340
我们还有最后一步, 也就是最后一个函数要做, 它是主要的正向函数｡

14:02.340 --> 14:09.720
所以我们要把信号从大脑开始传播, 也就是从人工智能的眼睛传播到输出层｡

14:09.720 --> 14:12.060
那是在第二次完全连接之后｡ 

14:12.180 --> 14:14.100
我们将在下一个教程中进行此操作｡ 

14:14.100 --> 14:15.870
在那之前, 好好享受我｡