WEBVTT

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

00:02.880 --> 00:08.360
这是一个额外的教程来讨论软Mac和交叉熵函数｡ 

00:08.370 --> 00:15.570
这并不是100%必要的, 你要完成我们在这一节的主要部分,

00:15.570 --> 00:21.120
讨论的卷积神经网络的所有部分｡

00:21.120 --> 00:26.490
但同时, 我认为这将是一个很好的除了你的袋子的知识和技能集｡ 

00:26.490 --> 00:30.450
让我们继续深入研究这些函数｡ 

00:30.570 --> 00:46.560
首先, 我们在这一节的主要部分建立了一个卷积神经网络, 最后它会给出0的概率｡

00:46.560 --> 00:46.560
95为一只狗和0.

00:46.560 --> 00:47.790
055或对于猫为5%｡

00:47.820 --> 00:52.530
考虑到左边的照片作为输入, 这是在训练已经进行之后｡ 

00:52.530 --> 00:57.120
这实际上是它在运行, 它在对某个图像进行分类｡ 

00:57.120 --> 01:00.690
所以这里的问题是, 为什么这两个值加起来是1？

01:00.690 --> 01:06.150
因为就我们所知, 从我们对人工神经网络的所有了解来看,

01:06.150 --> 01:11.490
没有任何东西可以说这两个最终的神经元是相互连接的｡

01:11.490 --> 01:16.680
那么他们怎么知道他们每个人的价值, 另一个的价值,

01:16.680 --> 01:20.070
他们怎么知道把他们的价值加起来？

01:20.070 --> 01:26.010
答案是, 在经典版的人工神经网络中, 它们不会｡ 

01:26.100 --> 01:33.720
唯一的办法就是我们引入了一个特殊的函数, 叫做软极大函数, 来帮助我们摆脱这种情况｡

01:33.720 --> 01:40.620
所以通常情况下, 狗和猫的神经元会有任何的真实的值｡ 

01:41.400 --> 01:44.910
它们不必是B, 它们不必加起来是1｡ 

01:44.910 --> 01:51.510
然后我们应用软最大函数, 写在上面, 它会使这些值在0和1之间,

01:51.510 --> 01:56.100
它会使它们加起来等于1｡

01:56.100 --> 02:03.180
引用维基百科的话,

02:03.180 --> 02:15.240
源最大函数或归一化指数函数是逻辑函数的推广, 它将任意真实的数值的k维向量挤压成0到1范围内的实数值的k维向量, 这些实数值加起来等于1｡

02:15.240 --> 02:17.460
所以基本上它做的正是我们想要的｡ 

02:17.460 --> 02:22.650
它使这些值介于0和1之间, 并确保它们之和为1｡ 

02:22.650 --> 02:26.400
它的运作方式是这样的, 这是可能的｡ 

02:26.400 --> 02:29.790
是因为在这里的底部, 你可以看到有一个求和｡ 

02:29.790 --> 02:36.480
所以它取指数, 把它放在Z的幂中, 然后把它加起来｡ 

02:36.480 --> 02:39.690
所以Z1在所有的类中都是2, 所有这些值｡ 

02:39.690 --> 02:43.470
这就是你的正常化过程｡ 

02:44.130 --> 02:47.310
这就是软极大函数的工作原理｡ 

02:47.310 --> 02:54.810
在卷积神经网络中引入一个软最大函数是有意义的, 因为如果你有一只狗和一只猫的可能分类, 对于狗类,

02:54.810 --> 03:02.370
你有80%的概率, 对于猫类, 你有45%的概率,

03:03.450 --> 03:08.250
那会有多奇怪｡

03:08.250 --> 03:08.610
对不对？

03:08.610 --> 03:11.190
这样说不通啊

03:11.190 --> 03:15.810
因此, 当你引入这个偏最大函数时效果会更好,

03:15.810 --> 03:19.230
这也是你会发现在卷积神经网络中大部分时间发生的事情｡

03:19.530 --> 03:27.240
另一件事是, 软极大函数和交叉熵函数是紧密联系在一起的｡

03:27.240 --> 03:28.950
这对我们来说非常方便｡ 

03:28.950 --> 03:30.450
我们先来看看公式｡ 

03:30.480 --> 03:32.730
这就是交叉熵函数的样子｡ 

03:32.910 --> 03:36.930
我们实际上要用一种不同的计算方法｡ 

03:36.930 --> 03:40.590
我们将使用这种交叉输入的表示法, 但结果基本上是一样的｡ 

03:40.590 --> 03:42.150
这只是更容易计算｡ 

03:42.270 --> 03:48.990
据我所知, 这听起来可能与现在的任何事情都没有关系, 只是屏幕上的公式,

03:48.990 --> 03:53.010
但在本节的最后会有一些额外的推荐阅读｡

03:53.010 --> 03:58.290
所以如果你不懂数学, 也不用担心, 就像我如果我们现在还没有解释数学.

03:58.290 --> 04:01.710
但这里的重点是什么是交叉熵？

04:01.710 --> 04:03.540
交叉熵函数｡ 

04:03.540 --> 04:11.460
还记得我们以前在人工神经网络中, 我们有一个函数, 叫做均方误差函数,

04:11.460 --> 04:17.700
我们用它作为评估网络性能的代价函数｡

04:17.700 --> 04:23.670
我们的目标是最大限度地减少MSI, 以优化网络性能｡ 

04:23.670 --> 04:26.700
这就是我们的成本函数｡ 

04:26.700 --> 04:34.500
在卷积神经网络中, 我们仍然可以使用MSI, 但是在卷积神经网络中, 在应用了软最大函数之后,

04:34.500 --> 04:39.600
一个更好的选择是交叉熵函数｡

04:39.600 --> 04:45.540
在卷积神经网络中, 当你应用交叉熵函数时, 不再叫成本函数, 而是叫损失函数,

04:45.540 --> 04:49.410
它们非常相似｡

04:49.410 --> 04:55.440
它们只是在术语上有一点不同, 在含义上也有一点不同｡ 

04:55.440 --> 04:58.920
但对于我们的目的来说, 这是几乎相同的事情｡ 

04:59.750 --> 05:09.430
损失函数是我们想要最小化的函数, 以最大化网络性能｡

05:09.440 --> 05:15.170
让我们看一个快速示例, 了解如何应用此函数｡ 

05:15.170 --> 05:19.070
假设我们把一只狗的图像放到我们的网络中｡ 

05:19.550 --> 05:24.410
犬的预测值为0｡  9而且这是在训练期间｡ 

05:24.410 --> 05:27.020
所以我们知道我们知道狗的标签｡ 

05:27.020 --> 05:29.320
因此预测值为0｡  9.

05:29.330 --> 05:32.180
猫的预测值为0｡  1.

05:32.180 --> 05:33.650
然后这里我们有标签｡ 

05:33.650 --> 05:37.700
所以我们知道这是一只狗, 因为这是训练, 一只狗, 零只猫｡ 

05:37.700 --> 05:42.410
在这种情况下, 您需要使用｡ 

05:43.330 --> 05:47.510
你应该把这些数字代入到交叉熵的公式中｡ 

05:47.530 --> 05:52.780
那么你是怎么做到的呢, 把左边的值放到变量里？

05:52.780 --> 05:58.870
在右边的对数下的那个, 右边的值会进入P, 所以记住哪个值在哪里很重要,

05:58.870 --> 06:03.940
因为如果你把它们弄错了,

06:03.940 --> 06:09.460
你不想从一个0值取对数, 或者从一个1取对数｡

06:09.460 --> 06:16.960
所以你只需要把它们插进去, 确保你把它们插到正确的地方, 然后你基本上把它们加起来｡

06:16.960 --> 06:19.390
这就是交叉记账的原理｡ 

06:19.390 --> 06:26.650
我们现在要看一个具体的例子, 一步一步地, 在真实的生活中应用这个函数｡

06:26.650 --> 06:30.220
这样交叉熵就更有意义了｡ 

06:30.220 --> 06:36.340
我在这篇教程中的目的不是让你们更熟悉交叉熵,

06:36.340 --> 06:48.190
因为它听起来很复杂, 没有双关语, 它可能像卷积神经网络一样, 听起来很复杂｡

06:48.190 --> 06:48.690
好吧, 我知道了

06:48.790 --> 06:50.740
很可怕, 但不是｡ 

06:50.740 --> 06:51.550
这才是重点.

06:51.550 --> 06:54.010
所以让我们继续应用它, 这样我们就知道它并不可怕｡ 

06:54.010 --> 06:56.290
这是神经网络

06:56.290 --> 07:01.510
这也解释了为什么我们要这么做, 为什么我们要研究不同的类函数｡ 

07:01.510 --> 07:06.280
神经网络一, 神经网络二,

07:06.280 --> 07:11.890
假设我们有两个神经网络, 然后我们传递一个狗的图像, 我们知道这是狗, 而不是猫｡

07:11.890 --> 07:16.840
然后我们有另一张猫的图片这次是一只动物｡ 

07:16.840 --> 07:17.830
是只猫, 不是狗｡ 

07:17.830 --> 07:23.590
这是一只看起来很奇怪的动物, 如果你仔细看的话, 它实际上是一只狗, 而不是猫｡

07:24.100 --> 07:26.280
所以我们想看看我们的神经网络是什么｡ 

07:26.470 --> 07:32.290
在第一种情况下, 神经网络会预测一只90%狗10%猫｡ 

07:32.290 --> 07:33.160
正确｡ 

07:33.160 --> 07:37.510
神经网络二号60%狗40%猫仍然正确｡ 

07:37.510 --> 07:39.040
更糟但正确｡ 

07:40.120 --> 07:46.810
第二个选项第一个神经网络10%猫狗90%猫正确｡ 

07:47.160 --> 07:51.010
你说的只是两只30%狗70%猫｡ 

07:51.280 --> 07:53.260
更糟, 但仍然正确｡ 

07:53.260 --> 07:58.930
最后, 神经网络一在图像中占三个神经网络一的40%｡ 

07:58.930 --> 08:08.020
狗60%猫不正确的神经网络数字二10%狗90%猫不正确和更糟｡ 

08:08.020 --> 08:15.430
所以这里的关键是, 即使两个网络在最后一个都错了, 通过所有三个图像, 神经网络,

08:15.430 --> 08:18.820
一个比神经网络二更好｡

08:18.820 --> 08:29.050
所以即使在最后一个例子中, 它给了狗40%的机会, 而神经网络只给予狗10%的机会｡

08:29.050 --> 08:34.990
因此, 与神经网络2相比, 神经网络1的整体表现更好｡ 

08:35.440 --> 08:42.730
现在, 我们将了解一下我们已经讨论过的用于衡量性能的函数｡

08:42.730 --> 08:44.770
让我们把这些放到一个表中｡ 

08:44.770 --> 08:46.180
这是第一个神经网络

08:46.630 --> 08:49.360
你有了行号, 这就是图像的编号｡ 

08:49.360 --> 08:53.830
第一张图, 和预测一样, 90%狗, 10%猫

08:53.830 --> 08:57.250
这些是帽子变量, 然后是实际值.

08:57.250 --> 08:57.430
是这样｡ 

08:57.430 --> 08:59.140
狗正确｡ 

08:59.140 --> 09:00.340
分类不正确｡ 

09:00.340 --> 09:07.630
二号图像也是一样三号图像也是一样二号神经网络也是一样

09:07.630 --> 09:12.010
所以在第一张图片中狗占60%, 猫占40%, 这就是它预测的｡ 

09:12.070 --> 09:14.440
正确答案是狗而不是猫等等｡ 

09:15.010 --> 09:17.950
现在让我们看看我们实际上会得到什么样的误差｡ 

09:17.950 --> 09:24.550
那么, 我们可以计算哪些误差来估计网络的性能并监控网络的性能｡ 

09:24.640 --> 09:33.940
有一种错误叫做分类错误, 基本上就是问, 你做对了吗？

09:33.940 --> 09:37.870
不管可能性有多大, 问题是你做对了还是没有做对？

09:37.870 --> 09:44.980
所以在这两种情况下, 对于两个神经网络, 他们每个人, 他们得到一个左右｡ 

09:44.980 --> 09:46.240
这是他们错了多少｡ 

09:46.240 --> 09:48.400
所以他们三分之一都错了｡ 

09:48.400 --> 09:54.940
因此, 神经网络1的错误率为33%, 神经网络2的错误率为33%｡ 

09:54.940 --> 09:59.080
所以从这个角度来看, 两个神经网络的表现基本上是一样的｡ 

09:59.080 --> 10:00.100
但我们知道那不是真的｡ 

10:00.100 --> 10:04.150
我们知道神经网络1的性能优于神经网络2｡ 

10:04.930 --> 10:13.690
这就是为什么分类误差不是一个很好的衡量标准, 特别是对于不同的反向传播均方误差而言｡

10:13.690 --> 10:16.720
顺便说一句, 我在Excel中做了这些计算｡ 

10:16.930 --> 10:18.340
我只是不想让你觉得无聊｡ 

10:18.340 --> 10:21.940
但你完全可以坐下来, 在纸上或Excel中做｡ 

10:21.940 --> 10:23.620
这些都是非常简单的计算｡ 

10:23.620 --> 10:32.800
基本上就是取误差平方和, 然后取观测值的平均值｡

10:32.800 --> 10:34.240
差不多就是这样了｡ 

10:34.840 --> 10:38.840
所以对于神经网络, 你得到25%｡ 

10:38.890 --> 10:42.530
对于神经网络, 2, 您得到71%

10:42.780 --> 10:43.260
错误率｡ 

10:43.260 --> 10:45.840
如你所见, 这个更准确｡ 

10:45.840 --> 10:52.890
它告诉我们神经网络1的错误率比神经网络2低得多, 然后又是交叉熵｡

10:52.890 --> 10:53.760
我们已经看过公式了｡ 

10:53.760 --> 10:54.900
你也可以这样算｡ 

10:54.900 --> 10:57.900
这实际上比均方误差更容易计算｡ 

10:57.900 --> 11:05.280
交叉误差交叉熵为神经网络1和1提供了38% 06用于神经网络二｡ 

11:05.280 --> 11:10.140
所以你可以看到, 当你这样看的时候, 结果有点不同｡ 

11:10.140 --> 11:19.950
当你看均方误差和交叉熵时, 为什么要用交叉熵来代替均方误差的问题,

11:19.950 --> 11:27.390
不仅仅是像它们吐出的数字那样｡

11:27.390 --> 11:32.430
这些计算只是为了告诉你这是所有可行的｡ 

11:32.430 --> 11:33.630
你可以写在纸上｡ 

11:33.630 --> 11:37.800
这不是这些不是很激烈的数学｡ 

11:37.800 --> 11:40.920
这些都是非常非常简单直接的事情｡ 

11:40.920 --> 11:46.140
但问题是, 为什么要用平均交叉熵来代替均方误差呢？

11:46.140 --> 11:48.150
这是一个非常非常好的问题｡ 

11:48.150 --> 11:49.200
我很高兴你问了｡ 

11:49.920 --> 12:01.320
这个问题的答案是交叉熵相对于均方误差有几个优势, 但这些优势并不明显｡

12:01.320 --> 12:07.080
我会提到几个, 然后我会告诉你在哪里可以找到更多｡ 

12:07.080 --> 12:16.830
其中之一是, 如果, 比如, 你在反向传播的最开始,

12:16.830 --> 12:22.110
你的输出值非常非常非常非常小｡

12:22.110 --> 12:25.470
所以它比你想要的实际值要小得多｡ 

12:25.470 --> 12:33.750
然后在最开始的时候, 梯度下降的梯度会非常非常低, 这是不够的｡

12:33.780 --> 12:40.470
神经网络很难真正开始做一些事情, 开始移动, 开始调整这些权重,

12:40.470 --> 12:44.910
并开始朝着正确的方向移动｡

12:44.910 --> 12:51.000
而当你使用交叉熵这样的东西时, 因为它包含了对数, 它实际上可以帮助网络评估哪怕是这样一个小错误,

12:51.270 --> 12:57.120
并采取措施｡

12:57.420 --> 12:58.410
下面是如何思考它｡ 

12:58.410 --> 13:03.180
所以让我们再说一遍, 这是非常直观的方法｡ 

13:03.180 --> 13:08.190
这将是一个与数学的联系, 你可以通过数学推导出这些东西的细节,

13:08.190 --> 13:10.980
但这是一个非常直观的方法｡

13:10.980 --> 13:17.520
假设你想要的结果是一｡ 

13:17.520 --> 13:23.070
而现在你是1的1/1000000, 对吧？

13:23.070 --> 13:24.900
一个0｡  000001.

13:25.020 --> 13:32.570
下一次你的结果从百万分之一提高到千分之一｡ 

13:32.580 --> 13:40.200
如果你计算平方误差, 你只需要把一个从另一个中减去, 或者基本上在每种情况下你都在计算平方误差,

13:40.200 --> 13:46.620
当你把一个情况和另一个情况比较时, 你会看到平方误差｡

13:46.620 --> 13:48.090
变化不大｡ 

13:48.150 --> 13:51.840
从均方误差来看, 网络并没有得到很大改善｡ 

13:51.840 --> 13:58.710
但是如果你看交叉熵, 因为你取对数,

13:58.710 --> 14:06.090
然后你比较两者除以另一个, 你会发现你实际上已经大大改善了你的网络,

14:06.090 --> 14:12.750
所以从百万分之一到千分之一的均方误差将非常低｡

14:12.750 --> 14:21.990
它将是无关紧要的, 它不会它不会引导你的梯度提升过程或你的反向传播在正确的方向｡

14:21.990 --> 14:26.640
它会它会引导它朝正确的方向前进, 但它会像一个非常缓慢的引导｡ 

14:26.640 --> 14:29.280
它没有足够的能量｡ 

14:29.490 --> 14:34.620
而如果你通过交叉熵来做, 交叉熵会明白, 哦,

14:34.620 --> 14:41.970
即使这些是非常小的调整, 从绝对意义上说, 只是做了一个微小的改变, 从相对意义上说, 这是一个巨大的进步,

14:41.970 --> 14:46.020
我们肯定在朝着正确的方向前进｡

14:46.020 --> 14:47.160
我们继续走吧｡ 

14:47.160 --> 14:56.040
所以交叉熵会帮助你的神经网络走向正确, 到达最优状态｡ 

14:56.760 --> 15:01.020
这是让神经网络达到最优状态的一种更好的方法｡ 

15:01.020 --> 15:08.160
但请记住, 这只在交叉熵仅是分类的首选方法时才起作用｡ 

15:08.160 --> 15:13.590
所以如果你在谈论回归, 就像我们在人工神经网络中所做的那样,

15:13.740 --> 15:17.280
那么你会更愿意相信我和平方误差｡

15:17.280 --> 15:23.610
而交叉熵更适合于分类, 这也是因为我们使用了软mac函数｡

15:23.610 --> 15:26.640
这是一种直观的解释｡ 

15:26.880 --> 15:29.280
这是一个学习更多相关知识的好地方｡ 

15:29.280 --> 15:34.440
如果你真的感兴趣, 为什么我们要用交叉熵和均方误差？

15:35.190 --> 15:42.150
Geoffrey欣顿的Google视频称之为软最大输出函数, 他解释了它｡ 

15:42.250 --> 15:42.850
很好, 我很好

15:42.850 --> 15:47.800
作为深度学习的教父, 谁能更好地解释它呢？

15:48.580 --> 15:51.610
顺便说一句, 杰弗里·欣顿的任何视频都是黄金｡ 

15:51.610 --> 15:54.220
他只是在解释问题上很有天赋｡ 

15:55.120 --> 15:58.540
总之, 这就是软最大值和交叉熵的关系｡ 

15:58.540 --> 16:03.100
我希望这能让你们对这里发生的事情有一个直观的理解,

16:03.100 --> 16:08.980
但更重要的是, 你们不会被交叉熵这个术语吓倒, 因为阿德隆会在实践教程中提到它｡

16:08.980 --> 16:11.020
我想确保你对此有所准备｡ 

16:11.020 --> 16:17.170
这只是计算损失函数的另一种方法, 也是优化网络的另一种方法,

16:17.170 --> 16:23.560
它是专门为分类问题量身定制的, 因此是卷积神经网络,

16:23.560 --> 16:27.730
它与软最大函数是相辅相成的｡

16:28.060 --> 16:36.370
如果你想了解交叉熵, 如果你对交叉熵更感兴趣的话, 我会给你一些补充阅读｡

16:36.400 --> 16:43.410
当然, 有一篇很好的文章值得一读, 叫做《交叉熵损失的友好介绍》, 作者是Rob de Pietro｡

16:44.110 --> 16:46.660
2016年这里是下面的链接.

16:47.020 --> 16:48.190
非常非常好｡ 

16:49.030 --> 16:50.410
非常柔软｡ 

16:50.440 --> 16:51.210
什么都没有？

16:51.220 --> 16:52.060
不, 不, 不, 不

16:52.060 --> 16:53.770
超级复杂的数学｡ 

16:54.130 --> 16:56.110
好的比喻就是好的例子｡ 

16:56.110 --> 17:01.120
用汽车的类比, 你看着汽车, 谈论信息, 比特和限制｡ 

17:01.900 --> 17:03.220
你会怎么编码呢？

17:03.220 --> 17:03.880
你会怎么编码？

17:03.890 --> 17:05.770
这是一篇值得一看的好文章｡ 

17:05.770 --> 17:08.800
我们给予你们一个很好的交叉熵的概述｡ 

17:09.580 --> 17:15.340
从入门的角度来看, 如果你想深入研究像这里所看到的那样繁重的数学, 那么请查看一篇文章或一篇博客, 作者是How to

17:15.820 --> 17:21.370
implement a Neural Network｡

17:21.370 --> 17:29.320
间奏曲, 所以间奏曲就像是, 一个中间的东西, 就像是一个间歇,

17:29.320 --> 17:36.100
就像当你去剧院的时候, 你在第一部分和第二部分之间有一个休息｡

17:36.100 --> 17:41.440
因为他要经历所有这些步骤, 然后他说, 哦, 我得先解释一下｡

17:42.250 --> 17:44.020
是的, 所以这就是为什么它被称为间奏｡ 

17:44.020 --> 17:46.000
据我所知, 没有其他原因｡ 

17:46.540 --> 17:50.650
这篇文章是由彼得罗林斯2016年以及｡ 

17:50.650 --> 17:52.270
所以这两个都是最近的事｡ 

17:52.270 --> 18:00.020
是的, 如果你想深入研究交叉熵背后的数学原理, 看看这个, 实际上在这篇文章中,

18:00.020 --> 18:02.370
在软最大值和交叉熵背后｡

18:02.680 --> 18:03.730
好了, 我们走吧｡ 

18:03.730 --> 18:07.210
这就是他们两个的全部｡ 

18:07.240 --> 18:12.670
希望我能够增加一些额外的清晰度和祝你好运｡ 

18:12.670 --> 18:16.870
这将是有趣的, 享受实用教程.

18:16.870 --> 18:17.950
下次再见

18:17.950 --> 18:19.840
在此之前, 请尽情享受深度学习｡