卷积

​ 用MLP处理图片的问题：假设一张图片有12M像素，那么RGB图片就有36M元素，使用大小为100的单隐藏层，模型有3.6B元素，这个数量非常大。

识别模式的两个原则：

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

从全连接层到卷积

​ 需要将输入和输出变形为矩阵(宽度，高度)，因为现在处理的信息含有空间上的信息

​ 将权重变形为四维张量，从(h,w)到(h’,w’)，记录输入图的横纵坐标，对输出图的横纵坐标的影响。
$$\begin{gathered} h_{i,j}=b_{i,j}+\sum _k\sum _l{w}_{i,j,k,l}{x}_{k,l}=b_{i,j}+\sum _a\sum _b{v}_{i,j,a,b}{x}_{i+a,i+b} \\ v是w的重新索引v_{i,j,a,b}=w_{i,j,i+a,j+b} \end{gathered}$$
​ 索引$a$和$b$通过在正偏移和负偏移之间移动覆盖了整个图像。对于隐藏表示中任意给定位置$(i,j)$处的像素值$h_{i,j}$，可以通过$x$中以$(i,j)$为中心对像素进行加权求和得到，加权使用的权重为$v_{i,j,a,b}$

平移不变性

​ $x$的平移导致$h$的平移$h_{i,j}=b_{i,j}+{\sum }_a{\sum }_b{v}_{i,j,a,b}{x}_{i+a,i+b}$,$v$应该不依赖于$i,j$，它是整张图的权重，则我们可以让$v_{i,j,a,b}=v_{a,b}$，则
$$h_{i,j}=b_{i,j}+\sum _a\sum _b{v}_{a,b}{x}_{i+a,i+b}$$
​ 这就是2维卷积，数学上叫做2维交叉相关

​ 这样的简化让权重矩阵简化了不少

局部性

$$h_{i,j}=b_{i,j}+\sum _a\sum _b{v}_{a,b}{x}_{i+a,i+b}$$

​ 在评估$h_{i,j}$时，我们不应该用远离$x_{i,j}$的参数，那么，可以只取一个小范围：

​ 当$|a|,|b|>\Delta$时，使得$v_{a,b}=0$
$$h_{i,j}=b_{i,j}+\sum _{a=-\Delta }^{\Delta }\sum _{b=-\Delta }^{\Delta }{v}_{a,b}{x}_{i+a,j+b}$$
对全连接层使用平移不变性和局部性得到了卷积层
$$h_{i,j}=b_{i,j}+\sum _a\sum _b{v}_{i,j,a,b}{x}_{i+a,i+b}⟹h_{i,j}=b_{i,j}+\sum _{a=-\Delta }^{\Delta }\sum _{b=-\Delta }^{\Delta }{v}_{a,b}{x}_{i+a,j+b}$$

卷积层

二维交叉相关

​ 对应数字相乘再相加。

二维卷积层

输入$X:n_h\times n_w$

核$W:k_h\times k_w$

偏差$b\in \mathbb{R}$

输出$Y:(n_h-k_h+1)\times (n_w-k_w+1)$ (卷积核横向和纵向滑动的次数)
$$Y=X\cdot W+b$$
$W$和$b$是可学习的参数

边缘检测：中间大，周围是负数

由于对称性，交叉相关和卷积在实际使用中没有区别

一维和三维交叉相关

1.一维

$$y_i=\sum _{a=1}^h{w}_a{x}_{i+1}$$

​ 文本，语言，时序序列

2.三维

​
$$y_{i,j,k}=\sum _{a=1}^h\sum _{b=1}^w\sum _{c=1}^d{w}_{a,b,c}{x}_{i+a,j+b,k+c}$$
​ 视频，医学图像，气象地图

​ 卷积层将输入和核矩阵进行交叉相关，加上偏移后得到输出，核矩阵和偏移是可学习的参数，核矩阵的大小是超参数。

代码实现

import torch
from torch import nn
from d2l import torch as d2l


def corr2d(X, K):  # X是输入矩阵，K是核矩阵 2D卷积
    """计算二维互相关运算"""
    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]])
Y = corr2d(X, K)
print(Y)

'''卷积层，卷积层在进行互相关运算后，加上偏置产生输出，那么卷积层被训练的参数是卷积核权重和标量偏置'''


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  # 前向传播函数调用corr2d并进行偏置


'''将带有h×w卷积核的卷积层称为h×w卷积层'''

# 检测图像中不同颜色的边缘
X = torch.ones((6, 8))
X[:, 2:6] = 0
print(X)
# 如果元素相同，则输出为0，不同则非0
k = torch.tensor([[1.0, -1.0]])
Y = corr2d(X, k)
print('边缘检测结果:\n', Y)

# 这个K只能检测垂直边缘，将X转置后：
Z = corr2d(X.t(), k)
print('垂直边缘检测结果:\n', Z)

'''学习卷积核'''

# 构造一个二维卷积层，它具有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}')

print("训练结果:", conv2d.weight.data.reshape((1, 2)))

个人理解

​ 卷积的动机是为了减少训练的参数，模式识别的特点(平移不变性，局部性)也保证了这样是合理的。