WEBVTT

00:00.520 --> 00:03.860
大家好, 欢迎回到人工智能课程｡ 

00:03.880 --> 00:05.860
在今天的教程中, 我们将有一些乐趣｡ 

00:05.860 --> 00:13.270
我们将看到一个人工智能正在穿过我们一直在谈论的迷宫｡

00:13.480 --> 00:18.340
它将使用关键的学习来导航并找到出路｡ 

00:18.340 --> 00:24.250
我们将看到提示值会发生什么变化, 策略会发生什么变化, 等等｡ 

00:24.250 --> 00:25.810
让我们来看看｡ 

00:26.080 --> 00:31.780
我们将使用一些由伯克利大学提供的材料｡ 

00:31.780 --> 00:41.110
所以如果你去I, Berkeley, B, r k e l e y edu, 如果你去那个链接, 输入,

00:41.110 --> 00:41.920
你会看到这个网站｡

00:42.160 --> 00:49.720
这里我们要看的是我们要看的是帕克曼项目｡ 

00:50.440 --> 00:50.700
是的, 我知道

00:50.710 --> 00:51.930
口袋妖怪项目｡ 

00:51.940 --> 00:59.020
这里如果你向下滚动, 你会看到强化学习, 这就是我们正在研究的｡ 

00:59.020 --> 01:01.630
所以在这里你可以下载zip压缩包｡ 

01:01.630 --> 01:04.960
所以如果你想的话, 你就不必这样做｡ 

01:04.960 --> 01:08.020
在本教程中, 我们不会一起讨论解决方案.

01:08.020 --> 01:16.120
我只是想让你们知道这些都是从哪里来的, 因为我们非常感谢加州大学伯克利分校提供了这些材料｡

01:16.120 --> 01:21.790
但如果你们真的想自己做实验, 记住这不是我们课程的一部分｡

01:21.790 --> 01:23.140
这是伯克利课程的一部分｡ 

01:23.140 --> 01:26.050
我将向你们展示它是如何工作的, 以便于说明｡ 

01:26.050 --> 01:31.060
但是如果你真的想尝试一下, 你可以在这里找到它, zip存档和所有的说明｡

01:31.180 --> 01:34.780
我们马上就来看看Python｡ 

01:34.810 --> 01:41.050
首先, 我想向大家展示的是, 这里有许可信息｡ 

01:41.050 --> 01:42.700
所以这就是我的意思｡ 

01:42.700 --> 01:47.650
我们很幸运, 他们说我们可以自由地使用或扩展这些项目用于教育目的, 你知道, 分布式解决方案,

01:47.650 --> 01:50.860
我们不会这样做｡

01:50.890 --> 01:57.790
您保留我们拥有的此通知, 并提供明确的加州大学伯克利分校归属, 包括我们也拥有的链接｡

01:57.790 --> 02:01.660
所以, 如果你想了解更多, 这里有一个链接, 你可以看看｡ 

02:01.660 --> 02:05.380
非常感谢所有为这个项目工作的人｡ 

02:05.380 --> 02:08.170
这就是我们将要研究的网格世界｡ 

02:08.170 --> 02:09.280
有一个解决办法｡ 

02:09.280 --> 02:14.650
为了让它起作用, 你必须要么孤立自己, 要么找到解决办法｡

02:14.950 --> 02:20.140
也许你们中的一些人, 或者一些人, 你认识的人, 可能会帮助你摆脱困境, 如果你想的话｡

02:20.140 --> 02:24.850
你不必这样做, 因为我们现在就在屏幕上看｡ 

02:24.850 --> 02:29.440
创建完所有这些文件后, 我们可以在这里启动它｡ 

02:29.440 --> 02:34.450
所以在这个世界上有一些参数｡ 

02:34.570 --> 02:39.010
现在我将向你们展示如果我们发射它的样子｡ 

02:39.010 --> 02:41.470
让我们尝试以手动模式启动它｡ 

02:41.470 --> 02:46.990
如果我手动减去其中一个参数, 我就可以手动控制代理｡ 

02:46.990 --> 02:48.190
这里你可以看到我们的网格｡ 

02:48.190 --> 02:50.110
这样我就可以上去了｡ 

02:50.110 --> 02:54.910
所以你可以看到它在采取行动, 在我所在的州开始｡ 

02:54.910 --> 03:00.100
然后你看到你看到我压上去, 向北行动, 第一次我在01结束｡ 

03:00.100 --> 03:00.970
所以我就上去了｡ 

03:01.270 --> 03:04.510
但第二次我采取行动了, 我结束了同样的状态｡ 

03:04.510 --> 03:04.930
我没动｡ 

03:04.930 --> 03:06.160
所以发生了一些事｡ 

03:06.370 --> 03:07.180
随机性发生了｡ 

03:07.180 --> 03:10.810
我要么向左走, 要么向右走, 默认情况下, 参数是设置好的｡ 

03:10.810 --> 03:17.080
你可以看到, 默认情况下, 它们的设置与我们讨论的完全相同, 即操作导致意外方向的频率为20%,

03:17.080 --> 03:20.800
10%向左, 10%向右｡

03:20.950 --> 03:23.350
所以如果我往上走, 你看, 我往上走, 我往右走｡ 

03:23.350 --> 03:25.570
我现在就去｡ 

03:25.570 --> 03:29.080
没有发生的权利再次和权利｡ 

03:29.080 --> 03:29.680
我就完了｡ 

03:29.680 --> 03:34.210
但是在这个实现中, 您必须再次单击才能退出这个最终输出｡ 

03:34.210 --> 03:37.000
因此, 在退出时, 您只需再次单击, 即可完成｡ 

03:37.000 --> 03:40.630
这是一个终端状态, 所以我们可以运行一个手动｡ 

03:40.630 --> 03:45.520
你可以看到, 如果我向右, 右, 右, 左向上｡ 

03:45.520 --> 03:49.990
我们之前看到代理不会直接向上, 对吗？

03:49.990 --> 03:53.230
如果有机会进坑, 那上去又有什么意义呢？

03:53.230 --> 03:54.370
让我们看看代理人会怎么做｡ 

03:54.490 --> 03:56.680
你会向左走, 你会向西走, 所以向西走｡ 

03:56.680 --> 04:01.930
你看, 我点击了左边, 但是它上升了, 在这里我点击了右边, 我最终进入了最后的退出状态,

04:01.930 --> 04:04.780
你看, 得到了等于1的奖励｡

04:05.170 --> 04:06.910
这就是手动操作的效果｡ 

04:06.910 --> 04:12.460
现在让我们把一个人工智能连接到这个上, 让它通过｡ 

04:12.460 --> 04:16.720
让我们在这里做一个H, 并添加一些参数｡ 

04:16.720 --> 04:18.970
让我看看我在这里输入了什么｡ 

04:18.970 --> 04:27.910
希望你们能看到, 蟒蛇网格世界的点P, 这里减去R表示这是活着的回报｡

04:27.910 --> 04:31.630
所以我有两个, 所以我可能应该删除这个｡ 

04:31.960 --> 04:34.510
那么减去K是多少次迭代？

04:34.840 --> 04:36.610
这是太多的迭代方式｡ 

04:36.610 --> 04:37.390
让我们少做点｡ 

04:37.390 --> 04:39.850
让我们做十次迭代｡ 

04:39.850 --> 04:40.690
应该够了｡ 

04:40.960 --> 04:48.100
减a是我想用哪种类型的代理, 对一个随机代理, 某个值代理或者Q, Q, Q,

04:48.100 --> 04:54.850
学习代理, 做这个, 减s是s的速度｡

04:54.850 --> 04:56.530
所以这太快了｡ 

04:56.530 --> 04:58.810
现在我们使用默认速度｡ 

04:58.810 --> 05:02.440
减R是活的惩罚｡ 

05:02.440 --> 05:04.690
所以默认为零｡ 

05:04.690 --> 05:07.630
所以请记住, 在一开始, 我们从零生活惩罚开始｡ 

05:07.630 --> 05:10.000
所以我们也称之为零｡ 

05:10.000 --> 05:15.760
这里我们可以去掉这个参数, dx就是DX折扣.

05:15.760 --> 05:16.990
所以我们的折扣系数｡ 

05:16.990 --> 05:18.310
所以让它保持在0｡  9.

05:18.310 --> 05:21.580
这与我们在这节课开始时讲的内容非常相似｡ 

05:21.580 --> 05:25.420
所以我们再跑一次吧｡ 

05:26.300 --> 05:26.500
我想是的｡ 

05:26.580 --> 05:27.420
哦, 事实上, 它是如此漂亮｡ 

05:27.630 --> 05:29.280
所以你可以看到他是如何探索的｡ 

05:30.410 --> 05:33.350
到目前为止, 他已经三次击中了负值｡ 

05:33.350 --> 05:36.410
你可以看到Q值是如何在这些方块中更新的｡ 

05:36.410 --> 05:37.810
这些就是价值观｡ 

05:37.820 --> 05:38.990
它们从零开始｡ 

05:39.020 --> 05:40.640
现在可以看到Q值｡ 

05:40.640 --> 05:46.220
所以他又一次学到了, 这一个是有点不同的实施, 因为一旦你到了最后一个阶段, 你必须离开它｡

05:46.370 --> 05:48.890
您只需再单击一个按钮即可退出｡ 

05:48.890 --> 05:51.350
所以它非常接近于一, 但不完全是一｡ 

05:51.530 --> 05:57.290
但同时, 你可以看到, 这里, 你知道,

05:57.290 --> 06:04.520
价值是慢慢地在0种结晶｡ 8显然是有进展了, 但其他的都是零因为他没有足够的信息来理解到底发生了什么.

06:05.360 --> 06:05.520
好吧, 我会的

06:05.660 --> 06:08.600
让我们看看, 看看会发生什么.

06:10.080 --> 06:13.590
探索, 探索, 探索将要发生的事情｡ 

06:13.620 --> 06:14.850
杨帆楞了好一会｡ 

06:15.540 --> 06:17.610
别忘了, 这里有一些随机性｡ 

06:17.850 --> 06:20.580
所以现在有几次击中了那个好的｡ 

06:20.910 --> 06:24.090
他只有10次迭代, 所以他得学得快｡ 

06:25.640 --> 06:26.630
我需要你｡ 

06:27.140 --> 06:28.670
让我们看看发生了什么｡ 

06:29.180 --> 06:29.980
来吧, 来吧

06:29.990 --> 06:31.790
快离开迷宫｡ 

06:32.760 --> 06:40.200
是的, 十集, 所以平均回报, 这是我们真的不感兴趣｡ 

06:40.200 --> 06:42.510
让我们看看我以前从没见过他们.

06:42.510 --> 06:43.770
如果我点击这里, 我们去｡ 

06:43.770 --> 06:49.530
所以你可以看到这是他提出的政策, 即使只有十集｡ 

06:49.530 --> 06:50.610
他已经有保险了｡ 

06:50.610 --> 06:52.290
好吧, 我要去巴巴巴嘣｡ 

06:52.380 --> 06:54.030
我要从这里下去｡ 

06:54.030 --> 06:55.440
我要下去了｡ 

06:55.440 --> 06:58.230
我会撞到墙上然后弹到这边来｡ 

06:58.440 --> 06:59.250
那很酷｡ 

07:00.180 --> 07:02.100
现在让我们加快速度｡ 

07:02.430 --> 07:05.520
这里的参数sx是多少, 我们来取double｡ 

07:05.520 --> 07:11.220
好吧, 让我们, 让我们把速度提高四倍, 让我们增加迭代的次数｡ 

07:11.220 --> 07:13.440
假设这次迭代20次｡ 

07:13.830 --> 07:18.660
让我们看看他现在能不能再多穿一点, 这样你就可以看到他走得更快了｡ 

07:19.580 --> 07:20.960
他在学习｡ 

07:20.960 --> 07:24.080
他正在学习, 它并没有真正走出这个状态｡ 

07:24.440 --> 07:29.990
没有太多好的行为, 或者这些行为的权利和直不是那么好｡ 

07:30.020 --> 07:30.530
绝对的｡ 

07:30.530 --> 07:31.910
这个肯定不好｡ 

07:32.300 --> 07:33.380
他还需要学习｡ 

07:33.380 --> 07:34.550
所以从这里看也是好的｡ 

07:34.640 --> 07:36.290
你可以看到这个动作相当不错｡ 

07:36.710 --> 07:37.220
好吧, 我会的

07:37.220 --> 07:38.390
他得到了什么？

07:38.430 --> 07:40.340
好吧, 这个政策很有意思｡ 

07:40.640 --> 07:42.020
他决定上去｡ 

07:42.050 --> 07:43.190
只是信息不够｡ 

07:43.190 --> 07:44.360
所以我们｡ 

07:44.420 --> 07:45.530
我们再来一次｡ 

07:46.780 --> 07:50.140
把速度提高到100｡ 

07:50.230 --> 07:51.310
所以速度超快｡ 

07:51.310 --> 07:57.940
迭代的次数将给予他们有100次STEM迭代来快速运行该场景｡

07:57.940 --> 08:00.700
你可以看到这一点, 因为有太多的迭代｡ 

08:01.000 --> 08:07.360
他有了更多的信息, 更多的机会去实验, 去构建这个, 这个矩阵,

08:07.360 --> 08:10.750
这些队列值, 对于他现在知道的每一个状态｡

08:10.930 --> 08:13.070
您可以看到0. 89.

08:13.090 --> 08:15.730
在我们的例子中, 我们说的是0｡  86.

08:15.880 --> 08:20.080
另一件事要记住这一点, 即任何给定状态的值｡ 

08:20.620 --> 08:24.130
请记住, 我们的公式是Q值的最大值｡ 

08:24.130 --> 08:26.930
记住我们想出的捷径公式｡ 

08:26.950 --> 08:29.370
那么在这种状态下的值是多少呢？

08:29.380 --> 08:34.390
这个状态的V, 应该是0 89因为这是四个中最高的｡ 

08:34.540 --> 08:37.030
这里, 该状态的值为0｡  71.

08:37.030 --> 08:40.150
此状态的值为0｡  61等等｡ 

08:40.150 --> 08:41.350
所以这是需要记住的｡ 

08:41.350 --> 08:45.130
我记得在我们的例子中, 我想我们有0｡  86年左右, 非常接近｡ 

08:45.670 --> 08:51.130
所以如果我们再往下看, 它就消失了｡ 

08:51.580 --> 08:54.490
让我们再来一次让它回来｡ 

08:55.090 --> 08:55.660
好吗？

08:55.670 --> 08:56.060
好吧, 我会的

08:56.140 --> 08:57.250
慢点慢点慢点｡ 

08:57.250 --> 09:00.310
填补一些空白｡ 

09:01.060 --> 09:01.420
我明白了｡ 

09:01.420 --> 09:06.100
它也是随机的, 因为不仅环境是随机的,

09:06.100 --> 09:10.150
而且他在不知道策略的情况下开始探索的方式也是随机的.

09:10.960 --> 09:12.020
它只是不断消失｡ 

09:12.040 --> 09:13.180
我不明白为什么｡ 

09:13.510 --> 09:19.660
不管怎样, 让我们看看如果我们增加这里的数字会发生什么, 这里应该会花同样多的时间｡

09:20.700 --> 09:22.800
如果速度没有上限的话｡ 

09:23.820 --> 09:26.880
所以你可以看到他有更多的机会去探索事物｡ 

09:27.740 --> 09:32.490
OC让我们看看它是如何进行的, 你可以看到值正在收敛｡ 

09:32.500 --> 09:36.240
它们会上下波动,

09:36.240 --> 09:43.050
因为有一些随机性, 他可能会像在坑里一样结束, 尽管他是这样走的, 但同时它们会慢慢地开始收敛到某种最终值｡

09:43.050 --> 09:44.130
Q值？

09:44.900 --> 09:48.450
OC大概1000在时间上有点太多了｡ 

09:48.450 --> 09:53.010
看起来速度也没有成比例地增加｡ 

09:53.460 --> 09:55.110
所以它可能会切断那部分｡ 

09:55.470 --> 09:57.090
我是说, 比如降低速度｡ 

09:57.420 --> 09:57.610
是的, 我知道

09:57.720 --> 09:59.070
而这一段则很长｡ 

09:59.900 --> 10:01.970
您不必一直观看本教程的结尾部分｡ 

10:01.970 --> 10:03.320
我只是想尝试一下｡ 

10:03.320 --> 10:10.490
我给予你们举几个例子来说明我们一直在做的事情, 但你们应该明白, 它贯穿了所有这一切｡

10:10.670 --> 10:14.600
它有一些随机性, 就像Ram是它行为的一部分｡ 

10:14.600 --> 10:18.560
所以即使它已经有了政策, 它还是会继续探索｡ 

10:18.560 --> 10:23.240
所以它不会像一旦有了基本政策, 它不会只是继续遵循它的政策｡ 

10:23.240 --> 10:28.760
它仍然会偶尔尝试其他变化, 以加强其政策｡ 

10:28.760 --> 10:31.280
也许它还没有马上找到最好的策略｡ 

10:31.280 --> 10:33.140
也许这能改善政策｡ 

10:33.140 --> 10:38.720
这就是为什么, 即使经过这么多次迭代, 你仍然可以看到一些随机效应｡ 

10:39.030 --> 10:43.640
它有时会跳到随机状态,

10:43.640 --> 10:49.040
不仅仅是因为环境的随机性, 还因为有一些级别, 比如你可以控制的参数,

10:49.040 --> 10:55.430
你可以为你的代理设置, 比如说大多数时间, 80%的时间, 做你的策略告诉你做的任何事情｡

10:55.430 --> 11:00.620
但有20%的时间, 你知道, 只是有一些有趣的实验, 看看会发生什么,

11:00.620 --> 11:03.140
并使用您收集的信息来更新您的政策｡

11:03.200 --> 11:03.400
好吧, 我会的

11:03.500 --> 11:05.150
这花的时间太长了｡ 

11:05.180 --> 11:06.270
我们再来一次｡ 

11:06.290 --> 11:06.680
是的, 我知道

11:06.680 --> 11:11.540
这就是代理人在不同状态下学习的方式｡ 

11:11.540 --> 11:11.780
也许吧｡ 

11:11.780 --> 11:14.000
出于好奇我们再跑一次吧｡ 

11:14.000 --> 11:16.520
所以我们还有什么可以改变的吗？

11:18.390 --> 11:20.540
对它们进行迭代｡ 

11:21.600 --> 11:22.800
原币原币

11:22.810 --> 11:24.060
我们来看看｡ 

11:24.360 --> 11:26.610
是啊, 好吧, 比如说, 我们可以改变折扣｡ 

11:26.610 --> 11:29.280
所以在这种情况下, 我们可以说｡ 

11:30.640 --> 11:39.780
K-100, 减去一个q-, 再减去一个q-, 就是千｡ 

11:39.790 --> 11:41.260
所以奖励｡ 

11:41.260 --> 11:42.100
我们想保留它｡ 

11:42.100 --> 11:45.610
也许我们把它保持在0｡  04, 但让我们再说一遍｡ 

11:46.030 --> 11:49.210
让我们把奖励保持在-0｡  每次都这样｡ 

11:49.210 --> 11:53.470
这里我们说D｡ 

11:54.250 --> 11:58.900
折扣不为0｡  9, 但它就像0.. 5.

11:58.900 --> 12:02.140
所以当你玩游戏的时候, 它会打很多折扣｡ 

12:02.350 --> 12:10.360
所以实际上现在它会被激励去更接近终点而不是更接近终点的状态, 我们会得到更高的价值｡

12:10.360 --> 12:12.790
所以你可以看到这个值很快就下降了｡ 

12:12.790 --> 12:15.340
它不像以前那么绿色了｡ 

12:16.130 --> 12:20.100
在这里, 您可以看到这是现在的策略｡ 

12:20.120 --> 12:23.180
就像这样, 像这样, 像这样, 像这样｡ 

12:23.180 --> 12:24.950
和我们之前看到的非常相似｡ 

12:24.980 --> 12:28.430
可能唯一的区别就是直接跳到这里｡ 

12:28.580 --> 12:29.840
这就是那个了

12:29.840 --> 12:32.420
我们再跑一次｡ 

12:32.450 --> 12:33.390
这太有趣了

12:33.410 --> 12:34.430
我们再跑一次｡ 

12:34.430 --> 12:34.880
是这样｡ 

12:34.910 --> 12:38.940
K减k 100一q折｡ 

12:38.960 --> 12:41.720
请保持原样｡ 

12:41.720 --> 12:45.620
让我来运行这个基本的香草设置｡ 

12:46.690 --> 12:49.540
好了好了好了｡ 

12:49.540 --> 12:51.730
让我们看看最后它是否会显示策略｡ 

12:53.300 --> 12:53.840
是的, 我知道

12:53.840 --> 12:54.770
我们有保单｡ 

12:54.770 --> 12:55.060
是的, 我知道

12:55.070 --> 12:55.880
很好的结束｡ 

12:56.180 --> 12:58.610
这就是我们的策略｡ 

12:58.730 --> 12:59.740
你知道, 这很熟悉｡ 

12:59.750 --> 13:04.580
还记得那次我们看到人工智能比人类聪明, 撞到墙上去那里, 撞到墙上去,

13:04.580 --> 13:08.510
这样做, 以增加概率｡

13:08.510 --> 13:09.190
好了, 我们走吧｡ 

13:09.200 --> 13:13.760
这是人工智能的一个例子｡ 

13:13.760 --> 13:16.250
非常, 非常基本, 简单的杀戮学习｡ 

13:16.250 --> 13:18.050
所以在这个阶段没有深度学习｡ 

13:18.440 --> 13:21.830
但与此同时, 它已经相当聪明了｡ 

13:21.830 --> 13:23.540
我希望你喜欢今天的教程｡ 

13:23.540 --> 13:29.540
再次感谢加州大学伯克利分校, 我希望你们喜欢今天的教程, 我期待着下一次见到你们｡

13:29.540 --> 13:30.680
在那之前, 好好享受吧｡ 

13:30.680 --> 13:31.220
一､