深度学习—— 6 卷积神经网络
深度学习—— 6 卷积神经网络
可爱可倾6 卷积神经网络
卷积神经网络（convolutional neural network，CNN）是一类强大的、为处理图像数据而设计的神经网络，利用相近像素之间的相互关联性，从图像数据中学习得到有效的模型。
6.1 从全连接层到卷积层
- 平移不变性：不管检测对象出现在图像中的哪个位置，神经网络的前面几层应该对相同的图像区域具有相似的反应。
- 局部性：神经网络的前面几层应该只探索输入图像中的局部区域，而不过度在意图像中相隔较远区域的关系。
最终，可以聚合这些局部特征，以在整个图像级别进行预测。
- 图像的平移不变性使我们以相同的方式处理局部图像，而不在乎它的位置。
- 局部性意味着计算相应的隐藏表示只需一小部分局部图像像素。
- 在图像处理中，卷积层通常比全连接层需要更少的参数，但依旧获得高效用的模型。
- 卷积神经网络（CNN）是一类特殊的神经网络，它可以包含多个卷积层。
- 多个输入和输出通道使模型在每个空间位置可以获取图像的多方面特征。
其实也就是说，卷积层是用来提取图像的局部特征，全连接层是用来整合这些局部特征: 卷积的本质是有效提取相邻像素间的相关特征。
6.2 图像卷积
输入\(n_h \times n_w\)的图像，卷积核\(k_h \times k_w\)，输出将是\((n_h - k_h + 1) \times (n_w - k_w + 1)\)的图像。
6.2.1 互相关运算
卷积运算其实是互相关运算：
图6.1：二维互相关运算
def corr2d(X, K):
"""计算二维互相关运算"""
h, w = K.shape
Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
Y[i, j] = (X[i:i + h, j:j + w] * K).sum()
return Y6.2.2 卷积层
class Conv2D(nn.Module):
def __init__(self, kernel_size):
super().__init__()
self.weight = nn.Parameter(torch.rand(kernel_size))
self.bias = nn.Parameter(torch.zeros(1))
def forward(self, x):
return corr2d(x, self.weight) + self.bias6.2.3 卷积核训练
# 构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
conv2d = nn.Conv2d(1,1, kernel_size=(1, 2), bias=False)
# 这个二维卷积层使用四维输入和输出格式（批量大小、通道、高度、宽度），
# 其中批量大小和通道数都为1
X = X.reshape((1, 1, 6, 8))
Y = Y.reshape((1, 1, 6, 7))
lr = 3e-2 # 学习率
for i in range(10):
Y_hat = conv2d(X) # 通过卷积层 conv2d 计算输出 Y_hat
l = (Y_hat - Y) ** 2 # 计算损失 l（均方误差损失）
conv2d.zero_grad() # 将卷积层 conv2d 中的所有参数梯度清零
l.sum().backward() # 对损失 l 进行反向传播，计算参数的梯度
# 迭代卷积核
conv2d.weight.data[:] -= lr * conv2d.weight.grad # 使用梯度下降法更新卷积核的权重
if (i + 1) % 2 == 0:
print(f'epoch {i+1}, loss {l.sum():.3f}') # 每两轮迭代打印一次损失6.3 填充和步幅
6.3.1 填充
在输入图像的边界填充元素（通常填充元素是\(0\)）。 假设填充\(p_h\)行和\(p_w\)列(上下左右各大约一半)，输出形状为：\((n_h-k_h+p_h+1)\times(n_w-k_w+p_w+1)\) 所以许多情况下，我们会设置\(p_h=k_h-1\)和$p_w=k_w-1，这样输入和输出具有相同的高度和宽度。 因此卷积核也通常设置为奇数，方便各填充一半。还可以得到对于任何二维张量X，当满足： 1. 卷积核的大小是奇数； 2. 所有边的填充行数和列数相同； 3. 输出与输入具有相同高度和宽度 则可以得出：输出Y[i, j]是通过以输入X[i, j]为中心，与卷积核进行互相关计算得到的。
6.3.2 步幅
卷积窗口可以跳过中间位置，每次滑动多个元素。我们将每次滑动元素的数量称为步幅（stride）。
为了计算输出中第一列的第二个元素和第一行的第二个元素，卷积窗口分别向下滑动三行和向右滑动两列:
图6.2：垂直步幅为 3，水平步幅为 2 的二维互相关运算
此时的输出形状为：\(\lfloor(n_h-k_h+p_h+s_h)/s_h\rfloor \times \lfloor(n_w-k_w+p_w+s_w)/s_w\rfloor.\)
6.4 多输入通道和多输出通道
6.4.1 多输入通道
当输入包含多个通道时，需要构造一个与输入数据具有相同输入通道数的卷积核: \(c_i\times k_h\times k_w\)
图6.3：多输入通道的互相关计算
6.4.2 多输出通道
为了获得多个通道的输出，我们可以为每个输出通道创建一个形状为\(c_i\times k_h\times k_w\)的卷积核张量，则\(c_o\times c_i\times k_h\times k_w\)。
6.4.3 \(1\times 1\)卷积层
\(1\times 1\)卷积核的主要作用是调整网络层之间的通道数，而不是识别相邻元素间相互作用。
图6.4：互相关计算使用了具有3个输入通道和2个输出通道的$1\times 1$卷积核
本质相当于一个调整通道数的全连接层。
6.5 汇聚层(池化层)
降低卷积层对位置的敏感性，同时降低对空间降采样表示的敏感性
最大汇聚层和平均汇聚层是最常见的汇聚层，分别取池化窗口中输入的最大值和平均值。
相比卷积层:
- 相同：汇聚层也有填充和步幅。
- 不同：1. 汇聚层的参数不需要训练，是固定的；2. 在处理多通道输入数据时，汇聚层在每个输入通道上单独运算，而不是像卷积层一样在通道上对输入进行汇总(这意味着汇聚层的输出通道数与输入通道数相同)。
6.6 卷积神经网络(以 LeNet 为例)
LeNet（LeNet-5）由两个部分组成：
- 卷积编码器：由两个卷积层组成;
- 全连接层密集块：由三个全连接层组成。
图6.5：LeNet中的数据流。输入是手写数字，输出为10种可能结果的概率
图6.6：LeNet 的简化版
import torch
from torch import nn
from d2l import torch as d2l
def evaluate_accuracy_gpu(net, data_iter, device=None): # @save
"""使用GPU计算模型在数据集上的精度"""
if isinstance(net, nn.Module):
net.eval() # 设置为评估模式
if not device:
device = next(iter(net.parameters())).device
# 正确预测的数量，总预测的数量
metric = d2l.Accumulator(2)
with torch.no_grad():
for X, y in data_iter:
if isinstance(X, list):
# BERT微调所需的（之后将介绍）
X = [x.to(device) for x in X]
else:
X = X.to(device)
y = y.to(device)
metric.add(d2l.accuracy(net(X), y), y.numel())
return metric[0] / metric[1]
def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):
"""用GPU训练模型"""
def init_weights(m):
if type(m) == nn.Linear or type(m) == nn.Conv2d:
nn.init.xavier_uniform_(m.weight)
net.apply(init_weights)
print('training on', device)
# 模型转移到GPU上
net.to(device)
optimizer = torch.optim.SGD(net.parameters(), lr=lr)
loss = nn.CrossEntropyLoss()
animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
legend=['train loss', 'train acc', 'test acc'])
timer, num_batches = d2l.Timer(), len(train_iter)
for epoch in range(num_epochs):
# 训练损失之和，训练准确率之和，样本数
metric = d2l.Accumulator(3)
net.train()
for i, (X, y) in enumerate(train_iter):
timer.start()
optimizer.zero_grad()
# 在每一个批量上计算梯度并更新模型参数，需要转移到GPU
X, y = X.to(device), y.to(device)
y_hat = net(X)
l = loss(y_hat, y)
l.backward()
optimizer.step()
with torch.no_grad():
metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
timer.stop()
train_l = metric[0] / metric[2]
train_acc = metric[1] / metric[2]
if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
animator.add(epoch + (i + 1) / num_batches,
(train_l, train_acc, None))
test_acc = evaluate_accuracy_gpu(net, test_iter)
animator.add(epoch + 1, (None, None, test_acc))
print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
f'test acc {test_acc:.3f}')
print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
f'on {str(device)}')
if __name__ == '__main__':
net = nn.Sequential(
nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
nn.AvgPool2d(kernel_size=2, stride=2),
nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
nn.AvgPool2d(kernel_size=2, stride=2),
nn.Flatten(), # 在全连接层之前要先展平
nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
nn.Linear(120, 84), nn.Sigmoid(),
nn.Linear(84, 10))
# 读取数据
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)
# 训练
lr, num_epochs = 0.9, 10
train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())
