卷积层、卷积层里的填充和步幅

多层感知机

正式总结卷积层之前，先把上次多层感知机落下的一点内容补一补。

几个概念：

训练数据集：训练模型参数。

验证数据集：选择模型超参数。

训练误差：模型在训练数据上的误差。

泛化误差：模型在新数据上的误差。

结论：

非大数据集上通常使用k-折交叉验证。

权重衰退通过L2正则项使得模型参数不会过大，从而控制模型复杂度。

正则项权重是控制模型复杂度的超参数。

让训练更稳定的方法：

让梯度在合理的范围

将乘法变加法。

归一化。

合理的权重初始和激活函数。

卷积层

二维卷积层

输入X，卷积核W，输出Y=X*W+b，w和b是可学习的参数

一维和三维交叉相关

一维：

比如说，文本，语言，时间序列。

三维：

比如说视频，医学影像，气象地图。

卷积层将输入和核矩阵进行交叉相关，加上偏移后得到输出。

核矩阵和偏移是可学习的参数。

核矩阵的大小是超参数。

互相关运算（卷积层）代码实现：

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))
    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))

tensor([[19., 25.],
        [37., 43.]])

实现二维卷积层（检测图像中不同颜色的边缘）

class Conv2D(nn.Module):
    def __int__(self,kernel_size):
        super().__int__()
        self.weight=nn.Parameter(torch.range(kernel_size))
        self.bias=nn.Parameter(torch.zeros(1))

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

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

K=torch.tensor([[1.0,-1.0]])
Y=corr2d(X, K)
print(Y)

#卷积核k只可以检测垂直边缘
print(corr2d(X.t(),K))

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.]])
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.]])
tensor([[0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.]])

学习由X生成Y的卷积核

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}')

# 所学的卷积核的权重张量
print(conv2d.weight.data.reshape((1,2)))

batch 2,loss11.545
batch 4,loss4.023
batch 6,loss1.530
batch 8,loss0.607
batch 10,loss0.245
tensor([[ 1.0442, -0.9339]])

填充和步幅

填充就是在输入周围添加额外的行/列，填充减小的输出大小与层数线性相关

步幅是指行/列的滑动步长

填充和步幅是卷积层的超参数。

填充在输入周围添加额外的行/列，来控制输出形状的减少量。

步幅是每次滑动核窗口时的行/列的步长，可以成倍的减少输出形状。

在所有侧边填充1个像素

def comp_conv2d(conv2d,X):
    X=X.reshape((1,1)+X.shape)
    Y=conv2d(X)
    return  Y.reshape(Y.shape[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)

torch.Size([8, 8])
torch.Size([8, 8])

将高度和宽度的步幅设置为2

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

torch.Size([4, 4])

一个稍微复杂的例子

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

torch.Size([2, 2])