1 从全连接层到卷积
当使用MLP处理数据时，我们发现尽然有36亿个特征，显然输出参数太多，不合理。
以图识别为例，我们的分类器应该有两个原则，平移不变性和局部性原则 。下面我们将从这两个原则出发，从全连接层得到卷积。
1.1 不变性和局部性
我们可以使用一个“检测器”扫描图像。 该检测器将图像分割成多个区域，并为每个区域包含目标的可能性打分。 卷积神经网络正是将空间不变性（spatial invariance）的这一概念系统化，从而基于这个模型使用较少的参数来学习有用的表示。
神经网络的前面几层应该只探索输入图像中的局部区域，而不过度在意图像中相隔较远区域的关系，这就是“局部性”原则。 最终，在后续神经网络，整个图像级别上可以集成这些局部特征用于预测。
1.2 限制多层感知机
之前的全连接层：输入输出是一维张量，发生长度上的转化。权重是上一层的神经元个数（行）和下一层的神经元个数（列）的2维矩阵。
V 被称为 卷积核 （convolution kernel） 或者 滤波器 （filter），它仅仅是可学习的一个层的权重。
1.3 通道
然而这种方法有一个问题：我们忽略了图像一般包含三个通道/三种原色（红色、绿色和蓝色）。 实际上，图像不是二维张量，而是一个由高度、宽度和颜色组成的三维张量，比如包含 1024×1024×3 个像素。
这些通道有时也被称为 特征映射 （feature maps），因为每个通道都向后续层提供一组空间化的学习特征。 直观上你可以想象在靠近输入的底层，一些通道专门识别边，而其他通道专门识别纹理。
2 图像卷积
2.1. 互相关运算
首先，我们暂时忽略通道（第三维）这一情况，看看如何处理二维图像数据和隐藏表示。
输入是高度为 3 、宽度为 3 的二维张量（即形状为 3×3 ）。卷积核的高度和宽度都是 2 ，而卷积核窗口（或卷积窗口）的形状由内核的高度和宽度决定（即 2×2 ）。
互相关代码：
import torch
from torch import nn
from d2l import torch as d2l
def corr2d(X, K):
"""计算二维互相关运算"""
h, w = K.shape
Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1)) # 计算输出Y的维度
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 Y
X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
print(corr2d(X, K))
先由结论得到输出矩阵的维数，然后将输出矩阵的高度和宽度作为限制条件，来进行核心运算。
img.shape[i]函数记录：
对于图像来说：
img.shape[0]：图像的垂直尺寸（高度）
img.shape[1]：图像的水平尺寸（宽度）
img.shape[2]：图像的通道数
而对于矩阵来说：
shape[0]：表示矩阵的行数
shape[1]：表示矩阵的列数
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.bias
rand&randn函数记录
torch.rand(*sizes, out=None) → Tensor
返回一个张量，包含了从区间[0, 1)的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义。
torch.rand(2, 3)
torch.randn(*sizes, out=None) → Tensor
返回一个张量，包含了从标准正态分布（均值为0，方差为1，即高斯白噪声）中抽取的一组随机数。张量的形状由参数sizes定义。
torch.randn(2, 3)
torch.normal&torch.linspace函数记录
离散正态分布
torch.normal(means, std, out=None) → → Tensor
线性间距向量
torch.linspace(start, end, steps=100, out=None) → Tensor
返回一个1维张量，包含在区间start和end上均匀间隔的step个点。输出张量的长度由steps决定。
2.3. 图像中目标的边缘检测
如下是卷积层的一个简单应用：通过找到像素变化的位置，来检测图像中不同颜色的边缘。
首先，我们构造一个 6×8 像素的黑白图像。中间四列为黑色（ 0 ），其余像素为白色（ 1 ）。
接下来，我们构造一个高度为 1 、宽度为 2 的卷积核 K 。当进行互相关运算时，如果水平相邻的两元素相同，则输出为零，否则输出为非零。
X = torch.ones((6, 8))
X[:, 2:6] = 0
print(X)
K = torch.tensor([[1.0, -1.0]])
Y = corr2d(X, K)
print(Y)
2.4. 学习卷积核
我们是否可以学习由X生成Y的卷积核呢？
现在让我们看看是否可以通过仅查看“输入-输出”对来学习由 X 生成 Y 的卷积核。 我们先构造一个卷积层，并将其卷积核初始化为随机张量。接下来，在每次迭代中，我们比较 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))
for i in range(10):
Y_hat = conv2d(X)
l = (Y_hat - Y) ** 2
conv2d.zero_grad()
l.sum().backward()
conv2d.weight.data[:] -= 3e-2 * conv2d.weight.grad
if (i + 1) % 2 == 0:
print(f'batch{i + 1}, loss{l.sum():.3f}')
conv2d.weight.data.reshape((1, 2))
print(conv2d.weight.data)
######################
batch2, loss8.572
batch4, loss1.830
batch6, loss0.468
batch8, loss0.144
batch10, loss0.051
tensor([[[[ 0.9642, -1.0084]]]])
我们学习到的卷积核权重非常接近我们之前定义的卷积核 K 。
Conv2d函数记录
2.5 特征映射和感受野
上图中输出的卷积层有时被称为 特征映射 （Feature Map），因为它可以被视为一个输入映射到下一层的空间维度的转换器。 在CNN中，对于某一层的任意元素 x ，其 感受野 （Receptive Field）是指在前向传播期间可能影响 x 计算的所有元素（来自所有先前层）。
在卷积神经网络中，感受野（Receptive Field）的定义是卷积神经网络每一层输出的特征图（feature map）上的像素点在输入图片上映射的区域大小。再通俗点的解释是，特征图上的一个点对应输入图上的区域。
3 填充和步幅
3.1 填充 padding
在应用多层卷积时，我们常常丢失边缘像素。 由于我们通常使用小卷积核，因此对于任何单个卷积，我们可能只会丢失几个像素。 但随着应用许多连续卷积层，累积丢失的像素数就多了。 解决这个问题的简单方法即为填充（padding）：在输入图像的边界填充元素（通常填充元素是 0 ）。
卷积神经网络中卷积核的高度和宽度通常为奇数，例如 1、3、5 或 7。 选择奇数的好处是，保持空间维度的同时，我们可以在顶部和底部填充相同数量的行，在左侧和右侧填充相同数量的列。
import torch
from torch import nn
# 为了方便起见，我们定义了一个计算卷积层的函数。
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数
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))
print(comp_conv2d(conv2d, X).shape)
conv2d = nn.Conv2d(1, 1, kernel_size=(5, 3), padding=(2, 1))
print(comp_conv2d(conv2d, X).shape)
3.2. 步幅 stride
注意是向下取整。
# 下面，我们将高度和宽度的步幅设置为2，
# 从而将输入的高度和宽度减半。
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)
print(comp_conv2d(conv2d, X).shape)
conv2d = nn.Conv2d(1, 1, kernel_size=(3, 5), padding=(0, 1), stride=(3, 4))
print(comp_conv2d(conv2d, X).shape)
可以先依据公式推算输出维度是多少。
4. 多输入多输出通道
当我们添加通道时，我们的输入和隐藏的表示都变成了三维张量。例如，每个RGB输入图像具有 3×h×w 的形状 。我们将这个大小为 3 的轴称为 通道（channel） 维度。
4.1. 多输入通道
当输入包含多个通道时，需要构造一个与输入数据具有相同输入通道数目的卷积核，以便与输入数据进行互相关运算。
import torch
from d2l import torch as d2l
def corr2d_multi_in(X, K):
print(list(zip(X, K)))
return sum(d2l.corr2d(x, k) for x, k in zip(X, K))
X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])
print(corr2d_multi_in(X, K))
###################
[(tensor([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]]), tensor([[0., 1.],
[2., 3.]])), (tensor([[1., 2., 3.],
[4., 5., 6.],
[7., 8., 9.]]), tensor([[1., 2.],
[3., 4.]]))]
zip函数记录
当 zip() 函数有两个参数时，分别从两个参数中依次各取出一个元素组成元组，再将依次组成的元组组合成一个新的迭代器。
4.2. 多输出通道
随着神经网络层数的加深，我们常会增加输出通道的维数，通过减少空间分辨率以获得更大的通道深度。直观地说，我们可以将每个通道看作是对不同特征的响应。而现实可能更为复杂一些，因为每个通道不是独立学习的，而是为了共同使用而优化的。因此，多输出通道并不仅是学习多个单通道的检测器。
# K.shape == [2, 2, 2]
K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])
K = torch.stack((K, K + 1, K + 2), 0) # 每个元素+1, +2
# 0是选择维度
print(K.shape)
################
torch.Size([3, 2, 2, 2])
通过将核张量 K 与 K+1 （ K 中每个元素加 1 ）和 K+2 连接起来，构造了一个具有 3 个输出通道的卷积核。
def corr2d_multi_in_out(X, K):
# 迭代“K”的第0个维度，每次都对输入“X”执行互相关运算。
# 最后将所有结果都叠加在一起
return torch.stack([corr2d_multi_in(X, k) for k in K], 0)
K = torch.stack((K, K + 1, K + 2), 0)
print(corr2d_multi_in_out(X, K))
stack函数记录
官方解释：沿着一个新维度对输入张量序列进行连接。 序列中所有的张量都应该为相同形状。
浅显说法：把多个2维的张量凑成一个3维的张量；多个3维的凑成一个4维的张量…以此类推，也就是在增加新的维度进行堆叠。
4.3 1×1 卷积层
1×1 卷积，即 k_h=k_w=1 ，看起来似乎没有多大意义。 毕竟，卷积的本质是有效提取相邻像素间的相关特征，而 1×1 卷积显然没有此作用。
上图展示了使用 1×1 卷积核与 3 个输入通道和 2 个输出通道的互相关计算。 这里输入和输出具有相同的高度和宽度，输出中的每个元素都是从输入图像中同一位置的元素的线性组合。
卷积核有几组，就有几个输出通道。
我们可以将 1×1 卷积层看作是在每个像素位置应用的全连接层，以 c_i 个输入值转换为 c_o 个输出值。
把输入当作全连接层的输入，任取一组的核函数作为权重，进行相乘求和，得到输出。（和全连接层一模一样）。
同时， 1×1 卷积层需要的权重维度为 c_o×c_i ，再额外加上一个偏置。
def corr2d_multi_in_out_1x1(X, K):
c_i, h, w = X.shape # 通道，行，列
c_o = K.shape[0] # 通道
X = X.reshape((c_i, h * w)) # 展成3个条形数组
K = K.reshape((c_o, c_i))
# 全连接层中的矩阵乘法
Y = torch.matmul(K, X)
return Y.reshape((c_o, h, w))
X = torch.normal(0, 1, (3, 3, 3)) # torch.Size([3, 3, 3])
K = torch.normal(0, 1, (2, 3, 1, 1)) # torch.Size([2, 3, 1, 1])
Y1 = corr2d_multi_in_out_1x1(X, K)
Y2 = corr2d_multi_in_out(X, K)
print(Y1) # torch.Size([2, 3, 3])
print(Y2) # torch.Size([2, 3, 3])
print(Y1 == Y2)
assert float(torch.abs(Y1 - Y2).sum()) < 1e-6
5 池化层pooling
池化（pooling）层，它具有双重目的：降低卷积层对位置的敏感性，同时降低对空间降采样表示的敏感性。
5.1. 最大汇聚层和平均汇聚层
与卷积层类似，汇聚层运算符由一个固定形状的窗口组成，该窗口根据其步幅大小在输入的所有区域上滑动，为固定形状窗口（有时称为 池化窗口）遍历的每个位置计算一个输出。
然而，不同于卷积层中的输入与卷积核之间的互相关计算，汇聚层不包含参数。 相反，池运算符是确定性的，我们通常计算池化窗口中所有元素的最大值或平均值。这些操作分别称为 最大汇聚层 （maximum pooling）和 平均汇聚层 （average pooling）。
池化窗口形状为 p×q 的汇聚层，称为 p×q 汇聚层。池化操作称为 p×q 池化。
import torch
from torch import nn
def pool2d(X, pool_size, mode='max'):
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 = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
print(pool2d(X, (2, 2)))
print(pool2d(X, (2, 2), 'avg'))
####################
tensor([[4., 5.],
[7., 8.]])
tensor([[2., 3.],
[5., 6.]])
5.2. 填充padding和步幅stride
与卷积层一样，汇聚层也可以改变输出形状。和以前一样，我们可以通过填充和步幅以获得所需的输出形状。
import torch
from torch import nn
from d2l import torch as d2l
# 样本数和通道数都是 1
X = torch.arange(16, dtype=d2l.float32).reshape((1, 1, 4, 4))
# 默认情况下，深度学习框架中的步幅与池化窗口的大小相同
pool2d = nn.MaxPool2d(3) # （3，3）
print(pool2d(X)) # tensor([[[[10.]]]])
print(pool2d(X).shape) # torch.Size([1, 1, 1, 1])
# 填充和步幅可以手动设定。
pool2d = nn.MaxPool2d(3, padding=1, stride=2)
print(pool2d(X))
# 设定一个任意大小的矩形池化窗口，并分别设定填充和步幅的高度和宽度。
pool2d = nn.MaxPool2d((2, 3), padding=(1, 1), stride=(2, 3))
print(pool2d(X))
默认情况下，深度学习框架中的步幅与池化窗口的大小相同。
5.3. 多个通道
X = torch.cat((X, X + 1), 1) #在X的第一维上进行连接（从零开始计数）
print(X)
pool2d = nn.MaxPool2d(3, padding=1, stride=2)
print(pool2d(X))
###############
X.shape:torch.Size([1, 1, 4, 4]), X.shape.cat:torch.Size([1, 2, 4, 4])
cat函数记录
torch.cat是将两个张量（tensor）拼接在一起，cat是concatenate的意思，即拼接，联系在一起。
6. 卷积神经网络（LeNet）
通过之前几节，我们学习了构建一个完整卷积神经网络的所需组件。 回想一下，之前我们将 softmax 回归模型和多层感知机模型应用于 Fashion-MNIST 数据集中的服装图片上。 为了能够应用 softmax 回归和多层感知机，我们首先将每个大小为 28×28 的图像展平为一个 784 固定长度的一维向量，然后用全连接层对其进行处理。 而现在，我们已经掌握了卷积层的处理方法，我们可以在图像中保留空间结构。 同时，用卷积层代替全连接层的另一个好处是：更简洁的模型所需的参数更少。
6.1. LeNet
总体来看，LeNet（LeNet-5）由两个部分组成：
卷积编码器： 由两个卷积层组成 ;
全连接层密集块：由三个全连接层组成。
每个卷积块中的基本单元是一个卷积层、一个 sigmoid 激活函数和平均汇聚层。
每个卷积层使用 5×5 卷积核和一个 sigmoid 激活函数。这些层将输入映射到多个二维特征输出，通常同时增加通道的数量。第一卷积层有 6 个输出通道，而第二个卷积层有 16 个输出通道。
每个 2×2 池操作通过空间下采样将维数减少 4 倍。卷积的输出形状由批量大小、通道数、高度、宽度决定。
为了将卷积块的输出传递给稠密块，我们必须在小批量中展平每个样本。
import torch
from torch import nn
from d2l import torch as d2l
import matplotlib.pyplot as plt
class Reshape(torch.nn.Module):
def forward(self, x):
return x.view(-1, 1, 28, 28) # 相当于numpy中resize的功能
net = torch.nn.Sequential(
Reshape(),
# 第1层
nn.Conv2d(1, 6, kernel_size=5,padding=2), nn.Sigmoid(),
nn.AvgPool2d(kernel_size=2, stride=2),
# 第2层
nn.Conv2d(6, 16, kernel_size=5, padding=2), 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)
######################
Reshape output shape: torch.Size([1, 1, 28, 28])
Conv2d output shape: torch.Size([1, 6, 28, 28])
Sigmoid output shape: torch.Size([1, 6, 28, 28])
AvgPool2d output shape: torch.Size([1, 6, 14, 14])
Conv2d output shape: torch.Size([1, 16, 10, 10])
Sigmoid output shape: torch.Size([1, 16, 10, 10])
AvgPool2d output shape: torch.Size([1, 16, 5, 5])
Flatten output shape: torch.Size([1, 400])
Linear output shape: torch.Size([1, 120])
Sigmoid output shape: torch.Size([1, 120])
Linear output shape: torch.Size([1, 84])
Sigmoid output shape: torch.Size([1, 84])
Linear output shape: torch.Size([1, 10])
6.2. 模型训练
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):
if isinstance(net, torch.nn.Module): # 判断类型是否相同，返回布尔值
net.eval()
if not device:
device = next(iter(net.parameters())).device
metric = d2l.Accumulator(2)
for X, y in data_iter:
if isinstance(X, list):
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]
net.eval()函数记录：
神经网络模块存在两种模式，train模式（net.train())和eval模式（net.eval())。一般的神经网络中，这两种模式是一样的，只有当模型中存在dropout和batchnorm的时候才有区别。
为了使用 GPU，我们还需要一点小改动。在进行正向和反向传播之前，我们需要将每一小批量数据移动到我们指定的设备（例如 GPU）上。
def train(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(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())
plt.show()
364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
