WEBVTT

00:00.700 --> 00:03.010
大家好, 欢迎回到课程和深度学习｡ 

00:03.010 --> 00:08.190
既然我们已经看到了神经网络的作用, 现在是时候了解它们是如何学习的了｡ 

00:08.200 --> 00:09.820
所以让我们直接进入它｡ 

00:10.270 --> 00:16.000
有两种根本不同的方法可以让程序做你想让它做的事情｡ 

00:16.030 --> 00:24.580
一种是硬编码, 你告诉程序具体的规则和你想要的结果, 你只是全程指导它,

00:24.580 --> 00:32.920
你解释程序必须处理的所有可能的选项｡

00:33.070 --> 00:37.300
另一方面, 你有神经网络, 你可以创建一个｡ 

00:38.700 --> 00:43.430
使程序能够理解它需要自己做什么的工具｡ 

00:43.440 --> 00:49.410
所以你基本上创建了这个神经网络, 你给它输入, 你告诉它你想要什么作为输出,

00:49.410 --> 00:52.980
然后你让它自己解决所有问题｡

00:53.310 --> 00:55.650
两种根本不同的方法｡ 

00:55.770 --> 01:00.450
这是我们在学习这些教程时要记住的｡ 

01:00.660 --> 01:05.910
我们的目标是创建这个网络, 然后它自己学习｡ 

01:05.920 --> 01:10.920
我们将避免试图把规则｡ 

01:10.920 --> 01:18.030
我现在可以给你们举一个很好的例子, 这在课程中会更进一步, 但这只是一个非常直观的例子｡

01:18.030 --> 01:23.660
例如, 你如何区分一只狗和一只猫, 左边有四只？

01:23.670 --> 01:30.480
在左边描述的方法中, 你可以对一些东西进行编程, 比如猫的耳朵必须是这样的｡

01:30.480 --> 01:34.080
注意胡须, 注意这种鼻子｡ 

01:34.080 --> 01:37.680
注意这种脸型｡ 

01:37.740 --> 01:38.790
注意这些颜色｡ 

01:38.790 --> 01:43.650
你可以描述所有这些东西, 你会有条件, 比如如果耳朵是尖的,

01:43.650 --> 01:48.960
那么猫, 如果耳朵是下垂的, 那么可能是狗, 等等｡

01:49.440 --> 01:54.690
另一方面, 对于一个神经网络,

01:54.690 --> 02:02.580
你只需要编码神经网络, 你编码架构, 然后你把神经网络指向一个文件夹, 里面有所有这些猫和狗的图片, 这些图片已经分类了｡

02:02.580 --> 02:04.530
你说出来, 好吧, 我抓住你了｡ 

02:04.530 --> 02:06.630
我有一些猫和狗的图像｡ 

02:06.660 --> 02:08.790
去学学什么是猫吧｡ 

02:08.790 --> 02:10.470
去学学什么是狗吧｡ 

02:10.470 --> 02:15.030
而神经网络会自己理解它需要理解的一切｡ 

02:15.030 --> 02:21.390
然后再往下, 一旦它被训练好了, 当你给予它一个新的猫或狗的形象时, 它就能理解它是什么｡

02:21.390 --> 02:23.070
所以他们在那里｡ 

02:23.100 --> 02:25.440
这是两种根本不同的方法｡ 

02:25.440 --> 02:30.920
今天我们将慢慢地开始了解第二种方法是如何工作的｡ 

02:30.930 --> 02:31.410
好吧, 我会的

02:31.410 --> 02:33.480
所以我们直接进入正题吧｡ 

02:33.480 --> 02:39.450
我们有一个非常基本的神经网络, 它有一层, 这叫做单层, 前馈神经网络,

02:39.450 --> 02:42.540
它也叫感知器｡

02:42.540 --> 02:47.910
现在, 在我们继续之前, 有一件事我们确实需要调整, 那就是现在的输出值,

02:47.910 --> 02:50.970
你可以看到, 这就是为什么我们需要在那里放一个y帽子｡

02:50.970 --> 02:56.400
原因通常是, Y代表实际值, 这就是我们要用到的｡ 

02:56.400 --> 02:59.910
所以Y是我们看到的实际值｡ 

02:59.910 --> 03:06.750
实际上, 输出值是算法的预测值, 通过神经网络, y

03:06.750 --> 03:09.150
hat是输出值｡

03:09.150 --> 03:11.460
基本上这就是产值的单位｡ 

03:11.460 --> 03:17.220
感知器是1957年由弗兰克·罗森布拉特发明的｡ 

03:17.220 --> 03:24.930
他的整个想法是创造一种可以学习和自我调整的东西｡ 

03:24.930 --> 03:27.780
这就是我们现在要看的｡ 

03:27.780 --> 03:30.150
所以我们有一个感知器｡ 

03:30.150 --> 03:31.830
让我们来看看感知器是如何学习的｡ 

03:31.830 --> 03:40.080
假设我们有一些输入值, 这些值被提供给感知器, 或者基本上是神经网络｡

03:40.080 --> 03:49.050
然后应用激活函数, 我们得到一个输出, 现在我们要在图表上绘制输出｡

03:49.050 --> 03:51.480
这就是我们的输出y hat｡ 

03:51.510 --> 03:57.030
现在我们需要做的是为了能够学习, 我们需要比较输出值和实际值,

03:57.030 --> 04:01.200
我们希望神经网络得到正确的｡

04:01.290 --> 04:04.320
这就是Y值｡ 

04:04.620 --> 04:07.710
所以如果我们在这里画出来, 你会发现有一点不同｡ 

04:08.100 --> 04:16.890
现在我们要计算一个函数, 成本函数是实际值和输出值的平方差的一半｡

04:16.920 --> 04:20.430
现在有很多方法可以得到一个代价函数｡ 

04:20.430 --> 04:23.040
您可以使用许多不同的成本函数｡ 

04:23.250 --> 04:30.480
这可能是最常用的类函数, 也是我们专门使用这个函数的原因｡

04:30.480 --> 04:34.200
当我们讨论梯度下降时, 我们会进一步了解.

04:34.200 --> 04:37.650
但现在我们要承认这是代价函数.

04:37.650 --> 04:44.040
基本上, 成本函数告诉我们的是, 在你的预测中, 误差是多少？

04:44.040 --> 04:51.480
我们的目标是最小化代价函数因为代价函数越小, y就越接近Y.

04:52.290 --> 04:54.360
只要我们达成一致, 我们就继续｡ 

04:54.360 --> 04:58.320
所以基本上从这里开始, 这就是我们的成本函数｡ 

04:58.320 --> 05:04.830
从这里开始, 我们要做的是, 一旦我们比较了,

05:04.980 --> 05:08.760
我们要把这些信息反馈回神经网络.

05:08.760 --> 05:09.630
好了, 我们走吧｡ 

05:09.630 --> 05:15.480
这些信息会返回到神经网络中, 然后传递到权重中, 权重会得到更新.

05:15.480 --> 05:20.820
基本上, 在这个非常简单的神经网络中,

05:20.820 --> 05:26.700
我们唯一能控制的就是权重wone, wtwo, 一直到wm, 我们的目标是最小化代价函数｡

05:26.700 --> 05:29.280
所以我们能做的就是更新权重｡ 

05:29.280 --> 05:37.800
所以我们更新了权重, 稍微调整了一下, 我们会找到的, 但是现在我们同意我们已经有了｡

05:37.970 --> 05:40.010
然后我们继续｡ 

05:40.010 --> 05:48.200
所以我在这里放了这个数据的截图, 只是为了说明一点, 在整个实验中,

05:48.200 --> 05:53.930
我们现在所做的一切, 都是在处理这一行｡

05:53.930 --> 06:01.970
所以我们要处理的是一个数据集, 例如, 我们要处理的是你学习了多长时间｡

06:01.970 --> 06:08.150
比如我们预测的变量是你在考试中会得到什么结果｡ 

06:08.150 --> 06:12.530
我们得到的因变量是你学习了多少小时？

06:12.530 --> 06:16.700
你睡了几个小时, 在学期中期的测验中你得到了什么？

06:16.700 --> 06:18.860
所以在学期中间有一个小测验｡ 

06:18.860 --> 06:19.820
你在那里得到了多少百分比？

06:19.820 --> 06:24.590
所以基于这些变量, 我们试图预测你的考试成绩｡ 

06:24.590 --> 06:27.950
在考试中, 93%, 这是实际值｡ 

06:27.950 --> 06:35.330
所以这就是为什么, 所以, 我们把这三个值, 第二次输入到神经网络中,

06:35.960 --> 06:38.900
然后我们把结果和Y进行比较｡

06:38.900 --> 06:40.220
让我们来看看它是如何工作的｡ 

06:40.490 --> 06:42.920
我们将这些值输入神经网络｡ 

06:43.670 --> 06:46.610
所有的东西都要调整, 重量也要调整｡ 

06:46.610 --> 06:50.090
如你所见, 这又是一次, 我们要输入值｡ 

06:50.090 --> 06:53.090
同样, 这里的重点是, 我们正在喂养这些相同的价值观｡ 

06:53.090 --> 06:54.410
所以我们只有一行｡ 

06:54.410 --> 06:56.330
我们在试着我们在一排训练｡ 

06:56.330 --> 06:59.390
这是因为这只是一个非常简单的基本示例｡ 

06:59.390 --> 07:01.520
然后我们会看到当有更多的行时会发生什么｡ 

07:01.520 --> 07:06.080
所以, 我们在成本函数中输入这些行, 得到调整｡ 

07:06.080 --> 07:10.430
正如你所看到的, 所有的事情都是沿着这些路线发生的｡ 

07:10.430 --> 07:15.320
正如你所看到的, 每次我们的白色帽子改变, 因为我们调整了重量, 我们的高头也改变了,

07:15.320 --> 07:17.500
我们的成本函数也改变了｡

07:17.540 --> 07:18.290
让我们再看看｡ 

07:18.290 --> 07:22.670
所以我们养活那些戴白色的人是在变, 成本函数也是在变｡ 

07:22.670 --> 07:26.960
我们将信息反馈给权重, 以便再次调整权重｡ 

07:26.960 --> 07:32.300
我们每次都输入相同的值, 每次都调整好, 然后回到权重,

07:32.300 --> 07:36.590
再输入一次, 再输入一次｡

07:36.590 --> 07:41.300
所以我们调整了权重, 调整了权重, 我们输入了信息, 然后就这样｡ 

07:41.300 --> 07:45.770
所以这一次y等于函数0｡ 

07:45.770 --> 07:48.350
通常我们不会得到等于零的代价函数｡ 

07:48.350 --> 07:50.120
但这是一个非常简单的例子｡ 

07:50.630 --> 07:57.410
所以希望每次我们输入同一行的时候, 所有这些都是有意义的, 因为在这个例子中,

07:57.410 --> 08:01.220
我们只是在处理神经网络中的一行｡

08:01.670 --> 08:06.920
然后权重得到, 值乘以激活函数的应用方式｡ 

08:06.920 --> 08:09.740
我们得到y hat y hat和y相比｡ 

08:10.130 --> 08:12.230
然后我们看到成本函数是如何变化的｡ 

08:12.230 --> 08:17.900
反馈将这些信息反馈回神经网络, 然后再次调整权重,

08:17.900 --> 08:21.230
然后我们对同一行重复相同的过程｡

08:21.410 --> 08:23.180
我们试图最小化这个代价函数｡ 

08:23.180 --> 08:26.750
所以到目前为止, 我们只处理了这一行｡ 

08:26.780 --> 08:29.360
让我们看看当您有多行时会发生什么｡ 

08:29.360 --> 08:31.220
这是完整的数据集｡ 

08:31.220 --> 08:39.140
我们有八行你睡了多少小时, 或者也许这些是不同的学生在参加同一个考试｡

08:39.140 --> 08:44.000
他们还学习了多少小时, 考试前睡了多少小时, 他们在测验中得到了什么,

08:44.000 --> 08:47.210
以及他们的最终成绩｡

08:47.210 --> 08:51.830
就像你在左边看到的, 我有八个这样的认知｡ 

08:51.830 --> 08:54.680
实际上, 它们都是同一个感知器｡ 

08:54.680 --> 08:55.940
所以这一点也很重要｡ 

08:55.940 --> 09:04.220
我只是把它乘以八次, 这样我们就能从概念上理解了｡ 

09:04.220 --> 09:06.680
但这里重要的是相同的神经网络｡ 

09:06.680 --> 09:10.310
我们将把这些输入同一个神经网络｡ 

09:10.310 --> 09:10.940
所以我们走吧｡ 

09:10.940 --> 09:11.570
我们开始吧

09:11.570 --> 09:20.480
你们会听到, 艾伦提到的一个时期是, 我们遍历整个数据集,

09:20.480 --> 09:26.240
在所有这些行上训练神经网络｡

09:26.240 --> 09:26.780
所以我们走吧｡ 

09:26.780 --> 09:27.350
我们开始吧

09:27.350 --> 09:31.400
这是我们的第一排, 这是第一排的y帽子.

09:32.390 --> 09:33.590
还有第二排｡ 

09:33.620 --> 09:35.150
第二排有个白色帽子｡ 

09:35.150 --> 09:39.260
所以, 每次都被输入到同一个神经网络中｡ 

09:39.260 --> 09:44.000
我只是复制了几次, 这样我们就可以直观地看到这是如何发生的｡ 

09:44.890 --> 09:47.670
然后, 又一次, 它再次发生｡ 

09:47.680 --> 09:48.850
那是第三排

09:48.850 --> 09:49.990
第四排｡ 

09:50.470 --> 09:52.960
这是第四排的白色, 以此类推｡ 

09:52.960 --> 09:56.530
基本上, 我们也会为其余四行获得相同的值｡ 

09:56.530 --> 10:02.620
所以每次我们把一行输入到神经网络中, 我们就得到一个值｡ 

10:03.550 --> 10:06.880
然后与实际值进行比较｡ 

10:06.880 --> 10:08.470
所以它们是实际值｡ 

10:08.470 --> 10:11.230
因此, 对于每一行, 我们都有一个实际值｡ 

10:11.350 --> 10:18.220
现在基于所有这些白色和y之间的差值,

10:18.220 --> 10:27.280
我们可以计算出成本函数, 它是白帽和y之间所有差值的平方和, 所有这些都减半了｡

10:27.940 --> 10:29.740
这是我们的成本函数｡ 

10:30.070 --> 10:36.880
基本上, 在我们得到完整的成本函数后, 我们会返回并更新权重, 我们更新aw1, w2,

10:36.880 --> 10:39.430
w3｡

10:39.430 --> 10:47.260
这里要记住的重要一点是, 所有这些感知器, 所有这些神经网络实际上是一个神经网络｡

10:47.260 --> 10:48.250
所以他们不是八个人｡ 

10:48.250 --> 10:49.240
只有一个｡ 

10:49.360 --> 10:54.430
当我们更新权重时, 我们会更新这个神经网络中的权重｡ 

10:54.430 --> 10:57.640
所以基本上, 所有行的权重都是一样的｡ 

10:57.640 --> 11:00.430
所以不是每一行都有自己的权重｡ 

11:00.430 --> 11:02.650
现在, 所有行共享权重｡ 

11:02.650 --> 11:11.860
这就是为什么我们研究了成本函数, 它是差值的平方和, 然后我们更新了权重｡

11:11.860 --> 11:15.190
从现在开始, 这只是一次迭代｡ 

11:15.190 --> 11:18.940
接下来, 我们将再次运行整个过程｡ 

11:18.940 --> 11:26.290
我们要把每一行都输入到神经网络中, 找出我们的成本函数, 然后再做一次｡

11:26.290 --> 11:33.520
就像我们之前看到的, 我们只有一行, 我们一遍又一遍地做着同样的事情｡

11:33.520 --> 11:37.510
但现在我们要做8行､ 800行或8000行｡ 

11:37.510 --> 11:43.510
无论数据集中有多少行, 都要执行此过程, 然后计算成本函数｡ 

11:44.020 --> 11:54.280
这里的目标是最小化代价函数, 一旦找到代价函数的最小值, 就得到最终的神经网络｡

11:54.280 --> 12:10.720
这意味着您的权重已经调整, 并且您已经找到了用于训练的数据集的最佳权重, 您可以进入测试阶段或应用阶段｡

12:11.320 --> 12:14.620
这整个过程被称为反向传播｡ 

12:14.710 --> 12:20.380
你可能还想阅读一些关于成本函数的内容｡ 

12:20.380 --> 12:24.790
我知道我们刚刚谈到了一个, 他们是许多不同的｡ 

12:24.790 --> 12:28.420
良好的文章位于交叉验证｡ 

12:28.660 --> 12:32.830
它被称为成本函数列表, 用于神经网络和应用程序｡ 

12:32.830 --> 12:41.950
URL就在那里, 但你可以在谷歌上搜索那个确切的搜索词或搜索短语, 你会看到这个将是第一个弹出的｡

12:41.950 --> 12:48.340
它实际上有一些很好的例子和应用程序或不同成本函数的用例｡ 

12:48.340 --> 12:51.520
因此, 如果您有兴趣了解更多关于成本函数的信息, 请查看这篇文章｡ 

12:51.700 --> 12:54.310
在这一点上, 我希望你喜欢今天的教程｡ 

12:54.310 --> 12:55.930
我期待着下次见到你｡ 

12:55.930 --> 12:58.150
在此之前, 请尽情享受深度学习｡