WEBVTT

00:00.240 --> 00:03.300
大家好, 欢迎来到本部分的最后一步｡ 

00:03.300 --> 00:04.620
一号楼I｡ 

00:04.650 --> 00:10.200
现在,

00:10.200 --> 00:17.160
我们唯一要做的就是建立这个大的向前函数, 它将把信号从大脑获取图像的最开始传播到眼睛播放动作的最后｡

00:17.160 --> 00:21.060
所以我们要建立整个函数, 这将是我们的最后一步｡ 

00:21.090 --> 00:26.430
在我们进入第二部分之前, 用深度卷积学习来训练我们的人工智能｡ 

00:26.670 --> 00:27.840
所以我们开始吧｡ 

00:27.840 --> 00:33.600
我们将使用函数调用, 它实际上与init函数类似.

00:33.600 --> 00:39.240
这是一个现有的函数,

00:39.240 --> 00:45.390
但这次我们用它来调用其他函数, 我们之前做过的, 因为我们将使用大脑的正向函数和身体的正向函数.

00:45.390 --> 00:50.070
所以我们现在使用这个调用函数来调用这些函数｡ 

00:50.280 --> 00:53.040
所以调用需要两个参数｡ 

00:53.040 --> 00:55.830
第一个当然是自我, 客体｡ 

00:55.830 --> 01:00.120
第二个论点, 根据你的说法, 它会是什么？

01:00.120 --> 01:02.700
这次我们要做整个传播过程｡ 

01:02.700 --> 01:08.370
所以我们想要输入的是输入图像, 因为这是人工智能玩游戏的起点,

01:08.370 --> 01:16.680
它首先将游戏的图像可视化, 然后在大脑中传播信号, 然后玩游戏｡

01:17.010 --> 01:24.360
因此, 第二个参数将是输入, 现在我们准备好进行整个传播｡ 

01:24.600 --> 01:25.830
所以我们开始吧｡ 

01:25.860 --> 01:27.750
好吧, 那么第一步, 是什么？

01:27.750 --> 01:31.740
第一步是从游戏中接收输入图像｡ 

01:31.950 --> 01:39.570
既然这些图像要进入神经网络, 那么, 你可以想象我们必须把它们格式化成一个特殊的结构｡

01:39.570 --> 01:42.480
而这个结构当然是火炬结构｡ 

01:42.570 --> 01:48.510
首先我们要把这些图像转换成一个数组,

01:48.510 --> 01:58.140
然后我们把numpy数组转换成torch张量, 最后我们把torch张量放到一个torch变量里, 这个变量包含张量和梯度｡

01:58.140 --> 02:04.350
这是为了我们的动态图非常有效地计算随机梯度下降的梯度层｡

02:04.350 --> 02:06.090
这是我们的第一步｡ 

02:06.090 --> 02:12.180
一旦我们得到了正确的图像格式, 它们就可以进入神经网络,

02:12.180 --> 02:15.510
然后我们就可以在那里完成信号的整个传播｡

02:16.150 --> 02:20.200
因此, 让我们做第一步, 将图像转换为正确的格式｡ 

02:20.200 --> 02:22.980
所以我们的图像是目前为止的输入｡ 

02:22.990 --> 02:26.620
现在我们要创建一个新变量, 我称之为input｡ 

02:26.620 --> 02:29.290
这就是神经网络的真实的输入｡ 

02:29.290 --> 02:31.690
而这个输入, 它会在哪里？

02:31.690 --> 02:34.300
首先我们要听取意见｡ 

02:34.300 --> 02:36.580
那是我们最初的影像｡ 

02:36.580 --> 02:42.130
然后, 就像我们说的, 我们要把这些图像转换成numpy数组｡ 

02:42.130 --> 02:49.150
要做到这一点, 我们可以简单地取NumPy, 它有一个快捷键, 然后取P, 再取函数数组｡ 

02:49.240 --> 02:52.660
所以我们把输入放在函数数组的括号里｡ 

02:52.690 --> 02:53.260
我们走吧｡ 

02:53.260 --> 02:55.930
现在它被数组转换成了一些东西｡ 

02:55.930 --> 03:04.330
但是, 由于numpy数组的单元格将包含像素, 因此实际上指定float类型更安全｡

03:04.360 --> 03:12.160
最好确保我们现在有一些浮点数, 为了确保它, 我们可以在这里使用NP浮点数32｡

03:12.550 --> 03:13.180
好吧, 我会的

03:13.180 --> 03:17.080
所以现在我们仍然有一个裁判数组, 但类型为float｡ 

03:17.680 --> 03:18.040
好吧, 我会的

03:18.040 --> 03:19.510
还有一个原因｡ 

03:19.510 --> 03:24.040
传感器是单一类型的阵列｡ 

03:24.040 --> 03:27.340
所以我们选择了一个浮点数类型, float 32.

03:27.910 --> 03:28.210
好吧, 我会的

03:28.210 --> 03:33.730
现在我们有了numpy数组, 下一步就是把它转换成火炬张量｡ 

03:33.730 --> 03:42.610
要做到这一点, 我们可以使用, 比如, 火炬, 然后从下划线numpy函数,

03:42.610 --> 03:44.920
这样我们就可以把它转换成火炬张量｡

03:45.160 --> 03:46.000
我们走吧｡ 

03:46.000 --> 03:53.140
现在最后一步是把这些火炬传感器放入一个火炬变量中, 这个变量包含张量和梯度｡

03:53.140 --> 03:54.850
你知道怎么做｡ 

03:54.850 --> 04:05.470
当然, 我们使用变量类是因为这个变量里面的所有东西都是变量类的输入.

04:05.470 --> 04:11.530
但我想用这种方式向你们展示, 因为我们从输入图像开始, 然后我们把它们转换成numpy数组,

04:11.530 --> 04:15.880
然后转换成torch传感器, 最后转换成variable｡

04:15.880 --> 04:17.020
现在我们没事了｡ 

04:17.020 --> 04:25.450
他们被允许进入神经网络, 首先是人工智能的眼睛, 然后是完全连接的层, 以导致预测｡

04:25.930 --> 04:30.100
说到眼睛, 说到眼睛, 这正是我们现在要做的.

04:30.280 --> 04:38.590
我们现在要把这些被允许的图像传播到眼睛里, 这是通过三个卷积层｡

04:38.590 --> 04:41.410
要做到这一点, 你会看到它是多么简单｡ 

04:41.410 --> 04:46.030
这是因为我们已经从init函数中得到了大脑｡ 

04:46.030 --> 04:55.780
我们只需要把我们的大脑, 这样自我点大脑, 并把这个大脑, 以输入图像,

04:55.780 --> 05:03.160
并将传播感谢这里的向前功能, 从大脑, 将传播信号在大脑内｡

05:03.160 --> 05:11.170
由于大脑的第四个功能返回, 输出信号, 即包含线索值的输出层的神经元｡

05:11.170 --> 05:17.770
这个自我, 大脑的输入会返回这个输出信号, 因此我们把它放进一个变量,

05:17.770 --> 05:23.230
我们简单地称之为, 输出.

05:24.040 --> 05:26.570
而这个输出就是大脑的输出信号｡ 

05:26.590 --> 05:32.690
现在我们有了大脑的输出信号, 我们必须把这个输出信号传播到身体｡

05:32.710 --> 05:36.790
为了做到这一点, 我们要使用物体的第二个向前函数｡ 

05:36.790 --> 05:45.250
要做到这一点, 我们只需要把我们的身体, 当然, 把它应用到输出上,

05:45.250 --> 05:50.470
因为身体的前向功能把大脑的输出信号作为输入｡

05:50.470 --> 05:55.780
这就是现在的输出, 并返回操作｡ 

05:55.780 --> 06:03.340
因此, 由于它返回了动作, 我们要在这里加上动作等于自我身体输出｡

06:03.760 --> 06:04.090
好吧, 我会的

06:04.090 --> 06:09.670
所以现在你可以看到, 非常简单, 我们在大脑内部传播信号,

06:09.670 --> 06:16.000
然后通过使用大脑的全部功能, 首先从大脑传播到身体, 大脑将输入图像作为输入, 然后将它们传播到大脑,

06:16.000 --> 06:19.660
以返回线索值｡

06:19.960 --> 06:26.530
然后我们把这个输出信号传播到身体里, 用我们身体的正向功能来让动作开始｡

06:26.590 --> 06:34.150
所以现在我们要做的唯一一件事, 也是第一部分的最后一行代码, 构建眼睛｡

06:34.180 --> 06:39.040
好吧, 我们得把动作放回去, 那就是动作｡ 

06:39.310 --> 06:45.040
然而, 现在的动作有火炬格式, 我们需要将它们转换回numpy数组｡ 

06:45.040 --> 06:53.650
为了做到这一点, 我们要取这些操作的数据结构, 然后在这里加上非pi函数, 这样就可以了｡

06:53.650 --> 06:56.470
现在, 我们以正确的格式返回了操作｡ 

06:56.470 --> 06:57.910
所以恭喜你

06:57.910 --> 07:00.520
我们现在完成了第一部分｡ 

07:00.520 --> 07:03.190
我们用三个步骤构建了人工智能｡ 

07:03.190 --> 07:06.640
首先, 我们制造了大脑, 其次, 我们制造了身体｡ 

07:06.640 --> 07:14.860
第三, 我们把大脑组装在身体里, 我们把整个信号从眼睛传播到我们演奏动作的那一刻｡

07:15.310 --> 07:16.960
这是第一步｡ 

07:16.960 --> 07:18.280
这是一个巨大的进步｡ 

07:18.280 --> 07:22.030
但现在, 正如你所理解的, 我们建造了一个人工智能, 但它仍然是愚蠢的｡ 

07:22.030 --> 07:26.410
我们需要训练它变得聪明, 所以我们需要训练它做我们想做的事情｡ 

07:26.410 --> 07:31.450
为了做到这一点,

07:31.450 --> 07:38.500
我们将在愚蠢的环境之后使用奖励因为它从奖励中学习当它得到好的奖励时, 它会得到加强当它得到坏的奖励时, 它会受到惩罚或削弱｡

07:38.530 --> 07:41.410
这就是Q学习的用武之地｡ 

07:41.410 --> 07:47.260
这就是我们在第二部分要做的, 用深度卷积学习来训练人工智能｡ 

07:47.260 --> 07:50.440
我等不及要开始了, 在那之前, 好好享受人工智能吧｡