WEBVTT

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

00:02.400 --> 00:06.150
现在我们必须定义init函数的五个变量｡ 

00:06.150 --> 00:09.420
这是三个回旋和两个完整的连接｡ 

00:09.510 --> 00:11.040
让我们从第一个开始｡ 

00:11.070 --> 00:15.960
卷积一将卷积应用于输入图像｡ 

00:15.960 --> 00:17.970
这就是原始图像｡ 

00:17.970 --> 00:22.580
现在你将看到, 如何将一切变得如此简单, 以创建这个卷积｡ 

00:22.590 --> 00:29.010
我们要做的就是创建一个特定类的对象, 这个类是从RN中提取的,

00:29.010 --> 00:32.400
然后这些类就可以了.

00:33.000 --> 00:34.260
去卫生署｡ 

00:34.380 --> 00:34.830
去卫生署｡ 

00:34.830 --> 00:37.260
因为我们要处理两张DH图像｡ 

00:37.620 --> 00:40.670
现在, 如您所见, 我们需要输入几个参数｡ 

00:40.680 --> 00:45.450
第一个在通道中, 所以让我们把它放在通道中｡ 

00:45.870 --> 00:48.810
第二个是灭通道｡ 

00:49.200 --> 00:56.910
第三个是内核大小, 其余的被破坏, 填充膨胀组和偏差｡ 

00:56.910 --> 00:59.040
所有这些都有默认值｡ 

00:59.040 --> 01:00.450
所以我们不输入它们｡ 

01:00.450 --> 01:02.220
我们将保留默认值｡ 

01:02.220 --> 01:07.560
但重要的是这三个参数在通道, alt通道和col大小｡ 

01:07.560 --> 01:09.660
你猜它们对应什么？

01:09.690 --> 01:17.670
很简单, in通道对应于卷积的输入, alt通道对应于卷积的输出｡

01:17.670 --> 01:19.850
那么在渠道中, 它会是什么呢？

01:19.860 --> 01:24.330
很简单, 这就是我们图像中的通道数｡ 

01:24.330 --> 01:31.230
事实上, 我们将使用白色图像, 因为基本上我们不需要颜色来识别怪物｡

01:31.260 --> 01:36.780
人工智能完全能够识别黑白色的怪物, 所以我们不需要颜色｡ 

01:36.780 --> 01:41.550
它只能通过形状识别它们, 因此我们将使用一个通道｡ 

01:41.550 --> 01:46.650
因此, 一个通道是当你有白色图像和三个通道是当你有彩色图像｡ 

01:46.650 --> 01:51.720
因此, 因为我们在通道中处理白色图像, 所以等于1｡

01:52.580 --> 01:54.010
然后我们的渠道｡ 

01:54.020 --> 02:02.750
因此, 我们的通道将等于卷积层中的图像, 即卷积层的输出｡

02:02.750 --> 02:08.960
基本上, 这等于你想要在原始图像中检测的特征数量, 因为我们会为每个想要检测的特征创建一张图像,

02:08.960 --> 02:14.870
因为你基本上知道它是如何工作的｡

02:14.870 --> 02:23.000
我们将一个特征检测器应用于输入图像, 以检测输入图像中的特定特征, 并因此检测输出图像的数量｡

02:23.000 --> 02:25.970
这是我们要检测的特征数｡ 

02:26.210 --> 02:29.990
那么现在的问题是我们要检测多少个特征？

02:30.020 --> 02:34.640
通常的做法是从32个特征检测器开始｡ 

02:34.850 --> 02:41.240
这将导致我们在第一个卷积层中得到32个处理过的图像｡ 

02:41.240 --> 02:45.710
所以输入是一个白色图像, 一个真实的图像｡ 

02:45.710 --> 02:51.200
并且第一卷积层中的输出是32个经处理的图像｡ 

02:51.200 --> 02:59.510
所谓处理, 我的意思当然是对输入图像应用卷积, 以得到32个具有检测到的特征的新图像｡

02:59.960 --> 03:09.350
然后我们需要指定一个核大小, 它就是要穿过原始图像的正方形的尺寸｡

03:09.350 --> 03:16.610
在通常的实践中, 我们使用二乘二､ 三乘三或五乘五, 对于第一个,

03:16.610 --> 03:20.720
我们将使用五乘五特征检测器｡

03:20.840 --> 03:24.410
这是一个具有5 × 5维的特征检测器｡ 

03:24.560 --> 03:28.910
然后, 我们将为下一个卷积层减小该内核的大小｡ 

03:29.090 --> 03:32.150
说起来, 这正是我们现在要做的｡ 

03:32.150 --> 03:37.490
我们要复制这个来定义第二个卷积｡ 

03:37.790 --> 03:40.820
因此, 我现在就把它建立在这里｡ 

03:40.820 --> 03:42.080
这很有趣, 也很简单｡ 

03:42.080 --> 03:43.280
就像多米诺骨牌一样｡ 

03:43.310 --> 03:49.700
第二卷积层的输入信道是第一卷积层的输出信道｡

03:49.700 --> 03:55.250
因此, 这里的输出端32的数量与这里的输入端32的数量相同｡ 

03:55.250 --> 04:01.160
这是因为在第二个卷积的输入卷积层中有32个图像｡ 

04:01.160 --> 04:10.280
并且因此第二卷积被应用于该第二卷积层以返回第三卷积层｡

04:10.280 --> 04:15.860
现在的问题是, 我们需要多少张新图片, 我们创建32张新图片｡ 

04:15.860 --> 04:19.760
32实际上是卷积神经网络中非常常见的数｡ 

04:19.760 --> 04:23.630
如果您看一下这些体系结构, 您会发现其中许多都有32个｡ 

04:23.780 --> 04:30.530
对于内核方面, 我们需要减小内核大小, 也就是我们的特征检测器的尺寸｡

04:30.530 --> 04:37.400
所以现在我们要从五只眼睛到四只甚至三只眼睛, 然后我们会做得更小｡ 

04:37.700 --> 04:38.090
好吧, 我会的

04:38.090 --> 04:40.520
所以我们的第二个卷积已经准备好了｡ 

04:40.580 --> 04:48.350
它将32个经处理的图像作为输入, 每个经处理的图像检测原始输入图像的第一特征｡

04:48.350 --> 04:54.650
由于特征检测器的尺寸减小, 它创建了32个新图像｡ 

04:54.890 --> 04:57.140
现在让我们再进一步｡ 

04:57.140 --> 05:05.120
所以我把这个复制粘贴到这里来创建第三个卷积来检测一些特征｡ 

05:05.210 --> 05:07.940
输入通道也是如此｡ 

05:07.940 --> 05:17.570
这里是卷积连接左边的输入图像的数量, 也就是前一个卷积连接右边的已处理图像的数量｡

05:17.580 --> 05:18.620
所以是32个｡ 

05:18.620 --> 05:19.970
因此我们在这里保留32个｡ 

05:19.970 --> 05:20.900
太完美了

05:20.900 --> 05:24.950
现在的问题是, 我们要检测多少新的图像？

05:25.040 --> 05:30.980
我们现在要取64个输出, 处理后的图像｡ 

05:30.980 --> 05:36.170
当然, 现在我们取一个较小的内核大小, 我们将取两个｡ 

05:36.560 --> 05:45.620
这是一个非常经典的卷积层架构, 在图像内部进行高水平的特征检测非常高效｡

05:46.070 --> 05:46.550
好吧, 我会的

05:46.550 --> 05:52.940
现在我们有了三个卷积层, 感谢这里的三个卷积连接, 好了,

05:52.940 --> 05:57.350
现在是时候得到我提醒的两个完整连接了｡

05:57.350 --> 06:04.430
我们取这个巨大的向量, 是把所有的64次, 32乘以32, 都展平后得到的｡ 

06:04.430 --> 06:07.910
再一次, 我们从这些卷积中得到的图像｡ 

06:07.910 --> 06:14.000
所以我们把这些图像的所有像素都变平了, 我们可以得到一个巨大的向量, 这个向量将成为一个新的,

06:14.000 --> 06:16.580
完全连接的神经网络的输入｡

06:16.580 --> 06:21.800
这时候我们必须首先在这个巨大的向量和一个隐藏层之间建立完整的连接,

06:21.800 --> 06:31.580
然后在隐藏层和输出层之间建立第二个完整的连接, 输出层由输出神经元组成, 每一个都对应于可能动作的q值｡

06:31.700 --> 06:33.830
让我们建立这两个完整的连接｡ 

06:33.830 --> 06:35.060
你知道该怎么做｡ 

06:35.060 --> 06:37.400
这正是我们为自动驾驶汽车所做的｡ 

06:37.400 --> 06:38.720
我们再来一次｡ 

06:38.720 --> 06:48.830
首先我们取RN模块, 然后我们取线性类, 因为我们创建的全连接是线性类的一个对象.

06:49.040 --> 06:52.100
然后在括号里, 嗯, 这是相同的第一｡ 

06:52.240 --> 06:58.210
输入输入要素, 即输入要素的个数, 然后输出要素｡ 

06:58.630 --> 07:03.060
那么第一个完整连接的输入特性是什么？

07:03.070 --> 07:09.610
这将等于像素的数量, 这个巨大的矢量是在三次卷积之后,

07:09.610 --> 07:13.420
把所有处理过的图像展平后得到的｡

07:13.540 --> 07:14.970
那么这个数字是多少呢？

07:14.980 --> 07:17.170
实际上, 这里面有个窍门.

07:17.220 --> 07:19.390
这个数字其实很难弄到｡ 

07:19.420 --> 07:22.690
我们实际上需要一个函数来计算这个数｡ 

07:22.690 --> 07:25.510
我们没有一个变量可以得到这个数字｡ 

07:25.510 --> 07:26.680
我们必须计算它｡ 

07:26.680 --> 07:33.910
因此, 我们现在要做的是, 理解我们必须具备的编程思维是非常重要的｡

07:33.910 --> 07:40.900
我试着把心态, 这是你必须思考的权利, 现在做, 以克服这一障碍｡

07:40.900 --> 07:46.450
因为第一次你可能会说, 嘿, 我没有这个数量的神经元在扁平向量中, 我该怎么办？

07:46.450 --> 07:47.500
我被困在这里了｡ 

07:47.500 --> 07:56.140
事实上, 不是这样的, 因为你现在可以做的就是在这里输入任何一个代表这个神经元数量的名字｡

07:56.140 --> 07:58.180
所以我称之为神经元数量｡ 

07:58.180 --> 07:59.320
神经元数量｡ 

07:59.320 --> 08:07.030
然后我们只需要一个函数, 返回神经元的数量, 我们要找的像素的数量｡

08:07.120 --> 08:08.800
所以我们完全可以这么做｡ 

08:08.800 --> 08:10.540
我们完全可以把这个变量｡ 

08:10.540 --> 08:15.970
当然我们会得到一个警告, 因为它还不存在, 但是我们会在函数之后创建它,

08:15.970 --> 08:20.920
我们完全可以这样做, 即使函数是在函数之后｡

08:20.920 --> 08:25.780
这是典型的编程思维, 当你遇到这种障碍时, 你必须要有这种思维｡ 

08:25.780 --> 08:28.840
你可以做一个函数来得到你缺少的东西｡ 

08:29.560 --> 08:29.980
好吧, 我会的

08:29.980 --> 08:37.720
然后输出特征, 输出特征, 这是隐藏层的神经元数量, 这一次由你决定｡

08:37.720 --> 08:40.960
这取决于您要创建的神经网络的架构｡ 

08:40.960 --> 08:44.050
所以一个好的数字将是为了小的数字｡ 

08:44.050 --> 08:46.900
比如说, 40个神经元就可以了｡ 

08:46.900 --> 08:48.610
我们可以试着增加它｡ 

08:48.610 --> 08:51.100
如果训练不是太慢, 可以尝试增加｡ 

08:51.100 --> 08:53.560
也许这会改善预测｡ 

08:53.560 --> 08:54.760
但我们从40开始吧｡ 

08:54.760 --> 08:56.530
也许我们以后会增加｡ 

08:56.950 --> 08:57.280
好吧, 我会的

08:57.280 --> 08:59.800
第一个完整连接到此结束｡ 

08:59.800 --> 09:05.290
然后, 我们将此页复制到此处, 以进行第二次完整连接｡ 

09:05.290 --> 09:09.040
这是隐藏层和输出层之间的连接｡ 

09:09.040 --> 09:15.610
所以这里的内部特征变成了前一层的外部特征, 也就是40｡ 

09:15.610 --> 09:17.830
所以这里我们放40｡ 

09:18.010 --> 09:22.900
当然, 这是隐藏层的神经元数量,

09:22.900 --> 09:27.070
这里的特征等于神经网络中输出神经元的数量｡

09:27.070 --> 09:32.950
因为每个输出神经元对应一个键值, 一个键值对应一个动作, 这里输出神经元的数量,

09:32.950 --> 09:36.730
当然就是动作的数量.

09:36.730 --> 09:39.820
我们有一个变量, 那就是行动数量

09:39.820 --> 09:42.970
因此我们在这里输入数字｡ 

09:43.880 --> 09:44.750
行动｡ 

09:44.840 --> 09:45.950
好了

09:45.980 --> 09:47.160
恭喜你啊

09:47.180 --> 09:50.540
我们定义了神经网络的架构｡ 

09:50.750 --> 09:55.880
我们的神经网络由三个卷积层和一个隐层组成｡ 

09:55.910 --> 09:59.030
所有这些都在一个大的CNN和这个｡ 

09:59.030 --> 10:04.490
CNN会检测游戏中的功能, 这样AI就会知道它要做什么, 要去哪里,

10:04.490 --> 10:06.380
需要在哪里拍摄｡

10:06.650 --> 10:08.180
我们开始这一步｡ 

10:08.180 --> 10:10.430
这是非常重要的第一步｡ 

10:10.460 --> 10:16.820
现在我们要进行下一步, 当然, 就是要得到这些缺失的神经元｡

10:16.820 --> 10:18.710
这就是为什么我们在这里有警告｡ 

10:18.710 --> 10:21.720
神经元的数目未定名, 但不用担心｡ 

10:21.740 --> 10:26.720
现在我们要做一个函数, 返回这个巨大向量中的神经元数目, 然后把这个数目放进一个变量,

10:26.720 --> 10:30.030
叫做神经元数目.

10:30.050 --> 10:31.940
我们将在下一个教程中进行此操作｡ 

10:31.940 --> 10:33.020
这是我们的下一步｡ 

10:33.020 --> 10:34.280
在那之前, 好好享受吧｡ 

10:34.280 --> 10:34.640
一､