零基础入门深度学习(4) - 卷积神经网络

• ；
• 计算每个神经元连接权重的梯度（表示从神经元连接到神经元的权重），公式为

3. ，其中，表示神经元的输出。

最后，根据梯度下降法则更新每个权重即可。

对于卷积神经网络，由于涉及到局部连接、下采样的等操作，影响到了第二步误差项的具体计算方法，而权值共享影响了第三步权重的梯度的计算方法。接下来，我们分别介绍卷积层和Pooling层的训练算法。

卷积层的训练

对于卷积层，我们先来看看上面的第二步，即如何将误差项传递到上一层；然后再来看看第三步，即如何计算filter每个权值的梯度。

卷积层误差项的传递

最简单情况下误差项的传递

我们先来考虑步长为1、输入的深度为1、filter个数为1的最简单的情况。

假设输入的大小为3*3，filter大小为2*2，按步长为1卷积，我们将得到2*2的feature map。如下图所示：

在上图中，为了描述方便，我们为每个元素都进行了编号。用表示第层第行第列的误差项；用表示filter第行第列权重，用表示filter的偏置项；用表示第层第行第列神经元的输出；用表示第行神经元的加权输入；用表示第层第行第列的误差项；用表示第层的激活函数。它们之间的关系如下：

上式中，、、都是数组，是由组成的数组，表示卷积操作。

在这里，我们假设第中的每个值都已经算好，我们要做的是计算第层每个神经元的误差项。

根据链式求导法则：

我们先求第一项

。我们先来看几个特例，然后从中总结出一般性的规律。

例1，计算

，仅与的计算有关：

因此：

例2，计算

，与和的计算都有关：

因此：

例3，计算

，与、、和的计算都有关：

因此：

从上面三个例子，我们发挥一下想象力，不难发现，计算

，相当于把第层的sensitive map周围补一圈0，在与180度翻转后的filter进行cross-correlation，就能得到想要结果，如下图所示：

因为卷积相当于将filter旋转180度的cross-correlation，因此上图的计算可以用卷积公式完美的表达：

上式中的表示第层的filter的权重数组。也可以把上式的卷积展开，写成求和的形式：

现在，我们再求第二项

。因为

所以这一项极其简单，仅求激活函数的导数就行了。

将第一项和第二项组合起来，我们得到最终的公式：

也可以将式7写成卷积的形式：

其中，符号表示element-wise product，即将矩阵中每个对应元素相乘。注意式8中的、、都是矩阵。

以上就是步长为1、输入的深度为1、filter个数为1的最简单的情况，卷积层误差项传递的算法。下面我们来推导一下步长为S的情况。

卷积步长为S时的误差传递

我们先来看看步长为S与步长为1的差别。

如上图，上面是步长为1时的卷积结果，下面是步长为2时的卷积结果。我们可以看出，因为步长为2，得到的feature map跳过了步长为1时相应的部分。因此，当我们反向计算误差项时，我们可以对步长为S的sensitivity map相应的位置进行补0，将其『还原』成步长为1时的sensitivity map，再用式8进行求解。

输入层深度为D时的误差传递

当输入深度为D时，filter的深度也必须为D，层的通道只与filter的通道的权重进行计算。因此，反向计算误差项时，我们可以使用式8，用filter的第通道权重对第层sensitivity map进行卷积，得到第层通道的sensitivity map。如下图所示：

filter数量为N时的误差传递

filter数量为N时，输出层的深度也为N，第个filter卷积产生输出层的第个feature map。由于第层每个加权输入都同时影响了第层所有feature map的输出值，因此，反向计算误差项时，需要使用全导数公式。也就是，我们先使用第个filter对第层相应的第个sensitivity map进行卷积，得到一组N个层的偏sensitivity map。依次用每个filter做这种卷积，就得到D组偏sensitivity map。最后在各组之间将N个偏sensitivity map 按元素相加，得到最终的N个层的sensitivity map：

以上就是卷积层误差项传递的算法，如果读者还有所困惑，可以参考后面的代码实现来理解。

卷积层filter权重梯度的计算

我们要在得到第层sensitivity map的情况下，计算filter的权重的梯度，由于卷积层是权重共享的，因此梯度的计算稍有不同。

如上图所示，是第层的输出，是第层filter的权重，是第层的sensitivity map。我们的任务是计算的梯度，即

。

为了计算偏导数，我们需要考察权重对的影响。权重项通过影响的值，进而影响。我们仍然通过几个具体的例子来看权重项对的影响，然后再从中总结出规律。

例1，计算

：

从上面的公式看出，由于权值共享，权值对所有的都有影响。是、、...的函数，而、、...又是的函数，根据全导数公式，计算

就是要把每个偏导数都加起来：

例2，计算

：

通过查看与的关系，我们很容易得到：

实际上，每个权重项都是类似的，我们不一一举例了。现在，是我们再次发挥想象力的时候，我们发现计算

规律是：

也就是用sensitivity map作为卷积核，在input上进行cross-correlation，如下图所示：

最后，我们来看一看偏置项的梯度

。通过查看前面的公式，我们很容易发现：

也就是偏置项的梯度就是sensitivity map所有误差项之和。

对于步长为S的卷积层，处理方法与传递**误差项*是一样的，首先将sensitivity map『还原』成步长为1时的sensitivity map，再用上面的方法进行计算。

获得了所有的梯度之后，就是根据梯度下降算法来更新每个权重。这在前面的文章中已经反复写过，这里就不再重复了。

至此，我们已经解决了卷积层的训练问题，接下来我们看一看Pooling层的训练。

Pooling层的训练

无论max pooling还是mean pooling，都没有需要学习的参数。因此，在卷积神经网络的训练中，Pooling层需要做的仅仅是将误差项传递到上一层，而没有梯度的计算。

Max Pooling误差项的传递

如下图，假设第层大小为4*4，pooling filter大小为2*2，步长为2，这样，max pooling之后，第层大小为2*2。假设第层的值都已经计算完毕，我们现在的任务是计算第层的值。

我们用表示第层的加权输入；用表示第层的加权输入。我们先来考察一个具体的例子，然后再总结一般性的规律。对于max pooling：

也就是说，只有区块中最大的才会对的值产生影响。我们假设最大的值是，则上式相当于：

那么，我们不难求得下面几个偏导数：

因此：

而：

现在，我们发现了规律：对于max pooling，下一层的误差项的值会原封不动的传递到上一层对应区块中的最大值所对应的神经元，而其他神经元的误差项的值都是0。如下图所示(假设、、、为所在区块中的最大输出值)：

Mean Pooling误差项的传递

我们还是用前面屡试不爽的套路，先研究一个特殊的情形，再扩展为一般规律。

如上图，我们先来考虑计算。我们先来看看如何影响。

根据上式，我们一眼就能看出来：

所以，根据链式求导法则，我们不难算出：

同样，我们可以算出、、：

现在，我们发现了规律：对于mean pooling，下一层的误差项的值会平均分配到上一层对应区块中的所有神经元。如下图所示：

上面这个算法可以表达为高大上的克罗内克积(Kronecker product)的形式，有兴趣的读者可以研究一下。

其中，是pooling层filter的大小，、都是矩阵。

至此，我们已经把卷积层、Pooling层的训练算法介绍完毕，加上上一篇文章讲的全连接层训练算法，您应该已经具备了编写卷积神经网络代码所需要的知识。为了加深对知识的理解，接下来，我们将展示如何实现一个简单的卷积神经网络。

卷积神经网络的实现

完整代码请参考GitHub: https://github.com/hanbt/learn_dl/blob/master/cnn.py (python2.7)

现在，我们亲自动手实现一个卷积神经网络，以便巩固我们所学的知识。

首先，我们要改变一下代码的架构，『层』成为了我们最核心的组件。这是因为卷积神经网络有不同的层，而每种层的算法都在对应的类中实现。

这次，我们用到了在python中编写算法经常会用到的numpy包。为了使用numpy，我们需要先将numpy导入：

1. import numpy as np

卷积层的实现

卷积层初始化

我们用ConvLayer类来实现一个卷积层。下面的代码是初始化一个卷积层，可以在构造函数中设置卷积层的超参数。

1. class ConvLayer(object):
2. def __init__(self, input_width, input_height,
3. channel_number, filter_width,
4. filter_height, filter_number,
5. zero_padding, stride, activator,
6. learning_rate):
7. self.input_width = input_width
8. self.input_height = input_height
9. self.channel_number = channel_number
10. self.filter_width = filter_width
11. self.filter_height = filter_height
12. self.filter_number = filter_number
13. self.zero_padding = zero_padding
14. self.stride = stride
15. self.output_width = \
16. ConvLayer.calculate_output_size(
17. self.input_width, filter_width, zero_padding,
18. stride)
19. self.output_height = \
20. ConvLayer.calculate_output_size(
21. self.input_height, filter_height, zero_padding,
22. stride)
23. self.output_array = np.zeros((self.filter_number,
24. self.output_height, self.output_width))
25. self.filters = []
26. for i in range(filter_number):
27. self.filters.append(Filter(filter_width,
28. filter_height, self.channel_number))
29. self.activator = activator
30. self.learning_rate = learning_rate

calculate_output_size函数用来确定卷积层输出的大小，其实现如下：

1. @staticmethod
2. def calculate_output_size(input_size,
3. filter_size, zero_padding, stride):
4. return (input_size - filter_size +
5. 2 * zero_padding) / stride + 1

Filter类保存了卷积层的参数以及梯度，并且实现了用梯度下降算法来更新参数。

1. class Filter(object):
2. def __init__(self, width, height, depth):
3. self.weights = np.random.uniform(-1e-4, 1e-4,
4. (depth, height, width))
5. self.bias = 0
6. self.weights_grad = np.zeros(
7. self.weights.shape)
8. self.bias_grad = 0
10. def __repr__(self):
11. return ‘filter weights:\n%s\nbias:\n%s‘ % (
12. repr(self.weights), repr(self.bias))
14. def get_weights(self):
15. return self.weights
17. def get_bias(self):
18. return self.bias
20. def update(self, learning_rate):
21. self.weights -= learning_rate * self.weights_grad
22. self.bias -= learning_rate * self.bias_grad

我们对参数的初始化采用了常用的策略，即：权重随机初始化为一个很小的值，而偏置项初始化为0。

Activator类实现了激活函数，其中，forward方法实现了前向计算，而backward方法则是计算导数。比如，relu函数的实现如下：

1. class ReluActivator(object):
2. def forward(self, weighted_input):
3. #return weighted_input
4. return max(0, weighted_input)
6. def backward(self, output):
7. return 1 if output > 0 else 0

卷积层前向计算的实现

ConvLayer类的forward方法实现了卷积层的前向计算（即计算根据输入来计算卷积层的输出），下面是代码实现：

1. def forward(self, input_array):
2. ‘‘‘
3. 计算卷积层的输出
4. 输出结果保存在self.output_array
5. ‘‘‘
6. self.input_array = input_array
7. self.padded_input_array = padding(input_array,
8. self.zero_padding)
9. for f in range(self.filter_number):
10. filter = self.filters[f]
11. conv(self.padded_input_array,
12. filter.get_weights(), self.output_array[f],
13. self.stride, filter.get_bias())
14. element_wise_op(self.output_array,
15. self.activator.forward)

上面的代码里面包含了几个工具函数。element_wise_op函数实现了对numpy数组进行按元素操作，并将返回值写回到数组中，代码如下：

1. # 对numpy数组进行element wise操作
2. def element_wise_op(array, op):
3. for i in np.nditer(array,
4. op_flags=[‘readwrite‘]):
5. i[...] = op(i)

conv函数实现了2维和3维数组的卷积，代码如下：

1. def conv(input_array,
2. kernel_array,
3. output_array,
4. stride, bias):
5. ‘‘‘
6. 计算卷积，自动适配输入为2D和3D的情况
7. ‘‘‘
8. channel_number = input_array.ndim
9. output_width = output_array.shape[1]
10. output_height = output_array.shape[0]
11. kernel_width = kernel_array.shape[-1]
12. kernel_height = kernel_array.shape[-2]
13. for i in range(output_height):
14. for j in range(output_width):
15. output_array[i][j] = (
16. get_patch(input_array, i, j, kernel_width,
17. kernel_height, stride) * kernel_array
18. ).sum() + bias

padding函数实现了zero padding操作：

1. # 为数组增加Zero padding
2. def padding(input_array, zp):
3. ‘‘‘
4. 为数组增加Zero padding，自动适配输入为2D和3D的情况
5. ‘‘‘
6. if zp == 0:
7. return input_array
8. else:
9. if input_array.ndim == 3:
10. input_width = input_array.shape[2]
11. input_height = input_array.shape[1]
12. input_depth = input_array.shape[0]
13. padded_array = np.zeros((
14. input_depth,
15. input_height + 2 * zp,
16. input_width + 2 * zp))
17. padded_array[:,
18. zp : zp + input_height,
19. zp : zp + input_width] = input_array
20. return padded_array
21. elif input_array.ndim == 2:
22. input_width = input_array.shape[1]
23. input_height = input_array.shape[0]
24. padded_array = np.zeros((
25. input_height + 2 * zp,
26. input_width + 2 * zp))
27. padded_array[zp : zp + input_height,
28. zp : zp + input_width] = input_array
29. return padded_array

卷积层反向传播算法的实现

现在，是介绍卷积层核心算法的时候了。我们知道反向传播算法需要完成几个任务：

1. 将误差项传递到上一层。
2. 计算每个参数的梯度。
3. 更新参数。

以下代码都是在ConvLayer类中实现。我们先来看看将误差项传递到上一层的代码实现。

1. def bp_sensitivity_map(self, sensitivity_array,
2. activator):
3. ‘‘‘
4. 计算传递到上一层的sensitivity map
5. sensitivity_array: 本层的sensitivity map
6. activator: 上一层的激活函数
7. ‘‘‘
8. # 处理卷积步长，对原始sensitivity map进行扩展
9. expanded_array = self.expand_sensitivity_map(
10. sensitivity_array)
11. # full卷积，对sensitivitiy map进行zero padding
12. # 虽然原始输入的zero padding单元也会获得残差
13. # 但这个残差不需要继续向上传递，因此就不计算了
14. expanded_width = expanded_array.shape[2]
15. zp = (self.input_width +
16. self.filter_width - 1 - expanded_width) / 2
17. padded_array = padding(expanded_array, zp)
18. # 初始化delta_array，用于保存传递到上一层的
19. # sensitivity map
20. self.delta_array = self.create_delta_array()
21. # 对于具有多个filter的卷积层来说，最终传递到上一层的
22. # sensitivity map相当于所有的filter的
23. # sensitivity map之和
24. for f in range(self.filter_number):
25. filter = self.filters[f]
26. # 将filter权重翻转180度
27. flipped_weights = np.array(map(
28. lambda i: np.rot90(i, 2),
29. filter.get_weights()))
30. # 计算与一个filter对应的delta_array
31. delta_array = self.create_delta_array()
32. for d in range(delta_array.shape[0]):
33. conv(padded_array[f], flipped_weights[d],
34. delta_array[d], 1, 0)
35. self.delta_array += delta_array
36. # 将计算结果与激活函数的偏导数做element-wise乘法操作
37. derivative_array = np.array(self.input_array)
38. element_wise_op(derivative_array,
39. activator.backward)
40. self.delta_array *= derivative_array

expand_sensitivity_map方法就是将步长为S的sensitivity map『还原』为步长为1的sensitivity map，代码如下：

1. def expand_sensitivity_map(self, sensitivity_array):
2. depth = sensitivity_array.shape[0]
3. # 确定扩展后sensitivity map的大小
4. # 计算stride为1时sensitivity map的大小
5. expanded_width = (self.input_width -
6. self.filter_width + 2 * self.zero_padding + 1)
7. expanded_height = (self.input_height -
8. self.filter_height + 2 * self.zero_padding + 1)
9. # 构建新的sensitivity_map
10. expand_array = np.zeros((depth, expanded_height,
11. expanded_width))
12. # 从原始sensitivity map拷贝误差值
13. for i in range(self.output_height):
14. for j in range(self.output_width):
15. i_pos = i * self.stride
16. j_pos = j * self.stride
17. expand_array[:,i_pos,j_pos] = \
18. sensitivity_array[:,i,j]
19. return expand_array

create_delta_array是创建用来保存传递到上一层的sensitivity map的数组。

1. def create_delta_array(self):
2. return np.zeros((self.channel_number,
3. self.input_height, self.input_width))

接下来，是计算梯度的代码。

1. def bp_gradient(self, sensitivity_array):
2. # 处理卷积步长，对原始sensitivity map进行扩展
3. expanded_array = self.expand_sensitivity_map(
4. sensitivity_array)
5. for f in range(self.filter_number):
6. # 计算每个权重的梯度
7. filter = self.filters[f]
8. for d in range(filter.weights.shape[0]):
9. conv(self.padded_input_array[d],
10. expanded_array[f],
11. filter.weights_grad[d], 1, 0)
12. # 计算偏置项的梯度
13. filter.bias_grad = expanded_array[f].sum()

最后，是按照梯度下降算法更新参数的代码，这部分非常简单。

1. def update(self):
2. ‘‘‘
3. 按照梯度下降，更新权重
4. ‘‘‘
5. for filter in self.filters:
6. filter.update(self.learning_rate)

卷积层的梯度检查

为了验证我们的公式推导和代码实现的正确性，我们必须要对卷积层进行梯度检查。下面是代吗实现：

1. def init_test():
2. a = np.array(
3. [[[0,1,1,0,2],
4. [2,2,2,2,1],
5. [1,0,0,2,0],
6. [0,1,1,0,0],
7. [1,2,0,0,2]],
8. [[1,0,2,2,0],
9. [0,0,0,2,0],
10. [1,2,1,2,1],
11. [1,0,0,0,0],
12. [1,2,1,1,1]],
13. [[2,1,2,0,0],
14. [1,0,0,1,0],
15. [0,2,1,0,1],
16. [0,1,2,2,2],
17. [2,1,0,0,1]]])
18. b = np.array(
19. [[[0,1,1],
20. [2,2,2],
21. [1,0,0]],
22. [[1,0,2],
23. [0,0,0],
24. [1,2,1]]])
25. cl = ConvLayer(5,5,3,3,3,2,1,2,IdentityActivator(),0.001)
26. cl.filters[0].weights = np.array(
27. [[[-1,1,0],
28. [0,1,0],
29. [0,1,1]],
30. [[-1,-1,0],
31. [0,0,0],
32. [0,-1,0]],
33. [[0,0,-1],
34. [0,1,0],
35. [1,-1,-1]]], dtype=np.float64)
36. cl.filters[0].bias=1
37. cl.filters[1].weights = np.array(
38. [[[1,1,-1],
39. [-1,-1,1],
40. [0,-1,1]],
41. [[0,1,0],
42. [-1,0,-1],
43. [-1,1,0]],
44. [[-1,0,0],
45. [-1,0,1],
46. [-1,0,0]]], dtype=np.float64)
47. return a, b, cl
50. def gradient_check():
51. ‘‘‘
52. 梯度检查
53. ‘‘‘
54. # 设计一个误差函数，取所有节点输出项之和
55. error_function = lambda o: o.sum()
57. # 计算forward值
58. a, b, cl = init_test()
59. cl.forward(a)
61. # 求取sensitivity map，是一个全1数组
62. sensitivity_array = np.ones(cl.output_array.shape,
63. dtype=np.float64)
64. # 计算梯度
65. cl.backward(a, sensitivity_array,
66. IdentityActivator())
67. # 检查梯度
68. epsilon = 10e-4
69. for d in range(cl.filters[0].weights_grad.shape[0]):
70. for i in range(cl.filters[0].weights_grad.shape[1]):
71. for j in range(cl.filters[0].weights_grad.shape[2]):
72. cl.filters[0].weights[d,i,j] += epsilon
73. cl.forward(a)
74. err1 = error_function(cl.output_array)
75. cl.filters[0].weights[d,i,j] -= 2*epsilon
76. cl.forward(a)
77. err2 = error_function(cl.output_array)
78. expect_grad = (err1 - err2) / (2 * epsilon)
79. cl.filters[0].weights[d,i,j] += epsilon
80. print ‘weights(%d,%d,%d): expected - actural %f - %f‘ % (
81. d, i, j, expect_grad, cl.filters[0].weights_grad[d,i,j])

上面代码值得思考的地方在于，传递给卷积层的sensitivity map是全1数组，留给读者自己推导一下为什么是这样（提示：激活函数选择了identity函数：）。读者如果还有困惑，请写在文章评论中，我会回复。

运行上面梯度检查的代码，我们得到的输出如下，期望的梯度和实际计算出的梯度一致，这证明我们的算法推导和代码实现确实是正确的。

以上就是卷积层的实现。

Max Pooling层的实现

max pooling层的实现相对简单，我们直接贴出全部代码如下：

1. class MaxPoolingLayer(object):
2. def __init__(self, input_width, input_height,
3. channel_number, filter_width,
4. filter_height, stride):
5. self.input_width = input_width
6. self.input_height = input_height
7. self.channel_number = channel_number
8. self.filter_width = filter_width
9. self.filter_height = filter_height
10. self.stride = stride
11. self.output_width = (input_width -
12. filter_width) / self.stride + 1
13. self.output_height = (input_height -
14. filter_height) / self.stride + 1
15. self.output_array = np.zeros((self.channel_number,
16. self.output_height, self.output_width))
18. def forward(self, input_array):
19. for d in range(self.channel_number):
20. for i in range(self.output_height):
21. for j in range(self.output_width):
22. self.output_array[d,i,j] = (
23. get_patch(input_array[d], i, j,
24. self.filter_width,
25. self.filter_height,
26. self.stride).max())
28. def backward(self, input_array, sensitivity_array):
29. self.delta_array = np.zeros(input_array.shape)
30. for d in range(self.channel_number):
31. for i in range(self.output_height):
32. for j in range(self.output_width):
33. patch_array = get_patch(
34. input_array[d], i, j,
35. self.filter_width,
36. self.filter_height,
37. self.stride)
38. k, l = get_max_index(patch_array)
39. self.delta_array[d,
40. i * self.stride + k,
41. j * self.stride + l] = \
42. sensitivity_array[d,i,j]

全连接层的实现和上一篇文章类似，在此就不再赘述了。至此，你已经拥有了实现了一个简单的卷积神经网络所需要的基本组件。对于卷积神经网络，现在有很多优秀的开源实现，因此我们并不需要真的自己去实现一个。贴出这些代码的目的是为了让我们更好的了解卷积神经网络的基本原理。

卷积神经网络的应用

MNIST手写数字识别

LeNet-5是实现手写数字识别的卷积神经网络，在MNIST测试集上，它取得了0.8%的错误率。LeNet-5的结构如下：

关于LeNet-5的详细介绍，网上的资料很多，因此就不再重复了。感兴趣的读者可以尝试用我们自己实现的卷积神经网络代码去构造并训练LeNet-5（当然代码会更复杂一些）。

小节

由于卷积神经网络的复杂性，我们写出了整个系列目前为止最长的一篇文章，相信读者也和作者一样累的要死。卷积神经网络是深度学习最重要的工具（我犹豫要不要写上『之一』呢），付出一些辛苦去理解它也是值得的。如果您真正理解了本文的内容，相当于迈过了入门深度学习最重要的一到门槛。在下一篇文章中，我们介绍深度学习另外一种非常重要的工具：循环神经网络，届时我们的系列文章也将完成过半。每篇文章都是一个过滤器，对于坚持到这里的读者们，入门深度学习曙光已现，加油。

参考资料

1. CS231n Convolutional Neural Networks for Visual Recognition
2. ReLu (Rectified Linear Units) 激活函数
3. Jake Bouvrie, Notes on Convolutional Neural Networks, 2006
4. Ian Goodfellow, Yoshua Bengio, Aaron Courville, Deep Learning, MIT Press, 2016