6.2-6.5 卷积的一些基础代码

互相关运算

1
import torch
2
from torch import nn
3
from d2l import torch as d2l
4

5
def corr2d(X, K):
6
    """计算二维互相关运算"""
7
    h, w = K.shape
8
    Y = torch.zeros(X.shape[0] - h + 1, X.shape[1] - w + 1)
9
    for i in range(Y.shape[0]):
10
        for j in range(Y.shape[1]):
11
            Y[i, j] = (X[i:i + h, j:j + w] * K).sum()
12
    return Y

二维卷积层

1
class Conv2D(nn.Module):
2
    def __init__(self, kernel_size):
3
        super().__init__()
4
        self.weight = nn.Parameter(torch.rand(kernel_size))
5
        self.bias = nn.Parameter(torch.zeros(1))
6
        # nn.Parameter()包装可训练参数
7

8
    def forward(self, x):
9
        return corr2d(x, self.weight) + self.bias

高度和宽度分别为 $h$ 和 $w$ 的卷积核可以被称为 $h\times w$ 卷积或 $h\times w$ 卷积核。我们也将带有 $h\times w$ 卷积核的卷积层称为 $h\times w$ 卷积层。

边缘检测
如下是卷积层的一个简单应用：通过找到像素变化的位置，来检测图像中不同颜色的边缘。我们构造一个高度为1、宽度为2的卷积核K。当进行互相关运算时，如果水平相邻的两元素相同，则输出为零，否则输出为非零。

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

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

6
Y = corr2d(X, K)
7
Y

1
tensor([[ 0.,  1.,  0.,  0.,  0., -1.,  0.],
2
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
3
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
4
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
5
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
6
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.]])

这个卷积核K只可以检测垂直边缘，无法检测水平边缘。

1
corr2d(X.t(), K)

1
tensor([[0., 0., 0., 0., 0.],
2
        [0., 0., 0., 0., 0.],
3
        [0., 0., 0., 0., 0.],
4
        [0., 0., 0., 0., 0.],
5
        [0., 0., 0., 0., 0.],
6
        [0., 0., 0., 0., 0.],
7
        [0., 0., 0., 0., 0.],
8
        [0., 0., 0., 0., 0.]])

学习卷积核
复杂情况时，我们不可能手动设计滤波器。那么是否可以学习由X生成Y的卷积核呢？

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

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

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

1
epoch2, loss8.690
2
epoch4, loss1.499
3
epoch6, loss0.268
4
epoch8, loss0.052
5
epoch10, loss0.012

在10次迭代之后，误差已经降到足够低。现在我们来看看我们所学的卷积核的权重张量，注意到我们学习到的卷积核权重非常接近我们之前定义的卷积核K。

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

1
tensor([[ 0.9777, -0.9920]])

填充和步幅

填充(Padding)
- 通常取 $p_h=k_h-1$ ， $p_w=k_w-1$ ，使输入输出形状相同；
- 当 $k_h$ 为奇数：在上下左右各填充 $p_h/2$
- 当 $k_h$ 为偶数：在上侧填充 $\lceil p_h/2\rceil$ ，下侧填充 $\lfloor p_h/2\rfloor$

1
import torch
2
from torch import nn
3

4
def comp_conv2d(conv2d, X):
5
    # 这里的（1，1）表示批量大小和通道数都是1
6
    X = X.reshape((1, 1) + X.shape)
7
    Y = conv2d(X)
8
    return Y.reshape(Y.shape[2:])
9

10
# 这里每边都填充了1行或1列，因此总共添加了2行或2列
11
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
12
X = torch.rand(size=(8, 8))
13
comp_conv2d(conv2d, X).shape

1
torch.Size([8, 8])

我们使用高度为5，宽度为3的卷积核，高度和宽度两边的填充分别为2和1。

1
conv2d = nn.Conv2d(1, 1, kernel_size=(5, 3), padding=(2, 1))
2
comp_conv2d(conv2d, X).shape

1
torch.Size([8, 8])

步幅(Stride)
- 给定高度 $s_h$ 和宽度 $s_w$ 的步幅，输出形状是： $\lfloor(n_h-k_h+p_h+s_h)/s_h\rfloor\times\lfloor(n_w-k_w+p_w+s_w)/s_w\rfloor$
- 如果 $p_h=k_h-1$ ， $p_w=k_w-1$ $\lfloor(n_h+s_h-1)/s_h\rfloor\times\lfloor(n_w+s_w-1)/s_w\rfloor$
- 如果输入高度和宽度可以被步幅整除 $(n_h/s_h)\times(n_w/s_w)$

下面，我们将高度和宽度的步幅设置为2，从而将输入的高度和宽度减半。

1
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)
2
comp_conv2d(conv2d, X).shape

1
torch.Size([4, 4])

来个复杂一些的例子，有 $\lfloor\frac{8-3+0+3}{3}\rfloor=2$ $\lfloor\frac{8-5+1+4}{4}\rfloor=2$

1
conv2d = nn.Conv2d(1, 1, kernel_size=(3, 5), padding=(0, 1), stride=(3, 4))
2
comp_conv2d(conv2d, X).shape

1
torch.Size([2, 2])

多输入多输出通道

多个输入通道
输入 $\bf X$ ： $c_i\times n_h\times n_w$
核 $\bf W$ ： $c_i\times k_h\times k_w$
输出 $\bf Y$ ： $m_h\times m_w$
$\bf Y=\sum_{i=0}^{c_i}X_i\star W_i$

其中， $c_i$ 表示输入的通道维

1
import torch
2
from d2l import torch as d2l
3

4
def corr2d_multi_in(X, K):
5
    # 先遍历“X”和“K”的第0个维度（通道维度），再把它们加在一起
6
    return sum(d2l.corr2d(x,k) for x, k in zip(X, K))
7

8

9
X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
10
               [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
11
K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])
12

13
corr2d_multi_in(X, K)

1
tensor([[ 56.,  72.],
2
        [104., 120.]])

多输出通道
输入 $\bf X$ ： $c_i\times n_h\times n_w$
核 $\bf W$ ： $c_o\times c_i\times k_h\times k_w$
输出 $\bf Y$ ： $c_o\times m_h\times m_w$
$\bf{Y_i}=X * W_i \quad \text{for i=1,…,}\mathbb{c_0}$

其中， $c_o$ 表示输出的通道维

1
def corr2d_multi_in_out(X, K):
2
    # 迭代“K”的第0个维度，每次都对输入“X”执行互相关运算。
3
    # 最后将所有结果都叠加在一起
4
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)
5

6
K = torch.stack((K, K + 1, K + 2), 0)
7
# K.shape = (3, 2, 2, 2)
8

9
corr2d_multi_in_out(X, K)

1
tensor([[[ 56.,  72.],
2
         [104., 120.]],
3

4
        [[ 76., 100.],
5
         [148., 172.]],
6

7
        [[ 96., 128.],
8
         [192., 224.]]])

$1 \times 1$ 卷积层
可看作在每个像素位置应用的全连接层，以 $c_i$ 个输入值转换为 $c_o$ 个输出值。下面，我们使用全连接层实现 $1 \times 1$ 卷积。请注意，我们需要对输入和输出的数据形状进行调整。

1
def corr2d_multi_in_out_1x1(X, K):
2
    c_i, h, w = X.shape
3
    c_o = K.shape[0]
4
    X = X.reshape(c_i, h * w)
5
    K = K.reshape(c_o, c_i)
6
    #全连接层中的矩阵乘法
7
    Y = torch.matmul(K, X)
8
    return Y.reshape(c_o, h, w)
9

10
X = torch.normal(0, 1, (3, 3, 3))
11
K = torch.normal(0, 1, (2, 3, 1, 1))
12

13
Y1 = corr2d_multi_in_out_1x1(X, K)
14
Y2 = corr2d_multi_in_out(X, K)
15
float(torch.abs(Y1 - Y2).sum()) < 1e-6

1
True

池化层

最大池化层和平均池化层
在下面的代码中的pool2d函数，我们实现池化层的前向传播。

1
import torch
2
from torch import nn
3
from d2l import torch as d2l
4

5
def pool2d(X, pool_size, mode='max'):
6
    p_h, p_w = pool_size
7
    Y = torch.zeros(X.shape[0] - p_h + 1, X.shape[1] - p_w + 1)
8
    for i in range(Y.shape[0]):
9
        for j in range(Y.shape[1]):
10
            if mode == 'max':
11
                Y[i, j] = X[i: i + p_h, j: j + p_w].max()
12
            elif mode == 'avg':
13
                Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
14
    return Y
15

16
X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
17
pool2d(X, (2, 2))

1
tensor([[4., 5.],
2
        [7., 8.]])

试试平均池化层。

1
pool2d(X, (2, 2), 'avg')

1
tensor([[2., 3.],
2
        [5., 6.]])

填充和步幅
默认情况下，深度学习框架中的步幅与汇聚窗口的大小相同。因此，如果我们使用形状为(3, 3)的汇聚窗口，那么默认情况下，我们得到的步幅形状为(3, 3)。

1
X = torch.arange(16, dtype=torch.float32).reshape(1, 1, 4, 4)
2
X

1
tensor([[[[ 0.,  1.,  2.,  3.],
2
          [ 4.,  5.,  6.,  7.],
3
          [ 8.,  9., 10., 11.],
4
          [12., 13., 14., 15.]]]])

1
pool2d = nn.MaxPool2d(3)
2
pool2d(X)

1
tensor([[[[10.]]]])

1
pool2d = nn.MaxPool2d((2, 3), stride=(2, 3), padding=(0, 1))
2
pool2d(X)

1
tensor([[[[ 5.,  7.],
2
          [13., 15.]]]])

多个通道
在处理多通道输入数据时，池化层在每个输入通道上单独运算，而不是像卷积层一样在通道上对输入进行汇总。这意味着池化层的输出通道数与输入通道数相同。

1
X = torch.cat((X, X + 1), 1)
2
X

1
tensor([[[[ 0.,  1.,  2.,  3.],
2
          [ 4.,  5.,  6.,  7.],
3
          [ 8.,  9., 10., 11.],
4
          [12., 13., 14., 15.]],
5

6
         [[ 1.,  2.,  3.,  4.],
7
          [ 5.,  6.,  7.,  8.],
8
          [ 9., 10., 11., 12.],
9
          [13., 14., 15., 16.]]]])

1
pool2d = nn.MaxPool2d(3, padding=1, stride=2)
2
pool2d(X)

1
tensor([[[[ 5.,  7.],
2
          [13., 15.]],
3

4
         [[ 6.,  8.],
5
          [14., 16.]]]])