卷积神经网络（Convolutional Neural Network，CNN）
7.1 整体结构
之前介绍的神经网络中，相邻层的所有神经元之间都有连接，这称为全连接（fully-connected）。
CNN
7.2 卷积层
全连接层存在什么问题呢？那就是数据的形状被“忽视”了。比如，输 入数据是图像时，图像通常是高、长、通道方向上的3维形状。
CNN 中，有时将卷积层的输入输出数据称为特征图（feature map）。其中，卷积层的输入数据称为输入特征图（input feature map），输出 数据称为输出特征图（output feature map）。
7.2.2 卷积运算
如图7-4所示，将各个位置上滤 波器的元素和输入的对应元素相乘，然后再求和（有时将这个计算称为乘积累加运算）。
参考论文：
具体的计算过程：
CNN同样可以加偏置
7.2.3 填充
在进行卷积层的处理之前，有时要向输入数据的周围填入固定的数据（比 如0等），这称为填充（padding）
这个例 子中将填充设成了1，不过填充的值也可以设置成2、3等任意的整数。
在图7-5 的例子中，如果将填充设为2，则输入数据的大小变为(8, 8)；如果将填充设 为3，则大小变为(10, 10)。
使用填充主要是为了调整输出的大小
7.2.4 步幅
应用滤波器的位置间隔称为步幅（stride）
假设输入大小为(H, W)，滤波器大小为(FH, FW)，输出大小为 (OH, OW)，填充为P，步幅为S。此时，输出大小可通过式(7.1)进行计算
利用公式计算：
既然是除法，就要注意是否可以除尽，如果不能除尽，则进行报错等措施。
根据深度学习 的框架的不同，当值无法除尽时，有时会向最接近的整数四舍五入，不进行 报错而继续运行
7.2.5 3维数据的卷积运算
之前的卷积运算的例子都是以有高、长方向的2维形状为对象的
除了高、长方向之外，还需要处理通道方向。
图7-8是卷积运算的例子，图7-9是计算顺序。这里以3通道的数据为例， 展示了卷积运算的结果。
输入数据和滤波器的通道数一致，均为3
通道数只能设定为和输入数据的通道数相同的值
7.2.6 结合方块思考
把3维数据表示为多维数组 时，书写顺序为（channel, height, width）。比如，通道数为C、高度为H、 长度为W的数据的形状可以写成（C, H, W）。通道数为C、滤波器高度为FH（Filter Height）、长度为FW（Filter Width）时，可以写成（C, FH, FW）
在这个例子中，数据输出是1张特征图。所谓1张特征图，换句话说， 就是通道数为1的特征图。那么，如果要在通道方向上也拥有多个卷积运算的输出，该怎么做呢？
如图 7-11 所示，关于卷积运算的滤波器，也必须考虑滤波器的数量。因此，作为4维数据，滤波器的权重数据要按(output_channel, input_ channel, height, width)的顺序书写。
比如，通道数为3、大小为5 × 5的滤 波器有20个时，可以写成(20, 3, 5, 5)。
格式非常重要
在图7-11的例子中，如果进 一步追加偏置的加法运算处理，则结果如下面的图7-12所示。
7.2.7 批处理
批处理将N次 的处理汇总成了1次进行
7.3 池化层
池化是缩小高、长方向上的空间的运算。
池化的窗口大小会 和步幅设定成相同的值
池化层的特征
- 通道数不发生变化
- 对微小的位置变化具有鲁棒性（健壮）
7.4 卷积层和池化层的实现
7.4.1 4维数组
CNN中各层间传递的数据是4维数据。
7.4.2 基于 im2col的展开
im2col这个名称是“image to column”的缩写，翻译过来就是“从图像到矩阵”的意思。
我们不使用for语句，而是使 用im2col这个便利的函数进行简单的实现。
im2col是一个函数，将输入数据展开以适合滤波器（权重）。如图7-17所示， 对3维的输入数据应用im2col后，数据转换为2维矩阵（正确地讲，是把包含批数量的4维数据转换成了2维数据）。
im2col会把输入数据展开以适合滤波器（权重）。具体地说，如图7-18所示， 对于输入数据，将应用滤波器的区域（3维方块）横向展开为1列。im2col会 在所有应用滤波器的地方进行这个展开处理。
注意：
- 为了便于观察，将步幅设置得很大，以使滤波器的应用区域不重叠。
- 实际的卷积运算中，滤波器的应用区域几乎都是重叠的。
使用im2col展开后，展开后的元素个数会多于原方块的元素个数。
因此，使用im2col的实现存在比普通的实现消耗更多内存的缺点。
然而大的矩阵运算是可以被优化的
7.4.3 卷积层的实现
Im2col会考虑滤波器大小、步幅、填充，将输入数据展开为2纬数组
利用前面提及到的公式
下面是卷积层实现类：
其中transpose函数的可以基于Numpy调换索引对应元素的位置：
注：
（权重）、偏置、步幅、填充作为参数接收。
滤波器是 (FN, C, FH, FW)的 4 维形状。另外，FN、C、FH、FW分别是 Filter Number（滤波器数量）、Channel、Filter Height、Filter Width的缩写
7.4.4 池化层的实现
池化层可以单独按通道展开，如下图所示：
展开后根据矩阵的行选择需要的函数进行取值即可，如这里使用的是max函数，取完值之后在用reshape函数进行重构维度即可，如图所示：
池化层实现类：
总结：实现池化层的3个步骤：
1. 展开输入数据
2.求各行的最大值
3.转换为合适的输出大小
7.5 CNN的实现
我们已经实现了卷积层和池化层，现在来组合这些层。
搭建进行手写数字识别的CNN。这里要实现如图所示的CNN
SimpleConvNet的初始化（__init__）
实现代码：
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
import pickle
import numpy as np
from collections import OrderedDict
from common.layers import *
from common.gradient import numerical_gradient
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):
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'])
# 只有SoftmaxWithLoss层被添加到别的变量lastLayer中
self.last_layer = SoftmaxWithLoss()
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)
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):
"""求梯度（误差反向传播法）
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
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)]
test acc:0.9892
注意：
将第1层的卷积层的权重设为关键字W1，偏置设为关键字b1。同样，分别用关键字W2、b2和关键字W3、b3 来保存第2个和第3个全连接层的权重和偏置。
预测与损失函数
是基于误差反向传播法求梯度
实现部分与前面的一样：
# 读入数据
(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!")7.6 CNN的可视化
7.6.1 第 1层权重的可视化
我们将卷积层（第1层）的滤波器显示为图像
学习前的滤波器是随机进行初始化的，所以在黑白的浓淡上 没有规律可循，但学习后的滤波器变成了有规律的图像
7.6.2 基于分层结构的信息提取
随着层次加深，提取的信息（正确地讲，是反映强烈的神经元）也越来越抽象
7.7 具有代表性的 CNN
7.7.1 LeNet
它有连续的卷积层和池化层（正确地讲，是只“抽选元素”的子采样层），最后经全连接层输出结果。
“现在的CNN”相比，LeNet有几个不同点:
-
第一个不同点在于激活函数。LeNet中使用sigmoid函数，而现在的CNN中主要使用ReLU函数。
-
原始的LeNet中使用子采样（subsampling）缩小中间数据的大小，而 现在的CNN中Max池化是主流
LeNet与现在的CNN虽然有些许不同，但差别并不是那么大.古老的东西
7.7.2 AlexNet
它的网络结构和LeNet基本上没有什么不同，AlexNet叠有多个卷积层和池化层，最后经由全连接层输出结果。
AlexNet和LeNet没有大的不同，但有以下几点差异
小结
- CNN在此前的全连接层的网络中新增了卷积层和池化层。
- 使用im2col函数可以简单、高效地实现卷积层和池化层。
- 通过CNN的可视化，可知随着层次变深，提取的信息愈加高级。
- LeNet和AlexNet是CNN的代表性网络。
- 在深度学习的发展中，大数据和GPU做出了很大的贡献。
卷积-ReLu函数-池化层-卷积-ReLu函数-池化层-卷积-ReLu函数-Affine-ReLu-Affine-Softmax