目录
上期回顾
【李沐 动手学深度学习】视频课程笔记与重点总结 01-18-CSDN博客
https://blog.csdn.net/qq_52589927/article/details/141156454?spm=1001.2014.3001.5502还是提醒一下，文章中代码仅作展示。使用的是pytorch框架，在运行代码的时候，不要忘了先导包
import torch
from torch import nn
from d2l import torch as d2l
from torch.nn import functional as F卷积神经网络
相信大家对卷积都稍微有些了解，就是一个卷积核（权重矩阵）在图片上不断扫描求值，如下动图就是一个3*3的卷积核在5*5的图片上做卷积。
下面会从底层逻辑开始讲起，卷积是怎么出现的
从全连接到卷积
对全连接层（输入和输出为一维向量）使用如下两种性质就会变成卷积层（输入和输出为二维矩阵）
通俗来讲就是：
平移不变性
- 确定卷积核的个数唯一
- 要识别图片上的猫，不管猫在图片的哪个位置，只需要同一个卷积核（权重矩阵）来扫描即可，即卷积核的参数不变，从图中提取到的特征就不变
局限性
- 确定卷积核的大小适当
- 无需整张图一起看，只需要看某一个位置点附近的地方
通过改变卷积核中的参数，可以实现不同目的，如边缘检测，锐化，模糊........
也可以使用一维，三维的数据来做卷积。要注意，输入输出变化的同时，卷积核也会改变维度哦
一维：文本，语言，时序序列
三维：视频，医学图像
卷积的简单公式：
- 输入 X 和 权重矩阵 W（卷积核）交叉相乘，再加上偏移 b，得到输出 Y
- 可学习的参数：W 和 b
- 超参数：W 的大小
图像卷积
实现二维卷积层
class Conv2D(nn.Module): # 继承nn.Module
def __init__(self, kernel_size): # W 的大小
super().__init__()
self.weight = nn.Parameter(torch.rand(kernel_size)) # W 可学习参数
self.bias = nn.Parameter(torch.zeros(1)) # b 可学习参数
def forward(self, x):
return corr2d(x, self.weight) + self.bias # Y = X * W + b学习卷积核
学习由 X输入 生成 Y输出 的卷积核，无需自己设计卷积核的参数，而是让网络来学习
# 构造一个二维卷积层，它具有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)
l = (Y_hat - Y) ** 2 # 均方误差作为loss
conv2d.zero_grad() # conv2d的梯度设为0
l.sum().backward()
# 迭代卷积核，梯度下降的方式
conv2d.weight.data[:] -= lr * conv2d.weight.grad
if (i + 1) % 2 == 0:
print(f'epoch {i+1}, loss {l.sum():.3f}')
# 查看这个卷积核的权重tensor
conv2d.weight.data.reshape((1, 2))填充和步幅
卷积的超参数：填充padding、步幅stride
先讲填充，假设如下情况：
形状减小到 ( 32 - 5 + 1 ) * ( 32 - 5 + 1 )，即第一层输出大小 28 * 28
如此往复，输出结果越来越小，为了防止这一现象的出现，可以采取如下措施：
在输入的周围添加额外的行列，这也就是为什么文章开头的动图中，蓝色方框外还有一圈虚线，那个就是额外添加的padding
如果添加 ph 行填充和 pw 列填充，则输出形状将为：
p：填充padding 、k：卷积核kernel 、n：输入
h：高 、 w：宽
这样选取的话，在经过不断卷积后，输出的形状不会发生变化，和输入时大小一样（Pw同理）
代码实现：
在所有侧边填充 1 个像素（填一圈）
# 为了方便起见，我们定义了一个计算卷积层的函数。
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数
def comp_conv2d(conv2d, X):
# 这里的（1，1）表示批量大小和通道数都是1
X = X.reshape((1, 1) + X.shape)
Y = conv2d(X)
# 省略前两个维度：批量大小和通道
return Y.reshape(Y.shape[2:])
# 请注意，这里每边都填充了1行或1列，因此总共添加了2行或2列，左边一行，右边一行
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
X = torch.rand(size=(8, 8)) # 输入为 8*8
comp_conv2d(conv2d, X).shape放入之前的公式就是：
Ph=(3-1)=2，Pw=(3-1)=2，因为Kh为奇数，故在上下两侧都填充Ph/2=1行，即共填充2行
Pw同理，填充左右两侧。所以说，其实就是填充了一圈
填充不同的高度和宽度
conv2d = nn.Conv2d(1, 1, kernel_size=(5, 3), padding=(2, 1))
comp_conv2d(conv2d, X).shape接下来讲步幅，假设希望 输出的大小 比 输入小
那么就需要很多层的计算才能得到较小输出，为解决这一问题，采取如下措施：
高度3，宽度2 的步幅（行/列的滑动步长）
如果给定 高度Sh 和 宽度Sw 的步幅，则输出形状将为：
代码实现：
高度和宽度的步幅设置为 2
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)
comp_conv2d(conv2d, X).shape此时输入为 8*8，输出为 4*4
多输入多输出通道
卷积的超参数：输出的通道数
例如，彩色图像都有RGB三个通道，红绿蓝，这时就是多输入
多个输入通道
每个通道都有一个独立的二维卷积核 (长宽) ，所有通道卷积结果相加 得到一个输出结果
多个输出通道
可以有多个3维卷积核 (长 宽 通道) ，每个核对应生成一个输出通道
此时，核变成4维，输出变成3维
其实这里也就是说，我们可以用不同的3维卷积核，实现不同的目标，对应不同的通道
多输出的特定：每个输出可以识别特定模式
多输入的特定：识别并组合
1 * 1卷积
作用：通道融合
输入通道为3，长宽为3，要想输出通道为2（或n），则使用2（或n）个 1*1 的卷积核堆
- 卷积核堆的个数 = 输出通道数
- 一个堆中的卷积核个数 = 输入通道数
二维卷积层
公式如下：
此时，就是多输入通道，多输出通道，其中：
ci ：卷积核的数（输入通道数）
co ：卷积核的数（输出通道数）
n ：输入
m ：输出
拓展
eg：图像中rgb三个通道，是用 [height,width,3] 的卷积核去做卷积操作，那个3是指的卷积核的厚度，所以卷积不是在单个通道上，而是3个通道一起。我希望下一层有多少个feature map(特征映射，或者说希望下一次得到多少个通道），我就用几个不同的卷积核去做卷积。
比如，现在得到了64个通道的结果，就是用64个卷积核得到64个feature map。下一次做卷积操作时，你希望通道数翻倍，就是得到128个特征图。这时，你用128个大小为 [height, width, 64] 的不同卷积核去做卷积。为什么是三个维度的卷积核，因为你上一次得到的是64个feature map，要对这64个通道做卷积，你需要使用厚度为64的卷积核。
如果把输入和输出的高宽都减半的情况下，输出通道数要翻倍。意思就是把空间信息压缩了，然后把这些压缩的信息，更多在通道中存储下来。
卷积层的可学习参数个数 = 输入通道 * 输出通道 * 核大小
池化层
出现原因：卷积层中，矩阵乘积时，对数字的位置很敏感。例如边缘发生一点变化，结果就会产生巨大变化
所以需要：一定的平移不变性，就像是让结果的边缘模糊一些
二维最大池化层
返回滑动窗口的最大值
平均池化层
同上，将最大值替换为平均值即可
- 没有可学习参数
- 在多输入通道时：对每个输入通道应用池化以获得相应的输出通道（输入通道数=输出通道数）
- 超参数：窗口大小、填充、步幅
代码实现
def pool2d(X, pool_size, mode='max'): # 输入 池化窗口大小 mode
p_h, p_w = pool_size
Y = torch.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1)) # 设定输出大小
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
if mode == 'max':
Y[i, j] = X[i: i + p_h, j: j + p_w].max() # 取最大值
elif mode == 'avg':
Y[i, j] = X[i: i + p_h, j: j + p_w].mean() # 取平均值
return Y
# 构建输入X
X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
# 验证输出 max
pool2d(X, (2, 2)) # tensor([[4., 5.],[7., 8.]])
# 验证输出 mean
pool2d(X, (2, 2), 'avg') # tensor([[2., 3.],[5., 6.]])
# 填充和步幅
# 通道1，批量大小1，4*4的矩阵
X = torch.arange(16, dtype=torch.float32).reshape((1, 1, 4, 4))
# 框架中步幅和窗口大小相同 都设为3
pool2d = nn.MaxPool2d(3)
pool2d(x)
# 窗口3*3 填充1 步幅2
pool2d = nn.MaxPool2d(3, padding=1, stride=2)
pool2d(x)LeNet
这是一个很老的卷积网络了，大家简单了解一下就行
卷积层学习图片空间信息，全连接层转换到类别空间
代码（定义、训练、评估）
class Reshape(torch.nn.Module):
def forward(self, x):
return x.view(-1, 1, 28, 28)
# 模型定义
net = nn.Sequential(
Reshape(),
nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
nn.AvgPool2d(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))
# 设定输入，检查模型每一步的变化
X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)
for layer in net:
X = layer(X)
print(layer.__class__.__name__,'output shape: \t',X.shape)
# Fashion-MNIST数据集
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)
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)
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()
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)}')
# 训练和评估
lr, num_epochs = 0.9, 10
train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())现代卷积神经网络
到目前为止，很基础的部分已经大致讲完了。接下来的内容，将越来越靠近当前流行的方向
深度卷积神经网络（AlexNet）
图中的汇聚层，就是池化层的意思
从 LeNet（左图）到 AlexNet（右图）的变化
- 输入图片更大，所以核大小和池化大小都更大了
- 新增了3层卷积层和更多的输出通道，识别更多的特征
- 输出的类别变到1000
- 激活函数从sigmod变为ReLU（缓解梯度消失）
- 隐藏全连接层（两个4096）后加入了dropout丢弃层
- 加入了最大池化层
- 数据增强（裁剪、调色...）
代码实现
# ---------定义网络----------
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))
# 构造一个高度和宽度都为224的单通道数据，来观察每一层输出的形状
X = torch.randn(1, 1, 224, 224)
for layer in net:
X=layer(X)
print(layer.__class__.__name__,'output shape:\t',X.shape)
# 读取Fashion-MNIST数据集
batch_size = 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
# 训练
lr, num_epochs = 0.01, 10
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())使用块的网络（VGG）
VGG块：
- 可重复使用的卷积块
- 不同的卷积块个数和超参数可以得到不同复杂度的变种
VGG：
- 多个VGG块后接全连接层
- 每个块由 填充1的3*3卷积 和 步幅2的2*2最大池化 组成
代码实现
# ------定义VGG块------
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)
# ------定义5个VGG块------
conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))
# ------定义VGG------
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)
# 构建一个高度和宽度为224的单通道数据样本，以观察每个块之间输出的形状
X = torch.randn(size=(1, 1, 224, 224))
for blk in net:
X = blk(X)
print(blk.__class__.__name__,'output shape:\t',X.shape)
# 训练Fashion-MNIST数据集
ratio = 4
small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch]
net = vgg(small_conv_arch)
lr, num_epochs, batch_size = 0.05, 10, 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())网络中的网络（NiN）
NiN块：
- 一个卷积层跟两个全连接层，步幅1，无填充
- 这里的全连接层就是1*1的卷积，相当于全连接层的作用
NiN：
- 交替使用NiN块和步幅为2的最大池化层（减小高宽，增大通道数）
- 最后使用全局平均池化层得到输出（输入通道数=输出类别数，每个通道取一个数做类别）
代码实现
# --------定义NiN块--------
def nin_block(in_channels, out_channels, kernel_size, strides, padding):
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size, strides, padding),
nn.ReLU(),
nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU(), # strides默认为1，padding默认为0
nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU())
# --------定义NiN--------
net = nn.Sequential(
nin_block(1, 96, kernel_size=11, strides=4, padding=0),
nn.MaxPool2d(3, stride=2),
nin_block(96, 256, kernel_size=5, strides=1, padding=2),
nn.MaxPool2d(3, stride=2),
nin_block(256, 384, kernel_size=3, strides=1, padding=1),
nn.MaxPool2d(3, stride=2),
nn.Dropout(0.5),
# 标签类别数是10
nin_block(384, 10, kernel_size=3, strides=1, padding=1),
nn.AdaptiveAvgPool2d((1, 1)),
# 将四维的输出转成二维的输出，其形状为(批量大小,10)
nn.Flatten())
# 创建一个数据样本来查看每个块的输出形状
X = torch.rand(size=(1, 1, 224, 224))
for layer in net:
X = layer(X)
print(layer.__class__.__name__,'output shape:\t', X.shape)
# 训练
lr, num_epochs, batch_size = 0.1, 10, 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())含并行连接的网络（GoogLeNet）
首先介绍 Inception 块，如下图所示：
假设输入是192*28*28，则各步骤通道数如上图所示，最终输出通道数为 256 = (64+128+32+32)
其中，
- 4条有不同超参数的卷积层或池化层，分别抽取不同信息，然后在输出通道合并
- 输出的高宽不变，和输入时相同
- 通道的分配不是固定的，是实验测试出来的
白色块的1*1卷积层，用作降低通道数来控制模型复杂度- 蓝色块的卷积层，用于提取空间信息
GoogLeNet
其中，可以分为5个阶段，一共有9个inception块
使用MaxPool降低高宽
使用FC全连接层映射，改变通道适应最终目标
一个stage：高宽减半
代码实现
# --------定义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)
# --------定义GooLeNet--------
# stage1到stage5
b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1),
nn.ReLU(),
nn.Conv2d(64, 192, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),
Inception(256, 128, (128, 192), (32, 96), 64),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),
Inception(512, 160, (112, 224), (24, 64), 64),
Inception(512, 128, (128, 256), (24, 64), 64),
Inception(512, 112, (144, 288), (32, 64), 64),
Inception(528, 256, (160, 320), (32, 128), 128),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
Inception(832, 384, (192, 384), (48, 128), 128),
nn.AdaptiveAvgPool2d((1,1)),
nn.Flatten())
net = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))
# Fashion-MNIST数据集，将输入的高宽从224降到96，简化计算。下面演示各个模块输出的形状变化。
X = torch.rand(size=(1, 1, 96, 96))
for layer in net:
X = layer(X)
print(layer.__class__.__name__,'output shape:\t', X.shape)
# 训练
lr, num_epochs, batch_size = 0.1, 10, 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())批量归一化（BN）
这里也就是我们常说的BN层（batch normalization），网上对其解释有很多，我觉得可以采用如下方式来讲比较好理解
前情提要
我们都知道，数据进入网络训练前，不是一下子训练所有数据，而是把其分成一批一批的，依次送入，我们常提到的batch size就是指每个批次的数据量。
同时我们也知道，在深度学习网络中，有许多的隐藏层。在训练过程中，每一层的输入分布会随着前一层参数的变化而变化，上层网络（深层）需要不停调整来适应输入数据分布的变化，这句话的意思就是：
对于某一层来说，我需要不断学习各式各样的输入数据，然后再输出。当这些输入数据千奇百怪时，我要学起来也很复杂，需要不停的调整自己来适应。而要是能将其变为统一的分布，那我学起来就简单了一些。
目的
如何统一分布，就用BN来实现。
就是把每一层的输出归一化
固定小批量中的均值和方差，然后学习出适合的 偏移和缩放（这两个参数是BN公式中的，影响batch的参数）
可以加速收敛，但一般不改变模型精度
作用在
- 全连接层和卷积层输出上，激活函数前
- 全连接层和卷积层输入上
- 对于全连接层，作用在特征维
- 对于卷积层，作用在通道维
代码实现
# 定义batch norm
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
# 创建一个batchnorm层
class BatchNorm(nn.Module):
# num_features：完全连接层的输出数量或卷积层的输出通道数。
# num_dims：2表示完全连接层，4表示卷积层
def __init__(self, num_features, num_dims):
super().__init__()
if num_dims == 2:
shape = (1, num_features)
else:
shape = (1, num_features, 1, 1)
# 参与求梯度和迭代的拉伸和偏移参数，分别初始化成1和0
self.gamma = nn.Parameter(torch.ones(shape))
self.beta = nn.Parameter(torch.zeros(shape))
# 非模型参数的变量初始化为0和1
self.moving_mean = torch.zeros(shape)
self.moving_var = torch.ones(shape)
def forward(self, X):
# 如果X不在内存上，将moving_mean和moving_var
# 复制到X所在显存上
if self.moving_mean.device != X.device:
self.moving_mean = self.moving_mean.to(X.device)
self.moving_var = self.moving_var.to(X.device)
# 保存更新过的moving_mean和moving_var
Y, self.moving_mean, self.moving_var = batch_norm(
X, self.gamma, self.beta, self.moving_mean,
self.moving_var, eps=1e-5, momentum=0.9)
return Y
# 将BN层应用于LeNet
net = nn.Sequential(
nn.Conv2d(1, 6, kernel_size=5), BatchNorm(6, num_dims=4), nn.Sigmoid(), # 通道数6，4D卷积
nn.AvgPool2d(kernel_size=2, stride=2),
nn.Conv2d(6, 16, kernel_size=5), BatchNorm(16, num_dims=4), nn.Sigmoid(), # 加在激活函数前
nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(), # 压扁 多维变一维
nn.Linear(16*4*4, 120), BatchNorm(120, num_dims=2), nn.Sigmoid(), # 输入，2D卷积
nn.Linear(120, 84), BatchNorm(84, num_dims=2), nn.Sigmoid(),
nn.Linear(84, 10))
# 在Fashion-MNIST数据集训练
lr, num_epochs, batch_size = 1.0, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())残差网络（ResNet）
模型很深，很复杂，不一定就好，有可能小一点，简单一点的模型能达到更好的效果
- 残差允许输入跨过一些层，跳过一些运算步骤，更快向前传播
- 使得更深的网络更容易训练
残差块
如下两种都是残差的实现，分别是 包含以及不包含 1×1 卷积层的残差块
可以看到侧面都有一个箭头，从上一次的输出，与当前输出相加，以此跳过中间的部分
ResNet-18
有非常多的变体，如下是其中的一种，
代码实现
# ---------定义残差块---------
class Residual(nn.Module): #@save
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)
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)
# ---------定义ResNet---------
# 输出通道数为64、步幅为2的7×7卷积层后，接步幅为2的3×3的最大汇聚层
# 每个卷积层后增加了批量规范化层
b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
nn.BatchNorm2d(64), nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
# 除第一个残差块步幅为2，其余不变
def resnet_block(input_channels, num_channels, num_residuals,
first_block=False):
blk = []
for i in range(num_residuals):
if i == 0 and not first_block:
blk.append(Residual(input_channels, num_channels,
use_1x1conv=True, strides=2))
else:
blk.append(Residual(num_channels, num_channels))
return blk
# 模块2到5，每个模块使用2个残差块
b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))
# 全局平均池化，以及全连接层输出
net = nn.Sequential(b1, b2, b3, b4, b5,
nn.AdaptiveAvgPool2d((1,1)),
nn.Flatten(), nn.Linear(512, 10))
# 观察一下ResNet中不同模块的输入形状是如何变化的
X = torch.rand(size=(1, 1, 224, 224))
for layer in net:
X = layer(X)
print(layer.__class__.__name__,'output shape:\t', X.shape)
# 训练
lr, num_epochs, batch_size = 0.05, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())密集连接网络（DenseNet）
这部分内容，视频里没有，但是书中有，我认为也是比较重要的，所以还是讲一下。
看图说话：
ResNet是每个层与前面的某层（一般是2~3层）短路连接在一起，连接方式是通过元素级相加
DenseNet中，每个层都会与前面所有层在channel维度上连接（concat）在一起（这里各个层的特征图大小是相同的，后面会有说明），并作为下一层的输入
每个层都会接受其前面所有层作为其额外的输入，越往后通道数数越多
由于每个稠密块都会带来通道数的增加，使用过多则会过于复杂化模型。 而过渡层可以用来控制模型复杂度。 它通过1×1卷积层来减小通道数，并使用步幅为2的平均汇聚层减半高和宽，从而进一步降低模型复杂度。
代码实现
# 定义块
def conv_block(input_channels, num_channels):
return nn.Sequential(
nn.BatchNorm2d(input_channels), nn.ReLU(),
nn.Conv2d(input_channels, num_channels, kernel_size=3, padding=1))
class DenseBlock(nn.Module):
def __init__(self, num_convs, input_channels, num_channels):
super(DenseBlock, self).__init__()
layer = []
for i in range(num_convs):
layer.append(conv_block(
num_channels * i + input_channels, num_channels))
self.net = nn.Sequential(*layer)
def forward(self, X):
for blk in self.net:
Y = blk(X)
# 连接通道维度上每个块的输入和输出
X = torch.cat((X, Y), dim=1)
return X
# 定义一个有2个输出通道数为10的DenseBlock。 使用通道数为3的输入时，我们会得到通道数为的输出
blk = DenseBlock(2, 3, 10)
X = torch.randn(4, 3, 8, 8)
Y = blk(X)
Y.shape # torch.Size([4, 23, 8, 8])
# 定义过滤层
def transition_block(input_channels, num_channels):
return nn.Sequential(
nn.BatchNorm2d(input_channels), nn.ReLU(),
nn.Conv2d(input_channels, num_channels, kernel_size=1),
nn.AvgPool2d(kernel_size=2, stride=2))
# 对上一个例子中稠密块的输出使用通道数为10的过渡层。 此时输出的通道数减为10，高和宽均减半
blk = transition_block(23, 10)
blk(Y).shape # torch.Size([4, 10, 4, 4])
# 定义DenseBlock
b1 = nn.Sequential(
nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
nn.BatchNorm2d(64), nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
# num_channels为当前的通道数
num_channels, growth_rate = 64, 32
num_convs_in_dense_blocks = [4, 4, 4, 4]
blks = []
for i, num_convs in enumerate(num_convs_in_dense_blocks):
blks.append(DenseBlock(num_convs, num_channels, growth_rate))
# 上一个稠密块的输出通道数
num_channels += num_convs * growth_rate
# 在稠密块之间添加一个转换层，使通道数量减半
if i != len(num_convs_in_dense_blocks) - 1:
blks.append(transition_block(num_channels, num_channels // 2))
num_channels = num_channels // 2
net = nn.Sequential(
b1, *blks,
nn.BatchNorm2d(num_channels), nn.ReLU(),
nn.AdaptiveAvgPool2d((1, 1)),
nn.Flatten(),
nn.Linear(num_channels, 10))
# 训练
lr, num_epochs, batch_size = 0.1, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())下期预告
后面讲啥我也不太清楚，看课程似乎是一些零碎的知识点 ——2024.8.20
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
