第六章.卷积神经网络(CNN)
6.1 卷积层(Convolution)&池化层(Pooling)
1.整体结构
以5层神经网络的实现为例：
1).基于全连接层(Affine)的网络
全连接层：相邻层的所有神经元之间都有连接
2).常见的CNN的网络
3).全连接层存在的问题
数据的形状容易被“忽视”了，比如输入的数据是图像时，图像通常是高，长，通道方向上的3维形状，但是，全连接层输入时，需要将3维数据拉平为1维数据，所以无法利用与形状相关的信息。
2.卷积层
卷积层可以保持形状不变，当输入数据是图像时，卷积层会以3维数据的形式接受输入数据，并同样以3维数据的形式输出至下一层，因此在CNN中可以正确理解图像等具有形状的数据。
1).卷积运算
-
一维数据的卷积计算
示例：填充为0，步幅为1的卷积运算
-
三维数据的卷积计算
示例：填充为0，步幅为1的卷积运算
计算方式：
通道方向有多特征图时，会按通道进行输入数据和滤波器的卷积运算，并结果相加，从而得到输出。注意：
①.在三维数据的卷积运算中，输入数据和滤波器的通道数必须设置为相同的值。(在本例中同时设置为3) -
结合方块来思考卷积计算
图像描述:
每个通道只有一个偏置，这里偏置的形状为(FN,1,1)，滤波器的输出结果形状为（FN,OH,OW）,这两个方块相加，要对滤波器的输出结果按通道加上相同的偏置。 -
卷积计算的批处理
注意：
①.网络间传递的是四维数据，对这N个数据进行了卷积运算，也就是说，批处理将N次的处理汇总成1次进行。
2).填充&步幅
-
填充
①.定义：
在进行卷积层处理之前，有时需要向输入数据的周围填入固定的数据(比如填充值0等)，这称为填充。
②.目的：
主要是为了调整输出的大小，因为每次在进行卷积运算时都会缩小空间，那么在某个时刻输出大小就有可能变为1，导致无法在进行卷积运算，为了避免出现这种情况，就要使用填充 -
步幅
①.定义：
应用滤波器的位置间隔称为步幅。(之前的应用都是步幅为1，下面的应用步幅为2)
3).计算输出核的大小
假设输入大小为（H,W）,滤波大小为（FH,FW）,输出大小为（OH,OW）,填充为P，步幅为S，输出大小为：
注意：
①.所设定的值必须使式(H+2P-FH)/S和(W+2P-FW)/S分别可以整除，当输入大小无法整除时，需要采取报错等对策。有的深度学习框架，当值无法除尽时，有时会向最接近的整数四舍五入，不进行报错而继续进行。
4).实现扩展
①.CNN处理4维数据时，卷积运算的实现看上去会很复杂，可以使用im2col（图像转化成矩阵）这个技巧，问题会变得很简单。
②.im2col函数会将输入数据展开以适合滤波器（权重）。具体来说，对于输入数据，将应用滤波器的区域（3维方块）横向展开为一列。
③.卷积运算的滤波器处理细节：使用im2col函数展开输入数据后，将卷积层的滤波器纵向展开为一列，计算两个矩阵的乘积，最后转化（reshape）为输出数据大小。
5).卷积层的实现
import numpy as np
# 从图像到矩阵
def im2col(input_data, filter_h, filter_w, stride=1, pad=0):
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
# 从矩阵到图像
def col2im(col, input_shape, filter_h, filter_w, stride=1, pad=0):
N, C, H, W = input_shape
out_h = (H + 2 * pad - filter_h) // stride + 1
out_w = (W + 2 * pad - filter_w) // stride + 1
col = col.reshape(N, out_h, out_w, C, filter_h, filter_w).transpose(0, 3, 4, 5, 1, 2)
img = np.zeros((N, C, H + 2 * pad + stride - 1, W + 2 * pad + stride - 1))
for y in range(filter_h):
y_max = y + stride * out_h
for x in range(filter_w):
x_max = x + stride * out_w
img[:, :, y:y_max:stride, x:x_max:stride] += col[:, :, y, x, :, :]
return img[:, :, pad:H + pad, pad:W + pad]
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 = int((H + 2 * self.pad - FH) / self.stride) + 1
out_w = int((W + 2 * self.pad - FW) / self.stride) + 1
col = im2col(x, FH, FW, self.stride, self.pad)
col_W = self.W.reshape(FN, -1).T
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
3.池化层
池化是缩小高，长方向上的空间运算。
1).池化的处理方法
示例：填充为0，步幅为2的池化
-
Max池化：(本书中所说的池化层是Max池化)
方式：从目标区域中取最大值
-
Average池化：
方式：从目标区域中取均值
2).池化层的特征
-
没有要学习的参数：
池化层和卷积层不同，没有要学习的参数。池化只是从目标区域中选出最大值（或均值）。 -
通道数不发生改变：
经过池化运算，输入数据和输出数据的通道数不发生变化，计算是按通道独立进行的。
-
对微小的位置变化具有鲁棒性（健壮）：
输入数据发生微小偏差时，池化仍会返回相同的结果。示例：输入数据在高方向上只偏离一个像素时：
3).池化层的实现步骤
①.展开输入数据：
②.求各行的最大值：
③.转换为合适的输出大小：
4).池化层的实现
import numpy as np
# 从图像到矩阵
def im2col(input_data, filter_h, filter_w, stride=1, pad=0):
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
# 从矩阵到图像
def col2im(col, input_shape, filter_h, filter_w, stride=1, pad=0):
N, C, H, W = input_shape
out_h = (H + 2 * pad - filter_h) // stride + 1
out_w = (W + 2 * pad - filter_w) // stride + 1
col = col.reshape(N, out_h, out_w, C, filter_h, filter_w).transpose(0, 3, 4, 5, 1, 2)
img = np.zeros((N, C, H + 2 * pad + stride - 1, W + 2 * pad + stride - 1))
for y in range(filter_h):
y_max = y + stride * out_h
for x in range(filter_w):
x_max = x + stride * out_w
img[:, :, y:y_max:stride, x:x_max:stride] += col[:, :, y, x, :, :]
return img[:, :, pad:H + pad, pad:W + pad]
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)
col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
col = col.reshape(-1, self.pool_h * self.pool_w)
arg_max = np.argmax(col, axis=1)
out = np.max(col, axis=1)
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
