第七章 现代卷积神经网络
AlexNet
回顾LeNet与AlexNet架构
graph BT
%% 定义节点样式，还原图片中的颜色
classDef blueNode fill:#8bc4fc,stroke:#000,stroke-width:1px,color:#000;
classDef greyNode fill:#6c6e75,stroke:#000,stroke-width:1px,color:#000;
%% 左侧网络结构
subgraph Left_Net [ ]
direction BT
L1["图片 (28 × 28)"]:::greyNode
L2["5 × 5 卷积层 (6), 填充2"]:::blueNode
L3["2 × 2 平均汇聚层, 步幅2"]:::blueNode
L4["5 × 5 卷积层 (16)"]:::blueNode
L5["2 × 2 平均汇聚层, 步幅2"]:::blueNode
L6["全连接层 (120)"]:::greyNode
L7["全连接层 (84)"]:::greyNode
L8["全连接层 (10)"]:::greyNode
L1 --> L2 --> L3 --> L4 --> L5 --> L6 --> L7 --> L8
end
%% 右侧网络结构
subgraph Right_Net [ ]
direction BT
R1["图片 (3 × 224 × 224)"]:::greyNode
R2["11 × 11 卷积层 (96), 步幅 4"]:::blueNode
R3["3 × 3 最大汇聚层, 步幅 2"]:::blueNode
R4["5 × 5 卷积层 (256), 填充 2"]:::blueNode
R5["3 × 3 最大汇聚层, 步幅 2"]:::blueNode
R6["3 × 3 卷积层 (384), 填充 1"]:::blueNode
R7["3 × 3 卷积层 (384), 填充 1"]:::blueNode
R8["3 × 3 卷积层 (256), 填充 1"]:::blueNode
R9["3 × 3 最大汇聚层, 步幅 2"]:::blueNode
R10["全连接层 (4096)"]:::greyNode
R11["全连接层 (4096)"]:::greyNode
R12["全连接层 (1000)"]:::greyNode
R1 --> R2 --> R3 --> R4 --> R5 --> R6 --> R7 --> R8 --> R9 --> R10 --> R11 --> R12
end
%% 隐藏子图的边框和背景，使其看起来像并列的两个独立流程
style Left_Net fill:transparent,stroke:none
style Right_Net fill:transparent,stroke:none更多细节：
- 激活函数从sigmoid变成了ReLu
- 隐藏全连接层后加入了丢弃层
- 数据增强
总结：
- 就是一个更大更深的
LeNet，参数 * 10，计算复杂度 * 260 - 加入了丢弃法、ReLU、最大池化层、和数据增强
- 是神经网络热潮的开始
代码
import torch
from torch import nn
net = nn.Sequential(
# 这里使用一个11*11的更大窗口来捕捉对象。
# 同时，步幅为4，以减少输出的高度和宽度。
# 另外，输出通道的数目远大于LeNet
nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2),
# 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2),
# 使用三个连续的卷积层和较小的卷积窗口。
# 除了最后的卷积层，输出通道的数量进一步增加。
# 在前两个卷积层之后，汇聚层不用于减少输入的高度和宽度
nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Flatten(),
# 这里，全连接层的输出数量是LeNet中的好几倍。使用dropout层来减轻过拟合
nn.Linear(6400, 4096), nn.ReLU(),
nn.Dropout(p=0.5),
nn.Linear(4096, 4096), nn.ReLU(),
nn.Dropout(p=0.5),
# 最后是输出层。由于这里使用Fashion-MNIST，所以用类别数为10，而非论文中的1000
nn.Linear(4096, 10))
VGG
更深更大
把AlexNet中间新加的一块规则的块抽象出来，作为VGG块，然后通过不同次数的重复得到不同的架构VGG-16, VGG-19, ...
代码
def vgg_block(num_convs, in_channels, out_channels):
layers = []
for _ in range(num_convs):
layers.append(nn.Conv2d(in_channels, out_channels,
kernel_size=3, padding=1))
layers.append(nn.ReLU())
in_channels = out_channels
layers.append(nn.MaxPool2d(kernel_size=2,stride=2))
return nn.Sequential(*layers)
VGG-11
通道数翻倍，高宽减半，是一种经典的设计
# (卷积层数， 输出通道数)
conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))
# 卷积：增大通道数
# 池化层：缩小图片大小
def vgg(conv_arch):
conv_blks = []
in_channels = 1
# 卷积层部分
for (num_convs, out_channels) in conv_arch:
conv_blks.append(vgg_block(num_convs, in_channels, out_channels))
in_channels = out_channels
return nn.Sequential(
*conv_blks, nn.Flatten(),
# 全连接层部分
nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5),
nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5),
nn.Linear(4096, 10))
net = vgg(conv_arch)
NiN 网络中的网络
NiN块
一个卷积层后跟两个全连接层（全连接层使用1*1卷积层代替）
这就是一个NiN块
- 3*3卷积层：空间特征提取，捕捉局部空间信息
- 1*1卷积层，对所有通道的同一个位置的像素点做一次全连接，所以叫网络中的网络(NiN)
回顾：1*1的卷积层为什么等价于全连接层
- 11卷积对每一个输入通道的同一位置的空间像素点单独跑一遍这个11卷积
- 本质在于所有像素共享同一套权重W和b
- 且算完后不会对h*w的结构造成损坏
但注意他是通道维度的全连接，不是对空间维度的全连接
NiN架构就是：
- 无全连接层
- 交替使用NiN块和步幅为2点最大池化层（逐步减少高宽和增大通道数）
- 最后使用全局平均池化层得到输出（其输入通道数十类别数）
GoogLeNet 含并行连结的网络
Inception块
class Inception(nn.Module):
# c1--c4是每条路径的输出通道数
def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
super(Inception, self).__init__(**kwargs)
# 线路1，单1x1卷积层
self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
# 线路2，1x1卷积层后接3x3卷积层
self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)
self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
# 线路3，1x1卷积层后接5x5卷积层
self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)
self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
# 线路4，3x3最大汇聚层后接1x1卷积层
self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)
def forward(self, x):
p1 = F.relu(self.p1_1(x))
p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
p4 = F.relu(self.p4_2(self.p4_1(x)))
# 在通道维度上连结输出
return torch.cat((p1, p2, p3, p4), dim=1)
批量归一化
当深度较深时，随着网络参数不断更新，每一层的输入分布也会不断发生改变（内部协变量偏移）
这会导致：
- 训练极度不稳定且缓慢：后面的层要不断适应前面层传来的新分布
- 容易陷入梯度消失/爆炸
- 对初始化敏感
如何批量归一化？
- 求这批数据的均值\(\mu_B\)
- 求这批数据的方差\(\sigma_B^2\)
- 标准化$\(\hat{x}_i = \frac{x_i - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}\)$
- 缩放和平移
\[y_i = \gamma \hat{x}_i + \beta\]
\(\gamma 缩放因子 和 \beta 平移因子\)为可学习参数
通常放在卷积层和激活函数中间
效果类似正则化、dropout，通过在每个小批量里加入噪音来控制模型复杂度（也因此没必要和dropout混用）
代码实现
def batch_norm(X, gamma, beta, moving_mean, moving_var, eps, momentum):
# 通过is_grad_enabled来判断当前模式是训练模式还是预测模式
if not torch.is_grad_enabled():
# 如果是在预测模式下，直接使用传入的移动平均所得的均值和方差
X_hat = (X - moving_mean) / torch.sqrt(moving_var + eps)
else:
assert len(X.shape) in (2, 4)
if len(X.shape) == 2:
# 使用全连接层的情况，计算特征维上的均值和方差
mean = X.mean(dim=0)
var = ((X - mean) ** 2).mean(dim=0)
else:
# 使用二维卷积层的情况，计算通道维上（axis=1）的均值和方差。
# 这里我们需要保持X的形状以便后面可以做广播运算
mean = X.mean(dim=(0, 2, 3), keepdim=True)
var = ((X - mean) ** 2).mean(dim=(0, 2, 3), keepdim=True)
# 训练模式下，用当前的均值和方差做标准化
X_hat = (X - mean) / torch.sqrt(var + eps)
# 更新移动平均的均值和方差
moving_mean = momentum * moving_mean + (1.0 - momentum) * mean
moving_var = momentum * moving_var + (1.0 - momentum) * var
Y = gamma * X_hat + beta # 缩放和移位
return Y, moving_mean.data, moving_var.data
ResNet 残差网络
加更多的层总是改进精度吗？显然不是
ResNet引入了残差块
网络中间的层不再去学习完整的输出\(H(x)\)，而是去学习输出与输入之间的差值\(F(x)\)
\[H(x) = x + F(x)\]
称为跳跃连接
- 有高宽减半的ResNet块（步幅2）
- 有高宽不变的ResNet块
代码实现
class Residual(nn.Module):
def __init__(self, input_channels, num_channels,
use_1x1conv=False, strides=1):
super().__init__()
self.conv1 = nn.Conv2d(input_channels, num_channels,
kernel_size=3, padding=1, stride=strides)
self.conv2 = nn.Conv2d(num_channels, num_channels,
kernel_size=3, padding=1)
# 如果输出和原始输入的形状不一样就没法加起来，所以用1*1卷积层调整形状
if use_1x1conv:
self.conv3 = nn.Conv2d(input_channels, num_channels,
kernel_size=1, stride=strides)
else:
self.conv3 = None
# 每个卷积层后面都跟了一个批量归一化层
self.bn1 = nn.BatchNorm2d(num_channels)
self.bn2 = nn.BatchNorm2d(num_channels)
def forward(self, X):
Y = F.relu(self.bn1(self.conv1(X)))
Y = self.bn2(self.conv2(Y))
if self.conv3:
X = self.conv3(X)
Y += X
return F.relu(Y)