计算机视觉（Computer vision）

一般计算机视觉的问题：

• 图片分类Image Classification

• 目标识别Object detection

• 图片风格迁移Neural Style Transfer

使用传统神经网络处理机器视觉的一个主要问题是输入层维度很大。例如一张64x64x3的图片，神经网络输入层的维度为12288。如果图片尺寸较大，例如一张1000x1000x3的图片，神经网络输入层的维度将达到3百万，使得网络权重W非常庞大。这样会造成两个后果，一是神经网络结构复杂，数据量相对不够，容易出现过拟合；二是所需内存、计算量较大。解决这一问题的方法就是使用卷积神经网络（CNN）。

边缘检测示例（Edge detection example）

使用边缘检测作为入门样例，如何在一张图片中进行边缘检测。

给了这样一张图片，让电脑去搞清楚照片里有什么物体，你可能做的第一件事是检测图片中的垂直边缘。比如说，在这张图片中的栏杆就对应垂直线，与此同时，这些行人的轮廓线某种程度上也是垂线，这些线是垂直边缘检测器的输出。同样，你可能也想检测水平边缘，比如说这些栏杆就是很明显的水平线，它们也能被检测到。

所以如何在图像中检测这些边缘？

看一个例子，这是一个6×6的灰度图像, 它是6×6×1的矩阵，而不是6×6×3的，因为没有RGB三通道。为了检测图像中的垂直边缘，你可以构造一个3×3矩阵。在卷积神经网络的术语中，它被称为过滤器。我要构造一个3×3的过滤器，像这样 [ 1 0 − 1 1 0 − 1 1 0 − 1 ] \begin{bmatrix}1 & 0 & -1\\1 & 0 & -1\\ 1 & 0 & -1\end{bmatrix} ⎣⎡​111​000​−1−1−1​⎦⎤​。在论文它有时候会被称为核。对这个6×6的图像进行卷积运算，卷积运算用*来表示，用3×3的过滤器对其进行卷积。

关于符号表示: 有一些问题，在数学中“$$”就是卷积的标准标志，但是在Python中，这个标识常常被用来表示乘法或者元素乘法。所以这个“$$”有多层含义，它是一个重载符号。

这个卷积运算的输出将会是一个4×4的矩阵，你可以将它看成一个4×4的图像。下面来说明是如何计算得到这个4×4矩阵的。为了计算第一个元素，在4×4左上角的那个元素，使用3×3的过滤器，将其覆盖在输入图像，如下图所示。然后进行元素乘法（element-wise products）运算，所以 [ 3 × 1 0 × 0 1 × ( 1 ) 1 × 1 5 × 0 8 × ( − 1 ) 2 × 1 7 × 0 2 × ( − 1 )   ] = [ 3 0 − 1 1 0 − 8 2 0 − 2 ] \begin{bmatrix} 3 \times 1 & 0 \times 0 & 1 \times \left(1 \right) \\ 1 \times 1 & 5 \times 0 & 8 \times \left( - 1 \right) \\ 2 \times1 & 7 \times 0 & 2 \times \left( - 1 \right) \ \end{bmatrix} = \begin{bmatrix}3 & 0 & - 1 \\ 1 & 0 & - 8 \\ 2 & 0 & - 2 \\ \end{bmatrix} ⎣⎡​3×11×12×1​0×05×07×0​1×(1)8×(−1)2×(−1) ​⎦⎤​=⎣⎡​312​000​−1−8−2​⎦⎤​，然后将该矩阵每个元素相加得到最左上角的元素，即 3 + 1 + 2 + 0 + 0 + 0 + ( − 1 ) + ( − 8 ) + ( − 2 ) = − 5 3+1+2+0+0 +0+(-1)+(-8) +(-2)=-5 3+1+2+0+0+0+(−1)+(−8)+(−2)=−5。

接下来，为了弄明白第二个元素是什么，你要把蓝色的方块，向右移动一步：

继续做同样的元素乘法，然后加起来，所以是 $0×1+5×1+7×1+1×0+8×0+2×0+2×(-1)+ 9×(-1)+5×(-1)=-4 $。

因此6×6矩阵和3×3矩阵进行卷积运算得到4×4矩阵。这些图片和过滤器是不同维度的矩阵，但左边矩阵容易被理解为一张图片，中间的这个被理解为过滤器，右边的图片我们可以理解为另一张图片。这个就是垂直边缘检测器，下一页中你就会明白。

在往下讲之前，多说一句，如果你要使用编程语言实现这个运算，不同的编程语言有不同的函数，而不是用“ ∗ * ∗”来表示卷积。所以在编程练习中，你会使用一个叫conv_forward的函数。如果在tensorflow下，这个函数叫tf.conv2d。在其他深度学习框架中，在后面的课程中，你将会看到Keras这个框架，在这个框架下用Conv2D实现卷积运算。所有的编程框架都有一些函数来实现卷积运算。

为什么这个可以做垂直边缘检测呢？来看另外一个例子。
这是一个简单的6×6图像，左边的一半是10，右边一般是0。如果你把它当成一个图片，左边那部分看起来是白色的，像素值10是比较亮的像素值，右边像素值比较暗，使用灰色来表示0。图片里，有一个特别明显的垂直边缘在图像中间，这条垂直线是从黑到白的过渡线.

所以，当用一个3×3过滤器进行卷积运算的时候，这个3×3的过滤器可视化为在左边有明亮的像素，然后有一个过渡，0在中间，然后右边是深色的。卷积运算后，你得到的是右边的矩阵。 10 × 1 + 10 × 1 + 10 × 1 + 10 × 0 + 10 × 0 + 10 × 0 + 10 × ( − 1 ) + 10 × ( − 1 ) + 10 × ( − 1 ) = 0 10×1+10×1+10×1+10×0+10×0+10×0+10×(-1)+10×(-1)+10×(-1)=0 10×1+10×1+10×1+10×0+10×0+10×0+10×(−1)+10×(−1)+10×(−1)=0

相反这个30是由这个

10 × 1 + 10 × 1 + 10 × 1 + 10 × 0 + 10 × 0 + 10 × 0 + 0 × ( − 1 ) + 0 × ( − 1 ) + 0 × ( − 1 ) = 30 10×1+10×1+10×1+10×0+10×0+10×0+0×(-1)+0×(-1)+ 0×(-1)=30 10×1+10×1+10×1+10×0+10×0+10×0+0×(−1)+0×(−1)+0×(−1)=30。

在这个例子中，在输出图像中间的亮处，表示在图像中间有一个特别明显的垂直边缘。从垂直边缘检测中可以得到的启发是，因为我们使用3×3的过滤器，所以垂直边缘是一个3×3的区域，左边是明亮的像素，中间的并不需要考虑，右边是深色像素。在这个6×6图像的中间部分，明亮的像素在左边，深色的像素在右边，就被视为一个垂直边缘，卷积运算提供了一个方便的方法来发现图像中的垂直边缘。

这张6×6的图片，左边较亮，而右边较暗，将它与垂直边缘检测滤波器进行卷积，检测结果就显示在了右边这幅图的中间部分。

现在这幅图有什么变化呢？它的颜色被翻转了，变成了左边比较暗，而右边比较亮。现在亮度为10的点跑到了右边，为0的点则跑到了左边。如果你用它与相同的过滤器进行卷积，最后得到的图中间会是-30，而不是30。如果你将矩阵转换为图片，就会是该矩阵下面图片的样子。现在中间的过渡部分被翻转了，之前的30翻转成了-30，表明是由暗向亮过渡，而不是由亮向暗过渡。

如果你不在乎这两者的区别，你可以取出矩阵的绝对值。但这个特定的过滤器确实可以为我们区分这两种明暗变化的区别。

再来看看更多的边缘检测的例子，右边这个过滤器，它能让你检测出水平的边缘。

我们现在所使用的都是相对很小的图片，仅有6×6。但假如这个一个非常大的1000×1000的类似这样棋盘风格的大图，就不会出现这些亮度为10的过渡带了，因为图片尺寸很大，这些中间值就会变得非常小。

总而言之，通过使用不同的过滤器，可以找出垂直的或是水平的边缘。

除了上面提到的这种简单的Vertical、Horizontal滤波器之外，还有其它常用的filters，例如Sobel filter和Scharr filter。这两种滤波器的特点是增加图片中心区域的权重。

在深度学习中，如果我们想检测图片的各种边缘特征，而不仅限于垂直边缘和水平边缘，那么filter的数值一般需要通过模型训练得到，类似于标准神经网络中的权重W一样由梯度下降算法反复迭代求得。CNN的主要目的就是计算出这些filter的数值。确定得到了这些filter后，CNN浅层网络也就实现了对图片所有边缘特征的检测。

Padding

我们在之前视频中看到，如果你用一个3×3的过滤器卷积一个6×6的图像，你最后会得到一个4×4的输出，也就是一个4×4矩阵。这背后的数学解释是，如果我们有一个 n × n n×n n×n的图像，用 f × f f×f f×f的过滤器做卷积，那么输出的维度就是 ( n − f + 1 ) × ( n − f + 1 ) (n-f+1)×(n-f+1) (n−f+1)×(n−f+1)。

这样的话会有两个缺点:

• 每次做卷积操作，图像就会缩小。

• 丢掉了图像边缘位置的许多信息。

为了解决这些问题，可以在卷积操作之前填充这幅图像。在这个案例中，你可以沿着图像边缘再填充一层像素。6×6的图像就被你填充成了一个8×8的图像。如果你用3×3的图像对这个8×8的图像卷积，你得到的输出就是6×6的图像，一个尺寸和原始图像6×6的图像。

习惯上用0去填充，如果 p p p是填充的数量（在这个案例中， p = 1 p=1 p=1），因为我们在周围都填充了一个像素点，输出也就变成了 ( n + 2 p − f + 1 ) × ( n + 2 p − f + 1 ) (n+2p-f+1)×(n+2p-f+1) (n+2p−f+1)×(n+2p−f+1)，所以就变成了 ( 6 + 2 × 1 − 3 + 1 ) × ( 6 + 2 × 1 − 3 + 1 ) = 6 × 6 (6+2×1-3+1)×(6+2×1-3+1)=6×6 (6+2×1−3+1)×(6+2×1−3+1)=6×6，和输入的图像一样大。这个涂绿的像素点（左边矩阵）影响了输出中的这些格子（右边矩阵）。这样一来，丢失信息或者更准确来说角落或图像边缘的信息发挥的作用较小的这一缺点就被削弱了。

如果你想的话，也可以填充两个像素点，也就是说在这里填充一层。实际上你还可以填充更多像素。我这里画的这种情况，填充后 p = 2 p=2 p=2。

选择填充多少像素：通常有两个选择，分别叫做Valid卷积和Same卷积。

Valid卷积意味着不填充。

Same卷积：那意味你填充后，输出大小和输入大小是一样的。

习惯上，计算机视觉中， f f f通常是奇数，有两个原因。

• 其中一个可能是，如果 f f f是一个偶数，那么你只能使用一些不对称填充。只有 f f f是奇数的情况下，Same卷积才会有自然的填充，我们可以以同样的数量填充四周，而不是左边填充多一点，右边填充少一点，这样不对称的填充。

• 第二个原因是当你有一个奇数维过滤器，比如3×3或者5×5的，它就有一个中心点。有时在计算机视觉里，如果有一个中心像素点会更方便，便于指出过滤器的位置。

卷积步长（Strided convolutions）

如果你想用3×3的过滤器卷积这个7×7的图像，把步幅设置成了2，最后结果为91。

之前我们移动蓝框的步长是1，现在移动的步长是2，我们让过滤器跳过2个步长，注意一下左上角，这个点移动到其后两格的点，跳过了一个位置。然后你还是将每个元素相乘并求和，你将会得到的结果是100。

现在我们继续，将蓝色框移动两个步长，你将会得到83的结果。当你移动到下一行的时候，你也是使用步长2而不是步长1，所以我们将蓝色框移动到这里：

所以在这个例子中，我们用3×3的矩阵卷积一个7×7的矩阵，得到一个3×3的输出。输入和输出的维度是由下面的公式决定的：

用一个 f × f f×f f×f的过滤器卷积一个 n × n n×n n×n的图像，padding为 p p p，步幅为 s s s，在这个例子中 s = 2 s=2 s=2，得到一个输出 n + 2 p − f s + 1 × n + 2 p − f s + 1 \frac{n+2p - f}{s} + 1 \times \frac{n+2p - f}{s} + 1 sn+2p−f​+1×sn+2p−f​+1

在我们的这个例子里， n = 7 n=7 n=7， p = 0 p=0 p=0， f = 3 f=3 f=3， s = 2 s=2 s=2，   7 + 0 − 3 2 + 1 = 3 \ \frac{7 + 0 - 3}{2} + 1 =3  27+0−3​+1=3，即3×3的输出。

如果商不是一个整数怎么办？在这种情况下，我们向下取整。 ⌊ ⌋ ⌊ ⌋ ⌊⌋这是向下取整的符号，这也叫做对 z z z进行地板除(floor)。
这个原则实现的方式是，你只在蓝框完全包括在图像或填充完的图像内部时，才对它进行运算。如果有任意一个蓝框移动到了外面，那你就不要进行相乘操作。你的3×3的过滤器必须完全处于图像中或者填充之后的图像区域内才输出相应结果。

总结一下维度情况，如果你有一个 n × n n×n n×n的矩阵或者 n × n n×n n×n的图像，与一个 f × f f×f f×f的矩阵卷积，或者说 f × f f×f f×f的过滤器。Padding是 p p p，步幅为 s s s没输出尺寸就是这样：

可以选择所有的数使结果是整数是挺不错的，尽管一些时候，你不必这样做，只要向下取整也就可以了。你也可以自己选择一些 n n n， f f f， p p p和 s s s的值来验证这个输出尺寸的公式是对的。

其实，目前为止我们介绍的CNN卷积实际上计算的是相关系数，而不是数学意义上的卷积。但是，为了简化计算，我们一般把CNN中的这种“相关系数”就称作卷积运算。之所以可以这么等效，是因为滤波器算子一般是水平或垂直对称的，180度旋转影响不大；而且最终滤波器算子需要通过CNN网络梯度下降算法计算得到，旋转部分可以看作是包含在CNN模型算法中。总的来说，忽略旋转运算可以大大提高CNN网络运算速度，而且不影响模型性能。

卷积运算服从结合律。

三维卷积（Convolutions over volumes）

现在看看如何执行卷积不仅仅在二维图像上，而是三维立体上。

假如说想检测RGB彩色图像的特征。彩色图像如果是6×6×3，这里的3指的是三个颜色通道，你可以把它想象成三个6×6图像的堆叠。为了检测图像的边缘或者其他的特征，跟一个三维的过滤器，它的维度是3×3×3，这样这个过滤器也有三层，对应红绿、蓝三个通道。

给这些起个名字（原图像），这里的第一个6代表图像高度，第二个6代表宽度，这个3代表通道的数目。同样你的过滤器也有一个高，宽和通道数，并且图像的通道数必须和过滤器的通道数匹配。这个的输出会是一个4×4的图像，注意是4×4×1，最后一个数不是3了。

我们研究下这背后的细节，首先先换一张好看的图片。这个是6×6×3的图像，这个是3×3×3的过滤器，最后一个数字通道数必须和过滤器中的通道数相匹配。为了简化这个3×3×3过滤器的图像，我们不把它画成3个矩阵的堆叠，而画成这样，一个三维的立方体。

为了计算这个卷积操作的输出，你要做的就是把这个3×3×3的过滤器先放到最左上角的位置，这个3×3×3的过滤器有27个数，27个参数就是3的立方。依次取这27个数，然后乘以相应的红绿蓝通道中的数字。先取红色通道的前9个数字，然后是绿色通道，然后再是蓝色通道，乘以左边黄色立方体覆盖的对应的27个数，然后把这些数都加起来，就得到了输出的第一个数字。

如果要计算下一个输出，你把这个立方体滑动一个单位，再与这27个数相乘，把它们都加起来，就得到了下一个输出，以此类推。

举个例子，这个过滤器是3×3×3的，如果你想检测图像红色通道的边缘，那么你可以将第一个过滤器设为 [ 1 0 − 1 1 0 − 1 1 0 − 1 ] \begin{bmatrix}1 & 0 & - 1 \\ 1 & 0 & - 1 \\ 1 & 0 & - 1 \\ \end{bmatrix} ⎣⎡​111​000​−1−1−1​⎦⎤​，和之前一样，而绿色通道全为0， [ 0 0 0 0 0 0 0 0 0 ] \begin{bmatrix} 0& 0 & 0 \\ 0 &0 & 0 \\ 0 & 0 & 0 \\\end{bmatrix} ⎣⎡​000​000​000​⎦⎤​，蓝色也全为0。如果你把这三个堆叠在一起形成一个3×3×3的过滤器，那么这就是一个检测垂直边界的过滤器，但只对红色通道有用。

或者如果你不关心垂直边界在哪个颜色通道里，那么你可以用一个这样的过滤器， [ 1 0 − 1 1 0 − 1 1 0 − 1 ] \begin{bmatrix}1 & 0 & - 1 \\ 1 & 0 & - 1 \\ 1 & 0 & - 1 \\ \end{bmatrix} ⎣⎡​111​000​−1−1−1​⎦⎤​， [ 1 0 − 1 1 0 − 1 1 0 − 1 ] \begin{bmatrix}1 & 0 & - 1 \\ 1 & 0 & - 1 \\ 1 & 0 & - 1 \\ \end{bmatrix} ⎣⎡​111​000​−1−1−1​⎦⎤​， [ 1 0 − 1 1 0 − 1 1 0 − 1 ] \begin{bmatrix}1 & 0 & - 1 \\ 1 & 0 & - 1 \\ 1 & 0 & - 1 \\\end{bmatrix} ⎣⎡​111​000​−1−1−1​⎦⎤​，所有三个通道都是这样。所以通过设置第二个过滤器参数，你就有了一个边界检测器，3×3×3的边界检测器，用来检测任意颜色通道里的边界。

按照计算机视觉的惯例，当你的输入有特定的高宽和通道数时，你的过滤器可以有不同的高，不同的宽，但是必须一样的通道数。理论上，我们的过滤器只关注红色通道，或者只关注绿色或者蓝色通道也是可行的。

再注意一下这个卷积立方体，一个6×6×6的输入图像卷积上一个3×3×3的过滤器，得到一个4×4的二维输出。

现在你已经了解了如何对立方体卷积，还有最后一个概念，对建立卷积神经网络至关重要。就是，如果我们不仅仅想要检测垂直边缘怎么办？如果我们同时检测垂直边缘和水平边缘，还有45°倾斜的边缘，还有70°倾斜的边缘怎么做？换句话说，如果你想同时用多个过滤器怎么办？

为了进行多个卷积运算，实现更多边缘检测，可以增加更多的滤波器组。例如设置第一个滤波器组实现垂直边缘检测，第二个滤波器组实现水平边缘检测。这样，不同滤波器组卷积得到不同的输出，个数由滤波器组决定。

若输入图片的尺寸为 n ∗ n ∗ n c n*n*n_c n∗n∗nc​，filter尺寸为 f ∗ f ∗ n c f*f*n_c f∗f∗nc​ ，则卷积后的图片尺寸为 ( n − f + 1 ) ∗ ( n − f + 1 ) ∗ n c ′ (n-f+1) *(n-f+1) *n_c' (n−f+1)∗(n−f+1)∗nc′​ 。其中，$n_c $ 为图片通道数目， n c ′ n_c' nc′​为滤波器组个数。

单层卷积网络（One layer of a convolutional network）

假设使用第一个过滤器进行卷积，得到第一个4×4矩阵。使用第二个过滤器进行卷积得到另外一个4×4矩阵。

最终各自形成一个卷积神经网络层，然后增加偏差，它是一个实数，通过Python的广播机制。然后应用非线性函数ReLU，输出结果是一个4×4矩阵。

对于第二个4×4矩阵，我们加上不同的偏差，它也是一个实数，16个数字都加上同一个实数，然后应用非线性**函数ReLU，最终得到另一个4×4矩阵。然后重复我们之前的步骤，把这两个矩阵堆叠起来，最终得到一个4×4×2的矩阵。我们通过计算，从6×6×3的输入推导出一个4×4×2矩阵，它是卷积神经网络的一层，把它映射到标准神经网络中四个卷积层中的某一层或者一个非卷积神经网络中。

注意前向传播中一个操作是 z [ 1 ] = W [ 1 ] a [ 0 ] + b [ 1 ] z^{[1]} = W^{[1]}a^{[0]} + b^{[1]} z[1]=W[1]a[0]+b[1]，其中 a [ 0 ] = x a^{[0]} =x a[0]=x，执行非线性函数 a [ 1 ] = g ( z [ 1 ] ) a^{[1]} = g(z^{[1]}) a[1]=g(z[1])。这里的输入是 a [ 0 ] a^{\left\lbrack 0\right\rbrack} a[0]，也就是 x x x，这些过滤器用变量 W [ 1 ] W^{[1]} W[1]表示。在卷积过程中，我们对这27个数进行操作，其实是27×2，因为我们用了两个过滤器，我们取这些数做乘法。实际执行了一个线性函数，得到一个4×4的矩阵。卷积操作的输出结果是一个4×4的矩阵，它的作用类似于 W [ 1 ] a [ 0 ] W^{[1]}a^{[0]} W[1]a[0]，也就是这两个4×4矩阵的输出结果，然后加上偏差。

这一部分（图中蓝色边框标记的部分）就是应用**函数ReLU之前的值，它的作用类似于 z [ 1 ] z^{[1]} z[1]，最后应用非线性函数，得到的这个4×4×2矩阵，成为神经网络的下一层，也就是**层。

这就是 a [ 0 ] a^{[0]} a[0]到 a [ 1 ] a^{[1]} a[1]的演变过程: 运用线性函数再加上偏差，然后应用**函数ReLU。这样就通过神经网络的一层把一个6×6×3的维度 a [ 0 ] a^{[0]} a[0]演化为一个4×4×2维度的 a [ 1 ] a^{[1]} a[1]，这就是卷积神经网络的一层。

示例中我们有两个过滤器，也就是有两个特征，因此我们才最终得到一个4×4×2的输出。但如果我们用了10个过滤器，而不是2个，我们最后会得到一个4×4×10维度的输出图像.

最后我们总结一下用于描述卷积神经网络中的一层（以 l l l层为例），也就是卷积层的各种标记。

这一层是卷积层，用 f [ l ] f^{[l]} f[l]表示过滤器大小，我们说过过滤器大小为 f × f f×f f×f，上标 [ l ] \lbrack l\rbrack [l]表示 l l l层中过滤器大小为 f × f f×f f×f。通常情况下，上标 [ l ] \lbrack l\rbrack [l]用来标记 l l l层。用 p [ l ] p^{[l]} p[l]来标记padding的数量，padding数量也可指定为一个valid卷积，即无padding。或是same卷积，即选定padding，如此一来，输出和输入图片的高度和宽度就相同了。用 s [ l ] s^{[l]} s[l]标记步幅。

这一层的输入会是某个维度的数据，表示为 n × n × n c n \times n \times n_{c} n×n×nc​， n c n_{c} nc​某层上的颜色通道数。

增加上标 [ l − 1 ] \lbrack l -1\rbrack [l−1]，即 n [ l − 1 ] × n [ l − 1 ] × n c [ l − 1 ] n^{\left\lbrack l - 1 \right\rbrack} \times n^{\left\lbrack l -1 \right\rbrack} \times n_{c}^{\left\lbrack l - 1\right\rbrack} n[l−1]×n[l−1]×nc[l−1]​，因为它是上一层的**值。

此例中，所用图片的高度和宽度都一样，但它们也有可能不同，所以分别用上下标 H H H和 W W W来标记，即 n H [ l − 1 ] × n W [ l − 1 ] × n c [ l − 1 ] n_{H}^{\left\lbrack l - 1 \right\rbrack} \times n_{W}^{\left\lbrack l - 1 \right\rbrack} \times n_{c}^{\left\lbrack l - 1\right\rbrack} nH[l−1]​×nW[l−1]​×nc[l−1]​。那么在第 l l l层，图片大小为 n H [ l − 1 ] × n W [ l − 1 ] × n c [ l − 1 ] n_{H}^{\left\lbrack l - 1 \right\rbrack} \times n_{W}^{\left\lbrack l - 1 \right\rbrack} \times n_{c}^{\left\lbrack l - 1\right\rbrack} nH[l−1]​×nW[l−1]​×nc[l−1]​， l l l层的输入就是上一层的输出，因此上标要用 [ l − 1 ] \lbrack l - 1\rbrack [l−1]。神经网络这一层中会有输出，它本身会输出图像。其大小为 n H [ l ] × n W [ l ] × n c [ l ] n_{H}^{[l]} \times n_{W}^{[l]} \times n_{c}^{[l]} nH[l]​×nW[l]​×nc[l]​，这就是输出图像的大小。

前面我们提到过，这个公式给出了输出图片的大小，至少给出了高度和宽度， ⌊ n + 2 p − f s + 1 ⌋ \lfloor\frac{n+2p - f}{s} + 1\rfloor ⌊sn+2p−f​+1⌋（注意：（ n + 2 p − f s + 1 ) \frac{n + 2p - f}{s} +1) sn+2p−f​+1)直接用这个运算结果，也可以向下取整）。在这个新表达式中， l l l层输出图像的高度，即 n H [ l ] = ⌊ n H [ l − 1 ] + 2 p [ l ] − f [ l ] s [ l ] + 1 ⌋ n_{H}^{[l]} = \lfloor\frac{n_{H}^{\left\lbrack l - 1 \right\rbrack} +2p^{[l]} - f^{[l]}}{s^{[l]}} +1\rfloor nH[l]​=⌊s[l]nH[l−1]​+2p[l]−f[l]​+1⌋，同样我们可以计算出图像的宽度，用 W W W替换参数 H H H，即 n W [ l ] = ⌊ n W [ l − 1 ] + 2 p [ l ] − f [ l ] s [ l ] + 1 ⌋ n_{W}^{[l]} = \lfloor\frac{n_{W}^{\left\lbrack l - 1 \right\rbrack} +2p^{[l]} - f^{[l]}}{s^{[l]}} +1\rfloor nW[l]​=⌊s[l]nW[l−1]​+2p[l]−f[l]​+1⌋，公式一样，只要变化高度和宽度的参数我们便能计算输出图像的高度或宽度。这就是由 n H [ l − 1 ] n_{H}^{\left\lbrack l - 1 \right\rbrack} nH[l−1]​推导 n H [ l ] n_{H}^{[l]} nH[l]​以及 n W [ l − 1 ] n_{W}^{\left\lbrack l - 1\right\rbrack} nW[l−1]​推导 n W [ l ] n_{W}^{[l]} nW[l]​的过程。

那么通道数量又是什么？这些数字从哪儿来的？输出通道数量就是输入通道数量，所以过滤器维度等于 f [ l ] × f [ l ] × n c [ l − 1 ] f^{[l]} \times f^{[l]} \times n_{c}^{\left\lbrack l - 1 \right\rbrack} f[l]×f[l]×nc[l−1]​。

应用偏差和非线性函数之后，这一层的输出等于它的**值 a [ l ] a^{[l]} a[l]，也就是这个维度（输出维度）。 a [ l ] a^{[l]} a[l]是一个三维体，即 n H [ l ] × n W [ l ] × n c [ l ] n_{H}^{[l]} \times n_{W}^{[l]} \times n_{c}^{[l]} nH[l]​×nW[l]​×nc[l]​。当你执行批量梯度下降或小批量梯度下降时，如果有 m m m个例子，就是有 m m m个**值的集合，那么输出 A [ l ] = m × n H [ l ] × n W [ l ] × n c [ l ] A^{[l]} = m \times n_{H}^{[l]} \times n_{W}^{[l]} \times n_{c}^{[l]} A[l]=m×nH[l]​×nW[l]​×nc[l]​。如果采用批量梯度下降，变量的排列顺序如下，首先是索引和训练示例，然后是其它三个变量。

该如何确定权重参数，即参数W呢？过滤器的维度已知，为 f [ l ] × f [ l ] × n c [ l − 1 ] f^{[l]} \times f^{[l]} \times n_{c}^{[l - 1]} f[l]×f[l]×nc[l−1]​，这只是一个过滤器的维度，有多少个过滤器，这（ n c [ l ] n_{c}^{[l]} nc[l]​）是过滤器的数量，权重也就是所有过滤器的集合再乘以过滤器的总数量，即 f [ l ] × f [ l ] × n c [ l − 1 ] × n c [ l ] f^{[l]} \times f^{[l]} \times n_{c}^{[l - 1]} \times n_{c}^{[l]} f[l]×f[l]×nc[l−1]​×nc[l]​，损失数量L就是 l l l层中过滤器的个数。

最后我们看看偏差参数，每个过滤器都有一个偏差参数，它是一个实数。偏差包含了这些变量，它是该维度上的一个向量。为了方便，偏差在代码中表示为一个1×1×1× n c [ l ] n_{c}^{[l]} nc[l]​的四维向量或四维张量。

池化层（Pooling layers）

除了卷积层，卷积网络也经常使用池化层来缩减模型的大小，提高计算速度，同时提高所提取特征的鲁棒性。

先举一个池化层的例子，然后我们再讨论池化层的必要性。假如输入是一个4×4矩阵，用到的池化类型是最大池化（max pooling）。执行最大池化的树池是一个2×2矩阵。

执行过程非常简单，把4×4的输入拆分成不同的区域，我把这个区域用不同颜色来标记。对于2×2的输出，输出的每个元素都是其对应颜色区域中的最大元素值。

因为我们使用的过滤器为2×2，最后输出是9。然后向右移动2个步幅，计算出最大值2。然后是第二行，向下移动2步得到最大值6。最后向右移动3步，得到最大值3。这是一个2×2矩阵，即 f = 2 f=2 f=2，步幅是2，即 s = 2 s=2 s=2。

最大化运算的实际作用就是，如果在过滤器中提取到某个特征，那么保留其最大值。如果没有提取到这个特征，可能在右上象限中不存在这个特征，那么其中的最大值也还是很小，这就是最大池化的直观理解。

人们使用最大池化的主要原因是此方法在很多实验中效果都很好。

其中一个有意思的特点就是，它有一组超参数，但并没有参数需要学习。

另外还有一种类型的池化，平均池化，这种运算顾名思义，选取的不是每个过滤器的最大值，而是平均值。

目前来说，最大池化比平均池化更常用。

总结:
池化的超级参数包括过滤器大小 f f f和步幅 s s s，常用的参数值为 f = 2 f=2 f=2， s = 2 s=2 s=2，应用频率非常高，其效果相当于高度和宽度缩减一半。
最大池化时，往往很少用到超参数padding. 输入通道与输出通道个数相同，因为我们对每个通道都做了池化。

池化过程中没有需要学习的参数。执行反向传播时，反向传播没有参数适用于最大池化。只有这些设置过的超参数，可能是手动设置的，也可能是通过交叉验证设置的。