计算机视觉——卷积神经网络基础
文章目录
一、计算机视觉的发展历程
计算机视觉的发展历程要从生物视觉讲起。对于生物视觉的起源，目前学术界尚没有形成定论。有研究者认为最早的生物视觉形成于距今约7亿年前的水母之中，也有研究者认为生物视觉产生于距今约5亿年前寒武纪【1, 2】。寒武纪生物大爆发的原因一直是个未解之谜，不过可以肯定的是在寒武纪动物具有了视觉能力，捕食者可以更容易地发现猎物，被捕食者也可以更早的发现天敌的位置。视觉能力加剧了猎手和猎物之间的博弈，也催生出更加激烈的生存演化规则。视觉系统的形成有力地推动了食物链的演化，加速了生物进化过程，是生物发展史上重要的里程碑。经过几亿年的演化，目前人类的视觉系统已经具备非常高的复杂度和强大的功能，人脑中神经元数目达到了1000亿个，这些神经元通过网络互相连接，这样庞大的视觉神经网络使得我们可以很轻松的观察周围的世界，如 图2 所示。
图2：人类视觉感知
对人类来说，识别猫和狗是件非常容易的事。但对计算机来说，即使是一个精通编程的高手，也很难轻松写出具有通用性的程序（比如：假设程序认为体型大的是狗，体型小的是猫，但由于拍摄角度不同，可能一张图片上猫占据的像素比狗还多）。那么，如何让计算机也能像人一样看懂周围的世界呢？研究者尝试着从不同的角度去解决这个问题，由此也发展出一系列的子任务，如 图3 所示。
图3：计算机视觉子任务示意图
(a) Image Classification： 图像分类，用于识别图像中物体的类别（如：bottle、cup、cube）。
(b) Object Localization： 目标检测，用于检测图像中每个物体的类别，并准确标出它们的位置。
© Semantic Segmentation： 图像语义分割，用于标出图像中每个像素点所属的类别，属于同一类别的像素点用一个颜色标识。
(d) Instance Segmentation： 实例分割，值得注意的是，（b）中的目标检测任务只需要标注出物体位置，而（d）中的实例分割任务不仅要标注出物体位置，还需要标注出物体的外形轮廓。
在早期的图像分类任务中，通常是先人工提取图像特征，再用机器学习算法对这些特征进行分类，分类的结果强依赖于特征提取方法，往往只有经验丰富的研究者才能完成，如 图4 所示。
图4：早期的图像分类任务
在这种背景下，基于神经网络的特征提取方法应运而生。Yann LeCun是最早将卷积神经网络应用到图像识别领域的，其主要逻辑是使用卷积神经网络提取图像特征，并对图像所属类别进行预测，通过训练数据不断调整网络参数，最终形成一套能自动提取图像特征并对这些特征进行分类的网络，如 图5 所示。
图5：早期的卷积神经网络处理图像任务示意
这一方法在手写数字识别任务上取得了极大的成功，但在接下来的时间里，却没有得到很好的发展。其主要原因一方面是数据集不完善，只能处理简单任务，在大尺寸的数据上容易发生过拟合；另一方面是硬件瓶颈，网络模型复杂时，计算速度会特别慢。
目前，随着互联网技术的不断进步，数据量呈现大规模的增长，越来越丰富的数据集不断涌现。另外，得益于硬件能力的提升，计算机的算力也越来越强大。不断有研究者将新的模型和算法应用到计算机视觉领域。由此催生了越来越丰富的模型结构和更加准确的精度，同时计算机视觉所处理的问题也越来越丰富，包括分类、检测、分割、场景描述、图像生成和风格变换等，甚至还不仅仅局限于2维图片，包括视频处理技术和3D视觉等。
二、卷积神经网络
卷积神经网络是目前计算机视觉中使用最普遍的模型结构。本章节主要向读者介绍卷积神经网络的一些基础模块，包括：
- 卷积（Convolution）
- 池化（Pooling）
- ReLU激活函数
- 批归一化（Batch Normalization）
- 丢弃法（Dropout）
手写数字识别任务，应用的是全连接网络进行特征提取，即将一张图片上的所有像素点展开成一个1维向量输入网络，存在如下两个问题：
1. 输入数据的空间信息被丢失。 空间上相邻的像素点往往具有相似的RGB值，RGB的各个通道之间的数据通常密切相关，但是转化成1维向量时，这些信息被丢失。同时，图像数据的形状信息中，可能隐藏着某种本质的模式，但是转变成1维向量输入全连接神经网络时，这些模式也会被忽略。
2. 模型参数过多，容易发生过拟合。 每个像素点都要跟所有输出的神经元相连接。当图片尺寸变大时，输入神经元的个数会按图片尺寸的平方增大，导致模型参数过多，容易发生过拟合。
为了解决上述问题，我们引入卷积神经网络进行特征提取，既能提取到相邻像素点之间的特征模式，又能保证参数的个数不随图片尺寸变化。图6 是一个典型的卷积神经网络结构，多层卷积和池化层组合作用在输入图片上，在网络的最后通常会加入一系列全连接层，ReLU激活函数一般加在卷积或者全连接层的输出上，网络中通常还会加入Dropout来防止过拟合。
图6：卷积神经网络经典结构
说明：
在卷积神经网络中，计算范围是在像素点的空间邻域内进行的，卷积核参数的数目也远小于全连接层。卷积核本身与输入图片大小无关，它代表了对空间邻域内某种特征模式的提取。比如，有些卷积核提取物体边缘特征，有些卷积核提取物体拐角处的特征，图像上不同区域共享同一个卷积核。当输入图片大小不一样时，仍然可以使用同一个卷积核进行操作。
卷积（Convolution）
这一小节将为读者介绍卷积算法的原理和实现方案，并通过具体的案例展示如何使用卷积对图片进行操作，主要涵盖如下内容：
-
卷积计算
-
填充（padding）
-
步幅（stride）
-
感受野（Receptive Field）
-
多输入通道、多输出通道和批量操作
-
飞桨卷积API介绍
-
卷积算子应用举例
卷积计算
卷积是数学分析中的一种积分变换的方法，在图像处理中采用的是卷积的离散形式。这里需要说明的是，在卷积神经网络中，卷积层的实现方式实际上是数学中定义的互相关 （cross-correlation）运算，与数学分析中的卷积定义有所不同，这里跟其他框架和卷积神经网络的教程保持一致，都使用互相关运算作为卷积的定义，具体的计算过程如 图7 所示。
图7：卷积计算过程
说明：
卷积核（kernel）也被叫做滤波器（filter），假设卷积核的高和宽分别为 k h k_h kh和 k w k_w kw，则将称为 k h × k w k_h\times k_w kh×kw卷积，比如 3 × 5 3\times5 3×5卷积，就是指卷积核的高为3, 宽为5。
- 如图7（a）所示：左边的图大小是 3 × 3 3\times3 3×3，表示输入数据是一个维度为 3 × 3 3\times3 3×3的二维数组；中间的图大小是 2 × 2 2\times2 2×2，表示一个维度为 2 × 2 2\times2 2×2的二维数组，我们将这个二维数组称为卷积核。先将卷积核的左上角与输入数据的左上角（即：输入数据的(0, 0)位置）对齐，把卷积核的每个元素跟其位置对应的输入数据中的元素相乘，再把所有乘积相加，得到卷积输出的第一个结果：
0 × 1 + 1 × 2 + 2 × 4 + 3 × 5 = 25 ( a ) 0\times1 + 1\times2 + 2\times4 + 3\times5 = 25 \ \ \ \ \ \ \ (a) 0×1+1×2+2×4+3×5=25 (a)
- 如图7（b）所示：将卷积核向右滑动，让卷积核左上角与输入数据中的(0,1)位置对齐，同样将卷积核的每个元素跟其位置对应的输入数据中的元素相乘，再把这4个乘积相加，得到卷积输出的第二个结果：
0 × 2 + 1 × 3 + 2 × 5 + 3 × 6 = 31 ( b ) 0\times2 + 1\times3 + 2\times5 + 3\times6 = 31 \ \ \ \ \ \ \ (b) 0×2+1×3+2×5+3×6=31 (b)
- 如图7（c）所示：将卷积核向下滑动，让卷积核左上角与输入数据中的(1, 0)位置对齐，可以计算得到卷积输出的第三个结果：
0 × 4 + 1 × 5 + 2 × 7 + 3 × 8 = 43 ( c ) 0\times4 + 1\times5 + 2\times7 + 3\times8 = 43 \ \ \ \ \ \ \ (c) 0×4+1×5+2×7+3×8=43 (c)
- 如图7（d）所示：将卷积核向右滑动，让卷积核左上角与输入数据中的(1, 1)位置对齐，可以计算得到卷积输出的第四个结果：
0 × 5 + 1 × 6 + 2 × 8 + 3 × 9 = 49 ( d ) 0\times5 + 1\times6 + 2\times8 + 3\times9 = 49 \ \ \ \ \ \ \ (d) 0×5+1×6+2×8+3×9=49 (d)
卷积核的计算过程可以用下面的数学公式表示，其中 a a a 代表输入图片， b b b 代表输出特征图， w w w 是卷积核参数，它们都是二维数组， ∑ u , v \sum{u,v}{\ } ∑u,v 表示对卷积核参数进行遍历并求和。
b [ i , j ] = ∑ u , v a [ i + u , j + v ] ⋅ w [ u , v ] b[i, j] = \sum_{u,v}{a[i+u, j+v]\cdot w[u, v]} b[i,j]=u,v∑a[i+u,j+v]⋅w[u,v]
举例说明，假如上图中卷积核大小是
2
×
2
2\times 2
2×2，则
u
u
u可以取0和1，
v
v
v也可以取0和1，也就是说：
b
[
i
,
j
]
=
a
[
i
+
0
,
j
+
0
]
⋅
w
[
0
,
0
]
+
a
[
i
+
0
,
j
+
1
]
⋅
w
[
0
,
1
]
+
a
[
i
+
1
,
j
+
0
]
⋅
w
[
1
,
0
]
+
a
[
i
+
1
,
j
+
1
]
⋅
w
[
1
,
1
]
b[i, j] = a[i+0, j+0]\cdot w[0, 0] + a[i+0, j+1]\cdot w[0, 1] + a[i+1, j+0]\cdot w[1, 0] + a[i+1, j+1]\cdot w[1, 1]
b[i,j]=a[i+0,j+0]⋅w[0,0]+a[i+0,j+1]⋅w[0,1]+a[i+1,j+0]⋅w[1,0]+a[i+1,j+1]⋅w[1,1]
读者可以自行验证，当 [ i , j ] [i, j] [i,j]取不同值时，根据此公式计算的结果与上图中的例子是否一致。
- 【思考】 当卷积核大小为 3 × 3 3 \times 3 3×3时， b b b和 a a a之间的对应关系应该是怎样的？
其它说明：
在卷积神经网络中，一个卷积算子除了上面描述的卷积过程之外，还包括加上偏置项的操作。例如假设偏置为1，则上面卷积计算的结果为：
0
×
1
+
1
×
2
+
2
×
4
+
3
×
5
+
1
=
26
0\times1 + 1\times2 + 2\times4 + 3\times5 \mathbf{\ + 1} = 26
0×1+1×2+2×4+3×5 +1=26
0
×
2
+
1
×
3
+
2
×
5
+
3
×
6
+
1
=
32
0\times2 + 1\times3 + 2\times5 + 3\times6 \mathbf{\ + 1} = 32
0×2+1×3+2×5+3×6 +1=32
0
×
4
+
1
×
5
+
2
×
7
+
3
×
8
+
1
=
44
0\times4 + 1\times5 + 2\times7 + 3\times8 \mathbf{\ + 1} = 44
0×4+1×5+2×7+3×8 +1=44
0
×
5
+
1
×
6
+
2
×
8
+
3
×
9
+
1
=
50
0\times5 + 1\times6 + 2\times8 + 3\times9 \mathbf{\ + 1} = 50
0×5+1×6+2×8+3×9 +1=50
填充（padding）
在上面的例子中，输入图片尺寸为 3 × 3 3\times3 3×3，输出图片尺寸为 2 × 2 2\times2 2×2，经过一次卷积之后，图片尺寸变小。卷积输出特征图的尺寸计算方法如下（卷积核的高和宽分别为 k h k_h kh和 k w k_w kw）：
H
o
u
t
=
H
−
k
h
+
1
H_{out} = H - k_h + 1
Hout=H−kh+1
W
o
u
t
=
W
−
k
w
+
1
W_{out} = W - k_w + 1
Wout=W−kw+1
如果输入尺寸为4，卷积核大小为3时，输出尺寸为
4
−
3
+
1
=
2
4-3+1=2
4−3+1=2。读者可以自行检查当输入图片和卷积核为其他尺寸时，上述计算式是否成立。当卷积核尺寸大于1时，输出特征图的尺寸会小于输入图片尺寸。如果经过多次卷积，输出图片尺寸会不断减小。为了避免卷积之后图片尺寸变小，通常会在图片的外围进行填充(padding)，如 图8 所示。
图8：图形填充
-
如图8（a）所示：填充的大小为1，填充值为0。填充之后，输入图片尺寸从 4 × 4 4\times4 4×4变成了 6 × 6 6\times6 6×6，使用 3 × 3 3\times3 3×3的卷积核，输出图片尺寸为 4 × 4 4\times4 4×4。
-
如图8（b）所示：填充的大小为2，填充值为0。填充之后，输入图片尺寸从 4 × 4 4\times4 4×4变成了 8 × 8 8\times8 8×8，使用 3 × 3 3\times3 3×3的卷积核，输出图片尺寸为 6 × 6 6\times6 6×6。
如果在图片高度方向，在第一行之前填充
p
h
1
p_{h1}
ph1行，在最后一行之后填充
p
h
2
p_{h2}
ph2行；在图片的宽度方向，在第1列之前填充
p
w
1
p_{w1}
pw1列，在最后1列之后填充
p
w
2
p_{w2}
pw2列；则填充之后的图片尺寸为
(
H
+
p
h
1
+
p
h
2
)
×
(
W
+
p
w
1
+
p
w
2
)
(H + p_{h1} + p_{h2})\times(W + p_{w1} + p_{w2})
(H+ph1+ph2)×(W+pw1+pw2)。经过大小为
k
h
×
k
w
k_h\times k_w
kh×kw的卷积核操作之后，输出图片的尺寸为：
H
o
u
t
=
H
+
p
h
1
+
p
h
2
−
k
h
+
1
H_{out} = H + p_{h1} + p_{h2} - k_h + 1
Hout=H+ph1+ph2−kh+1
W
o
u
t
=
W
+
p
w
1
+
p
w
2
−
k
w
+
1
W_{out} = W + p_{w1} + p_{w2} - k_w + 1
Wout=W+pw1+pw2−kw+1
在卷积计算过程中，通常会在高度或者宽度的两侧采取等量填充，即
p
h
1
=
p
h
2
=
p
h
,
p
w
1
=
p
w
2
=
p
w
p_{h1} = p_{h2} = p_h,\ \ p_{w1} = p_{w2} = p_w
ph1=ph2=ph, pw1=pw2=pw，上面计算公式也就变为：
H
o
u
t
=
H
+
2
p
h
−
k
h
+
1
H_{out} = H + 2p_h - k_h + 1
Hout=H+2ph−kh+1
W
o
u
t
=
W
+
2
p
w
−
k
w
+
1
W_{out} = W + 2p_w - k_w + 1
Wout=W+2pw−kw+1
卷积核大小通常使用1，3，5，7这样的奇数，如果使用的填充大小为
p
h
=
(
k
h
−
1
)
/
2
，
p
w
=
(
k
w
−
1
)
/
2
p_h=(k_h-1)/2 ，p_w=(k_w-1)/2
ph=(kh−1)/2，pw=(kw−1)/2，则卷积之后图像尺寸不变。例如当卷积核大小为3时，padding大小为1，卷积之后图像尺寸不变；同理，如果卷积核大小为5，padding大小为2，也能保持图像尺寸不变。
步幅（stride）
图8 中卷积核每次滑动一个像素点，这是步幅为1的特殊情况。图9 是步幅为2的卷积过程，卷积核在图片上移动时，每次移动大小为2个像素点。
图9：步幅为2的卷积过程
当宽和高方向的步幅分别为 s h s_h sh和 s w s_w sw时，输出特征图尺寸的计算公式是：
H o u t = H + 2 p h − k h s h + 1 H_{out} = \frac{H + 2p_h - k_h}{s_h} + 1 Hout=shH+2ph−kh+1
W o u t = W + 2 p w − k w s w + 1 W_{out} = \frac{W + 2p_w - k_w}{s_w} + 1 Wout=swW+2pw−kw+1
假设输入图片尺寸是 H × W = 100 × 100 H\times W = 100 \times 100 H×W=100×100，卷积核大小 k h × k w = 3 × 3 k_h \times k_w = 3 \times 3 kh×kw=3×3，填充 p h = p w = 1 p_h = p_w = 1 ph=pw=1，步幅为 s h = s w = 2 s_h = s_w = 2 sh=sw=2，则输出特征图的尺寸为：
H o u t = 100 + 2 − 3 2 + 1 = 50 H_{out} = \frac{100 + 2 - 3}{2} + 1 = 50 Hout=2100+2−3+1=50
W o u t = 100 + 2 − 3 2 + 1 = 50 W_{out} = \frac{100 + 2 - 3}{2} + 1 = 50 Wout=2100+2−3+1=50
感受野（Receptive Field）
输出特征图上每个点的数值，是由输入图片上大小为 k h × k w k_h\times k_w kh×kw的区域的元素与卷积核每个元素相乘再相加得到的，所以输入图像上 k h × k w k_h\times k_w kh×kw区域内每个元素数值的改变，都会影响输出点的像素值。我们将这个区域叫做输出特征图上对应点的感受野。感受野内每个元素数值的变动，都会影响输出点的数值变化。比如 3 × 3 3\times3 3×3卷积对应的感受野大小就是 3 × 3 3\times3 3×3，如 图10 所示。
图10：感受野为3×3的卷积
而当通过两层 3 × 3 3\times3 3×3的卷积之后，感受野的大小将会增加到 5 × 5 5\times5 5×5，如 图11 所示。
图11：感受野为5×5的卷积
因此，当增加卷积网络深度的同时，感受野将会增大，输出特征图中的一个像素点将会包含更多的图像语义信息。
多输入通道、多输出通道和批量操作
前面介绍的卷积计算过程比较简单，实际应用时，处理的问题要复杂的多。例如：对于彩色图片有RGB三个通道，需要处理多输入通道的场景。输出特征图往往也会具有多个通道，而且在神经网络的计算中常常是把一个批次的样本放在一起计算，所以卷积算子需要具有批量处理多输入和多输出通道数据的功能，下面将分别介绍这几种场景的操作方式。
- 多输入通道场景
上面的例子中，卷积层的数据是一个2维数组，但实际上一张图片往往含有RGB三个通道，要计算卷积的输出结果，卷积核的形式也会发生变化。假设输入图片的通道数为 C i n C_{in} Cin，输入数据的形状是 C i n × H i n × W i n C_{in}\times{H_{in}}\times{W_{in}} Cin×Hin×Win，计算过程如 图12 所示。
-
对每个通道分别设计一个2维数组作为卷积核，卷积核数组的形状是 C i n × k h × k w C_{in}\times{k_h}\times{k_w} Cin×kh×kw。
-
对任一通道 C i n ∈ [ 0 , C i n ) C_{in} \in [0, C_{in}) Cin∈[0,Cin)，分别用大小为 k h × k w k_h\times{k_w} kh×kw的卷积核在大小为 H i n × W i n H_{in}\times{W_{in}} Hin×Win的二维数组上做卷积。
-
将这 C i n C_{in} Cin个通道的计算结果相加，得到的是一个形状为 H o u t × W o u t H_{out}\times{W_{out}} Hout×Wout的二维数组。
图12：多输入通道计算过程
- **多输出通道场景**
一般来说，卷积操作的输出特征图也会具有多个通道 C o u t C_{out} Cout，这时我们需要设计 C o u t C_{out} Cout个维度为 C i n × k h × k w C_{in}\times{k_h}\times{k_w} Cin×kh×kw的卷积核，卷积核数组的维度是 C o u t × C i n × k h × k w C_{out}\times C_{in}\times{k_h}\times{k_w} Cout×Cin×kh×kw，如 图13 所示。
- 对任一输出通道 c o u t ∈ [ 0 , C o u t ) c_{out} \in [0, C_{out}) cout∈[0,Cout)，分别使用上面描述的形状为 C i n × k h × k w C_{in}\times{k_h}\times{k_w} Cin×kh×kw的卷积核对输入图片做卷积。
- 将这 C o u t C_{out} Cout个形状为 H o u t × W o u t H_{out}\times{W_{out}} Hout×Wout的二维数组拼接在一起，形成维度为 C o u t × H o u t × W o u t C_{out}\times{H_{out}}\times{W_{out}} Cout×Hout×Wout的三维数组。
说明：
通常将卷积核的输出通道数叫做卷积核的个数。
图13：多输出通道计算过程
- 批量操作
在卷积神经网络的计算中，通常将多个样本放在一起形成一个mini-batch进行批量操作，即输入数据的维度是 N × C i n × H i n × W i n N\times{C_{in}}\times{H_{in}}\times{W_{in}} N×Cin×Hin×Win。由于会对每张图片使用同样的卷积核进行卷积操作，卷积核的维度与上面多输出通道的情况一样，仍然是 C o u t × C i n × k h × k w C_{out}\times C_{in}\times{k_h}\times{k_w} Cout×Cin×kh×kw，输出特征图的维度是 N × C o u t × H o u t × W o u t N\times{C_{out}}\times{H_{out}}\times{W_{out}} N×Cout×Hout×Wout，如 图14 所示。
图14：批量操作
### 飞桨卷积API介绍
飞桨卷积算子对应的API是paddle.nn.Conv2D，用户可以直接调用API进行计算，也可以在此基础上修改。Conv2D名称中的“2D”表明卷积核是二维的，多用于处理图像数据。类似的，也有Conv3D可以用于处理视频数据（图像的序列）。
class paddle.nn.Conv2D (in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, padding_mode=‘zeros’, weight_attr=None, bias_attr=None, data_format=‘NCHW’)
常用的参数如下：
- in_channels(int) - 输入图像的通道数。
- out_channels(int) - 卷积核的个数，和输出特征图通道数相同，相当于上文中的 C o u t C_{out} Cout。
- kernel_size(int|list|tuple) - 卷积核大小，可以是整数，比如3，表示卷积核的高和宽均为3 ；或者是两个整数的list，例如[3,2]，表示卷积核的高为3，宽为2。
- stride(int|list|tuple，可选) - 步长大小，可以是整数，默认值为1，表示垂直和水平滑动步幅均为1；或者是两个整数的list，例如[3,2]，表示垂直滑动步幅为3，水平滑动步幅为2。
- padding(int|list|tuple|str，可选) - 填充大小，可以是整数，比如1，表示竖直和水平边界填充大小均为1；或者是两个整数的list，例如[2,1]，表示竖直边界填充大小为2，水平边界填充大小为1。
输入数据维度 [ N , C i n , H i n , W i n ] [N, C_{in}, H_{in}, W_{in}] [N,Cin,Hin,Win]，输出数据维度 [ N , o u t _ c h a n n e l s , H o u t , W o u t ] [N, out\_channels, H_{out}, W_{out}] [N,out_channels,Hout,Wout]，权重参数 w w w的维度 [ o u t _ c h a n n e l s , C i n , f i l t e r _ s i z e _ h , f i l t e r _ s i z e _ w ] [out\_channels, C_{in}, filter\_size\_h, filter\_size\_w] [out_channels,Cin,filter_size_h,filter_size_w]，偏置参数 b b b的维度是 [ o u t _ c h a n n e l s ] [out\_channels] [out_channels]。注意，即使输入只有一张灰度图片 [ H i n , W i n ] [H_{in}, W_{in}] [Hin,Win]，也需要处理成四个维度的输入向量 [ 1 , 1 , H i n , W i n ] [1, 1, H_{in}, W_{in}] [1,1,Hin,Win]。
卷积算子应用举例
下面介绍卷积算子在图片中应用的三个案例，并观察其计算结果。
案例1——简单的黑白边界检测
下面是使用Conv2D算子完成一个图像边界检测的任务。图像左边为光亮部分，右边为黑暗部分，需要检测出光亮跟黑暗的分界处。
设置宽度方向的卷积核为 [ 1 , 0 , − 1 ] [1, 0, -1] [1,0,−1]，此卷积核会将宽度方向间隔为1的两个像素点的数值相减。当卷积核在图片上滑动时，如果它所覆盖的像素点位于亮度相同的区域，则左右间隔为1的两个像素点数值的差为0。只有当卷积核覆盖的像素点有的处于光亮区域，有的处在黑暗区域时，左右间隔为1的两个点像素值的差才不为0。将此卷积核作用到图片上，输出特征图上只有对应黑白分界线的地方像素值才不为0。具体代码如下所示，结果输出在下方的图案中。
import matplotlib.pyplot as plt
import numpy as np
import paddle
from paddle.nn import Conv2D
from paddle.nn.initializer import Assign
%matplotlib inline
# 创建初始化权重参数w
w = np.array([1, 0, -1], dtype='float32')
# 将权重参数调整成维度为[cout, cin, kh, kw]的四维张量
w = w.reshape([1, 1, 1, 3])
# 创建卷积算子，设置输出通道数，卷积核大小，和初始化权重参数
# kernel_size = [1, 3]表示kh = 1, kw=3
# 创建卷积算子的时候，通过参数属性weight_attr指定参数初始化方式
# 这里的初始化方式时，从numpy.ndarray初始化卷积参数
conv = Conv2D(in_channels=1, out_channels=1, kernel_size=[1, 3],
weight_attr=paddle.ParamAttr(
initializer=Assign(value=w)))
# 创建输入图片，图片左边的像素点取值为1，右边的像素点取值为0
img = np.ones([50,50], dtype='float32')
img[:, 30:] = 0.
# 将图片形状调整为[N, C, H, W]的形式
x = img.reshape([1,1,50,50])
# 将numpy.ndarray转化成paddle中的tensor
x = paddle.to_tensor(x)
# 使用卷积算子作用在输入图片上
y = conv(x)
# 将输出tensor转化为numpy.ndarray
out = y.numpy()
f = plt.subplot(121)
f.set_title('input image', fontsize=15)
plt.imshow(img, cmap='gray')
f = plt.subplot(122)
f.set_title('output featuremap', fontsize=15)
# 卷积算子Conv2D输出数据形状为[N, C, H, W]形式
# 此处N, C=1，输出数据形状为[1, 1, H, W]，是4维数组
# 但是画图函数plt.imshow画灰度图时，只接受2维数组
# 通过numpy.squeeze函数将大小为1的维度消除
plt.imshow(out.squeeze(), cmap='gray')
plt.show()
# 查看卷积层的权重参数名字和数值
print(conv.weight)
# 参看卷积层的偏置参数名字和数值
print(conv.bias)
案例2——图像中物体边缘检测
上面展示的是一个人为构造出来的简单图片，使用卷积网络检测图片明暗分界处的示例。对于真实的图片，也可以使用合适的卷积核(3*3卷积核的中间值是8，周围一圈的值是8个-1)对其进行操作，用来检测物体的外形轮廓，观察输出特征图跟原图之间的对应关系，如下代码所示：
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np
import paddle
from paddle.nn import Conv2D
from paddle.nn.initializer import Assign
img = Image.open('./work/images/section1/000000098520.jpg')
# 设置卷积核参数
w = np.array([[-1,-1,-1], [-1,8,-1], [-1,-1,-1]], dtype='float32')/8
w = w.reshape([1, 1, 3, 3])
# 由于输入通道数是3，将卷积核的形状从[1,1,3,3]调整为[1,3,3,3]
w = np.repeat(w, 3, axis=1)
# 创建卷积算子，输出通道数为1，卷积核大小为3x3，
# 并使用上面的设置好的数值作为卷积核权重的初始化参数
conv = Conv2D(in_channels=3, out_channels=1, kernel_size=[3, 3],
weight_attr=paddle.ParamAttr(
initializer=Assign(value=w)))
# 将读入的图片转化为float32类型的numpy.ndarray
x = np.array(img).astype('float32')
# 图片读入成ndarry时，形状是[H, W, 3]，
# 将通道这一维度调整到最前面
x = np.transpose(x, (2,0,1))
# 将数据形状调整为[N, C, H, W]格式
x = x.reshape(1, 3, img.height, img.width)
x = paddle.to_tensor(x)
y = conv(x)
out = y.numpy()
plt.figure(figsize=(20, 10))
f = plt.subplot(121)
f.set_title('input image', fontsize=15)
plt.imshow(img)
f = plt.subplot(122)
f.set_title('output feature map', fontsize=15)
plt.imshow(out.squeeze(), cmap='gray')
plt.show()
案例3——图像均值模糊
另外一种比较常见的卷积核（5*5的卷积核中每个值均为1）是用当前像素跟它邻域内的像素取平均，这样可以使图像上噪声比较大的点变得更平滑，如下代码所示：
import paddle
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np
from paddle.nn import Conv2D
from paddle.nn.initializer import Assign
# 读入图片并转成numpy.ndarray
# 换成灰度图
img = Image.open('./work/images/section1/000000355610.jpg').convert('L')
img = np.array(img)
# 创建初始化参数
w = np.ones([1, 1, 5, 5], dtype = 'float32')/25
conv = Conv2D(in_channels=1, out_channels=1, kernel_size=[5, 5],
weight_attr=paddle.ParamAttr(
initializer=Assign(value=w)))
x = img.astype('float32')
x = x.reshape(1,1,img.shape[0], img.shape[1])
x = paddle.to_tensor(x)
y = conv(x)
out = y.numpy()
plt.figure(figsize=(20, 12))
f = plt.subplot(121)
f.set_title('input image')
plt.imshow(img, cmap='gray')
f = plt.subplot(122)
f.set_title('output feature map')
out = out.squeeze()
plt.imshow(out, cmap='gray')
plt.show()
池化（Pooling）
池化是使用某一位置的相邻输出的总体统计特征代替网络在该位置的输出，其好处是当输入数据做出少量平移时，经过池化函数后的大多数输出还能保持不变。比如：当识别一张图像是否是人脸时，我们需要知道人脸左边有一只眼睛，右边也有一只眼睛，而不需要知道眼睛的精确位置，这时候通过池化某一片区域的像素点来得到总体统计特征会显得很有用。由于池化之后特征图会变得更小，如果后面连接的是全连接层，能有效的减小神经元的个数，节省存储空间并提高计算效率。
如 图15 所示，将一个
2
×
2
2\times 2
2×2的区域池化成一个像素点。通常有两种方法，平均池化和最大池化。
图15：池化
- 如图15（a）：平均池化。这里使用大小为 2 × 2 2\times2 2×2的池化窗口，每次移动的步幅为2，对池化窗口覆盖区域内的像素取平均值，得到相应的输出特征图的像素值。
- 如图15（b）：最大池化。对池化窗口覆盖区域内的像素取最大值，得到输出特征图的像素值。当池化窗口在图片上滑动时，会得到整张输出特征图。池化窗口的大小称为池化大小，用 k h × k w k_h \times k_w kh×kw表示。在卷积神经网络中用的比较多的是窗口大小为 2 × 2 2 \times 2 2×2，步幅为2的池化。
与卷积核类似，池化窗口在图片上滑动时，每次移动的步长称为步幅，当宽和高方向的移动大小不一样时，分别用 s w s_w sw和 s h s_h sh表示。也可以对需要进行池化的图片进行填充，填充方式与卷积类似，假设在第一行之前填充 p h 1 p_{h1} ph1行，在最后一行后面填充 p h 2 p_{h2} ph2行。在第一列之前填充 p w 1 p_{w1} pw1列，在最后一列之后填充 p w 2 p_{w2} pw2列，则池化层的输出特征图大小为：
H o u t = H + p h 1 + p h 2 − k h s h + 1 H_{out} = \frac{H + p_{h1} + p_{h2} - k_h}{s_h} + 1 Hout=shH+ph1+ph2−kh+1
W o u t = W + p w 1 + p w 2 − k w s w + 1 W_{out} = \frac{W + p_{w1} + p_{w2} - k_w}{s_w} + 1 Wout=swW+pw1+pw2−kw+1
在卷积神经网络中，通常使用 2 × 2 2\times2 2×2大小的池化窗口，步幅也使用2，填充为0，则输出特征图的尺寸为：
H o u t = H 2 H_{out} = \frac{H}{2} Hout=2H
W o u t = W 2 W_{out} = \frac{W}{2} Wout=2W
通过这种方式的池化，输出特征图的高和宽都减半，但通道数不会改变。
ReLU激活函数
前面介绍的网络结构中，普遍使用Sigmoid函数做激活函数。在神经网络发展的早期，Sigmoid函数用的比较多，而目前用的较多的激活函数是ReLU。这是因为Sigmoid函数在反向传播过程中，容易造成梯度的衰减。让我们仔细观察Sigmoid函数的形式，就能发现这一问题。
Sigmoid激活函数定义如下：
y = 1 1 + e − x y = \frac{1}{1 + e^{-x}} y=1+e−x1
ReLU激活函数的定义如下：
y = { 0 , ( x < 0 ) x , ( x ≥ 0 ) y=\left\{ \begin{aligned} 0 & , & (x<0) \\ x & , & (x\ge 0) \end{aligned} \right. y={0x,,(x<0)(x≥0)
下面的程序画出了Sigmoid和ReLU函数的曲线图：
# ReLU和Sigmoid激活函数示意图
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
plt.figure(figsize=(10, 5))
# 创建数据x
x = np.arange(-10, 10, 0.1)
# 计算Sigmoid函数
s = 1.0 / (1 + np.exp(0. - x))
# 计算ReLU函数
y = np.clip(x, a_min=0., a_max=None)
#####################################
# 以下部分为画图代码
f = plt.subplot(121)
plt.plot(x, s, color='r')
currentAxis=plt.gca()
plt.text(-9.0, 0.9, r'$y=Sigmoid(x)$', fontsize=13)
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
f = plt.subplot(122)
plt.plot(x, y, color='g')
plt.text(-3.0, 9, r'$y=ReLU(x)$', fontsize=13)
currentAxis=plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
plt.show()
梯度消失现象
在神经网络里，将经过反向传播之后，梯度值衰减到接近于零的现象称作梯度消失现象。
从上面的函数曲线可以看出，当 x x x为较大的正数的时候，Sigmoid函数数值非常接近于1，函数曲线变得很平滑，在这些区域Sigmoid函数的导数接近于零。当 x x x为较小的负数时，Sigmoid函数值也非常接近于0，函数曲线也很平滑，在这些区域Sigmoid函数的导数也接近于0。只有当 x x x的取值在0附近时，Sigmoid函数的导数才比较大。对Sigmoid函数求导数，结果如下所示：
d y d x = − 1 ( 1 + e − x ) 2 ⋅ d ( e − x ) d x = 1 2 + e x + e − x \frac{dy}{dx} = -\frac{1}{(1+e^{-x})^2} \cdot \frac{d(e^{-x})}{dx} = \frac{1}{2 + e^x + e^{-x}} dxdy=−(1+e−x)21⋅dxd(e−x)=2+ex+e−x1
从上面的式子可以看出，Sigmoid函数的导数 d y d x \frac{dy}{dx} dxdy最大值为 1 4 \frac{1}{4} 41。前向传播时， y = S i g m o i d ( x ) y=Sigmoid(x) y=Sigmoid(x)；而在反向传播过程中， x x x的梯度等于 y y y的梯度乘以Sigmoid函数的导数，如下所示：
∂ L ∂ x = ∂ L ∂ y ⋅ ∂ y ∂ x \frac{\partial{L}}{\partial{x}} = \frac{\partial{L}}{\partial{y}} \cdot \frac{\partial{y}}{\partial{x}} ∂x∂L=∂y∂L⋅∂x∂y
使得 x x x的梯度数值最大也不会超过 y y y的梯度的 1 4 \frac{1}{4} 41。
由于最开始是将神经网络的参数随机初始化的， x x x的取值很有可能在很大或者很小的区域，这些地方都可能造成Sigmoid函数的导数接近于0，导致 x x x的梯度接近于0；即使 x x x取值在接近于0的地方，按上面的分析，经过Sigmoid函数反向传播之后， x x x的梯度不超过 y y y的梯度的 1 4 \frac{1}{4} 41，如果有多层网络使用了Sigmoid激活函数，则比较靠后的那些层梯度将衰减到非常小的值。
ReLU函数则不同，虽然在 x < 0 x\lt 0 x<0的地方，ReLU函数的导数为0。但是在 x ≥ 0 x\ge 0 x≥0的地方，ReLU函数的导数为1，能够将 y y y的梯度完整的传递给 x x x，而不会引起梯度消失。
批归一化（Batch Normalization）
批归一化方法（Batch Normalization，BatchNorm）是由Ioffe和Szegedy于2015年提出的，已被广泛应用在深度学习中，其目的是对神经网络中间层的输出进行标准化处理，使得中间层的输出更加稳定。
通常我们会对神经网络的数据进行标准化处理，处理后的样本数据集满足均值为0，方差为1的统计分布，这是因为当输入数据的分布比较固定时，有利于算法的稳定和收敛。对于深度神经网络来说，由于参数是不断更新的，即使输入数据已经做过标准化处理，但是对于比较靠后的那些层，其接收到的输入仍然是剧烈变化的，通常会导致数值不稳定，模型很难收敛。BatchNorm能够使神经网络中间层的输出变得更加稳定，并有如下三个优点：
-
使学习快速进行（能够使用较大的学习率）
-
降低模型对初始值的敏感性
-
从一定程度上抑制过拟合
BatchNorm主要思路是在训练时以mini-batch为单位，对神经元的数值进行归一化，使数据的分布满足均值为0，方差为1。具体计算过程如下：
1. 计算mini-batch内样本的均值
μ B ← 1 m ∑ i = 1 m x ( i ) \mu_B \leftarrow \frac{1}{m}\sum_{i=1}^mx^{(i)} μB←m1i=1∑mx(i)
其中 x ( i ) x^{(i)} x(i)表示mini-batch中的第 i i i个样本。
例如输入mini-batch包含3个样本，每个样本有2个特征，分别是：
x ( 1 ) = ( 1 , 2 ) , x ( 2 ) = ( 3 , 6 ) , x ( 3 ) = ( 5 , 10 ) x^{(1)} = (1,2), \ \ x^{(2)} = (3,6), \ \ x^{(3)} = (5,10) x(1)=(1,2), x(2)=(3,6), x(3)=(5,10)
对每个特征分别计算mini-batch内样本的均值：
μ B 0 = 1 + 3 + 5 3 = 3 , μ B 1 = 2 + 6 + 10 3 = 6 \mu_{B0} = \frac{1+3+5}{3} = 3, \ \ \ \mu_{B1} = \frac{2+6+10}{3} = 6 μB0=31+3+5=3, μB1=32+6+10=6
则样本均值是:
μ B = ( μ B 0 , μ B 1 ) = ( 3 , 6 ) \mu_{B} = (\mu_{B0}, \mu_{B1}) = (3, 6) μB=(μB0,μB1)=(3,6)
2. 计算mini-batch内样本的方差
σ B 2 ← 1 m ∑ i = 1 m ( x ( i ) − μ B ) 2 \sigma_B^2 \leftarrow \frac{1}{m}\sum_{i=1}^m(x^{(i)} - \mu_B)^2 σB2←m1i=1∑m(x(i)−μB)2
上面的计算公式先计算一个批次内样本的均值 μ B \mu_B μB和方差 σ B 2 \sigma_B^2 σB2，然后再对输入数据做归一化，将其调整成均值为0，方差为1的分布。
对于上述给定的输入数据 x ( 1 ) , x ( 2 ) , x ( 3 ) x^{(1)}, x^{(2)}, x^{(3)} x(1),x(2),x(3)，可以计算出每个特征对应的方差：
σ B 0 2 = 1 3 ⋅ ( ( 1 − 3 ) 2 + ( 3 − 3 ) 2 + ( 5 − 3 ) 2 ) = 8 3 \sigma_{B0}^2 = \frac{1}{3} \cdot ((1-3)^2 + (3-3)^2 + (5-3)^2) = \frac{8}{3} σB02=31⋅((1−3)2+(3−3)2+(5−3)2)=38
σ B 1 2 = 1 3 ⋅ ( ( 2 − 6 ) 2 + ( 6 − 6 ) 2 + ( 10 − 6 ) 2 ) = 32 3 \sigma_{B1}^2 = \frac{1}{3} \cdot ((2-6)^2 + (6-6)^2 + (10-6)^2) = \frac{32}{3} σB12=31⋅((2−6)2+(6−6)2+(10−6)2)=332
则样本方差是：
σ B 2 = ( σ B 0 2 , σ B 1 2 ) = ( 8 3 , 32 3 ) \sigma_{B}^2 = (\sigma_{B0}^2, \sigma_{B1}^2) = (\frac{8}{3}, \frac{32}{3}) σB2=(σB02,σB12)=(38,332)
3. 计算标准化之后的输出
x ^ ( i ) ← x ( i ) − μ B ( σ B 2 + ϵ ) \hat{x}^{(i)} \leftarrow \frac{x^{(i)} - \mu_B}{\sqrt{(\sigma_B^2 + \epsilon)}} x^(i)←(σB2+ϵ) x(i)−μB
其中 ϵ \epsilon ϵ是一个微小值（例如 1 e − 7 1e-7 1e−7），其主要作用是为了防止分母为0。
对于上述给定的输入数据 x ( 1 ) , x ( 2 ) , x ( 3 ) x^{(1)}, x^{(2)}, x^{(3)} x(1),x(2),x(3)，可以计算出标准化之后的输出：
x ^ ( 1 ) = ( 1 − 3 8 3 , 2 − 6 32 3 ) = ( − 3 2 , − 3 2 ) \hat{x}^{(1)} = (\frac{1 - 3}{\sqrt{\frac{8}{3}}}, \ \ \frac{2 - 6}{\sqrt{\frac{32}{3}}}) = (-\sqrt{\frac{3}{2}}, \ \ -\sqrt{\frac{3}{2}}) x^(1)=(38 1−3, 332 2−6)=(−23 , −23 )
x ^ ( 2 ) = ( 3 − 3 8 3 , 6 − 6 32 3 ) = ( 0 , 0 ) \hat{x}^{(2)} = (\frac{3 - 3}{\sqrt{\frac{8}{3}}}, \ \ \frac{6 - 6}{\sqrt{\frac{32}{3}}}) = (0, \ \ 0) \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ x^(2)=(38 3−3, 332 6−6)=(0, 0)
x ^ ( 3 ) = ( 5 − 3 8 3 , 10 − 6 32 3 ) = ( 3 2 , 3 2 ) \hat{x}^{(3)} = (\frac{5 - 3}{\sqrt{\frac{8}{3}}}, \ \ \frac{10 - 6}{\sqrt{\frac{32}{3}}}) = (\sqrt{\frac{3}{2}}, \ \ \sqrt{\frac{3}{2}}) \ \ \ \ x^(3)=(38 5−3, 332 10−6)=(23 , 23 )
- 读者可以自行验证由 x ^ ( 1 ) , x ^ ( 2 ) , x ^ ( 3 ) \hat{x}^{(1)}, \hat{x}^{(2)}, \hat{x}^{(3)} x^(1),x^(2),x^(3)构成的mini-batch，是否满足均值为0，方差为1的分布。
如果强行限制输出层的分布是标准化的，可能会导致某些特征模式的丢失，所以在标准化之后，BatchNorm会紧接着对数据做缩放和平移。
y i ← γ x i ^ + β y_i \leftarrow \gamma \hat{x_i} + \beta yi←γxi^+β
其中 γ \gamma γ和 β \beta β是可学习的参数，可以赋初始值 γ = 1 , β = 0 \gamma = 1, \beta = 0 γ=1,β=0，在训练过程中不断学习调整。
上面列出的是BatchNorm方法的计算逻辑，下面针对两种类型的输入数据格式分别进行举例。飞桨支持输入数据的维度大小为2、3、4、5四种情况，这里给出的是维度大小为2和4的示例。
- 示例一： 当输入数据形状是 [ N , K ] [N, K] [N,K]时，一般对应全连接层的输出，示例代码如下所示。
这种情况下会分别对K的每一个分量计算N个样本的均值和方差，数据和参数对应如下：
- 输入 x, [N, K]
- 输出 y, [N, K]
- 均值 μ B \mu_B μB，[K, ]
- 方差 σ B 2 \sigma_B^2 σB2, [K, ]
- 缩放参数 γ \gamma γ, [K, ]
- 平移参数 β \beta β, [K, ]
# 输入数据形状是 [N, K]时的示例
import numpy as np
import paddle
from paddle.nn import BatchNorm1D
# 创建数据
data = np.array([[1,2,3], [4,5,6], [7,8,9]]).astype('float32')
# 使用BatchNorm1D计算归一化的输出
# 输入数据维度[N, K]，num_features等于K
bn = BatchNorm1D(num_features=3)
x = paddle.to_tensor(data)
y = bn(x)
print('output of BatchNorm1D Layer: \n {}'.format(y.numpy()))
# 使用Numpy计算均值、方差和归一化的输出
# 这里对第0个特征进行验证
a = np.array([1,4,7])
a_mean = a.mean()
a_std = a.std()
b = (a - a_mean) / a_std
print('std {}, mean {}, \n output {}'.format(a_mean, a_std, b))
# 建议读者对第1和第2个特征进行验证，观察numpy计算结果与paddle计算结果是否一致
- 示例二： 当输入数据形状是 [ N , C , H , W ] [N, C, H, W] [N,C,H,W]时， 一般对应卷积层的输出，示例代码如下所示。
这种情况下会沿着C这一维度进行展开，分别对每一个通道计算N个样本中总共 N × H × W N\times H \times W N×H×W个像素点的均值和方差，数据和参数对应如下：
- 输入 x, [N, C, H, W]
- 输出 y, [N, C, H, W]
- 均值 μ B \mu_B μB，[C, ]
- 方差 σ B 2 \sigma_B^2 σB2, [C, ]
- 缩放参数 γ \gamma γ, [C, ]
- 平移参数 β \beta β, [C, ]
小窍门：
可能有读者会问：“BatchNorm里面不是还要对标准化之后的结果做仿射变换吗，怎么使用Numpy计算的结果与BatchNorm算子一致？” 这是因为BatchNorm算子里面自动设置初始值 γ = 1 , β = 0 \gamma = 1, \beta = 0 γ=1,β=0，这时候仿射变换相当于是恒等变换。在训练过程中这两个参数会不断的学习，这时仿射变换就会起作用。
# 输入数据形状是[N, C, H, W]时的batchnorm示例
import numpy as np
import paddle
from paddle.nn import BatchNorm2D
# 设置随机数种子，这样可以保证每次运行结果一致
np.random.seed(100)
# 创建数据
data = np.random.rand(2,3,3,3).astype('float32')
# 使用BatchNorm2D计算归一化的输出
# 输入数据维度[N, C, H, W]，num_features等于C
bn = BatchNorm2D(num_features=3)
x = paddle.to_tensor(data)
y = bn(x)
print('input of BatchNorm2D Layer: \n {}'.format(x.numpy()))
print('output of BatchNorm2D Layer: \n {}'.format(y.numpy()))
# 取出data中第0通道的数据，
# 使用numpy计算均值、方差及归一化的输出
a = data[:, 0, :, :]
a_mean = a.mean()
a_std = a.std()
b = (a - a_mean) / a_std
print('channel 0 of input data: \n {}'.format(a))
print('std {}, mean {}, \n output: \n {}'.format(a_mean, a_std, b))
# 提示：这里通过numpy计算出来的输出
# 与BatchNorm2D算子的结果略有差别，
# 因为在BatchNorm2D算子为了保证数值的稳定性，
# 在分母里面加上了一个比较小的浮点数epsilon=1e-05
- 预测时使用BatchNorm
上面介绍了在训练过程中使用BatchNorm对一批样本进行归一化的方法，但如果使用同样的方法对需要预测的一批样本进行归一化，则预测结果会出现不确定性。
例如样本A、样本B作为一批样本计算均值和方差，与样本A、样本C和样本D作为一批样本计算均值和方差，得到的结果一般来说是不同的。那么样本A的预测结果就会变得不确定，这对预测过程来说是不合理的。解决方法是在训练过程中将大量样本的均值和方差保存下来，预测时直接使用保存好的值而不再重新计算。实际上，在BatchNorm的具体实现中，训练时会计算均值和方差的移动平均值。在飞桨中，默认是采用如下方式计算：
s a v e d _ μ B ← s a v e d _ μ B × 0.9 + μ B × ( 1 − 0.9 ) saved\_\mu_B \leftarrow \ saved\_\mu_B \times 0.9 + \mu_B \times (1 - 0.9) saved_μB← saved_μB×0.9+μB×(1−0.9)
s a v e d _ σ B 2 ← s a v e d _ σ B 2 × 0.9 + σ B 2 × ( 1 − 0.9 ) saved\_\sigma_B^2 \leftarrow \ saved\_\sigma_B^2 \times 0.9 + \sigma_B^2 \times (1 - 0.9) saved_σB2← saved_σB2×0.9+σB2×(1−0.9)
在训练过程的最开始将 s a v e d _ μ B saved\_\mu_B saved_μB和 s a v e d _ σ B 2 saved\_\sigma_B^2 saved_σB2设置为0，每次输入一批新的样本，计算出 μ B \mu_B μB和 σ B 2 \sigma_B^2 σB2，然后通过上面的公式更新 s a v e d _ μ B saved\_\mu_B saved_μB和 s a v e d _ σ B 2 saved\_\sigma_B^2 saved_σB2，在训练的过程中不断的更新它们的值，并作为BatchNorm层的参数保存下来。预测的时候将会加载参数 s a v e d _ μ B saved\_\mu_B saved_μB和 s a v e d _ σ B 2 saved\_\sigma_B^2 saved_σB2，用他们来代替 μ B \mu_B μB和 σ B 2 \sigma_B^2 σB2。
丢弃法（Dropout）
丢弃法（Dropout）是深度学习中一种常用的抑制过拟合的方法，其做法是在神经网络学习过程中，随机删除一部分神经元。训练时，随机选出一部分神经元，将其输出设置为0，这些神经元将不对外传递信号。
图16 是Dropout示意图，左边是完整的神经网络，右边是应用了Dropout之后的网络结构。应用Dropout之后，会将标了
×
\times
×的神经元从网络中删除，让它们不向后面的层传递信号。在学习过程中，丢弃哪些神经元是随机决定，因此模型不会过度依赖某些神经元，能一定程度上抑制过拟合。
图16 Dropout示意图
在预测场景时，会向前传递所有神经元的信号，可能会引出一个新的问题：训练时由于部分神经元被随机丢弃了，输出数据的总大小会变小。比如：计算其 L 1 L1 L1范数会比不使用Dropout时变小，但是预测时却没有丢弃神经元，这将导致训练和预测时数据的分布不一样。为了解决这个问题，飞桨支持如下两种方法：
- downscale_in_infer
训练时以比例 r r r随机丢弃一部分神经元，不向后传递它们的信号；预测时向后传递所有神经元的信号，但是将每个神经元上的数值乘以 ( 1 − r ) (1 - r) (1−r)。
- upscale_in_train
训练时以比例 r r r随机丢弃一部分神经元，不向后传递它们的信号，但是将那些被保留的神经元上的数值除以 ( 1 − r ) (1 - r) (1−r)；预测时向后传递所有神经元的信号，不做任何处理。
在飞桨Dropout API中，通过mode参数来指定用哪种方式对神经元进行操作，
paddle.nn.Dropout(p=0.5, axis=None, mode="upscale_in_train”, name=None)
主要参数如下：
-
p (float) ：将输入节点置为0的概率，即丢弃概率，默认值：0.5。该参数对元素的丢弃概率是针对于每一个元素而言，而不是对所有的元素而言。举例说，假设矩阵内有12个数字，经过概率为0.5的dropout未必一定有6个零。
-
mode(str) ：丢弃法的实现方式，有’downscale_in_infer’和’upscale_in_train’两种，默认是’upscale_in_train’。
说明：
不同框架对于Dropout的默认处理方式可能不同，读者可以查看API详细了解。
下面这段程序展示了经过Dropout之后输出数据的形式。
# dropout操作
import paddle
import numpy as np
# 设置随机数种子，这样可以保证每次运行结果一致
np.random.seed(100)
# 创建数据[N, C, H, W]，一般对应卷积层的输出
data1 = np.random.rand(2,3,3,3).astype('float32')
# 创建数据[N, K]，一般对应全连接层的输出
data2 = np.arange(1,13).reshape([-1, 3]).astype('float32')
# 使用dropout作用在输入数据上
x1 = paddle.to_tensor(data1)
# downgrade_in_infer模式下
drop11 = paddle.nn.Dropout(p = 0.5, mode = 'downscale_in_infer')
droped_train11 = drop11(x1)
# 切换到eval模式。在动态图模式下，使用eval（）切换到求值模式，该模式禁用了dropout。
drop11.eval()
droped_eval11 = drop11(x1)
# upscale_in_train模式下
drop12 = paddle.nn.Dropout(p = 0.5, mode = 'upscale_in_train')
droped_train12 = drop12(x1)
# 切换到eval模式
drop12.eval()
droped_eval12 = drop12(x1)
x2 = paddle.to_tensor(data2)
drop21 = paddle.nn.Dropout(p = 0.5, mode = 'downscale_in_infer')
droped_train21 = drop21(x2)
# 切换到eval模式
drop21.eval()
droped_eval21 = drop21(x2)
drop22 = paddle.nn.Dropout(p = 0.5, mode = 'upscale_in_train')
droped_train22 = drop22(x2)
# 切换到eval模式
drop22.eval()
droped_eval22 = drop22(x2)
print('x1 {}, \n droped_train11 \n {}, \n droped_eval11 \n {}'.format(data1, droped_train11.numpy(), droped_eval11.numpy()))
print('x1 {}, \n droped_train12 \n {}, \n droped_eval12 \n {}'.format(data1, droped_train12.numpy(), droped_eval12.numpy()))
print('x2 {}, \n droped_train21 \n {}, \n droped_eval21 \n {}'.format(data2, droped_train21.numpy(), droped_eval21.numpy()))
print('x2 {}, \n droped_train22 \n {}, \n droped_eval22 \n {}'.format(data2, droped_train22.numpy(), droped_eval22.numpy()))
从上述代码的输出可以发现，经过dropout之后，tensor中的某些元素变为了0，这个就是dropout实现的功能，通过随机将输入数据的元素置0，消除减弱了神经元节点间的联合适应性，增强模型的泛化能力。
总结
来源于：飞桨的免费课程