PyTorch构建卷积层

二维图像卷积

使用全连接层来处理图片时，如果图片的尺寸比较大，那么就会出现参数爆炸的情况，模型复杂度直线提升而难以训练。为了降低模型的复杂度，提出了卷积层的概念。
卷积层是在全连接层的基础上，对于参数的取值加以限制来降低模型的复杂度。基于这样两种假设：
- 平移不变性：
- 局部性原理：
在这两种假设的基础上，卷积层大大减低了参数的数量。

一、 二维卷积层的实现

1. 手动实现二维卷积层

import torch
from torch import nn

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

class Conv2D(nn.Module):
    """2维卷积层"""
    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

# 测试Conv2D是否正确
# 生成输入样本X
>>>X = torch.ones((6, 8))
>>>X[:, 2:6] = 0
>>>X
>tensor([[1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.]])

# 定义卷积核K，使用corr2d得到输出Y
>>>K = torch.tensor([[1.0, -1.0]])
>>>Y = corr2d(X, K)
>>>Y
>tensor([[ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.]])

# 实例化卷积模型，使用{X, Y}作为数据，训练模型参数K
conv2d = Conv2D(kernel_size=(1,2))

>>>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}')
>batch 2, loss 7.240
batch 4, loss 1.494
batch 6, loss 0.365
batch 8, loss 0.108
batch 10, loss 0.037

# 查看训练结果
>>>conv2d.weight.data
>tensor([[ 1.0058, -0.9686]])

2. Pytorch的卷积层API实现

class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
二维卷积层, 输入的尺度是(N, C_in,H,W)（批量大小，输入通道数，*输入尺寸），输出尺度（N,C_out,H_out,W_out）（批量大小，输出通道数，*输出尺寸）。
参数：
in_channels(int) – 输入信号的通道
out_channels(int) – 卷积产生的通道
kerner_size(int or tuple) - 卷积核的尺寸
stride(int or tuple, optional) - 卷积步长
padding (int or tuple, optional)- 输入的每一条边补充0的层数
dilation(int or tuple, `optional``) – 卷积核元素之间的间距
groups(int, optional) – 从输入通道到输出通道的阻塞连接数
bias(bool, optional) - 如果bias=True，添加偏置
训练变量：
weight(tensor) - 卷积的权重，大小是(out_channels, in_channels, kernel_size)
bias(tensor) - 卷积的偏置系数，大小是（out_channel）

import torch
from torch import nn

# 测试Conv2D是否正确
# 生成输入样本X
>>>X = torch.ones((6, 8))
>>>X[:, 2:6] = 0
>>>X
>tensor([[1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.],
        [1., 1., 0., 0., 0., 0., 1., 1.]])

# 定义卷积核K，使用corr2d得到输出Y
>>>K = torch.tensor([[1.0, -1.0]])
>>>Y = corr2d(X, K)
>>>Y
>tensor([[ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
        [ 0.,  1.,  0.,  0.,  0., -1.,  0.]])

# 实例化卷积模型，使用{X, Y}作为数据，训练模型参数K
conv2d = nn.Conv2d(1, 1, kernel_size=(1,2), bias=False)
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}')
>batch 2, loss 3.821
batch 4, loss 1.196
batch 6, loss 0.428
batch 8, loss 0.165
batch 10, loss 0.066

# 查看训练结果
>>>conv2d.weight.data
>tensor([[[[ 1.0198, -0.9673]]]])

二、 二维卷积层的填充和步幅

卷积会使得图像的大小逐渐减小，一个HW大小的图像，使用kk的卷积核，输出大小会降低为 (H - K + 1)( W - K + 1)。这会限制掉模型可以构建的最大深度。
填充是为了解决这个问题而出现的。填充就是在图像的四周加入额外的行和列，行列填充 P 行/列时，输出大小就变成了(H - K + P + 1)( W - K + P + 1)。
一般来说，使用填充是为了保持输入输出大小相同，所以，一般P的取值为 P = K - 1。
步幅是指卷积核在图像上滑动的步长，合理使用步长可以快速调整图像是尺寸。一般设置为2，将图像尺寸缩小一半。

import torch
from torch import nn

# 定义函数，查看卷积输出尺寸
def comp_conv2d(conv2d, x):
    x = x.reshape((1,1) + x.shape)
    Y = conv2d(x)
    return Y.reshape(Y.shape[2:])

# 定义卷积层，核 3*3，填充为1*1，输出尺寸不变
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
x =  torch.rand(size=(8, 8))
comp_conv2d(conv2d, x).shape
output: torch.Size([8, 8])

# 定义卷积层，核 5*3，填充为2*1，输出尺寸不变
conv2d = nn.Conv2d(1, 1, kernel_size=(5, 3), padding=(2, 1))
x =  torch.rand(size=(8, 8))x =  torch.rand(size=(8, 8))
comp_conv2d(conv2d, x).shape
output: torch.Size([8, 8])

# 定义卷积层，核 3*3，填充为1*1，步幅为1，输出尺寸减半
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
x =  torch.rand(size=(8, 8))
comp_conv2d(conv2d, x).shape
output: torch.Size([4, 4])