WEBVTT

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

00:02.940 --> 00:09.120
现在, 我们已经准备好训练网络, 使输出和目标之间的平方距离最小化,

00:09.120 --> 00:14.760
这要归功于我们在上一节中对资格跟踪所做的工作,

00:14.760 --> 00:20.640
基本上, 我们已经准备好通过获取输入､

00:20.640 --> 00:28.260
目标和预测来开始整个训练, 然后计算预测和目标之间的最后一个误差｡ 然后用随机梯度下降法进行反向传播来更新权值｡

00:28.260 --> 00:35.220
我们已经准备好了, 但是因为我们要计算100步的移动平均值, 为了跟踪训练中的平均值,

00:35.220 --> 00:40.770
在我们进行整个训练之前,

00:40.770 --> 00:47.250
我们要创建一个类, 来计算100步的移动平均值｡

00:47.250 --> 00:48.180
所以不用担心｡ 

00:48.180 --> 00:49.350
我们会尽快的｡ 

00:49.350 --> 00:53.580
我们将创建一个包含三个函数的类, 但我们将在本教程中完成所有这些操作｡ 

00:53.580 --> 00:54.810
所以我们会尽快完成｡ 

00:54.810 --> 00:55.770
我们已经做过了｡ 

00:55.770 --> 01:00.630
除此之外, 我们现在要专注于训练, 因为这是最重要的｡ 

01:00.630 --> 01:03.990
所以让我们在这一个教程中马上开始这门课｡ 

01:04.350 --> 01:04.740
好吧, 我会的

01:04.740 --> 01:10.800
所以我们要引入一个新的类, 我们称之为四移动平均线.

01:10.950 --> 01:13.230
现在我们开始第一个函数｡ 

01:13.230 --> 01:18.720
当然, 这是初始化函数, 它永远不会改变｡ 

01:18.720 --> 01:21.900
这个init函数有两个参数｡ 

01:21.900 --> 01:34.440
第一个是self, 代表移动平均未来对象和大小, 它对应于我们要计算平均值的奖励列表的大小.

01:34.440 --> 01:36.240
所以这将是100｡ 

01:36.720 --> 01:37.080
好吧, 我会的

01:37.080 --> 01:41.880
我们有了init函数的参数, 现在我们来看看函数内部.

01:41.890 --> 01:43.050
现在你知道该怎么做了｡ 

01:43.080 --> 01:47.220
我们必须初始化特定于对象的变量｡ 

01:47.220 --> 01:54.120
这些是第一个, 第一个是奖励列表.

01:54.120 --> 01:59.130
这是一个包含100个奖励的列表, 我们要计算它们的平均值.

01:59.130 --> 02:05.220
所以现在, 我们只是简单地用这个空列表初始化这个列表｡ 

02:05.640 --> 02:06.720
所以悬赏榜｡ 

02:06.720 --> 02:14.040
当然, 未来对象的第二个变量是大小,

02:14.040 --> 02:21.000
大小等于我们在创建未来移动平均对象时输入的参数,

02:21.000 --> 02:32.100
这里是大小, 我们已经准备好进入下一个函数, 即ADD函数, 它将增加累积奖励｡

02:32.100 --> 02:35.430
小心不是简单的奖励, 而是累积的奖励｡ 

02:35.430 --> 02:40.560
这是因为, 你知道, 我们正在做资格追踪, 因此每十步学习一次,

02:40.560 --> 02:44.430
因此学习是累积的奖励, 而不是简单的奖励｡

02:44.430 --> 02:52.440
所以我们要做的加法函数会把累积奖励加到奖励列表中.

02:52.590 --> 02:59.220
def, 我们称之为ADD, 这个ADD函数有两个参数｡ 

02:59.220 --> 03:08.250
第一个是self因为我们要用这个奖励列表因为我们要把累积奖励加到这个奖励列表上.

03:08.250 --> 03:11.550
所以我们需要这个自我才能得到这个所以自我｡ 

03:11.550 --> 03:17.760
第二个是奖励, 代表累积奖励.

03:18.420 --> 03:18.810
好吧, 我会的

03:18.810 --> 03:21.620
这就是ADD函数的两个参数｡ 

03:21.750 --> 03:25.230
现在让我们进入函数内部, 定义它要做什么.

03:25.590 --> 03:25.850
好吧, 我会的

03:25.890 --> 03:32.190
所以很简单, 它要做的第一件事就是每当我们得到一个累积的奖励,

03:32.190 --> 03:39.060
一个新的奖励, 你知道, 当我们在十个新的步骤上取得进展时, 我们要做的就是把这个累积的奖励加到列表上｡

03:39.060 --> 03:40.410
这正是我们要做的｡ 

03:40.410 --> 03:45.540
我们要写一行代码, 把这个新的累积奖励加到这个奖励列表上,

03:45.540 --> 03:48.840
这个奖励是我们在完成十个步骤后得到的.

03:49.050 --> 03:55.920
要做到这一点, 我们必须把两个条件分开, 因为我们要处理的是批次, 好吧,

03:55.920 --> 04:02.040
奖励会在一些列表中, 但在其他一些情况下, 奖励也可以作为一个单一的元素｡

04:02.040 --> 04:09.480
在列表中添加一个元素的语法, 也就是奖励列表, 无论你是添加一个列表还是一个元素,

04:09.480 --> 04:13.080
都是不一样的｡

04:13.080 --> 04:16.860
所以我们只需要建立一个条件来区分这两种情况｡ 

04:16.860 --> 04:23.430
让我们从第一种情况开始, 也就是说我们在这个奖励列表上添加的是一个列表.

04:23.430 --> 04:29.700
要做到这一点, 我们要添加一个实例, 在括号中输入两个参数｡ 

04:29.700 --> 04:34.080
第一个是我们的奖励, 我们增加了奖励｡ 

04:34.440 --> 04:37.170
第二个是列表｡ 

04:37.410 --> 04:47.340
如果是这样的话, 奖励列表意味着如果奖励被列在一个列表中, 那么如果奖励被列在一个列表中,

04:47.340 --> 04:54.870
我们所做的就是很简单的自我, 我们拿着我们的列表｡

04:55.680 --> 04:56.520
奖励｡ 

04:57.450 --> 05:08.250
我们要把这个列表相加因为这是一个列表, 我们可以用一个简单的加法运算, 因为我们可以把两个列表相加.

05:08.580 --> 05:09.180
的奖励｡ 

05:09.180 --> 05:11.670
这里是列表, 因为这将等于true｡ 

05:11.700 --> 05:13.110
我是说, 如果我们在这个案子里｡ 

05:13.110 --> 05:23.970
所以我们可以简单地把这个列表加到我们的奖励列表上, 所以我们可以简单地把奖励列表加上等于奖励｡

05:24.660 --> 05:30.300
通过这样做, 我们只是通过把这两个列表加在一起来扩展列表｡ 

05:30.930 --> 05:31.440
好吧, 我会的

05:31.440 --> 05:33.390
第二个条件

05:33.660 --> 05:35.910
所以我们可以简单地加上else｡ 

05:36.030 --> 05:41.640
如果奖励不是一个列表, 而是一个单一元素的话.

05:41.880 --> 05:44.180
那么, 在这种情况下会发生什么呢？

05:44.190 --> 05:45.210
那是一样的

05:45.210 --> 05:53.690
我们想把奖励添加到我们的奖励列表中, 但是我们不能使用这个语法, 因为奖励不再是一个列表｡

05:53.700 --> 05:55.250
它将是单个元素｡ 

05:55.260 --> 05:59.850
所以我们需要使用另一种语法, 就是append函数｡ 

05:59.850 --> 06:05.670
当你想添加一个单一的元素到一个列表中, 你可以添加一些你必须使用的两个append函数｡

06:05.670 --> 06:07.770
这正是我们现在要做的｡ 

06:07.770 --> 06:18.110
我们要把对象的奖励列表粘贴到这里, 然后加上点附加｡ 

06:18.120 --> 06:18.930
我们走吧｡ 

06:18.930 --> 06:24.540
第一个, 当然是在括号中, 我们输入我们想要附加的元素｡ 

06:24.540 --> 06:26.220
而这当然是奖励｡ 

06:26.220 --> 06:29.280
但在这种情况下, 奖励将不会是一个列表｡ 

06:29.280 --> 06:34.110
它将是一个单一的元素, 像一个单一的累积奖励, 而不是成一个列表｡ 

06:34.740 --> 06:35.160
好吧, 我会的

06:35.160 --> 06:39.300
然后我们想这样做, 但现在我们必须添加更多的东西｡ 

06:39.300 --> 06:45.180
这就是当这个奖励列表得到超过100个元素时会发生的事情｡ 

06:45.270 --> 06:51.210
这样的话, 我们要做的就是删除奖励列表中的第一个元素,

06:51.210 --> 06:56.160
以确保奖励列表中包含的元素不超过100个.

06:56.160 --> 07:00.330
所以就像我们在自动驾驶汽车上做的那样｡ 

07:00.330 --> 07:08.640
为了确保这一点, 我们要增加一个条件, 规定当奖励列表的长度,

07:08.910 --> 07:15.720
也就是奖励列表中元素的数量, 大于self时,

07:15.720 --> 07:25.350
这个大小, 就是我们在这里设定的大小, 当我们创建这个对象时, 它将等于100｡

07:25.350 --> 07:30.180
好吧, 只要这个奖励列表的元素数量大于100｡ 

07:30.180 --> 07:40.320
我们要做的是删除奖励列表中的第一个元素, 它可以通过取索引零来获得｡

07:40.320 --> 07:43.110
这是我们的奖励清单的第一个索引｡ 

07:43.350 --> 07:52.890
这是我们的奖励列表的第一个元素, 当我们的奖励列表包含超过100个元素时, 我们希望删除它｡

07:53.340 --> 08:01.620
所以在这个条件下, 我们要确保奖励列表中的元素不会超过100个.

08:01.950 --> 08:09.300
因此, 现在我们可以做的是,

08:09.300 --> 08:17.280
建立一个新的函数来计算我们的奖励列表的平均值, 它将包含100个元素, 因此我们将计算每次100步的移动平均值｡

08:17.880 --> 08:19.590
让我们来创建这个新函数｡ 

08:19.590 --> 08:24.600
这会很简单, 因为Python中有main函数, 它是NumPy中的一个函数,

08:24.630 --> 08:27.180
用来计算列表的平均值.

08:27.480 --> 08:31.710
让我们来介绍最后一个函数, 我们称之为average｡ 

08:31.980 --> 08:37.050
这个函数会有一个自变量, 它是self, 因为我们会用到,

08:37.050 --> 08:41.430
奖励列表, 它是对象的变量.

08:41.430 --> 08:44.220
所以自我和冒号｡ 

08:44.490 --> 08:51.630
现在让我们计算平均值, 我们直接返回平均值, 因为我们可以用均值函数来得到它,

08:51.630 --> 08:55.500
当然我们要用到均值函数｡

08:55.590 --> 09:00.000
我们要计算的是, 它的平均值就是我们的奖励列表.

09:00.000 --> 09:01.770
我想我还是复制了它｡ 

09:01.770 --> 09:02.100
是的, 我知道

09:02.100 --> 09:02.910
我们走吧｡ 

09:02.910 --> 09:07.050
所以我们只返回奖励列表的平均值｡ 

09:07.050 --> 09:11.210
平均值, 就像我说的, 是一个非π的函数｡ 

09:11.220 --> 09:16.500
所以这里我加上了快捷方式和p, 表示self的奖励列表｡ 

09:16.500 --> 09:17.460
好了

09:17.460 --> 09:20.370
我们有100步的平均值｡ 

09:20.850 --> 09:21.540
好极了｡ 

09:21.540 --> 09:23.970
所以我们非常有效率地上了这门课｡ 

09:23.970 --> 09:28.980
现在我们得到了如何获得100步移动平均线的说明｡ 

09:28.980 --> 09:38.490
既然我们在训练时要用到一个移动平均线对象, 那么, 我们先创建这个移动平均线对象｡

09:38.490 --> 09:46.260
所以我们称它为A, 简单地说, 火星就是A类的一个对象｡ 

09:46.260 --> 09:54.810
正如我们所说的, 我们希望大小为100, 因为我们希望计算100步的移动平均值｡ 

09:54.900 --> 09:55.920
太完美了｡ 

09:55.920 --> 09:56.670
我们走吧｡ 

09:56.890 --> 10:01.600
我们现在已经准备好训练我们的人工智能, 使其最终成为智能｡ 

10:01.630 --> 10:02.780
是时候了

10:02.800 --> 10:05.960
正是从这一点出发, 我们的AI才会变得聪明｡ 

10:05.980 --> 10:07.660
所以我等不及要训练它了｡ 

10:07.690 --> 10:11.190
这将是相当容易的, 因为这是我们已经做了｡ 

10:11.200 --> 10:12.580
但这会很有趣的｡ 

10:12.580 --> 10:18.640
除此之外, 在那之后, 将是时间有更多的乐趣, 因为基本上我们的眼睛将完全准备好｡

10:18.640 --> 10:24.850
它是内置的, 也是智能的,

10:24.850 --> 10:33.240
因此我们将执行代码, 然后我们的人工智能将发挥厄运, 最终我们将观看我们的人工智能发挥厄运的视频, 我们将看到它是否设法达到背心｡

10:33.250 --> 10:34.340
所以我等不及了｡ 

10:34.360 --> 10:35.650
让我们开始训练吧｡ 

10:35.650 --> 10:36.460
在那之前｡ 

10:36.460 --> 10:37.360
还有我｡