WEBVTT

00:00.550 --> 00:03.340
大家好, 欢迎回到深度学习课程｡ 

00:03.340 --> 00:06.580
在今天的教程中, 我们将讨论梯度下降｡ 

00:06.580 --> 00:14.260
我们之前学到的是, 为了让神经网络学习, 需要发生的是反向传播｡

00:14.260 --> 00:23.080
这是当误差､ y hat和y之间的差或平方差的和通过神经网络反向传播时,

00:23.080 --> 00:28.210
并且相应地调整权重｡

00:28.210 --> 00:34.150
我们已经看到了, 今天我们将学习如何调整这些权重｡ 

00:34.150 --> 00:35.230
让我们来看看｡ 

00:35.920 --> 00:44.590
这是我们非常简单的神经网络, 一个感知器或单层前馈神经网络｡

00:44.590 --> 00:52.360
这里我们可以看到整个过程, 我们有一些输入值, 然后我们有一个权重,

00:52.360 --> 00:56.920
然后应用一个激活函数｡

00:56.920 --> 00:59.800
我们得到白色白帽, 然后我们将其与实际值进行比较｡ 

00:59.800 --> 01:01.570
我们计算代价函数｡ 

01:01.570 --> 01:05.200
那么我们如何最小化代价函数呢？

01:05.200 --> 01:07.270
我们能做些什么呢？

01:07.270 --> 01:18.130
有一种方法是蛮力法, 我们取所有不同的权重, 然后看看哪一个最有效.

01:18.130 --> 01:24.760
我们要做的是, 比如说, 我们试着, 比如说, 1000个砝码, 然后我们试着用这个模型｡

01:24.940 --> 01:27.640
我们得到这样的代价函数｡ 

01:27.640 --> 01:32.740
这是一个图表, Y轴是成本函数, 垂直轴是成本函数｡ 

01:32.740 --> 01:39.100
在横轴上你有y帽子, 因为你可以看到公式是y帽子减去y平方, 这是成本函数的样子,

01:39.100 --> 01:41.590
类似这样｡

01:42.510 --> 01:47.100
基本上你会发现最好的一个在这里｡ 

01:47.760 --> 01:50.490
非常简单, 非常直观的方法｡ 

01:50.850 --> 01:53.130
为什么不采用这种蛮力的方法呢？

01:53.130 --> 02:02.940
为什么不尝试1000种不同的成本､ 上千种不同的参数或权重输入, 看看哪一种效果最好呢？

02:02.940 --> 02:04.110
这样你会找到最好的｡ 

02:04.140 --> 02:07.530
如果你只有一种优化方法, 这可能会奏效｡ 

02:07.530 --> 02:16.310
但是当你增加权重的数量, 增加网络中突触的数量, 你就不得不面对维度的诅咒｡

02:16.320 --> 02:18.690
那么, 维度的诅咒是什么呢？

02:19.350 --> 02:24.390
描述或解释这一点的最好方法是看一个实际的例子｡ 

02:24.390 --> 02:36.870
还记得我们讨论神经网络如何工作时的例子吗？我们在构建或运行一个神经网络来进行资产评估｡

02:36.870 --> 02:40.500
这是它训练好后的样子｡ 

02:40.500 --> 02:43.440
如果它以前没受过训练, 那它以前就受过训练了｡ 

02:43.440 --> 02:47.520
我们知道哪一个权重, 实际的神经网络看起来像这样｡ 

02:47.520 --> 02:54.960
对, 因为我们有所有这些不同的可能突触, 我们仍然需要训练权重｡ 

02:54.960 --> 03:00.600
这里我们总共有25个权重, 所以开始时是4乘以5, 再加上从隐藏层到输出层的5个权重,

03:00.600 --> 03:03.330
总共是25个权重｡

03:03.390 --> 03:09.030
让我们来看看我们怎么可能蛮力25个重量｡ 

03:09.150 --> 03:13.230
这是一个非常简单的神经网络, 非常简单｡ 

03:13.230 --> 03:14.400
只是一个隐藏层｡ 

03:14.400 --> 03:21.090
我们怎么能强行通过这么大的神经网络呢？

03:21.090 --> 03:24.150
好吧, 让我们做一些简单的数学计算｡ 

03:24.150 --> 03:25.800
我们有25个砝码｡ 

03:25.800 --> 03:30.330
这意味着如果我们有1000种组合,

03:30.330 --> 03:36.960
我们要测试每种重量, 组合的总数是1000的25次幂或1000或10的75次幂｡

03:37.680 --> 03:46.800
现在让我们看看, 截至2016年6月, 神威如何成为世界上最快的超级计算机｡ 

03:47.250 --> 03:49.590
它将如何处理这个问题呢？

03:49.590 --> 03:49.770
好吧, 我知道了

03:49.770 --> 03:53.730
所以某种方式联系到光, 它看起来像这样｡ 

03:53.760 --> 03:58.770
对于这台超级计算机来说, 这是一个巨大的建筑｡ 

03:58.770 --> 04:04.470
它还获得了吉尼斯世界纪录, 成为最快的超级计算机｡ 

04:05.100 --> 04:08.160
现在它是世界上最快的超级计算机｡ 

04:08.160 --> 04:14.730
而神威虎光的运算速度可以达到93 petaFLOPS｡ 

04:15.220 --> 04:27.930
一个flop代表每秒的浮点运算, 所以它每秒可以进行93次幂乘以10的15次幂的浮点运算｡

04:27.930 --> 04:32.280
相比之下, 这就是它的速度｡ 

04:32.280 --> 04:37.980
现在的普通电脑, 它们的浮点运算速度只有几个千兆位｡ 

04:37.980 --> 04:44.130
所以就像那些范围远小于神威暮光｡ 

04:44.130 --> 04:47.790
所以神威暮光是走在科技前沿的｡ 

04:48.150 --> 05:01.320
假设它可以在一次浮点运算中完成一个测试, 一个组合｡

05:01.560 --> 05:03.150
那是不可能的｡ 

05:03.150 --> 05:09.420
这是不实际的, 因为您需要多个浮点运算来测试神经网络中的单个权重｡

05:09.420 --> 05:11.190
但就算是让我们给予开始吧｡ 

05:11.190 --> 05:14.970
假设它在理想世界中也能做到｡ 

05:14.970 --> 05:17.310
它可以在一次浮动操作中完成此操作｡ 

05:17.310 --> 05:19.830
每一次浮动操作可进行一次测试｡ 

05:19.830 --> 05:28.470
这意味着它仍然需要10的75次幂除以93次, 10到bar, 15秒, 来运行所有这些测试,

05:28.470 --> 05:33.900
以暴力通过网络｡

05:33.900 --> 05:41.850
所以这意味着一秒或者大约十的58次幂, 这和十的50次幂是一样的｡

05:41.850 --> 05:44.220
这是一个巨大的数字｡ 

05:44.220 --> 05:48.120
比宇宙存在的时间还长｡ 

05:48.120 --> 05:52.800
而那绝对不是简单地将这个数字如此巨大｡ 

05:52.800 --> 05:58.860
在我们的优化中, 它肯定不会对我们起作用｡ 

05:58.860 --> 05:59.970
好了, 我们走吧｡ 

05:59.970 --> 06:01.170
这是一个没有没有｡ 

06:01.170 --> 06:05.340
即使是世界上最快的超级计算机神威称号也不轻｡ 

06:05.340 --> 06:07.560
所以我们必须想出一个不同的方法｡ 

06:07.560 --> 06:10.080
我们如何找到最佳重量？

06:10.080 --> 06:13.500
顺便说一句, 我们的神经网络非常简单｡ 

06:13.500 --> 06:17.060
如果神经网络看起来像这样呢？

06:17.100 --> 06:22.110
或者甚至比这更大, 那么是的, 它只是不会发生在所有, 永远｡ 

06:22.530 --> 06:26.100
我们要学习的方法叫做梯度下降法｡ 

06:26.100 --> 06:28.200
你可能已经听说过了｡ 

06:28.410 --> 06:30.630
如果没有, 我们现在就去查｡ 

06:30.630 --> 06:41.910
这就是我们的成本函数, 现在我们来看看如何找到一个更快的方法｡

06:41.980 --> 06:43.120
最好的选择｡ 

06:43.120 --> 06:44.980
所以我们从某个地方开始｡ 

06:44.980 --> 06:45.850
你总得有个开始｡ 

06:45.850 --> 06:52.810
我们从左上角的那一点开始, 我们要做的是,

06:52.810 --> 06:58.510
看看我们的成本函数在那一点的角度｡

06:58.510 --> 07:01.900
所以我们基本上这就是为什么它被称为梯度, 因为你必须微分｡ 

07:01.900 --> 07:03.790
我们不会去看数学方程｡ 

07:04.090 --> 07:09.220
在下一节课的最后, 我们将提供一些关于额外阅读的提示｡ 

07:09.580 --> 07:19.180
但基本上你只需要进行微分, 找出特定点的斜率, 然后找出斜率是正还是负｡

07:19.180 --> 07:23.890
如果斜率是负的, 就像这个例子, 意味着你在下坡｡ 

07:23.890 --> 07:27.070
所以右边是下坡, 左边是上坡｡ 

07:27.070 --> 07:29.620
从那里开始你需要向右走｡ 

07:29.620 --> 07:32.920
基本上, 你需要走下坡路, 这就是我们要做的｡ 

07:32.950 --> 07:35.140
房间需要一步, 对不对？

07:35.380 --> 07:37.390
球又滚了下来｡ 

07:37.390 --> 07:38.230
一样的东西｡ 

07:38.230 --> 07:39.460
您计算坡度｡ 

07:39.460 --> 07:44.860
这一次的斜率是正的, 意思是右边是上坡,

07:44.860 --> 07:52.120
左边是下坡, 你需要向左走, 你把球滚下来, 再一次你计算斜率, 你把球滚到右边｡

07:52.960 --> 07:53.470
我们走吧｡ 

07:53.470 --> 08:04.420
这就是你如何找到, 简单来说, 这就是你如何找到最佳权重, 最佳情况下, 最小化你的成本函数｡

08:04.420 --> 08:06.520
当然, 它不会像一个球｡ 

08:06.520 --> 08:14.860
滚动将是一种非常曲折的方式, 但更容易记住, 把它看作一个滚动的球会更有趣｡

08:14.860 --> 08:18.500
但在现实中, 是的, 你只是要像一步一步的方法｡ 

08:18.500 --> 08:20.560
所以这是一种锯齿形的方法｡ 

08:21.820 --> 08:22.210
是的, 我知道

08:22.210 --> 08:24.970
而且还有很多其他的元素｡ 

08:24.970 --> 08:31.540
比如说, 为什么为什么会下降？

08:31.540 --> 08:35.020
为什么它不喜欢越过界线？

08:35.020 --> 08:40.360
所以它可能是向上跳出来的, 而不是向下跳之类的｡ 

08:40.360 --> 08:41.890
所以它们是你可以调整的参数｡ 

08:41.890 --> 08:45.460
同样, 我们将提到在哪里可以找到更多关于这方面的信息｡ 

08:45.460 --> 08:50.470
另外, 我们将在实际应用中, 以最简单的直观方法来实现这一点｡ 

08:50.470 --> 08:51.670
这就是正在发生的事情｡ 

08:51.670 --> 08:57.730
我们通过了解我们需要走哪条路而不是通过成千上万､ 数百万､ 数十亿､

08:57.730 --> 09:02.800
数万亿的组合来达到目的｡

09:02.800 --> 09:08.860
我们可以只是简单地每一次看一下哪里是哪里, 它是朝哪个方向倾斜｡ 

09:08.860 --> 09:13.720
就像你想象自己站在一座山上, 你会觉得哪条路是下坡路, 无论哪条路是下坡路,

09:13.720 --> 09:16.420
你都要一直走下去.

09:16.420 --> 09:20.320
你会想, 你朝那个方向走了50步, 然后你再评估一下, 它会朝哪个方向走？

09:20.320 --> 09:21.370
往这边走

09:21.370 --> 09:23.170
好的, 现在走50步或更少｡ 

09:23.170 --> 09:27.880
向那边走40步, 越靠近它就越少｡ 

09:28.390 --> 09:32.650
这是一个二维空间中梯度下降的例子｡ 

09:32.650 --> 09:35.440
这是一个一维的例子

09:36.460 --> 09:40.180
这里我们有一个二维空间的梯度下降｡ 

09:40.180 --> 09:44.890
正如你所看到的, 它越来越接近最小值, 这也被称为梯度下降,

09:44.890 --> 09:49.240
因为你正在下降到成本函数的最小值｡

09:49.420 --> 09:53.260
最后, 这是应用于三维的梯度下降｡ 

09:53.260 --> 09:54.340
看起来是这样的

09:54.340 --> 09:59.260
如果你把它投影到二维上, 你可以看到它正曲折地走向最小值｡ 

09:59.440 --> 10:00.020
所以你去那里｡ 

10:00.070 --> 10:05.890
这是梯度下降, 我们将讨论随机梯度下降, 这是本教程的延续,

10:05.890 --> 10:08.620
我期待着在那里见到你｡

10:08.620 --> 10:10.720
所以下次好好享受深度学习吧｡