深度学习入门(鱼书)学习笔记：第7章 卷积神经网络
第7章 卷积神经网络
7.1 整体结构
卷积神经网络（Convolutional Neural Network, CNN），新增了卷积（Convolutional）层和池化（Pooling）层。
7.2 卷积层（Convolution）
7.2.1 全连接层存在的问题
全连接层（Affine层）会忽视数据的形状。比如将三维图像数据拉平为一维数据。而卷积层可以保持数据形状不变。
7.2.2 卷积运算
Fig.7-3 卷积运算的例子
Fig.7-4 卷积运算的计算顺序
Fig.7-5 卷积运算的偏置
7.2.3 填充（Padding）
为什么需要填充？
以Fig.7-3为例，输入数据为4*4，滤波器为3*3，输出数据为2*2。在深度网络中会多次进行卷积运算，那么在某个时刻输出数据可能就变为(1,1)，导致无法再应用卷积计算。为了避免这种情况，就需要使用填充，通过调整输入数据的大小，来调整输出数据的大小，使卷积计算可以进行下去。
Fig.7-6 卷积运算的填充处理
以Fig.7-6为例，输入数据(4,4)应用了幅度为1的填充后变成(6,6)，导致输出数据保持了原始形状(4,4)。注意：填充的数据为“0”，一般省略。
7.2.4 步幅（Stride）
Fig.7-7 步幅为2的卷积运算的例子
设输入数据大小为(H,W)，滤波器大小为(FH,FW)，输出大小为(OH,OW)，填充为P，步幅为S，则输出大小可通过式(7.1)进行计算。
\[OH=\frac{H+2P-FH}{S}+1\\
OW=\frac{W+2P-FW}{S}+1
\]
以Fig.7-7为例，\(OH=OW=(7+2*0-3)/2+1=3\)，因此输出为(3,3)。
7.2.5 3维数据的卷积运算
这里的三维图像数据的第三维，是指图像的通道。这里以3通道图像为例（比如RGB三个通道）。需要注意的是，输入数据和滤波器的通道数要设定为相同的值，这里为3。计算过程为按通道进行输入数据和滤波器的卷积运算，与前文相同，最后，将三个通道的输出数据相加，得到最终结果。
Fig.7-8 对三维数据进行卷积运算的例子
Fig.7-9 对三维数据进行卷积运算的计算顺序
7.2.6 结合方块思考
本节是以方块图的形式来帮助理解三维和四维卷积运算。
三维输入数据可表示为(C,H,W)，即(通道数C,高度H,宽度W)。对应的滤波器表示为(C,FH,FW)。此时，数据输出是1张特征图。可表示为：\((C,H,W)*(C,FH,FW)=(1,OH,OW)\)。
如果要得到FN张特征图，则需要FN个滤波器（权重）。可表示为\((C,H,W)*(FN,C,FH,FW)=(FN,OH,OW)\)。比如，通道数为3、大小为5×5的滤波器有20个时，可以写成(20,3,5,5)。
Fig.7-10 用方块表示卷积运算
Fig.7-11 基于多个滤波器的卷积运算的例子
Fig.7-12 卷积运算的处理流（追加了偏置项）
7.2.7 批处理
批处理将输入数据(C,H,W)扩展成(N,C,H,W)，N表示N个数据。
Fig.7-13 卷积运算的处理流（批处理）
7.3 池化层（Pooling）
池化 是缩小高、长方向上的空间的运算。
Fig.7-14 Max池化的处理顺序
图7-14的例子是按步幅2进行2 × 2的Max池化时的处理顺序。“Max池化”是获取最大值的运算，“2 × 2”表示目标区域的大小。除了Max池化，还有平均池化等其它方式，但在图像识别领域，主要用Max池化。
7.4 卷积层和池化层的实现
7.4.1 四维数组
7.4.2 基于im2col的展开
源代码在commom/util.py中：
点击查看im2col代码
def im2col(input_data, filter_h, filter_w, stride=1, pad=0):
"""
Parameters
----------
input_data : 由(数据量, 通道, 高, 长)的4维数组构成的输入数据
filter_h : 滤波器的高
filter_w : 滤波器的长
stride : 步幅
pad : 填充
Returns
-------
col : 2维数组
"""
N, C, H, W = input_data.shape
out_h = (H + 2*pad - filter_h)//stride + 1
out_w = (W + 2*pad - filter_w)//stride + 1
img = np.pad(input_data, [(0, 0), (0, 0), (pad, pad), (pad, pad)], 'constant')
col = np.zeros((N, C, filter_h, filter_w, out_h, out_w))
for y in range(filter_h):
y_max = y + stride*out_h
for x in range(filter_w):
x_max = x + stride*out_w
col[:, :, y, x, :, :] = img[:, :, y:y_max:stride, x:x_max:stride]
col = col.transpose(0, 4, 5, 1, 2, 3).reshape(N*out_h*out_w, -1)
return col
7.4.3 卷积层的实现
源代码在common/layers中，类class Convolution的实现如下：
点击查看class Convolution代码
# 卷积层
class Convolution:
def __init__(self, W, b, stride=1, pad=0):
self.W = W
self.b = b
self.stride = stride
self.pad = pad
# 中间数据（backward时使用）
self.x = None
self.col = None
self.col_W = None
# 权重和偏置参数的梯度
self.dW = None
self.db = None
def forward(self, x):
FN, C, FH, FW = self.W.shape
N, C, H, W = x.shape
out_h = 1 + int((H + 2*self.pad - FH) / self.stride)
out_w = 1 + int((W + 2*self.pad - FW) / self.stride)
col = im2col(x, FH, FW, self.stride, self.pad) # 输入数据的展开
col_W = self.W.reshape(FN, -1).T # 滤波器的展开，展开为FN列。参数指定为-1，reshape会自动计算出元素个数
out = np.dot(col, col_W) + self.b # 展开之后复用矩阵相乘进行高效计算
out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)
self.x = x
self.col = col
self.col_W = col_W
return out
def backward(self, dout):
FN, C, FH, FW = self.W.shape
dout = dout.transpose(0, 2, 3, 1).reshape(-1, FN)
self.db = np.sum(dout, axis=0)
self.dW = np.dot(self.col.T, dout)
self.dW = self.dW.transpose(1, 0).reshape(FN, C, FH, FW)
dcol = np.dot(dout, self.col_W.T)
dx = col2im(dcol, self.x.shape, FH, FW, self.stride, self.pad)
return dx
数据的变形没看懂，需要用小例子跑下。比如(2,2)三通道的2份数据(2,3,2,2)。
Fig.7-20中的(N,C,H,W)是否应该为(N,FN,H,W)，如Fig.7-13所示。
7.4.4 池化层的实现
源代码在common/layers中，类class Pooling的实现如下：
点击查看class Pooling代码
# 池化层
class Pooling:
def __init__(self, pool_h, pool_w, stride=1, pad=0):
self.pool_h = pool_h
self.pool_w = pool_w
self.stride = stride
self.pad = pad
self.x = None
self.arg_max = None
def forward(self, x):
N, C, H, W = x.shape
out_h = int(1 + (H - self.pool_h) / self.stride)
out_w = int(1 + (W - self.pool_w) / self.stride)
# 第1步展开输入数据
col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
col = col.reshape(-1, self.pool_h*self.pool_w)
# 第2步求各行最大值
arg_max = np.argmax(col, axis=1)
out = np.max(col, axis=1)
# 第3步转换为合适的输出大小
out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)
self.x = x
self.arg_max = arg_max
return out
def backward(self, dout):
dout = dout.transpose(0, 2, 3, 1)
pool_size = self.pool_h * self.pool_w
dmax = np.zeros((dout.size, pool_size))
dmax[np.arange(self.arg_max.size), self.arg_max.flatten()] = dout.flatten()
dmax = dmax.reshape(dout.shape + (pool_size,))
dcol = dmax.reshape(dmax.shape[0] * dmax.shape[1] * dmax.shape[2], -1)
dx = col2im(dcol, self.x.shape, self.pool_h, self.pool_w, self.stride, self.pad)
return dx
数据的变形没看懂，需要用小例子跑下。
7.5 CNN的实现
在源代码ch07/simple_convnet中实现为名为SimpleConvNet的类，框架如下：
点击查看class SimpleConvNet代码
class SimpleConvNet:
"""简单的ConvNet
conv - relu - pool - affine - relu - affine - softmax
Parameters
----------
input_size : 输入大小（MNIST的情况下为784）
hidden_size_list : 隐藏层的神经元数量的列表（e.g. [100, 100, 100]）
output_size : 输出大小（MNIST的情况下为10）
activation : 'relu' or 'sigmoid'
weight_init_std : 指定权重的标准差（e.g. 0.01）
指定'relu'或'he'的情况下设定“He的初始值”
指定'sigmoid'或'xavier'的情况下设定“Xavier的初始值”
"""
def __init__(self, input_dim=(1, 28, 28),
conv_param={'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1},
hidden_size=100, output_size=10, weight_init_std=0.01):
# 省略
def predict(self, x): # 推理
# 省略
def loss(self, x, t):
# 省略
def accuracy(self, x, t, batch_size=100):
if t.ndim != 1 : t = np.argmax(t, axis=1)
acc = 0.0
for i in range(int(x.shape[0] / batch_size)):
tx = x[i*batch_size:(i+1)*batch_size]
tt = t[i*batch_size:(i+1)*batch_size]
y = self.predict(tx)
y = np.argmax(y, axis=1)
acc += np.sum(y == tt)
return acc / x.shape[0]
def numerical_gradient(self, x, t):
"""求梯度（数值微分）
Parameters
----------
x : 输入数据
t : 教师标签
Returns
-------
具有各层的梯度的字典变量
grads['W1']、grads['W2']、...是各层的权重
grads['b1']、grads['b2']、...是各层的偏置
"""
loss_w = lambda w: self.loss(x, t)
grads = {}
for idx in (1, 2, 3):
grads['W' + str(idx)] = numerical_gradient(loss_w, self.params['W' + str(idx)])
grads['b' + str(idx)] = numerical_gradient(loss_w, self.params['b' + str(idx)])
return grads
def gradient(self, x, t):
# 省略
def save_params(self, file_name="params.pkl"):
params = {}
for key, val in self.params.items():
params[key] = val
with open(file_name, 'wb') as f:
pickle.dump(params, f)
def load_params(self, file_name="params.pkl"):
with open(file_name, 'rb') as f:
params = pickle.load(f)
for key, val in params.items():
self.params[key] = val
for i, key in enumerate(['Conv1', 'Affine1', 'Affine2']):
self.layers[key].W = self.params['W' + str(i+1)]
self.layers[key].b = self.params['b' + str(i+1)]
初始化部分实现如下：
点击查看__init__()代码
def __init__(self, input_dim=(1, 28, 28),
conv_param={'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1},
hidden_size=100, output_size=10, weight_init_std=0.01):
filter_num = conv_param['filter_num']
filter_size = conv_param['filter_size']
filter_pad = conv_param['pad']
filter_stride = conv_param['stride']
input_size = input_dim[1]
conv_output_size = (input_size - filter_size + 2*filter_pad) / filter_stride + 1
pool_output_size = int(filter_num * (conv_output_size/2) * (conv_output_size/2))
# 初始化权重
self.params = {}
self.params['W1'] = weight_init_std * \
np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
self.params['b1'] = np.zeros(filter_num)
self.params['W2'] = weight_init_std * \
np.random.randn(pool_output_size, hidden_size)
self.params['b2'] = np.zeros(hidden_size)
self.params['W3'] = weight_init_std * \
np.random.randn(hidden_size, output_size)
self.params['b3'] = np.zeros(output_size)
# 生成层
self.layers = OrderedDict()
self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'],
conv_param['stride'], conv_param['pad'])
self.layers['Relu1'] = Relu()
self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)
self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
self.layers['Relu2'] = Relu()
self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])
self.last_layer = SoftmaxWithLoss()
推理和求损失值方法实现如下：
点击查看predict()和loss()代码
def predict(self, x): # 推理
for layer in self.layers.values():
x = layer.forward(x)
return x
def loss(self, x, t):
"""求损失函数
参数x是输入数据、t是监督数据
"""
y = self.predict(x)
return self.last_layer.forward(y, t)
基于误差反向传播法求梯度的代码实现如下：
点击查看gradient()代码
def gradient(self, x, t):
"""求梯度（误差反向传播法）
Parameters
----------
x : 输入数据
t : 教师标签
Returns
-------
具有各层的梯度的字典变量
grads['W1']、grads['W2']、...是各层的权重
grads['b1']、grads['b2']、...是各层的偏置
"""
# forward
self.loss(x, t)
# backward
dout = 1
dout = self.last_layer.backward(dout)
layers = list(self.layers.values())
layers.reverse()
for layer in layers:
dout = layer.backward(dout)
# 设定
grads = {}
grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
return grads
使用SimpleConvnet类学习MNIST手写数字数据集，源代码在ch07/train_convnet.py中，实现如下：
点击查看train_convnet.py代码
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
import numpy as np
import matplotlib.pyplot as plt
from dataset_all.mnist import load_mnist
from simple_convnet import SimpleConvNet
from common_all.trainer import Trainer
# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
# 处理花费时间较长的情况下减少数据
#x_train, t_train = x_train[:5000], t_train[:5000]
#x_test, t_test = x_test[:1000], t_test[:1000]
max_epochs = 20
network = SimpleConvNet(input_dim=(1, 28, 28),
conv_param = {'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1},
hidden_size=100, output_size=10, weight_init_std=0.01)
trainer = Trainer(network, x_train, t_train, x_test, t_test,
epochs=max_epochs, mini_batch_size=100,
optimizer='Adam', optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=1000)
trainer.train()
# 保存参数
network.save_params("params.pkl")
print("Saved Network Parameters!")
# 绘制图形
markers = {'train': 'o', 'test': 's'}
x = np.arange(max_epochs)
plt.plot(x, trainer.train_acc_list, marker='o', label='train', markevery=2)
plt.plot(x, trainer.test_acc_list, marker='s', label='test', markevery=2)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()
运行结果如下：
Fig. train_convnet.py运行过程打印
Fig. train_convnet.py运行结果输出
由上两图可见，识别准确率还是非常高的，接近99%。而且收敛比较快，在第5次时已经接近98%的准确率。在本人的i3老爷机跑了将近一小时才跑完，还是比较耗时的。
7.6 CNN的可视化
在源代码ch07/visualize_filter.py中进行第1层卷积层的滤波器的权重的初始化，代码如下：
点击查看visualize_filter.py代码
# coding: utf-8
import numpy as np
import matplotlib.pyplot as plt
from simple_convnet import SimpleConvNet
# fig.7-24
def filter_show(filters, nx=8, margin=3, scale=10):
"""
c.f. https://gist.github.com/aidiary/07d530d5e08011832b12#file-draw_weight-py
"""
FN, C, FH, FW = filters.shape
ny = int(np.ceil(FN / nx))
fig = plt.figure()
fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)
for i in range(FN):
ax = fig.add_subplot(ny, nx, i+1, xticks=[], yticks=[])
ax.imshow(filters[i, 0], cmap=plt.cm.gray_r, interpolation='nearest')
plt.show()
network = SimpleConvNet()
# 随机进行初始化后的权重
filter_show(network.params['W1'])
# 学习后的权重
network.load_params("params.pkl")
filter_show(network.params['W1'])
Fig.7-24 学习前和学习后的第1层的卷积层的权重
“学习前的滤波器是随机进行初始化的，所以在黑白的浓淡上没有规律可循，但学习后的滤波器变成了有规律的图像。卷积层的滤波器会提取边缘或斑块等原始信息。”
在源代码ch07/apply_filter.py中应用第1层卷积层的滤波器到Lena的图像，效果如下：
根据可视化的研究成果：对于多层CNN结构，“最开始的层对简单的边缘有响应，接下来的层对纹理有响应，再后面的层对更加复杂的物体部件有响应。也就是说，随着层次加深，神经元从简单的形状向“高级”信息变化。”可参照图7-25。
7.7 具有代表性的CNN
介绍了其中特别重要的两个网络，一个是在1998年首次被提出的CNN元祖LeNet，另一个是在深度学习受到关注的2012年被提出的AlexNet。
7.8 小结
卷积神经网络CNN最重要的就是引入了卷积层和池化层这两个基本模块。CNN在图像处理领域非常常见。
