DL_8——卷积层

1 卷积

1.1 交叉相关和卷积

• 二维交叉相关
  $y_{i,j}={\sum }_{a=1}^h{\sum }_{b=1}^w{w}_{a,b}{x}_{i+a,j+b}$

• 二维卷积
  $y_{i,j}={\sum }_{a=1}^h{\sum }_{b=1}^w{w}_{-a,-b}{x}_{i+a,j+b}$

• 由于对称性，在实际使用中二者没有区别。

1.2 一维和三维交叉相关

• 一维
  $y_i={\sum }_{a=1}^h{w}_a{x}_{i+a}$
  • 文本
  • 语言
  • 时间序列
• 三维
  $y_{i,j,k}={\sum }_{a=1}^h{\sum }_{k=1}^w{\sum }_{c=1}^d{w}_{a,b,c}{x}_{i+a,j+b,k+c}$
  • 视频
  • 医学图像
  • 气象地图

1.3 总结

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

1.4 从零实现卷积操作和卷积层

# -*- coding: utf-8 -*- 
# @Time : 2021/9/14 21:23 
# @Author : Amonologue
# @software : pycharm   
# @File : conv2d_from_zero.py
import torch
from torch import nn
from torch.nn import functional as F


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):
	'''卷积层'''
    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


if __name__ == '__main__':
    X = torch.ones((6, 8))
    X[:, 2:6] = 0
    print(X)  # 原始图像
    k1 = torch.tensor([[1., -1.]])
    y1 = corr2d(X, k1)
    print(y1)  # 提取边缘特征
    conv2d = Conv2d(kernel_size=(1, 2))
    X = X.reshape((6, 8))
    Y = y1
    Y = Y.reshape((6, 7))

    # 训练10个epoch
    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  # 手动sgd
        print(f'batch {
      
      i}, loss {
      
      l.sum():.3f}')  # 输出训练过程

2 填充&步幅

2.1 填充 padding

在原数据周围添加 $n$ 圈为0的数据

• 填充 $p_h$ 行和 $p_w$ 列，输出形状为
  $$\left(n_h-k_h+p_h+1\right)\times \left(n_w-k_w+p_w+1\right)$$
• 通常取 $p_h=k_h-1,p_w=k_w-1$
  • 当 $k_h$ 为奇数：在上下两侧填充 $p_h/2$
  • 当 $k_h$ 为偶数：在上侧填充 $\lceil \frac{p_h}{2}\rceil$, 在下侧填充 $\lfloor \frac{p_h}{2}\rfloor$
• 注：此处的$p_h$是指总共添加的行数，即在原始数据上方添加$\frac{p_h}{2}$行，在原始数据下方添加$\frac{p_h}{2}$

在torch中，在创建卷积层时指定padding大小即可

	# 在原始数据周围添加一圈0
	conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
	# 在原始数据周围添加两圈0
	conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=2)
	# 在原始数据上方添加两行0,下方添加两行0,左侧添加一列0,右侧添加一列0
	conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=(2, 1))

2.2 步幅 stride

kernel的移动跨度

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

同样的，在torch中指定stride大小即可设置步幅

	# 将高度和宽度的步幅都设置为2
	conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)
	# 将高度步幅设置为3,宽度步幅设置为4
	conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=(3, 4))

2.3 总结

• 填充和步幅是卷积层的超参数
• 填充在输入周围添加额外的列/行，来控制输出形的减少量
• 步幅是每次滑动核窗口时的行/列的步长，可以成倍的减少输出形状

3 多输入多输出通道

对于灰度图只需要一个channel，但是对于彩色的图就需要用上rgb三个channel

3.1 多个输入通道

每个通道都有一个卷积核，结果是所有通道卷积结果的和

• 输入 $\mathbf{X}:c_i\times n_h\times n_w$
• 核 $\mathbf{W}:c_i\times k_h\times k_w$
• 输出 $\mathbf{Y}:m_h\times m_w$
  $$\mathbf{Y}=\sum _{i=0}^{c_i}{\mathbf{X}}_{i,:,:}^{\ast }\star {\mathbf{W}}_{i,:,:}$$
  其中 $c_i$ 表示输入通道数

def corr2d_multi_in(X, K):
    '''实现多输入通道'''
    return sum(corr2d(x, k) for x, k in zip(X, K))

3.2 多个输出通道

可以有多个三维卷积核，每个核生成一个输出通道

• 输入 $\mathbf{X}:c_i\times n_h\times n_w$
• 核 $\mathbf{W}:c_o\times c_i\times k_h\times k_w$
• 输出 $\mathbf{Y}:c_o\times m_h\times m_w$
  $${\mathbf{Y}}_{i,:,:}=\mathbf{X}\star {\mathbf{W}}_{i,:,:,:}\text{ for }i=1,\dots ,c_o$$
  其中 $c_o$ 表示输出通道数

def corr2d_multi_in_out(X, K):
    '''实现多输入多输出通道'''
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)

3.3 $1\times 1$卷积

$1\times 1$卷积等价于全连接

def corr2d_multi_in_out_1x1(X, K):
    '''实现 1 x 1卷积'''
    c_i, h, w = X.shape
    c_o = K.shape[0]
    x = X.reshape((c_i, h * w))
    k = K.reshape((c_o, c_i))
    Y = torch.matmul(x, k)
    return Y.reshape((c_o, h, w))