WEBVTT

00:01.340 --> 00:03.110
大家好, 欢迎回来

00:03.140 --> 00:11.300
在上一节课中, 你们看到了我们如何使用帮助函数来真正设置我们的核心功能, 以训练我们的模型｡

00:11.300 --> 00:16.430
因此, 我们有我们的终端状态, 我们的开始位置,

00:16.430 --> 00:21.460
我们的下一个行动, 下一个位置和最短路径真正定义了我们的代理或环境将如何工作的大部分｡

00:21.470 --> 00:25.520
我们最后要做的就是利用我们的训练来利用我们的训练｡ 

00:25.520 --> 00:31.940
这是非常直接的意义上说, 我们需要包括什么, 我们如何去做, 是一个不同的故事｡

00:32.180 --> 00:36.830
也就是说, 如果你们使用不同的方法, 或者你想定制它并进行实验,

00:36.830 --> 00:38.510
强烈推荐｡

00:38.510 --> 00:43.670
除此之外, 如果您使用了不同的方法, 并希望讨论它, 请随时在问答中分享｡

00:43.700 --> 00:45.470
非常乐意和你讨论｡ 

00:45.470 --> 00:50.510
这是一个很好的主意, 因为有很多方法可以解决这个问题, 你可能会找到一个更好的方法,

00:50.510 --> 00:52.220
更有利｡

00:52.220 --> 00:55.670
我们可以再看看利弊, 非常乐意讨论｡ 

00:55.670 --> 00:56.090
好吧, 我会的

00:56.090 --> 00:57.290
那我们该怎么办？

00:57.320 --> 00:59.090
我们得开始训练了｡ 

00:59.090 --> 01:00.050
为了我们的训练｡ 

01:00.050 --> 01:01.520
我们想用Epsilon｡ 

01:01.520 --> 01:08.960
所以基本上我们要采取的最佳行动的百分比, 而不是随机行动｡

01:08.960 --> 01:18.080
让我们把ε设为0｡  我们将对折扣因子和学习率做类似的处理｡

01:18.080 --> 01:23.300
所以让我们把贴现因子设为0｡  9.

01:23.660 --> 01:29.780
让我们把学习率设为0｡  9.

01:29.810 --> 01:33.860
这就是我们的经纪人将要学习或应该学习的速度｡ 

01:33.860 --> 01:39.320
我们还要取训练集的个数, 我们称之为n训练集｡ 

01:39.320 --> 01:41.330
所以我们有很多训练集｡ 

01:41.330 --> 01:42.560
让我们将其设置为1000｡ 

01:42.560 --> 01:46.640
它要训练多少次或者它要训练多少集？

01:48.140 --> 01:48.800
太棒了｡ 

01:49.010 --> 01:52.910
现在, 我们要做的就是遍历每一集｡ 

01:52.910 --> 02:00.100
我们要取训练集的数量范围, 并设置基本上的ε｡ 

02:00.110 --> 02:01.820
我们想找出我们的时间差｡ 

02:01.820 --> 02:04.640
要设置该值, 我们需要查看之前的一些Q值｡ 

02:04.640 --> 02:08.510
我们需要计算行动指数的起始位置｡ 

02:08.510 --> 02:10.790
那么我们开始吧｡ 

02:11.000 --> 02:12.500
让我们来做一个大的for循环｡ 

02:12.500 --> 02:14.750
所以我们有我们的四集｡ 

02:16.840 --> 02:20.080
在我们的训练次数范围内｡ 

02:22.120 --> 02:22.730
我们走吧｡ 

02:22.750 --> 02:33.970
如果我没有任何语法错误, 我们希望将网格的行索引和列索引作为玉米列索引｡

02:36.110 --> 02:39.950
并将其设置到目标起始位置｡ 

02:39.950 --> 02:44.480
我们需要一个开始的位置, 所以让我们有倾倒是每一集｡ 

02:45.040 --> 02:49.600
现在, 我们可以设置我们的终端状态｡ 

02:51.210 --> 02:51.990
不是的｡ 

02:52.880 --> 02:56.330
是终端状态｡ 

02:56.360 --> 03:01.580
我们想看看行索引和列索引｡ 

03:03.020 --> 03:07.340
接下来, 让我们为下一个动作设置动作索引｡ 

03:07.340 --> 03:09.050
所以我们确实需要下一步行动｡ 

03:09.050 --> 03:16.790
当这个代理为我们的动作索引遍历迷宫时, 我们可以使用get next action｡ 

03:17.740 --> 03:24.760
我们可以使用行索引列索引, 我们称之为epsilon｡ 

03:24.760 --> 03:29.860
所以我们想用这个来代替我们的随机操作, 让我们用列索引｡ 

03:32.020 --> 03:33.880
我们需要艾普西隆｡ 

03:34.300 --> 03:34.910
太棒了｡ 

03:35.350 --> 03:37.510
如果我没拼错的话, 我们在这里｡ 

03:37.510 --> 03:39.220
你想要艾普西隆？

03:39.910 --> 03:42.330
好吧, 让我删除这个OC｡ 

03:42.370 --> 03:48.280
让我来看看剩下的代码, 我们将逐步完成它, 这样我们就不必看着我键入每一行｡

03:48.280 --> 03:55.120
但请记住, 我们要如何处理设置旧行的问题, 我们需要一个旧行索引｡

03:55.120 --> 04:00.310
我们也希望我们的列和行得到奖励｡ 

04:00.310 --> 04:05.890
我们需要查看队列值和旧队列值, 并且需要计算时间差异｡ 

04:06.220 --> 04:10.000
所以你可以看到代码的变化或者代码的更新｡ 

04:10.000 --> 04:16.450
我们将使用旧的行索引和列索引来查看行索引和列索引｡ 

04:16.450 --> 04:22.300
我们的行索引列索引等于我们的下一个位置, 我们的下一个位置需要行索引, 列,

04:22.300 --> 04:24.280
索引和动作｡

04:25.250 --> 04:27.410
最后, 我们来看看奖励｡ 

04:27.680 --> 04:34.640
我们的旧Q值将是具有旧行索引､ 旧列索引的Q值,

04:34.640 --> 04:40.700
再次,

04:40.700 --> 04:48.440
参考我们的动作索引和时间差的计算, 这是我们的奖励, 加上折扣因子乘以具有行索引和列索引的Q值减去旧Q值的前一Q值｡

04:50.040 --> 04:56.040
差不多完成了, 我们需要新的Q值,

04:56.040 --> 05:04.560
它是旧的Q值加上学习率､ 时间､ 时间差和Q值, 旧的列索引中的旧的行索引等于新的Q值｡

05:05.770 --> 05:09.940
如果你们想进一步讨论这个问题, 强烈推荐问答｡ 

05:09.940 --> 05:11.270
请随意打印｡ 

05:11.290 --> 05:13.660
尝试使用此处使用的所有变量进行试验｡ 

05:13.660 --> 05:17.380
如果你想看到这些形状, 看看它们是如何使用的, 它所引用的是什么｡ 

05:17.380 --> 05:20.620
我强烈推荐这家酒店, 我非常乐意与您进一步讨论｡ 

05:21.040 --> 05:24.640
最后一件事, 我们可以做, 所以我们有一点点的通知｡ 

05:24.640 --> 05:30.040
让我们添加一条print语句, 以便知道1000行的训练何时完成｡ 

05:30.040 --> 05:30.880
好吧, 我会的

05:30.910 --> 05:34.660
如果我这边没有语法错误的话, 我们应该可以开始了｡ 

05:34.690 --> 05:36.730
协作笔记本已初始化｡ 

05:36.730 --> 05:37.770
我重新检查了一遍｡ 

05:37.820 --> 05:38.710
让我来查一下｡ 

05:38.710 --> 05:41.560
应该很快, 因为我们只使用麻木｡ 

05:41.590 --> 05:44.050
从某种意义上说, 这是一个非常优化的模型｡ 

05:44.080 --> 05:47.080
让我单击此按钮, 然后我们将查找最短路径｡ 

05:48.400 --> 05:48.790
好吧, 我会的

05:48.790 --> 05:50.320
我们的训练已经完成了｡ 

05:50.530 --> 05:54.820
让我们也打印一些起始选项的最短路径｡ 

05:54.820 --> 05:59.920
我们从第三行第九列开始, 最短路径选项是最短路径.

06:00.010 --> 06:06.940
我们要查看第五行和第零行, 从第九行和第五列开始｡ 

06:07.030 --> 06:08.320
把这些打印出来｡ 

06:08.920 --> 06:09.430
太棒了｡ 

06:09.430 --> 06:12.430
我们有最短的路径, 但我们还没有完成｡ 

06:12.430 --> 06:13.630
我们快到了｡ 

06:13.870 --> 06:22.840
我们可以看到我们的邮递员自动获得最短的路径, 从一个法律的, 我们可以考虑的位置从我们的城市到项目包装区｡

06:22.840 --> 06:25.540
但是, 反过来又会怎样呢？

06:25.540 --> 06:31.300
基本上是指我们的邮递员能把一件东西从城市的任何地方送到包装区吗？

06:31.300 --> 06:37.570
但在项目之后, 它将需要从该地区, 从包装区到城市的另一个位置,

06:37.570 --> 06:40.470
因为它将不得不拿起下一个项目｡

06:40.480 --> 06:43.840
那么我们能做些什么来解决这个问题呢？

06:43.840 --> 06:45.370
其实很简单｡ 

06:45.370 --> 06:48.100
您可以修改最短路径的顺序｡ 

06:48.700 --> 06:52.270
试着想一想, 然后这将是解决方案｡ 

06:53.290 --> 06:55.150
我们可以使用最短路径｡ 

06:55.150 --> 07:00.580
让我们取第五行第二列, 然后你需要做的就是使用相反的选项｡ 

07:00.580 --> 07:04.450
在Python中, 我们使用路径反转, 并且可以打印出路径｡ 

07:04.450 --> 07:06.250
所以我们要找的是5和2｡ 

07:07.080 --> 07:07.860
好了

07:07.860 --> 07:13.020
我们有最短的路径, 如果你想抓取单元格中的图像, 并把它拿下来比较和查看这些路径,

07:13.020 --> 07:14.940
这真的很有帮助｡

07:14.940 --> 07:20.370
但是你可以看到路径, 如果你把打印出来的报表, 看一下订单中的列,

07:20.370 --> 07:23.250
看看这些销售员是怎么走的｡

07:23.250 --> 07:25.770
你用的东西太棒了｡ 

07:25.770 --> 07:26.820
Q学习｡ 

07:26.820 --> 07:35.100
我们从这门课中学到了一些额外的, 有趣的场景和部分来解决这个本质上是旅行推销员的问题｡

07:35.100 --> 07:41.880
我们正在寻找邮递员在城市里投递包裹和物品时找到的那些最短的选择和最短的路径｡

07:41.880 --> 07:47.460
我强烈建议您自定义､ 测试其他选项､

07:47.460 --> 07:55.200
更改超级参数, 如果您发现任何更好的东西, 如果您发现任何可使用的优化或最佳参数, 请随时在问答中分享｡

07:55.680 --> 07:56.340
太神奇了｡ 

07:56.340 --> 07:58.260
我希望你们真的喜欢这个｡ 

07:58.260 --> 08:01.470
请自定义､ 试验并不断学习｡ 

08:01.470 --> 08:02.820
和它一起工作真的很有趣｡ 

08:02.830 --> 08:03.030
问：

08:03.030 --> 08:04.980
学习和享受我｡