WEBVTT

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

00:02.960 --> 00:08.150
好了, 现在我们要实现的下一个功能是,

00:08.150 --> 00:11.230
我们将训练人工智能内部的深层神经网络｡

00:11.240 --> 00:16.700
基本上, 我们将执行前向传播和后向传播的整个过程, 这样我们将获得输出,

00:16.700 --> 00:20.630
我们将获得目标｡

00:20.630 --> 00:24.290
我们将把输出与目标进行比较, 以计算最后的误差｡ 

00:24.290 --> 00:28.400
然后我们将最后一个误差反向传播到神经网络中｡ 

00:28.400 --> 00:34.700
并使用随机梯度下降法, 根据权重对最小误差的贡献大小来更新权重｡

00:34.910 --> 00:36.290
所以让我们来做这一切｡ 

00:36.290 --> 00:41.360
对于那些上过深度学习课程的人来说, 这是小孩子的事情, 但是对于其他人, 不用担心,

00:41.360 --> 00:43.580
我会再解释一遍｡

00:43.880 --> 00:47.240
所以我们把这个新函数叫做learn｡ 

00:47.390 --> 00:51.350
这个学习函数需要几个参数｡ 

00:51.350 --> 00:57.260
首先自我当然会指不同类的对象｡ 

00:57.260 --> 01:08.780
然后, 我们将把批处理状态作为当前状态, 然后是批处理的下一个状态, 然后是批处理奖励,

01:08.780 --> 01:14.810
最后是批处理操作｡

01:15.350 --> 01:16.790
那我们为什么要拿这个？

01:16.790 --> 01:19.700
你大概认出是什么系列了吧？

01:19.700 --> 01:27.290
当然, 这是一个转变, 马尔可夫决策过程的转变, 它是深度学习的基础｡

01:27.290 --> 01:30.350
为什么我们都把它们分成几批呢？

01:30.350 --> 01:36.140
好吧, 那是因为, 记住, 我们不考虑由一系列的跃迁产生的所有当前状态､

01:36.140 --> 01:39.410
当前奖励和当前行动的最上层下一个状态｡

01:39.410 --> 01:43.940
我们在这里创建了一些样品批次, 这要归功于sample函数｡ 

01:43.940 --> 01:49.400
所以现在我们的过渡是在形式上的, 第一批是状态, 第二批是下一个日期,

01:49.400 --> 01:53.120
一批是奖励, 一批是行动｡

01:53.300 --> 01:58.880
这就是我们现在的过渡形式, 它们都很好地与时间对齐,

01:58.880 --> 02:03.620
这要归功于我们在这里所做的关于第一维的连接｡

02:03.980 --> 02:11.450
所以现在我们有了批次的转换, 每个状态对应一个批次, 下一个状态对应奖励和操作｡

02:11.450 --> 02:18.410
我们之所以这么做是因为我们使用了这种经验回放的技巧, 这样我们的深层神经网络就可以学习到一些东西｡

02:18.410 --> 02:24.110
请记住, 如果我们只有转换本身, 那么, 这将是一些即时学习｡ 

02:24.110 --> 02:28.850
或者如果你想要一些非常短的记忆学习, 因此模型不会学习任何东西｡ 

02:28.850 --> 02:35.540
因此, 我们必须从内存中取出这些批次, 这些批次将成为我们的转换,

02:35.540 --> 02:39.320
然后最终我们将获得输入批次状态的每个状态的不同输出｡

02:39.320 --> 02:45.470
我们将对批次状态和批次下一个状态执行此操作, 因为我们需要这两个状态来计算损失｡

02:45.470 --> 02:51.080
我将很快提醒平衡方程, 这是深度学习算法的核心｡ 

02:51.680 --> 02:56.930
现在, 让我们进入函数, 首先获取批处理状态的输出｡ 

02:56.930 --> 02:59.600
所以我把第一个变量叫做输出｡ 

03:00.480 --> 03:04.980
当然, 我们还要用我们的自我模型｡ 

03:05.190 --> 03:14.230
所以自学模型是因为我们想得到我们的模型输出的输入状态的批处理状态｡ 

03:14.250 --> 03:25.080
由于我们的模型实际上需要一批输入状态, 因此, 我们现在完全可以输入批状态作为模型的输入｡

03:25.110 --> 03:33.390
这就是我们如何初始化进入网络的状态, 用火炬张量, 用这个假的维度｡

03:33.780 --> 03:34.900
那就完美了｡ 

03:34.920 --> 03:40.550
我们现在得到了模型的输出, 但接下来还有另一个技术技巧｡ 

03:40.560 --> 03:49.140
如果我们只做self, 很好地为批处理状态建模, 我们将得到所有可能操作的输出, 你知道, 01和2｡

03:49.260 --> 03:50.700
但那不是我们想要的｡ 

03:50.730 --> 03:58.600
我们只对被选择的动作感兴趣, 那些由网络决定在每个时间播放的动作｡

03:58.620 --> 04:03.060
所以要得到我们感兴趣的这些动作, 就是要把这些动作玩好｡ 

04:03.060 --> 04:11.640
我们必须使用这个gather函数, 在其中输入一个, 因为我们只需要选择的操作｡ 

04:12.000 --> 04:24.390
然后我们添加批处理操作, 我们每次都会收集批处理状态的每个输入状态的最佳操作.

04:24.540 --> 04:31.650
我们只需要播放的动作, 选择的动作, 我们通过收集一个和批处理动作得到这个｡

04:31.920 --> 04:33.150
但以后要小心｡ 

04:33.180 --> 04:41.040
这里的批处理状态有一个与批处理相对应的伪维, 批处理操作没有返回它, 状态有吗？

04:41.040 --> 04:46.230
因为我们在这里使用了条目, 但是我们没有在squeeze上使用任何操作｡ 

04:46.230 --> 04:52.740
因此, 我们必须在此处添加它, 以使批处理操作与批处理状态具有完全相同的维度｡ 

04:52.890 --> 04:57.000
所以我们要在挤压零点上加一个点｡ 

04:57.730 --> 04:58.780
就在这里｡ 

04:58.900 --> 05:05.620
实际上, 这不是零, 而是一, 因为零对应于国家的信念维度,

05:05.620 --> 05:09.050
而一对应于行动的虚假维度｡

05:09.070 --> 05:16.000
最后, 我们要做的最后一件事就是我们要用挤压的方法杀死这批假的｡ 

05:16.300 --> 05:17.910
我们为什么要这么做？

05:17.920 --> 05:19.990
因为现在我们脱离了神经网络｡ 

05:19.990 --> 05:22.840
我们有自己的产出, 但我们不希望它们成批出现｡ 

05:22.840 --> 05:27.460
我们希望它们是一个简单的张量, 一个简单的向量, 一个输出向量｡ 

05:27.610 --> 05:34.750
批处理只是当我们在神经网络中工作时, 因为神经网络是期望把传感器的格式转换成批处理的｡

05:34.780 --> 05:41.290
但现在我们有了自己的输出, 在下一个深度学习的平衡方程中, 我们不需要它们成为一批｡

05:41.290 --> 05:43.090
所以我要杀了这批人｡ 

05:43.090 --> 05:47.920
我正在摧毁这个假维度, 以恢复我们输出的简单形式｡ 

05:47.920 --> 05:50.710
所以我在这里加, 点, 然后挤压｡ 

05:51.320 --> 05:56.000
然后我自要杀掉那个假异次元空间相应的批了行动｡ 

05:56.000 --> 06:01.130
因为这个伪维度的索引是1, 所以我在这里加一个.

06:01.370 --> 06:01.940
好吧, 我会的

06:01.940 --> 06:03.500
现在, 我们开始吧｡ 

06:03.500 --> 06:05.810
我们有我们的输出, OC｡ 

06:05.810 --> 06:06.860
我们有一个小小的警告｡ 

06:06.860 --> 06:07.670
这是什么？

06:07.700 --> 06:10.940
局部变量输出已分配但从未使用｡ 

06:10.940 --> 06:11.750
没关系, 我会的

06:11.750 --> 06:13.220
我们会很快用上它｡ 

06:13.670 --> 06:15.410
这就是我们的输出｡ 

06:15.410 --> 06:18.560
现在我们想得到下一个｡ 

06:19.360 --> 06:20.260
输出｡ 

06:20.260 --> 06:23.560
所以现在你可能会想, 为什么我们需要下一个输出？

06:23.590 --> 06:28.840
为了理解这一点, 我们需要回到深度学习算法, 就在这里｡ 

06:28.840 --> 06:31.600
这是逻辑手册的一部分｡ 

06:31.600 --> 06:33.730
这就是整个深度学习的过程｡ 

06:33.730 --> 06:38.470
一开始, 我们初始化所有的值, 然后每次｡ 

06:38.470 --> 06:40.090
好了, 我们走吧｡ 

06:40.090 --> 06:42.190
我们选择具有软最大值的动作｡ 

06:42.190 --> 06:44.560
这就是我们对“选择操作”功能所做的｡ 

06:44.590 --> 06:50.890
然后, 我们添加过渡, 然后, 如您所见, 我们得到预测, 我们得到目标,

06:50.890 --> 06:51.940
我们计算损失｡

06:51.940 --> 06:54.130
那么, 为什么我们还需要下一个输出呢？

06:54.130 --> 06:55.780
那是因为目标｡ 

06:55.990 --> 07:03.670
目标值等于伽马乘以下一次产出加上奖励, 我们将在那之后计算目标值｡

07:03.670 --> 07:07.360
但是, 由于我们需要目标的下一个输出, 让我们先计算它｡ 

07:07.540 --> 07:10.780
同样, 要获得下一个输出, 这非常简单｡ 

07:10.780 --> 07:18.790
下一个输出将是我们的神经网络的结果, 当批处理下一个日期将其作为输入时｡

07:18.910 --> 07:30.640
很简单, 我们用神经网络作为模型, 这次神经网络的输入是下一个日期的批次｡

07:31.540 --> 07:32.940
下一批日期｡ 

07:32.950 --> 07:39.580
但是现在, 请记住, 如果我们回到深度学习算法,

07:39.580 --> 07:45.430
你可以看到, 下一个输出是下一个集合的队列值相对于所有动作的最大值｡

07:45.460 --> 07:49.920
现在, 要获得下一个输出, 我们需要获得这些Q值中的最大值｡ 

07:49.930 --> 07:57.910
因此, 我将在这里做一个分离,

07:57.910 --> 08:07.510
分离模型的所有输出, 因为我们在这批下一个状态中有几个状态, 这批下一个状态是从内存的随机样本中提取的所有转换中的所有下一个状态｡

08:07.600 --> 08:15.100
所以我使用detach函数分离所有的队列, 然后取所有队列值的最大值.

08:15.100 --> 08:22.810
因为我们要取这些Q值中的最大值, 关于这个作用量, 我们必须指定它是关于这个作用量的｡

08:22.810 --> 08:29.320
因为这个动作是用下标1来表示的, 我们必须把下标1放在这里, 然后我们必须指定, 我们要取,

08:29.650 --> 08:36.010
t的Q值加上1, 这就是下一个状态｡

08:36.010 --> 08:42.250
并且下一状态由索引零表示, 因为索引零对应于该状态｡ 

08:42.250 --> 08:47.140
因此这里我们需要加上括号, 索引为零｡ 

08:47.590 --> 08:57.430
这样, 我们根据索引1表示的所有动作, 得到索引0表示的下一个状态的Q值的最大值｡

08:58.000 --> 08:59.080
现在完美了｡ 

08:59.080 --> 09:01.400
我们得到下一个输出｡ 

09:01.420 --> 09:02.770
这些都是新的状态｡ 

09:02.770 --> 09:04.120
我们就是在那里得到警告的｡ 

09:04.120 --> 09:04.930
但那没关系｡ 

09:04.930 --> 09:07.690
我们现在就用它来计算目标｡ 

09:08.170 --> 09:12.160
说到目标, 这是学习功能的下一步｡ 

09:12.310 --> 09:13.060
好了, 我们走吧｡ 

09:13.090 --> 09:15.400
目的相等｡ 

09:15.430 --> 09:18.140
现在让我们回到我们的人工智能手册｡ 

09:18.160 --> 09:22.090
目标等于奖励加伽玛的倍数｡ 

09:22.090 --> 09:27.160
下一输出是根据动作的下一日期的Q值的最大值｡ 

09:27.430 --> 09:28.030
好了, 我们走吧｡ 

09:28.030 --> 09:29.080
让我们计算一下｡ 

09:29.080 --> 09:36.730
所以那个等于self, 那个γ和self, 那个γ在这里被初始化它被引入｡ 

09:36.730 --> 09:46.960
这是GQ和客体自我的一个变量, 它是伽马乘以下一个输出, 就像我们刚才说的, 再加上奖励,

09:47.110 --> 09:53.170
也就是我们这里用的批奖励, 再加上批｡

09:54.570 --> 09:55.290
奖赏｡ 

09:55.620 --> 09:59.190
这就是记忆样本中的目标｡ 

09:59.580 --> 10:03.360
伽玛乘以下一次的产出, 再加上奖励｡ 

10:03.720 --> 10:04.980
好吧, 完美｡ 

10:04.980 --> 10:06.890
现在我们有了输出｡ 

10:06.900 --> 10:08.670
我们也有了目标｡ 

10:08.670 --> 10:14.240
因此, 我们可以计算损失, 这个损失代表了预测的误差｡ 

10:14.250 --> 10:15.690
所以我们称之为损失｡ 

10:15.720 --> 10:23.850
TD损耗TD是时间差的损耗, 这也是CU学习的核心, 这个TD损耗将等于Huber损耗,

10:24.270 --> 10:30.290
它大大改善了Q学习｡

10:30.300 --> 10:34.350
这是我们为人工智能选择的最后一个功能｡ 

10:34.560 --> 10:40.620
对于那些从深度学习课程中走出来的人来说, 如果你想实施深度学习, 这就是我推荐的损失｡

10:40.620 --> 10:43.260
那么我们怎么才能得到这个Huber损失呢？

10:43.260 --> 10:49.110
再一次, 我们要从F表示的函数模块中取一个函数.

10:49.710 --> 10:57.660
因此, 这里我将使用我们的函数模块F dot和哈勃, 因为可以通过函数smooth

10:57.660 --> 11:07.710
l one loss that one来获得, 所以按回车键, 这是我推荐的深度学习的最佳lost函数｡

11:07.740 --> 11:10.650
它确实提高了Q学习, 但这是一个函数｡ 

11:10.650 --> 11:19.200
所以我加了一些括号, 现在没有什么比输入我们的预测和目标更简单的了｡

11:19.200 --> 11:24.000
所以预测当然是我们的输出, 因为这是神经网络的输出｡ 

11:24.000 --> 11:27.480
你知道, 神经网络的输出就是神经网络预测的结果｡ 

11:27.480 --> 11:28.950
这就是预测｡ 

11:28.950 --> 11:31.860
第一个参数是输出｡ 

11:32.250 --> 11:35.730
当然, 第二个论点是目标｡ 

11:35.910 --> 11:45.180
我们想要得到的东西, 已经计算完美了, 我们可以直接输入目标完美, 现在我们有了损失｡

11:45.210 --> 11:47.520
只是忘了一个小t在这里｡ 

11:48.060 --> 11:48.690
我们走吧｡ 

11:48.690 --> 11:50.340
现在警告应该消失了｡ 

11:50.670 --> 11:52.020
是的, 完美｡ 

11:52.020 --> 12:00.270
现在我们有了最后一个误差, 我们可以将这个误差反向传播到网络中, 用随机梯度下降法更新权重｡

12:00.270 --> 12:03.150
而这正是我们下一步要做的｡ 

12:03.240 --> 12:09.600
当然, 正如您可能猜到的, 现在我们要做的是使用优化器｡ 

12:10.050 --> 12:17.190
我们的优化器, 我们在这里再次介绍, 我们初始化了它, 这是一个原子优化器, 它实际上是原子类的一个对象,

12:17.190 --> 12:27.570
它已经拟合了我们模型的参数, 我们已经选择了学习率为0｡

12:27.570 --> 12:27.570
1个百分点｡ 

12:27.570 --> 12:36.960
如此完美, 我们的优化器已经准备就绪, 但现在我们需要将其应用于最后一个错误, 以执行随机梯度下降和数据权重｡

12:36.960 --> 12:43.980
因此, 当使用PyTorch时, 我们需要做的第一件事是在每次循环迭代时重新初始化它｡

12:43.980 --> 12:50.940
在随机梯度下降的循环中, 我们必须从一次迭代到另一次迭代重新初始化优化器,

12:50.940 --> 12:54.780
并且在循环的每个持续时间重新初始化它｡

12:54.930 --> 12:59.700
我们将使用下面的方法, 也就是零网格｡ 

12:59.730 --> 13:05.010
现在开始, zero grid将在每次循环迭代时重新初始化优化器｡ 

13:05.010 --> 13:06.990
那我们就别忘了括号｡ 

13:07.380 --> 13:08.040
好极了｡ 

13:08.040 --> 13:14.700
现在, 它已经被重新初始化, 我们可以使用优化器执行向后传播｡ 

13:15.000 --> 13:16.290
我们该怎么做呢？

13:16.290 --> 13:23.100
我们取TD损耗, 然后将其反向传播到网络中, 要将其反向传播到网络中,

13:23.100 --> 13:27.720
我们需要使用反向函数｡

13:27.960 --> 13:36.510
在这个向后的函数中, 我建议输入, 保留, 下划线变量, 并将其设置为true｡

13:37.080 --> 13:40.950
我建议这样做, 因为这将改善反向传播｡ 

13:40.980 --> 13:48.900
返回变量equals true的使用是为了释放一些内存, 我们需要释放内存因为我们会在丢失上做几次｡

13:48.900 --> 13:52.650
这样肯定会提高训练成绩｡ 

13:52.650 --> 13:58.890
最后, 该学习函数的最后一步是根据反向传播,

13:58.890 --> 14:02.550
即根据权重对误差的贡献程度来更新权重｡

14:02.550 --> 14:11.160
为此, 我们再次使用优化器, 该优化器已被初始化并重新初始化, 我们使用阶跃函数,

14:11.160 --> 14:19.110
只需通过使用阶跃函数的这行代码, 即可更新权重｡

14:19.260 --> 14:21.630
这是更新权重的代码行｡ 

14:21.660 --> 14:29.940
这一行代码将错误反向传播到神经网络中, 并且这一行代码使用优化器更新权重｡

14:30.210 --> 14:31.290
好了

14:31.290 --> 14:33.990
我们有了学习神经网络｡ 

14:35.030 --> 14:35.360
好吧, 我会的

14:35.360 --> 14:36.650
所以恭喜你

14:36.650 --> 14:42.200
这可能是所有深度学习模型中技术含量最高､ 难度最大的部分｡ 

14:42.200 --> 14:47.750
我知道PyTorch有时候会很棘手, 用这些和挤压和挤压,

14:47.750 --> 14:55.850
但最终我保证你会得到一个非常功能的神经网络, 因此深度学习模型, 并最终成为一个伟大的人工智能｡

14:56.360 --> 15:02.300
现在让我们进入深度学习模型的下一步, 这将是更新函数, 当人工智能发现新的状态时,

15:02.300 --> 15:06.950
它将进行更新｡

15:06.950 --> 15:12.140
所以, 你知道, 它会发现新的状态, 然后它会收到奖励,

15:12.140 --> 15:14.960
这取决于它刚刚玩的动作和这个新的状态｡

15:14.960 --> 15:19.460
我们将在下一个教程中使用update函数来解决这个问题｡ 

15:19.460 --> 15:20.810
在那之前, 好好享受吧｡ 

15:20.810 --> 15:21.290
一､