WEBVTT

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

00:02.820 --> 00:07.410
好的, 现在我们要做一个push函数, 它可以完成两个任务｡ 

00:07.410 --> 00:12.570
首先, 它将在存储器中附加新的过渡或新的事件｡ 

00:12.660 --> 00:17.910
其次, 它将确保内存始终有100个转换｡ 

00:17.940 --> 00:24.970
我说100是因为我们在上一个教程中给出了100个事件的例子, 但实际上, 这将远远超过100个｡

00:24.990 --> 00:28.340
这将是相当可能10, 000或100, 000｡ 

00:28.350 --> 00:29.220
等着瞧吧

00:29.220 --> 00:32.160
但无论如何, 这个值将是容量｡ 

00:32.700 --> 00:35.550
好的, 让我们把这个推函数｡ 

00:35.550 --> 00:41.340
所以像往常一样, 我们从def开始定义一个新函数, 然后给予这个函数命名｡ 

00:41.340 --> 00:46.320
我们称之为push, 这个函数有两个参数.

00:46.320 --> 00:50.990
第一, 像通常那样, 自我即指对象和下一个｡ 

00:51.000 --> 00:52.500
你觉得会是什么？

00:52.680 --> 00:58.670
记住, 这个push函数将用于在内存中添加一个新事件｡ 

00:58.680 --> 01:00.300
我们已经有记忆了｡ 

01:00.300 --> 01:03.420
所以我们现在需要的变量是事件｡ 

01:03.420 --> 01:12.150
这就是我们的参数, 我们的输入, 我们将把这个输入附加到内存中, 它是对象的变量｡

01:13.060 --> 01:17.710
好的, 事件你可以称之为事件或转换｡ 

01:17.710 --> 01:18.640
那是一样的｡ 

01:18.640 --> 01:23.770
在接下来的代码部分中, 您将看到这个事件到底是什么, 它有什么形式？

01:24.010 --> 01:30.930
实际上, 我现在可以告诉你, 这个事件, 这个我们添加到记忆中的过渡, 总共有四个元素｡

01:30.940 --> 01:33.910
第一个状态是最后一个状态｡ 

01:33.940 --> 01:37.210
第二个是新的状态, 即状态加1｡ 

01:37.240 --> 01:42.460
第三个是最后一个动作80, 即显示的动作｡ 

01:42.580 --> 01:46.750
而第四个是最后一个奖励, 最后一个获得的奖励｡ 

01:46.750 --> 01:47.740
这是正确的｡ 

01:48.010 --> 01:51.100
所以这就是这个活动的形式｡ 

01:51.610 --> 01:52.300
好吧, 我会的

01:52.450 --> 01:57.430
这就是我们所需要的, 因为我们只想把事件打开到内存中,

01:57.430 --> 02:00.760
然后确保内存有容量元素｡

02:01.060 --> 02:01.480
好吧, 我会的

02:01.480 --> 02:03.610
现在让我们进入函数内部｡ 

02:03.610 --> 02:07.390
因此, 我们要做的第一件事是将新事件附加到内存中｡ 

02:07.390 --> 02:10.660
这很简单, 因为我们要用append函数.

02:10.660 --> 02:12.070
所以这将是直接的｡ 

02:12.070 --> 02:18.370
而当我们使用append函数时, 我们必须从我们想要向其追加内容的列表开始｡ 

02:18.490 --> 02:20.770
而这个列表当然是记忆｡ 

02:20.770 --> 02:22.150
所以我们从记忆开始｡ 

02:22.150 --> 02:28.240
由于记忆是一个变量的对象, 我们在这里从self点记忆开始｡ 

02:29.320 --> 02:30.130
我们走吧｡ 

02:30.340 --> 02:35.710
所以self memory, 然后我们加一个点, 然后是append函数, 这是第一个｡ 

02:35.710 --> 02:44.290
在append函数中, 我们输入要添加到内存中的内容, 当然就是我们的事件.

02:44.530 --> 02:45.640
所以就算是在这里｡ 

02:46.180 --> 02:53.890
这将把由最后一个状态､ 新状态､ 更少的部分和更少的奖励组成的新事件附加到存储器中｡

02:54.400 --> 02:55.120
好吧, 我会的

02:55.120 --> 02:56.620
所以这是第一件事｡ 

02:56.620 --> 03:03.760
然后我们需要做的第二件事是确保内存始终包含容量元素｡ 

03:03.760 --> 03:07.300
假设现在的容量为100, 000｡ 

03:07.300 --> 03:12.520
这可能是我们将选择的容量, 因为100万个元素可能会使训练变慢｡

03:12.520 --> 03:14.920
所以我们假设10万｡ 

03:14.920 --> 03:22.600
现在, 我们要确保我们的记忆始终包含100, 000个转换, 100, 000个事件, 永远不会超过｡

03:22.600 --> 03:28.750
当然, 一开始它会有一个, 然后是两个和三个, 但是一旦它达到100, 000个事件, 那么,

03:28.750 --> 03:32.140
它将总是有100, 000个事件｡

03:32.140 --> 03:39.370
为了确定它, 我们只需要建立一个F条件, 它有一个我们不想超过的上限｡

03:39.370 --> 03:47.860
如果是这样的话, 我们在这里使用的ID是, 如果我们超过了极限, 那么,

03:47.860 --> 03:56.020
我们将删除第一个转换, 内存的第一个事件, 因此我们将使用Len函数来获取内存的长度｡

03:56.020 --> 03:58.120
这是内存中的元素数｡ 

03:58.240 --> 04:02.380
所以这里在land函数中我们输入self点记忆｡ 

04:02.650 --> 04:03.790
这就是记忆｡ 

04:04.180 --> 04:12.430
如果自我记忆中的元素数量大于容量, 那么,

04:12.430 --> 04:21.790
在这种情况下, 我们将删除第一个元素, 以确保记忆中总是有相同数量的容量元素, 并删除第一个元素｡

04:21.790 --> 04:22.960
没有什么比这更简单的了｡ 

04:22.960 --> 04:27.010
我们将使用另一个函数, 这就是del python技巧｡ 

04:27.010 --> 04:33.700
因此, 我们要删除第一个转换, 它是内存中最旧的转换,

04:33.700 --> 04:39.310
因为最后一个转换是我们附加的转换, 因此它是最新的转换｡

04:39.310 --> 04:41.800
所以第一次跃迁是最古老的｡ 

04:42.130 --> 04:52.810
所以这里我们要删除自学记忆和括号, 我们取记忆中索引为零的第一个元素｡

04:52.990 --> 04:54.670
所以自我记忆为零｡ 

04:55.300 --> 04:55.690
现在就去

04:55.690 --> 04:56.410
有意思｡ 

04:56.410 --> 05:00.710
我有一个小小的警告, 说有一个未定义的名称容量｡ 

05:00.730 --> 05:03.760
这是因为这里的容量不是输入｡ 

05:03.760 --> 05:07.320
必须是附加到对象的容量变量｡ 

05:07.330 --> 05:12.820
因此在这里我们需要添加一个自我自我能力而现在警告消失了｡ 

05:13.060 --> 05:15.610
所以现在你更了解自我的用途了｡ 

05:15.610 --> 05:22.360
这实际上是引用对象来获取将要创建的对象的容量｡ 

05:22.360 --> 05:25.120
这是重播内存类的一个实例｡ 

05:26.060 --> 05:29.060
好了, 我们完成了这个推送函数｡ 

05:29.060 --> 05:34.190
现在我们可以继续下一个函数, 即采样函数,

05:34.190 --> 05:38.590
它将从最后一个容量元素的内存中随机采样｡

05:38.600 --> 05:41.840
这样做将大大改善深度学习过程｡ 

05:42.320 --> 05:44.420
好的, 让我们在下一个教程中做这个｡ 

05:44.420 --> 05:45.710
在那之前, 好好享受吧｡ 

05:45.710 --> 05:46.220
一､