WEBVTT

00:00.180 --> 00:06.570
大家好, 欢迎来到I实现的第一部分, 第一部分构建AI,

00:06.570 --> 00:13.110
正如大家所看到的, 我已经在此实现的结构中添加了一个维度, 第一部分由三个部分组成,

00:13.110 --> 00:15.900
清楚地显示了我们将如何构建它｡

00:15.900 --> 00:20.760
首先我们要做的大脑就是神经网络｡ 

00:20.760 --> 00:25.320
然后我们要做一个身体来定义动作是如何进行的｡ 

00:25.320 --> 00:31.290
一旦我们有了大脑和身体, 我们将把它们组装起来, 制造人工智能,

00:31.290 --> 00:33.420
这将是第一部分的最后一节｡

00:33.630 --> 00:37.680
因此, 现在您已经可以很好地了解此实现的结构｡ 

00:37.680 --> 00:42.660
首先我们制造大脑, 然后我们制造身体, 然后我们组装身体来制造人工智能｡ 

00:42.750 --> 00:48.510
接下来这个教程, 我们将从第一节开始, 关于大脑的制作,

00:48.510 --> 00:51.210
这将是一个教程.

00:51.210 --> 00:54.720
你可以想象, 制造大脑不像做蛋糕｡ 

00:54.720 --> 00:57.000
因此, 这将需要多个教程｡ 

00:57.000 --> 01:03.630
当然, 像往常一样, 我们要用类来表示大脑, 因为我们需要几个函数,

01:03.630 --> 01:10.140
为了有一个由几个函数组成的结构, 这些函数将被组织在某种指令中, 当然,

01:10.140 --> 01:15.300
我们需要一个类, 这很完美,

01:15.300 --> 01:21.780
因为一旦我们把这个类做好, 我们就可以通过创建这个类的一些对象, 来创建我们想要的任意多个大脑｡

01:21.780 --> 01:28.050
同样的, Python中的类, 以及一般的面向对象编程语言中的类,

01:28.050 --> 01:33.420
都是非常实用的, 因为你可以为你想要构建的东西建立模型, 然后你就可以创建任意多的对象,

01:33.420 --> 01:37.710
它们将拥有你在类中定义的所有特性｡

01:37.710 --> 01:40.380
而对于我们的大脑来说, 这些特征当然会是｡ 

01:40.380 --> 01:45.870
首先, 神经网络的架构, 我想说的是CNN,

01:45.870 --> 01:52.230
当然, 还有不同的功能, 比如, 把信号从输入神经元传递到输出神经元｡

01:52.230 --> 01:55.290
这就是我们要做的第四个函数｡ 

01:55.680 --> 01:58.770
所以我们开始吧, 我们开始制造大脑｡ 

01:58.770 --> 02:00.510
这将是相当令人兴奋的｡ 

02:00.510 --> 02:04.650
这是我最喜欢的部分之一, 因此让我们直接进入它｡ 

02:04.650 --> 02:10.740
所以我们首先要引入一个类, 当然, 我们要把这个类叫做.

02:10.740 --> 02:18.270
好吧, 我犹豫着要不要叫它大脑, 但我们更直接地叫它CNN吧, 因为大脑实际上是一个CNN网络,

02:18.270 --> 02:22.290
一个卷积神经网络｡

02:22.290 --> 02:24.360
所以如果你愿意, 你可以称之为大脑｡ 

02:24.360 --> 02:27.450
但至少我们知道我们在造什么｡ 

02:28.490 --> 02:34.960
而美国有线电视新闻网（CNN）的自动驾驶汽车网络将继承GN模块｡ 

02:34.970 --> 02:43.040
请记住, DN模块是我们在这里导入的, 我们希望能够使用此引擎模块的所有工具,

02:43.040 --> 02:49.010
因此,

02:49.010 --> 02:55.100
我们希望在面向对象编程中使用此技术, 这是继承, 允许我们使用父类中的所有工具｡

02:55.100 --> 02:59.240
这个父类将是一个RN DOT模块｡ 

02:59.810 --> 03:00.710
我们走吧｡ 

03:00.710 --> 03:05.060
现在我们可以使用note模块的所有工具和对象了｡ 

03:05.360 --> 03:06.020
好吧, 我会的

03:06.020 --> 03:11.990
现在我们有了继承, 我们可以进入类来创建第一个函数｡ 

03:11.990 --> 03:18.500
正如你可能猜到的, 第一个函数是init函数, 它将定义未来大脑对象的所有变量,

03:18.500 --> 03:23.390
CNN对象将被创建｡

03:23.480 --> 03:31.850
好的, 我们来做这个def, 然后在这个过程中, 下划线是, 现在我们需要输入一些变量｡

03:31.850 --> 03:34.640
首先, 第一个变量是self｡ 

03:35.150 --> 03:37.250
那当然是指物体｡ 

03:37.280 --> 03:39.620
我猜你对这个很满意吧｡ 

03:39.620 --> 03:45.260
然后, 我们将添加另一个变量, 它将是哑环境中的操作数｡ 

03:45.260 --> 03:50.000
所以我们称之为数字行动, 一系列行动｡ 

03:50.300 --> 03:54.230
实际上, 这个变量对于init函数不是必需的｡ 

03:54.230 --> 03:59.690
如果您想测试我们将在其他环境中构建的API,

03:59.690 --> 04:08.270
那么这将非常实用, 因为我们将从Dhoom环境包装器中导入此数量的操作变量, 其中包含两个离散的操作｡

04:08.270 --> 04:13.880
当我们这样做的时候, 你知道, 输入环境的名称doom为零｡ 

04:13.880 --> 04:20.990
所以如果你想在其他的末日环境中, 或者在其他的游戏中,

04:20.990 --> 04:28.460
用这个I来做实验, 你不用做任何事情, 因为这个动作的数量, 会直接得到你将要玩的末日环境中的动作数量｡

04:28.940 --> 04:32.600
好了, 这就是init函数的两个参数｡ 

04:32.600 --> 04:36.290
所以现在我们可以进去了, 现在记住我们要做什么｡ 

04:36.320 --> 04:41.330
我们要做的第一件事是用超级函数激活继承｡ 

04:41.480 --> 04:43.730
这和自动驾驶汽车完全一样｡ 

04:43.730 --> 04:45.800
我们采取超级功能｡ 

04:45.890 --> 04:53.000
然后在里面, 我们开始输入定义神经网络的类, 这就是CNN｡ 

04:53.450 --> 04:56.930
这时我们必须输入自我来指称对象｡ 

04:56.930 --> 05:04.970
但是记住, 这还不是我们需要的全部, 在这里加上一个点, 然后是init函数和一些括号｡ 

05:04.970 --> 05:10.970
通过这样做, 我们激活了继承, 现在我们可以使用结束模块中的所有工具｡ 

05:11.330 --> 05:17.000
好了, 现在我想是时候构建神经网络的架构了｡ 

05:17.000 --> 05:23.120
所以, 大家还记得,

05:23.120 --> 05:31.130
我们要建立一个CNN, 一个卷积神经网络, 因为这一次人工智能将有眼睛, 人工智能的眼睛将是这个卷积神经网络的卷积层｡

05:31.220 --> 05:41.000
然后, 在人工智能用卷积层可视化图像后, 它会将信号传递到一个经典的人工神经网络｡

05:41.000 --> 05:50.300
这就是我们之前在完全连接的层上使用的, 它会尝试预测我们可以玩的每个可能动作的提示值｡

05:51.020 --> 05:53.540
因此, 您心中已经有了架构｡ 

05:53.540 --> 05:58.700
首先, 我们将有一些卷积层, 然后是一些完全连接的层,

05:58.700 --> 06:01.100
这将是我们的人工智能的大脑｡

06:01.280 --> 06:07.460
那么, 我们要做些什么才能在我们正在做的事情上后退一步呢？

06:07.460 --> 06:11.450
好吧, 让我们用我们想要创建的变量来创建这个架构｡ 

06:11.600 --> 06:18.740
实际上, 说到这个架构,

06:18.740 --> 06:25.940
我们将构建一个具有三个卷积层的CNN, 然后是一个隐藏层, 这意味着我们将需要三个卷积连接和两个全连接｡

06:25.940 --> 06:29.480
说到联系, 这正是我们将要定义的｡ 

06:29.480 --> 06:32.330
这将是我们CNN课程的变量｡ 

06:32.330 --> 06:37.250
因此, 现在, 我将定义五个变量, 三个是卷积连接,

06:37.250 --> 06:39.080
两个是全连接｡

06:39.080 --> 06:40.010
所以我们开始吧｡ 

06:40.010 --> 06:42.530
我们从卷积连接开始｡ 

06:42.530 --> 06:48.080
所以我称之为自点卷积1｡ 

06:48.440 --> 06:50.780
我会复制它｡ 

06:52.360 --> 06:54.890
在下面给他们定步调, 我们走｡ 

06:54.910 --> 06:58.570
自卷积二和自卷积三｡ 

06:58.810 --> 07:01.150
这是我们的卷积连接｡ 

07:01.150 --> 07:11.020
第一个卷积层将对输入图像进行一些卷积, 得到第一个卷积层, 然后是第二个卷积层｡

07:11.020 --> 07:19.540
这里的两个将第一卷积层作为输入, 并且通过再次应用一些卷积, 它将创建第二卷积层｡

07:19.540 --> 07:25.810
在这个卷积层中, 我们将得到一些新的图像, 每个图像检测一个特定的特征｡ 

07:25.810 --> 07:28.870
我们将在卷积层中得到这些新的图像｡ 

07:28.870 --> 07:40.210
然后, 我们将这个卷积应用到这里, 把这些来自第一卷积层的新图像连接到第二卷积层的一些新图像｡

07:40.210 --> 07:46.030
并且这些新的图像将再次检测第一卷积层的图像中的一些特征｡ 

07:46.030 --> 07:52.570
因此, 只需对特征检测进行增强, 然后对第二层卷积图像进行增强｡ 

07:52.570 --> 08:01.780
我们在这里应用第三次卷积, 为它们中的每一个获得更多的图像, 这些图像检测输入图像内部的更多特征｡

08:01.780 --> 08:07.240
所以我们做得越多, 我们就越多地对图像的不同层次进行卷积｡ 

08:07.270 --> 08:10.210
嗯, 我们越是能够察觉到一些特征｡ 

08:10.210 --> 08:15.460
这就是通过检测特征, 人工智能将了解怪物在哪里, 它必须在哪里开枪杀死他们,

08:15.460 --> 08:18.280
以及它应该去哪里｡

08:18.310 --> 08:23.110
它也会探测到墙壁, 障碍物, 嗯, 字面上它必须去的地方｡ 

08:23.110 --> 08:29.620
这要归功于所有这些卷积层在原始输入图像中检测到的内容｡ 

08:30.290 --> 08:30.650
好吧, 我会的

08:30.650 --> 08:34.910
这是CNN的卷积部分｡ 

08:34.910 --> 08:44.660
但是, 请记住, 在卷积层之后, 我们必须将应用的不同卷积系列获得的所有像素展平｡

08:44.660 --> 08:53.270
通过展平所有的像素阵列, 我们得到了这个巨大的向量, 它将成为经典人工神经网络的输入｡

08:53.270 --> 08:58.250
这就是我们得到完全连接的层, 因此我们的全部连接｡ 

08:58.430 --> 09:07.400
现在我们要做的就是创建两个新变量因为我们在这个经典的人工神经网络中有一个隐藏层｡

09:07.400 --> 09:13.340
因此, 我们需要一个完整的连接, 从这个巨大的扁平化向量到这个隐藏层,

09:13.340 --> 09:19.220
还有一个完整的连接, 在这个隐藏层和输出层之间, 由输出神经元组成,

09:19.220 --> 09:21.440
这些输出神经元是提示值｡

09:21.680 --> 09:26.870
我们先建立这些2/1连接, 然后定义所有这些连接｡ 

09:26.990 --> 09:35.510
至于自动驾驶汽车, 我们将称之为self dot FC 1, 然后再称之为self dot FC 2｡ 

09:36.080 --> 09:41.030
好了, 现在我们有了所有的变量,

09:41.030 --> 09:43.820
现在我们要做的就是用RN模块的类来定义它们｡

09:44.060 --> 09:50.260
这就意味着我们将基本上创建神经网络的架构, 这也是我们在下一个教程中要做的｡

09:50.270 --> 09:51.470
在那之前, 好好享受吧｡ 

09:51.470 --> 09:51.890
一､