Pytorch 卷积层

Pytorch 卷积层

0. 环境介绍

环境使用 Kaggle 里免费建立的 Notebook

教程使用李沐老师的 动手学深度学习 网站和 视频讲解

小技巧：当遇到函数看不懂的时候可以按 Shift+Tab 查看函数详解。

1. 从全连接到卷积

多层感知机十分适合处理表格数据，其中行对应样本，列对应特征。 对于表格数据，我们寻找的模式可能涉及特征之间的交互，但是我们不能预先假设任何与特征交互相关的先验结构。 此时，多层感知机可能是最好的选择，然而对于高维感知数据（图片，视频等），这种缺少结构的网络可能会变得不实用。

注 ：深度神经网络也不适合用于处理表格数据。
大家可以看一下以下资料：
深度神经网络为什么在表格数据上就是不行呢
论文地址

1.0 猫狗图像分类

假设有一个充分的猫狗照片数据集，每张照片具有百万级别的像素，这意味着网络的每次输入都有一百万（$10^6$）个维度（先不考虑 RGB 通道）。即使将隐藏层维度降低到 $1000(10^3)$，这个全连接层也将有 $10^6\times 10^3=10^9$ 个参数。

参数量太多，需要大量的 GPU 资源和分布式优化训练的经验。

然而，如今人类和机器都能很好地区分猫和狗：这是因为图像中本就拥有丰富的结构，而这些结构可以被人类和机器学习模型使用。 卷积神经网络（convolutional neural networks，CNN）是机器学习利用自然图像中一些已知结构的创造性方法。

1.1 平移不变性和局部性

假设你想从一张图片中找到某个物体。 合理的假设是：无论哪种方法找到这个物体，都应该和物体的位置无关。

沃尔多游戏：在这个游戏中包含了许多充斥着活动的混乱场景，而沃尔多通常潜伏在一些不太可能的位置，读者的目标就是找出他。 尽管沃尔多的装扮很有特点，但是在眼花缭乱的场景中找到他也如大海捞针。 然而沃尔多的样子并不取决于他潜藏的地方，因此我们可以使用一个“沃尔多检测器”扫描图像。 该检测器将图像分割成多个区域，并为每个区域包含沃尔多的可能性打分。 卷积神经网络正是将空间不变性（spatial invariance）的这一概念系统化，从而基于这个模型使用较少的参数来学习有用的表示。

总结下来就是两个原则：

1. 平移不变性（translation invariance）：不管检测对象出现在图像中的哪个位置，神经网络的前面几层应该对相同的图像区域具有相似的反应，即为“平移不变性”。
2. 局部性（locality）：神经网络的前面几层应该只探索输入图像中的局部区域，而不过度在意图像中相隔较远区域的关系，这就是“局部性”原则。最终，可以聚合这些局部特征，以在整个图像级别进行预测。

1.2 多层感知机的限制

使用 $[\mathbf{X}{]}_{i,j}$ 和 $[\mathbf{H}{]}_{i,j}$ 分别表示输入图像和隐藏表示中位置 $(i,j)$ 处的像素。
$$\begin{array}{rl}{\left[\mathbf{H}\right]}_{i,j}& =[\mathbf{U}{]}_{i,j}+\sum _k\sum _l[\mathsf{W}{]}_{i,j,k,l}[\mathbf{X}{]}_{k,l}\\ & =[\mathbf{U}{]}_{i,j}+\sum _a\sum _b[\mathsf{V}{]}_{i,j,a,b}[\mathbf{X}{]}_{i+a,j+b}.\end{array}$$
为了使每个隐藏神经元都能接收到每个输入像素的信息，我们将参数从权重矩阵（如同我们先前在多层感知机中所做的那样）替换为四阶权重张量 $W$。 $U$ 为偏置参数。$a$ 和 $b$ 通过在正偏移和负偏移之间移动覆盖了整个图像。 $[\mathsf{V}{]}_{i,j,a,b}$ 表示像素 $(i,j)$ 对于像素 $(i+a,j+b)$ 的权重。

可以发现参数量很大。

1.3 引入平移不变性

意味着对象在输入 $X$ 中的平移，应该仅导致隐藏层 $H$ 中的平移。也就是说 $V$ 和 $U$ 不依赖于 $(i,j)$ 的值，即 $[\mathsf{V}{]}_{i,j,a,b}=[\mathbf{V}{]}_{a,b}$。而且 $U$ 为一个常数 $u$。
$$[\mathbf{H}{]}_{i,j}=u+\sum _a\sum _b[\mathbf{V}{]}_{a,b}[\mathbf{X}{]}_{i+a,j+b}.$$
这就是卷积（convolution）。我们是在使用系数 $[\mathbf{V}{]}_{a,b}$ 对位置 $(i,j)$ 附近的像素 $(i+a,j+b)$ 进行加权得到 $[\mathbf{H}{]}_{i,j}$。

这样看的话，$[\mathbf{V}{]}_{a,b}$ 的参数量比 $[\mathsf{V}{]}_{i,j,a,b}$ 要少了很多。

1.4 引入局部性

为了收集训练参数 $[\mathbf{H}{]}_{i,j}$ 的相关信息，我们不应偏离到距 $(i,j)$ 很远的地方。这意味着在 $|a|>\Delta$ 或 $|b|>\Delta$ 的范围之外，我们可以设置 $[\mathbf{V}{]}_{a,b}=0$。因此，我们可以将 $[\mathbf{H}{]}_{i,j}$ 重写为：
$$[\mathbf{H}{]}_{i,j}=u+\sum _{a=-\Delta }^{\Delta }\sum _{b=-\Delta }^{\Delta }[\mathbf{V}{]}_{a,b}[\mathbf{X}{]}_{i+a,j+b}.$$

上式就是一个卷积层（convolutional layer），卷积神经网络（CNN）就是包含卷积层的一类特殊的神经网络。
$V$ 被称为卷积核（convolution kernel）或者滤波器（filter），亦或简单地称之为该卷积层的权重，通常该权重是可学习的参数。

当图像处理的局部区域很小时，卷积神经网络与多层感知机的训练差异可能是巨大的：以前，多层感知机可能需要数十亿个参数来表示网络中的一层，而现在卷积神经网络通常只需要几百个参数，而且不需要改变输入或隐藏表示的维数。 参数大幅减少的代价是，我们的特征现在是平移不变的，并且当确定每个隐藏活性值时，每一层只包含局部的信息。 以上所有的权重学习都将依赖于归纳偏置。当这种偏置与现实相符时，我们就能得到样本有效的模型，并且这些模型能很好地泛化到未知数据中。 但如果这偏置与现实不符时，比如当图像不满足平移不变时，我们的模型可能难以拟合我们的训练数据。

2. 卷积层

卷积层严格来讲，是错误的叫法，因为它所表达的运算其实是交叉相关运算（cross-correlation），而不是卷积运算。

注：：
想了解卷积的意义，这里推荐 B 站 一位 up 主的视频：
从“卷积”、到“图像卷积操作”、再到“卷积神经网络”，“卷积”意义的3次改变

2.1 2D 卷积层

输入 $X$ 是 $(3\times 3)$ 的张量，卷积核 $W$ 为 $(2\times 2)$。

输出 $Y$ 大小等于输入 $X$ 大小 $n_h\times n_w$ 减去卷积核 $W$ 大小 $k_h\times k_w$，即：
$$(n_h-k_h+1)\times (n_w-k_w+1).$$
然后再加上一个偏置项 $b$，$Y$ 表达式为：
$$Y=X★W+b$$
$★$ 表示卷积运算，$W$ 和 $b$ 是可学习的参数。卷积核的大小 $k_h\times k_w$ 是超参数。

3. 图像卷积代码实现

3.1 2D 卷积运算

!pip install d2l
import torch
from torch import nn
from d2l import torch as d2l

def corr2d(X, K):  #@save
    """计算二维互相关运算"""
    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 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]])
corr2d(X, K)

3.2 2D卷积层

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

3.3 图像中目标的边缘检测

X = torch.ones((6, 8))
X[:, 2:6] = 0
X

构造一个 $(1\times 2)$ 的卷积核 $K$，如果水平相邻的两元素相同，则输出为零，否则输出为非零。

K = torch.tensor([[1.0, -1.0]])

输出 $Y$ 中的 $1$ 代表从白色到黑色的边缘，$-1$ 代表从黑色到白色的边缘，其他情况的输出为 $0$。

Y = corr2d(X, K)
Y

现在我们将输入的二维图像转置，再运算。 其输出如下，之前检测到的垂直边缘消失了。 这个卷积核 $K$ 只可以检测垂直边缘，无法检测水平边缘：

corr2d(X.t(), K)

3.4 学习由 $X$ 生成 $Y$ 的卷积核 $K$

上一节（3.3）我们是设置的卷积核 $K$ 的值，通过与 $X$ 运算得到了 $Y$，下面我们通过 $X$ 和 $Y$ 训练学习出来 $K$。

我们先构造一个卷积层，并将其卷积核初始化为随机张量。接下来，在每次迭代中，我们比较 $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
    conv2d.zero_grad()
    l.sum().backward()
    # 迭代卷积核
    conv2d.weight.data[:] -= lr * conv2d.weight.grad
    if (i + 1) % 2 == 0:
        print(f'epoch {i+1}, loss {l.sum():.3f}')

注：关于为什么损失需要 sum() 之后再 backward() ：
参考 https://zhuanlan.zhihu.com/p/427853673

查看所学的卷积核的权重张量：

conv2d.weight.data.reshape((1, 2))

3.5 加入偏置 $b$ 后训练

# 构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
conv2d = nn.Conv2d(1,1, kernel_size=(1, 2), bias=True)

# 这个二维卷积层使用四维输入和输出格式（批量大小、通道、高度、宽度），
# 其中批量大小和通道数都为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
    conv2d.zero_grad()
    l.sum().backward()
    # 迭代卷积核
    conv2d.weight.data[:] -= lr * conv2d.weight.grad
    conv2d.bias.data[:] -= lr * conv2d.bias.grad
    if (i + 1) % 2 == 0:
        print(f'epoch {i+1}, loss {l.sum():.3f}')

可以发现无法收敛，这个时候应该调小学习率 lr 并且增加训练 epoch 数量：

# 构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
conv2d = nn.Conv2d(1,1, kernel_size=(1, 2), bias=True)

# 这个二维卷积层使用四维输入和输出格式（批量大小、通道、高度、宽度），
# 其中批量大小和通道数都为1
X = X.reshape((1, 1, 6, 8))
Y = Y.reshape((1, 1, 6, 7))
lr = 1e-2  # 学习率

for i in range(30):
    Y_hat = conv2d(X)
    l = (Y_hat - Y) ** 2
    conv2d.zero_grad()
    l.sum().backward()
    # 迭代卷积核
    conv2d.weight.data[:] -= lr * conv2d.weight.grad
    conv2d.bias.data[:] -= lr * conv2d.bias.grad
    if (i + 1) % 2 == 0:
        print(f'epoch {i+1}, loss {l.sum():.3f}')

print(conv2d.weight.data.reshape((1, 2)), conv2d.bias.data)