WEBVTT

00:00.300 --> 00:02.280
大家好, 欢迎学习本教程｡ 

00:02.310 --> 00:04.500
好了, 现在我们有了眼睛｡ 

00:04.530 --> 00:06.090
它已准备好接受训练｡ 

00:06.090 --> 00:09.610
而训练的第一步是设置体验回放｡ 

00:09.630 --> 00:11.220
所以我们正在慢慢地达到目标｡ 

00:11.220 --> 00:16.580
培训和好消息是, 我们有一个实现版本的经验重放｡ 

00:16.590 --> 00:23.430
除此之外, 这是适应资格跟踪, 我提醒是一个技术, 而不是学习线索值,

00:23.430 --> 00:27.060
每个过渡学习它, 每十个过渡｡

00:27.060 --> 00:29.340
所以基本上和之前的完全一样｡ 

00:29.340 --> 00:34.740
但是我们不再是一个单一的目标,

00:34.740 --> 00:40.710
每一步都有一个单一的奖励, 我们将有一个十步的累积目标和十步的累积奖励, 我们将在每一次的十步中学习｡

00:40.710 --> 00:44.900
所以我们学习十个转变, 十个步骤, 而不是像以前一样一个｡ 

00:44.910 --> 00:50.250
有了这个, 我们的眼睛将创造奇迹, 这将为训练过程创造一些奇迹｡ 

00:50.250 --> 00:53.730
你知道, 训练会花更少的时间感谢这种技术｡ 

00:53.730 --> 00:58.740
但是我们必须指定一个经验, 每十步就重放一次我们正在学习的东西｡ 

00:58.740 --> 01:06.000
所以这就是为什么这个体验回放不是像自动驾驶汽车那样的经典体验回放｡

01:06.030 --> 01:12.390
这是一个经验重放实现考虑到这十个步骤的学习, 因此,

01:12.390 --> 01:18.810
你会发现在这个经验重放文件两个类, 一个类, 使你的眼睛在十个步骤的进展,

01:18.810 --> 01:23.220
以便它可以总结在这十个步骤观察到的奖励.

01:23.220 --> 01:24.390
那是头等舱｡ 

01:24.390 --> 01:29.490
我们需要这个类, 因为我们需要在replay memory类中包含这十个步骤, replay

01:29.490 --> 01:31.560
memory类是我们为体验replay实现的类｡

01:31.560 --> 01:37.770
这就是我们如何确保记忆也考虑到我们是在十步学习的事实｡

01:37.770 --> 01:41.610
这就是为什么你会在体验回放的实现中发现两个类｡ 

01:41.610 --> 01:48.870
但这只是考虑到我们在学习十步, 这也必须在记忆中考虑到｡

01:49.140 --> 01:51.780
说到我们的记忆, 让我们来创造它｡ 

01:51.780 --> 01:54.600
我们将把我们的记忆称为记忆｡ 

01:55.140 --> 02:00.270
内存将成为重放内存类的一个对象｡ 

02:00.270 --> 02:04.740
而replay memory类就是这个体验类的replay P文件｡ 

02:04.740 --> 02:08.880
所以我先把这个文件重放一遍

02:10.100 --> 02:10.370
那就这样吧

02:10.370 --> 02:15.770
达特我在那里上了记忆回放课｡ 

02:15.770 --> 02:16.610
好极了｡ 

02:16.610 --> 02:19.720
现在, 正如你所看到的, 我们有两个输入, 两个参数｡ 

02:19.730 --> 02:27.320
第一个参数是和steps, 它正好对应于我们要学习Q值的步数｡

02:27.320 --> 02:31.910
所以, 你知道, 我们积累目标和奖励的步骤数｡ 

02:31.910 --> 02:35.630
所以我们要有一个累积目标和累积奖励｡ 

02:35.630 --> 02:39.620
第二个参数是容量, 也就是内存的大小｡ 

02:39.620 --> 02:42.560
例如, 这里我们可以看到10, 000｡ 

02:42.560 --> 02:47.600
因此, 如果容量等于10, 000, 则意味着存储器的大小为10, 000｡ 

02:47.600 --> 02:54.140
因此, 这意味着我们将获得人工智能少执行的10,000步的记忆｡ 

02:54.170 --> 02:57.170
但是, 我们也不会学习每一个转变｡ 

02:57.170 --> 03:01.700
我们要学习记忆中最后一万步中的每十步.

03:01.700 --> 03:05.960
这正是我们在这里介绍的与以前相比的新功能｡ 

03:05.960 --> 03:08.990
以前, 我们只有这种记忆回放的技巧｡ 

03:08.990 --> 03:13.940
这里我们有一个记忆回放的技巧, 再加上每十步学习一次的技巧｡ 

03:13.940 --> 03:19.940
我们要每十步学习一次我们要在记忆中学习最后的一万步.

03:19.940 --> 03:29.090
这是经验重放结合一个资格跟踪与十个步骤将大大提高训练性能｡

03:29.240 --> 03:31.040
让我们输入这两个参数｡ 

03:31.040 --> 03:38.540
第一个是steps, 它等于现在的, 比如说, steps｡ 

03:38.540 --> 03:44.810
我们将指定什么和步骤是正确的,

03:44.810 --> 03:52.070
在那之后它实际上将是这个体验重放文件的另一个类的对象, 这是MN步骤进度类, 它允许在十个步骤中进行AI进度｡

03:52.070 --> 03:57.920
请记住, 在十个步骤中, 我们会将十个步骤以下的奖励相加,

03:57.920 --> 04:01.970
以获得十个步骤以上的累积奖励, 这就是资格跟踪｡

04:01.970 --> 04:08.930
现在我们要做的是在这里创建这个和步骤, 我们用这个体验重放文件中的第二个类来创建它,

04:08.930 --> 04:12.830
这是在步骤进程中｡

04:12.830 --> 04:15.050
现在我们要创建结束步骤｡ 

04:16.170 --> 04:16.980
就像这样｡ 

04:17.220 --> 04:28.200
这将是MN Step Progress类的一个对象, 我们再次从我们的经验中获取｡ 

04:28.620 --> 04:30.450
重新执行档案｡ 

04:30.720 --> 04:31.570
我们走吧｡ 

04:31.590 --> 04:32.570
这就是最后一步｡ 

04:32.580 --> 04:33.480
进步班｡ 

04:33.480 --> 04:35.490
现在我们必须输入三个参数｡ 

04:35.520 --> 04:40.920
正如您所看到的, 我们必须输入环境, 这是我们在这里导入的Doom环境｡ 

04:40.950 --> 04:48.600
第二个论点是我们的人工智能, 当然, 这将是我们在预览部分构建的人工智能｡

04:48.840 --> 04:51.270
最后一个参数是结束步骤｡ 

04:51.270 --> 04:57.060
在这里, 我们会指定十步, 每十步学习一次.

04:57.060 --> 04:58.740
也就是说, 每十个转换｡ 

04:58.950 --> 05:01.050
让我们输入这些参数｡ 

05:01.050 --> 05:04.230
第一个是环境, 这就是厄运｡ 

05:04.740 --> 05:11.590
好的, 第二个是我们的人工智能, 我们称之为AI｡ 

05:11.610 --> 05:12.620
就是这里的那个

05:12.630 --> 05:16.530
所以这只是end step progress类的参数名称｡ 

05:16.530 --> 05:20.850
这个人工智能是我们的人工智能, 我们自己造的｡ 

05:21.060 --> 05:26.610
最后一个参数是end step, 它等于10｡ 

05:27.000 --> 05:27.690
好吧, 我会的

05:27.690 --> 05:33.270
所以现在, 我们只是在记忆中考虑到, 有一个十步学习.

05:33.270 --> 05:36.780
这种十步学习叫做资格追踪｡ 

05:36.960 --> 05:39.450
所以, 我们真的在这里工作的先进的东西｡ 

05:39.450 --> 05:44.060
但请记住, 因为我们试图成为哑巴, 这一点也不像做一块蛋糕｡ 

05:44.070 --> 05:47.310
所以我们需要这些先进的技术来使它工作｡ 

05:47.430 --> 05:54.610
现在, 我们几乎已经准备就绪, 可以进入下一步了, 下一步实际上是实现资格跟踪｡

05:54.630 --> 06:01.590
我们唯一需要考虑的是容量, 当然, 也就是说, 10000台｡ 

06:01.980 --> 06:09.210
内存的大小为10, 000, 这意味着内存将包含AI执行的最后10, 000个步骤,

06:09.210 --> 06:13.740
这将允许我们生成一些迷你批处理｡

06:13.740 --> 06:19.470
大家还记得, 使用采样函数时, 内存包含10,

06:19.470 --> 06:27.000
000个转换, 但为了训练人工智能, 我们将对一些包含10个转换的小批量进行采样, 而不是与之前的10个转换进行比较｡

06:27.000 --> 06:32.790
我们将在由10, 000个最后步骤组成的存储器中对这些10个转换的小批进行采样｡ 

06:33.300 --> 06:33.720
好吧, 我会的

06:33.720 --> 06:39.330
现在, 我想我们已经准备好进入下一步, 即实现资格跟踪｡

06:39.330 --> 06:41.490
所以我们要在这里进行一些冒险｡ 

06:41.490 --> 06:43.560
这将不是一个简单的实现｡ 

06:43.560 --> 06:45.090
所以好好休息吧｡ 

06:45.090 --> 06:47.580
等你准备好了, 我们就开始行动｡ 

06:47.700 --> 06:48.860
在那之前, 好好享受吧｡ 

06:48.870 --> 06:49.260
一､