WEBVTT

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

00:02.730 --> 00:06.060
今天我们终于到了第四步, 完全连接｡ 

00:06.060 --> 00:08.110
那么, 这一步到底是怎么回事呢？

00:08.130 --> 00:16.920
在这一步中, 我们在卷积神经网络中加入了一个完整的人工神经网络｡ 

00:16.920 --> 00:24.780
因此, 除了我们目前所做的卷积池化和平坦化之外, 现在我们将添加一个全新的｡

00:24.810 --> 00:28.920
在这背后, 有多激烈？

00:28.920 --> 00:32.310
这就是这就是这就是这绝对是一件事｡ 

00:32.310 --> 00:37.140
这里有输入层, 还有一个完全连接的LAN输出层｡ 

00:37.140 --> 00:42.960
顺便说一下, 人工神经网络中的全连接层, 我们过去称之为隐藏层,

00:42.960 --> 00:47.280
现在我们称之为全连接层, 因为它们是隐藏层｡

00:47.280 --> 00:54.060
但与此同时, 它们是一种更特殊的隐藏层, 是人工神经网络中的全连接层｡

00:55.440 --> 00:59.910
隐藏层不需要完全连接,

00:59.910 --> 01:05.400
而在卷积神经网络中, 我们将使用完全连接的层, 这就是为什么它们通常被称为完全连接的层｡

01:05.490 --> 01:12.570
因此, 基本上, 在平面化之后, 我们得到的输出的整个列或向量, 我们将其传递到输入层｡

01:12.570 --> 01:20.310
这里我们有一个非常简单的例子, 只是为了说明的目的,

01:20.310 --> 01:28.890
人工神经网络的主要目的是, 将我们的特征组合成更多的属性, 从而更好地预测类别｡

01:28.890 --> 01:37.800
因此, 我们已经在输出向量中使用了平坦度和平坦化结果｡

01:37.800 --> 01:44.010
我们有一些特征编码在向量中的数字中,

01:44.010 --> 01:53.640
它们可能已经很好地预测了我们所看到的是什么样的动物, 是狗还是猫, 是肿瘤还是非肿瘤, 等等｡

01:53.640 --> 01:59.310
但与此同时,

01:59.310 --> 02:07.290
我们知道我们有一个叫做人工神经网络的结构, 它是专门设计的, 它的目的是处理属性,

02:07.290 --> 02:16.620
处理特征, 提出新的属性, 并将属性组合在一起, 以更好地预测我们试图预测的事情｡

02:16.620 --> 02:18.600
我们从上一部分就知道了｡ 

02:18.600 --> 02:20.160
为什么不利用这一点呢？

02:20.160 --> 02:22.590
这就是我们的计划

02:22.590 --> 02:30.180
那么, 我们把这些值传递给一个人工神经网络, 让它进一步优化我们正在做的一切, 怎么样？

02:30.390 --> 02:31.800
这就是我们要做的｡ 

02:31.800 --> 02:36.300
但让我们看一个更现实的例子, 因为这个例子有点太简单了｡ 

02:36.300 --> 02:43.920
这里我们有一个更好的人工神经网络, 我们有五个输入属性｡ 

02:43.920 --> 02:50.970
第一层有六个神经元, 第二层有八个神经元, 然后我们有两个输出, 一个给狗,

02:50.970 --> 02:55.320
一个给猫.

02:55.320 --> 03:02.130
因此, 我们在这里要讨论的一个重要问题是, 为什么我们有两个输出？

03:02.130 --> 03:06.810
我们已经习惯了在人工神经网络中只有一个输出｡ 

03:06.810 --> 03:15.390
一个输出是当你预测一个数值时, 当你运行一个回归类的问题时｡

03:15.510 --> 03:22.680
但是当你进行分类的时候, 你需要每个类的输出, 例外的是当你只有两个类的时候, 比如我们这里有两个类,

03:22.680 --> 03:27.180
狗和猫, 我们可以只做一个输出,

03:27.180 --> 03:32.280
把它变成二进制输出, 说一是狗, 零是猫｡

03:32.280 --> 03:33.990
那样的话, 效果会很好的

03:33.990 --> 03:39.150
实际上, 你们会在实践教程中看到如何去做, 这就是它们的结构｡

03:39.150 --> 03:45.720
但同时, 如果你有两个以上的类别, 例如, 狗,

03:45.720 --> 03:49.410
猫和鸟, 那么你必须为每个类别都有一个神经元｡

03:49.410 --> 03:54.660
这就是为什么我们要在这个例子中用两个类别来练习, 这样我们就知道如果我们有两个以上的类别,

03:54.660 --> 03:57.780
会发生什么｡

03:58.380 --> 03:59.940
那么接下来会发生什么呢？

03:59.940 --> 04:04.590
所以我们已经做了所有的基础工作,

04:04.590 --> 04:09.480
我们已经做了卷积, 我们已经做了合并和平坦化, 现在信息将通过人工神经网络｡

04:09.480 --> 04:11.970
让我们来看看这一切是如何发生的｡ 

04:12.030 --> 04:18.160
信息从一开始就经过了处理, 从图像被处理的那一刻起, 然后可以涉及,

04:18.160 --> 04:24.420
然后汇集, 展平, 然后通过人工神经网络, 所有四个步骤｡

04:24.960 --> 04:29.580
然后进行预测, 我们马上就会看到这是如何发生的｡ 

04:29.580 --> 04:30.660
会非常非常有趣的｡ 

04:30.660 --> 04:32.820
但现在, 我们只能说是做出了预测｡ 

04:32.820 --> 04:40.470
比如说, 80%的人认为它是狗,

04:40.470 --> 04:51.240
但结果它是猫, 然后计算出一个误差, 这就是我们过去在人工神经网络中所称的成本函数, 我们在这里或卷积神经网络中使用的均方误差｡

04:51.240 --> 04:59.820
这叫做损失函数, 我们用交叉熵函数来表示, 我们会讨论交叉熵和均方误差｡

04:59.990 --> 05:02.660
在一个单独的教程中, 以及所有这些是如何发生的｡ 

05:02.660 --> 05:08.240
但现在, 我们只假设我们有一个丢失的函数, 它告诉我们网络的性能如何,

05:08.240 --> 05:13.460
我们正在尝试优化, 优化它或最小化该函数来优化我们的网络｡

05:13.460 --> 05:21.500
所以我们计算误差, 然后通过网络反向传播, 就像我们在人工神经网络中反向传播一样｡

05:21.500 --> 05:27.800
并且在网络中调整了一些东西以帮助优化性能｡ 

05:27.800 --> 05:31.880
调整的是人工神经网络部分的权重｡ 

05:31.880 --> 05:34.790
所以你在这里看到的蓝线, 是突触｡ 

05:35.120 --> 05:41.570
另外一个需要调整的是特征检测器｡ 

05:41.570 --> 05:46.070
所以我们知道我们在寻找特征, 但是如果我们寻找的是错误的特征呢？

05:46.070 --> 05:47.960
如果这不成怎么办？

05:47.960 --> 05:49.370
因为特征不正确｡ 

05:49.370 --> 05:55.940
所以特征检测器, 那些记住我们的小矩阵, 即3

05:55.940 --> 06:03.800
× 3矩阵, 它们被调整, 这样也许下次会更好, 让我们看看会发生什么｡

06:03.800 --> 06:11.000
当然, 这一切都是在大量的科学知识和大量的数学知识的背景下完成的, 这一切都是通过梯度,

06:11.000 --> 06:14.480
梯度下降和反向传播完成的｡

06:14.480 --> 06:17.870
所以这一切不仅仅是随机扰动｡ 

06:17.870 --> 06:20.780
它实际上是经过深思熟虑的｡ 

06:20.990 --> 06:28.460
但尽管如此, 特征检测器被调整, 权重被调整, 整个过程再次发生｡

06:28.550 --> 06:32.540
然后, 误差又会传播回来, 这种情况一直持续下去｡ 

06:32.540 --> 06:35.060
我们的网络就是这样优化的｡ 

06:35.060 --> 06:37.850
我们的网络就是这样训练数据的｡ 

06:37.850 --> 06:42.200
因此, 这里最重要的是, 数据从最开始到最后经过整个网络,

06:42.200 --> 06:45.950
然后比较误差｡

06:47.180 --> 06:49.880
因此, 计算误差, 然后将其反向传播｡ 

06:49.880 --> 06:57.800
和人工神经网络的情况一样, 只是时间稍长一点, 因为我们已经完成了前三步｡

06:58.820 --> 07:02.450
现在让我们来看看有趣的部分, 真正有趣的部分｡ 

07:02.450 --> 07:04.760
这两个类是如何工作的？

07:04.760 --> 07:07.070
这两个输出神经元是如何工作的？

07:07.070 --> 07:10.400
因为以前我们总是有一个输出神经元｡ 

07:10.400 --> 07:11.750
如果我们有两个呢？

07:11.750 --> 07:17.420
这是怎么样的这种情况下的图像分类发挥出来？

07:17.420 --> 07:19.460
好吧, 让我们先从最上面的神经元开始｡ 

07:19.460 --> 07:21.350
我们先从狗开始｡ 

07:21.890 --> 07:28.850
我们的主要目的是, 我们首先要做的是, 我们需要了解,

07:28.850 --> 07:37.760
这些连接到狗的突触, 应该分配什么样的权重, 这样我们就能知道, 之前的神经元中, 哪些对狗来说是重要的｡

07:37.760 --> 07:38.840
让我们看看这是怎么做到的｡ 

07:38.840 --> 07:47.870
假设, 我们在上一层得到了这些数, 上一层是全连通的, 最后的全连通层｡

07:47.870 --> 07:50.900
同样, 这些数字可以是任何数字｡ 

07:50.900 --> 07:53.780
它们不一定是任何数字｡ 

07:53.780 --> 08:01.730
但为了便于讨论, 我们会同意, 我们特别关注的是0和1之间的数字｡

08:02.210 --> 08:05.090
所以对我们来说, 争论这些事情和理解这些事情更容易｡ 

08:05.450 --> 08:11.360
其中一个意味着那个神经元非常自信地发现了某个特征｡ 

08:11.360 --> 08:15.980
而零就意味着神经元没有找到要寻找的特征｡ 

08:15.980 --> 08:25.280
因为在一天结束的时候, 这些神经元就像左边的其他东西一样, 只是在看一张图像的特征｡

08:25.280 --> 08:31.970
这已经是非常, 非常处理, 但它仍然是检测图像上的某个特征或特征组合｡

08:31.970 --> 08:36.860
就在我们进入控制步骤之前, 我们在泳池步骤中有一些可识别的特征｡ 

08:36.860 --> 08:42.410
它们变得不那么容易辨认, 然后在平面化的图像中变得更不容易辨认, 然后它们被组合起来, 等等｡

08:42.410 --> 08:48.650
但不管怎样, 我们在这里讨论的, 是呈现图像的某些特征或它们的组合｡

08:48.650 --> 08:54.440
所以一个被暂停的信号, 这很重要, 被同时传递给狗和猫,

08:54.440 --> 08:56.900
传递给两个输出神经元

08:56.900 --> 09:05.030
所以一个意思是, 对于我们来说, 对于我们的论点来说, 它意味着这个神经元正在被激发｡ 

09:05.030 --> 09:08.360
它能快速地检测到这个特征｡ 

09:08.360 --> 09:10.100
可能是眉毛｡ 

09:10.100 --> 09:15.080
它可能是在检测这个眉毛, 为了简单起见, 它是在检测这个眉毛｡ 

09:15.080 --> 09:17.300
它将这些信息传递给狗的神经元｡ 

09:17.330 --> 09:20.270
对猫的神经元说, 我能看到我的眉毛, 我能看到我的眉毛｡ 

09:20.270 --> 09:25.100
然后就由猫和狗的神经元来理解这对它们意味着什么｡ 

09:25.100 --> 09:25.640
好吧, 我知道了

09:25.640 --> 09:28.370
那么在这个例子中, 哪些神经元被激活了？

09:28.370 --> 09:30.530
这三个神经元在眉毛上放电｡ 

09:30.530 --> 09:36.020
比如说鼻子在说, 我能看到我能看到大鼻子, 我能看到耷拉的耳朵.

09:36.020 --> 09:40.460
所以它对狗和猫说了这些话, 然后又对狗说了什么｡ 

09:40.460 --> 09:43.280
然后我们知道这是一只狗｡ 

09:43.280 --> 09:49.880
所以狗的神经元知道答案是它实际上是一只狗, 因为在最后, 我们将它与图片或图片上的标签进行比较,

09:49.880 --> 09:53.570
它就知道这只狗了｡

09:53.570 --> 09:58.610
所以基本上狗的神经元会说, 啊哈, 所以在这个例子中我应该被触发｡ 

09:58.610 --> 09:59.540
所以这些都是｡ 

09:59.650 --> 10:00.370
我的神经

10:00.370 --> 10:06.190
他们告诉我, 他们发送给我, 狗和猫的信号, 实际上是在暗示我,

10:06.190 --> 10:08.920
这是一只狗｡

10:08.920 --> 10:13.540
在这些大量的迭代中,

10:13.540 --> 10:19.450
如果这种情况发生很多次, 狗会知道当这个特征属于狗的时候, 这些神经元确实会被激活｡

10:19.480 --> 10:24.100
另一方面, 猫的神经元会知道它不是猫, 它会知道这个特征被激活了, 这个神经元告诉我,

10:24.100 --> 10:28.480
它能看到下垂的耳朵, 下垂的耳朵, 下垂的耳朵,

10:28.480 --> 10:30.970
但同时它也不是猫｡

10:30.970 --> 10:35.740
所以基本上对我来说这是一个信号, 我应该忽略这个神经元｡ 

10:35.740 --> 10:41.440
这种情况发生得越多, 猫的神经元就越会忽略这个关于耷拉耳朵的神经元｡

10:42.160 --> 10:49.000
基本上这就是如何通过大量的迭代, 如果这种情况经常发生｡ 

10:49.000 --> 10:50.020
这只是一个例子｡ 

10:50.020 --> 10:54.370
但如果这种情况经常发生, 也许是1, 也许是0｡  八比零｡  9､ 也许有时候它不会开火｡ 

10:54.370 --> 10:59.410
但总的来说, 平均来说, 这个神经元是非常频繁地发光｡ 

10:59.410 --> 11:05.830
当它确实是一只狗时, 狗的神经元将开始赋予这个神经元更高的重要性｡ 

11:05.830 --> 11:06.520
所以我们开始了｡ 

11:06.520 --> 11:08.290
这就是我们要表达的意思｡ 

11:08.320 --> 11:14.200
我们会说这三个神经元, 通过这个迭代过程, 用很多很多的样本和很多很多的纪元,

11:14.200 --> 11:16.810
记住｡

11:16.810 --> 11:23.170
所以样本是数据集中的一行, 而时期是你一遍又一遍地检查整个数据集的时候｡

11:23.170 --> 11:25.000
有很多很多的迭代｡ 

11:25.000 --> 11:34.090
这个狗的神经元学习到这个眉毛神经元,

11:34.090 --> 11:43.690
这个大鼻子神经元, 还有这个耷拉耳朵神经元, 它们似乎都很好地帮助了它对狗的分类.

11:44.320 --> 11:45.520
原来如此｡ 

11:45.520 --> 11:55.060
再一次, 这些耳朵, 鼻子和眉毛, 这些都是非常, 非常近似或者非常牵强的例子,

11:55.060 --> 12:03.490
因为到了这个阶段, 在整个卷积神经网络中, 它们完全无法识别, 它们在寻找什么｡

12:03.490 --> 12:08.890
但与此同时, 它也是狗或猫或任何你正在分类的东西的特征｡ 

12:09.190 --> 12:11.140
然后让我们继续下一个｡ 

12:11.140 --> 12:17.830
现在我们来看看猫的神经元, 但是我们要记住这些权重是我们已经把狗的分类出来的｡

12:17.830 --> 12:21.130
所以狗几乎忽略了其他神经元｡ 

12:21.130 --> 12:22.570
一, 二, 三, 四, 五｡ 

12:22.570 --> 12:26.140
但它真正关注的是这三个神经元在说什么｡ 

12:26.290 --> 12:28.240
现在, 猫在听什么呢？

12:28.240 --> 12:31.480
好吧, 只要它实际上是一只猫, 对｡ 

12:32.500 --> 12:35.500
这是一个实际上是一只猫的例子｡ 

12:35.500 --> 12:42.460
所以你会看到这三个神经元, 0｡  九比零｡  9和1, 他们在说什么｡ 

12:42.460 --> 12:44.530
他们在对猫和狗说些什么｡ 

12:44.530 --> 12:45.730
这一点同样需要记住｡ 

12:45.730 --> 12:48.520
因此, 该输出信号双向传输｡ 

12:48.520 --> 12:49.450
这是一样的, 对吗？

12:49.450 --> 12:54.190
它对狗说的话就是对猫说的话,

12:54.190 --> 13:00.070
但接下来要由狗和猫来决定是否考虑这个信号, 并从中学习｡

13:00.280 --> 13:04.000
而狗和猫都能看出这是一张照片｡ 

13:04.030 --> 13:07.000
我应该在这里放一张猫的照片, 但基本上想象一张猫的照片｡ 

13:07.000 --> 13:09.910
狗和猫都能看出这实际上是一只猫｡ 

13:09.910 --> 13:18.970
所以基本上狗就像, 哦, 好吧, 所以这些胡须和这些尖尖的三角形耳朵和这个小尺寸, 我猜,

13:18.970 --> 13:26.320
或者哦, 也许这些类型, 你知道猫的眼睛里有这些东西吗？

13:26.320 --> 13:28.240
他们的眼睛都像小东西｡ 

13:28.240 --> 13:32.110
它们不是圆圈, 它们的线条或类似的东西｡ 

13:32.110 --> 13:33.280
就像猫的眼睛｡ 

13:33.280 --> 13:37.390
基本上, 这双猫眼, 绝对不适合我｡ 

13:37.390 --> 13:43.990
它们并没有帮助我做出预测, 因为每次这些神经元亮起的时候, 预测都不是我想要的｡

13:44.020 --> 13:46.810
另一方面, 猫会说, 嗯, 这很有趣｡ 

13:46.810 --> 13:51.430
每次这个灯亮起来, 它或大多数时候它都亮起来｡ 

13:51.430 --> 13:53.800
它符合我的期望｡ 

13:53.800 --> 13:55.210
和我想找的一样｡ 

13:55.240 --> 13:55.540
好吧, 我会的

13:55.540 --> 13:57.970
我要多听这个人的话｡ 

13:57.970 --> 13:58.870
这个也一样｡ 

13:58.870 --> 14:01.840
每次它亮起或大部分时间它亮起｡ 

14:02.620 --> 14:09.040
我碰巧得到了一个好的我碰巧因为我的预测而得到了奖励, 因为我做对了｡ 

14:09.040 --> 14:09.670
是只猫｡ 

14:09.670 --> 14:11.230
好吧, 我会多听他的｡ 

14:11.230 --> 14:16.060
你知道, 这个人对我没用, 因为他不像他｡ 

14:17.020 --> 14:17.980
他都没点烟｡ 

14:17.980 --> 14:19.870
是只猫, 但它没有点烟｡ 

14:19.870 --> 14:20.950
因此, 情况正好相反｡ 

14:20.950 --> 14:22.000
还有这个｡ 

14:22.000 --> 14:23.410
是只猫, 但它没有点烟｡ 

14:23.410 --> 14:24.340
所以我不打算听他的｡ 

14:24.340 --> 14:27.520
可是这一次, 他当这是什么？

14:27.520 --> 14:27.940
的眼睛｡ 

14:27.940 --> 14:29.350
猫的眼睛亮起来｡ 

14:29.590 --> 14:31.780
我们可以看到我可以看到它是一只猫｡ 

14:31.780 --> 14:33.220
大多数时候都是匹配的｡ 

14:33.220 --> 14:38.650
所以我会从中学习, 我会经常听这三个家伙的话｡ 

14:38.650 --> 14:42.940
所以基本上猫只听这三个而忽略了其他五个｡ 

14:42.940 --> 14:53.620
这就是这些最后的神经元如何学习在最后的, 完全连接的层中的哪些神经元要听｡

14:53.620 --> 14:58.330
因此输出神经元学习哪一个完全连接或哪一个最终完全连接｡ 

14:58.640 --> 14:59.990
他们的神经元听｡ 

14:59.990 --> 15:02.360
他们就是这样理解的｡ 

15:02.720 --> 15:08.720
基本上, 这就是特征如何通过网络传播并传递到输出｡ 

15:08.720 --> 15:13.820
所以尽管这些特征, 当然,

15:13.820 --> 15:21.770
对他们来说没有太多的意义, 比如松软的耳朵或者胡须, 但同时, 它们也有一些与众不同的地方它们是这个特定类别的与众不同的特征.

15:21.770 --> 15:26.810
这就是网络的训练方式, 因为我们在记忆过程中, 在反向传播过程中,

15:26.810 --> 15:29.660
我们也调整了特征检测器｡

15:29.660 --> 15:36.410
所以如果一个特性对输出无用, 它可能会被忽略, 因为这不会发生在一两天内,

15:36.410 --> 15:40.790
它只会发生在成千上万的迭代中｡

15:40.790 --> 15:47.120
所以随着时间的推移, 对网络无用的功能将被忽略, 并被有用的功能所取代｡

15:47.120 --> 15:53.510
所以在一天结束的时候, 在这最后一层神经元中,

15:53.510 --> 16:00.620
你很可能会有很多特征或者特征的组合, 这些特征来自于图像, 它们确实是狗和猫的代表或者描述｡

16:01.460 --> 16:06.560
所以一旦你的网络被训练好了, 这就是它的应用方式｡ 

16:06.560 --> 16:08.540
所以这是下一步, 就像我们已经训练过了一样｡ 

16:08.540 --> 16:12.950
让我们来看看应用这个网络后会发生什么｡ 

16:12.950 --> 16:15.170
假设我们传递了一个狗的图像｡ 

16:16.280 --> 16:20.300
这些值通过网络传播, 我们得到了特定的值｡ 

16:20.300 --> 16:24.860
所以这一次狗和猫的神经元不知道｡ 

16:24.860 --> 16:26.660
这里没有狗的形象｡ 

16:26.660 --> 16:28.370
他们不知道那是狗还是猫｡ 

16:28.370 --> 16:35.570
他们不知道这是什么, 但他们已经学会了倾听这里正在展示的东西, 对吗？

16:35.570 --> 16:40.670
他们已经学会了听狗的神经元, 听这三个神经元, 猫的神经元听这三个｡

16:40.670 --> 16:44.690
所以狗的神经元看到1到3, 就会说, 啊哈, 这些都很高｡ 

16:44.690 --> 16:47.570
所以我认为它是狗的概率很高｡ 

16:47.600 --> 16:53.450
猫的神经元看着这三个, 然后说, 好吧, 这个, 这个很高, 但是这个很低｡

16:53.450 --> 16:54.230
有意思｡ 

16:54.230 --> 16:56.870
所以我的概率是0｡  05.

16:56.870 --> 17:00.020
然后, 然后, 这就是你得到你的预测的地方｡ 

17:00.020 --> 17:05.600
所以你的第一选择是狗, 第二选择是猫｡ 

17:05.600 --> 17:06.830
差不多就是这样了｡ 

17:06.830 --> 17:08.030
所以答案是狗｡ 

17:08.150 --> 17:14.780
当你传递一张猫的图片时, 同样的事情也会发生, 你会得到新的值, 你可以看到, 尽管这个值很高,

17:14.780 --> 17:16.520
这些值很低｡

17:16.520 --> 17:20.450
对于猫来说, 这个高一些, 这个高一些, 这个低一些｡ 

17:20.450 --> 17:23.870
所以这里的概率可能没有之前那么大｡ 

17:23.870 --> 17:26.720
但你仍然可以看到它是一只79%的猫｡ 

17:26.720 --> 17:30.080
所以神经网络会投票决定它是一只猫｡ 

17:30.080 --> 17:33.140
所以基本上所有的神经网络都会断定它是猫｡ 

17:33.140 --> 17:36.230
投票是一个术语, 是用于这些家伙｡ 

17:36.230 --> 17:42.650
所以这些神经元在最后一个完全连接的层, 它们可以投票, 这些是它们的选票｡ 

17:42.650 --> 17:47.120
同样, 我们只是为了论证起见, 在这里把值放在0和1之间｡ 

17:47.120 --> 17:54.410
这些可以是任何值, 但是他们要投票, 然后这些权重就是他们投票的重要性｡

17:54.410 --> 18:00.470
所以这是这些紫色的权重是狗的神经元如何看待他们的投票｡ 

18:00.470 --> 18:04.730
它赋予这些神经元和这些选票的重要性有多大？

18:04.730 --> 18:12.650
这是猫神经元赋予这些投票的重要性｡ 

18:12.650 --> 18:16.580
所以这些神经元会根据它们学习到的权重来投票给狗和猫｡ 

18:16.580 --> 18:20.840
他们决定听谁的, 然后他们作出预测, 然后举行｡ 

18:20.840 --> 18:24.350
神经网络得出结论, 在这种情况下, 这是一只猫｡ 

18:24.350 --> 18:26.870
这就是你的结论｡ 

18:26.870 --> 18:36.740
这就是你如何得到这样的图像, 你有一个猎豹, 然后你有一个猎豹类像一个高, 高概率｡

18:36.740 --> 18:39.830
这就是网络预测的概率｡ 

18:39.830 --> 18:43.880
这些都是低点, 但它们仍然存在, 因为它们仍然是一种很小的机会｡ 

18:43.880 --> 18:49.220
其他的神经元也在倾听他们的选民, 他们说, 哦, 也许这实际上是一只豹子｡

18:49.220 --> 18:51.600
子弹头列车很有可能在这里｡ 

18:51.650 --> 18:57.440
剪刀, 你知道, 这个, 一个按钮的pangloss非常接近第二,

18:57.440 --> 19:03.020
然后是听诊器, 因为你可以看到像这些家伙, 这个这个神经元,

19:03.020 --> 19:09.740
剪刀神经元, 输出, 这个神经元听它的选民, 它有一个主要的投票, 但然后手光泽也有一个很好的结果｡

19:09.980 --> 19:10.760
好了, 我们走吧｡ 

19:10.760 --> 19:14.390
这就是完整连接的工作原理, 这就是它的工作原理｡ 

19:14.390 --> 19:16.400
所有这些都是一起发生的｡ 

19:16.400 --> 19:18.620
我希望你喜欢今天的教程｡ 

19:18.620 --> 19:22.730
我们也会在总结中总结所有这些内容, 下次再见｡ 

19:22.730 --> 19:24.800
在此之前, 请尽情享受深度学习｡