动手学深度学习V2每日笔记（卷积层）

本文主要参考沐神的视频教程 https://www.bilibili.com/video/BV1L64y1m7Nh/p=2&spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=c7bfc6ce0ea0cbe43aa288ba2713e56d
文档教程 https://zh-v2.d2l.ai/

本文的主要内容对沐神提供的代码中个人不太理解的内容进行笔记记录，内容不会特别严谨仅供参考。

1.函数目录

1.1 python

python	位置
元组加法操作	2.2

1.2 torch

torch.nn	位置
Conv2d	2.3
stack	2.3
cat	2.3

2. 卷积神经网络

2.1 卷积层

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

• 交叉相关VS卷积
• 二维交叉相关
  $$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}$$
• 由于对称性，在实际使用中没有区别
• 一维和三维交叉相关
• 一维
  $$y_i=\sum _{a=1}^h{w}_{a,}{x}_{i+a}$$
• 文本、语言、时序序列
• 三维
  $$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}$$
• 视频、医学图像、气象图像

2.1.1 二维互相关运算

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.arange(9).reshape(3,3)
K = torch.arange(4).reshape(2,2)

print(corr2d(X, K))

2.1.2 卷积层

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

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

2.1.3 完整代码

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.arange(9).reshape(3,3)
K = torch.arange(4).reshape(2,2)

print(corr2d(X, K))
# 自定义卷积层
class Conv2D(nn.Module):
    def __init__(self, kernel_size):
        super().__init__()
        self.weight = nn.Parameter(torch.rand(size=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)
# 学习卷积核
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)))

2.2 填充和步幅

2.2.1 填充padding

在输入周围添加额外的行、列

• 填充$p_h$行和$p_w$列，输出的形状为
• $$(n_h-k_h+p_h+1)\ast (n_w-k_w+p_w+1)$$

2.2.2 步幅stride

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

2.3.3 元组加法运算

a = (1, 1)
b = (8, 8)
print(a+b)

列表也具有相同的操作

a = [1, 1]
b = [8, 8]
print(a+b)

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

conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
X = torch.rand((8,8))
print(comp_conv2d(conv2d, X).shape)

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

2.3 多输入输出通道

2.3.1 多个输入通道

• 彩色图片可能有RGB三个通道
• 转换为灰度会丢失信息
  
  每个通道都有一个卷积核，结果是所有通道卷积结果的和。
  
  多个输入通道

输入X	核W	输出Y
$c_i\ast n_h\ast n_w$	$c_i\ast k_h\ast k_w$	$m_h\ast m_w$

$$Y=\sum _{i_0}^{c_i}{X}_{i,:,:}\ast W_{i,:,:}$$
无论有多少输入通道，到目前为止我们只用到单输出通道。

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

def corr2d_multi_in(X, K):
    return sum(corr2d(x,k) for x,k in zip(X, K))

X = torch.tensor([[[0.0,1.0,2.0],[3.0,4.0,5.0],[6.0,7.0,8.0]],[[1.0,2.0,3.0],
                [4.0,5.0,6.0],[7.0,8.0,9.0]]])
K = torch.tensor([[[0.0, 1.0],[2.0, 3.0]],[[1.0,2.0],[3.0,4.0]]])
print(corr2d_multi_in(X, K))

2.3.2 多个输出通道

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

输入X	核W	输出Y
$c_i\ast n_h\ast n_w$	$c_o\ast c_i\ast k_h\ast k_w$	$c_o\ast m_h\ast m_w$

$$Y=\sum _{i_0}^{c_i}{X}_{i,:,:}\ast W_{i,:,:}fori=1,...,c_o$$

• 每个输出通道都可以识别特定模式
  
• 输入通道核识别并组合输入中的模式

def corr2d_multi_in_out(X, K):
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)

K = torch.stack((K, K+1, K+2), 0)
print(K.shape)
print(corr2d_multi_in_out(X,K))

2.3.3 1*1卷积层

$k_h=k_w=1$是一个受欢迎的选择。它不识别空间模式，只是融合通道。

相当于输入形状为$n_h{n}_w\ast c_i$,权重为$c_o\ast c_i$的全连接层。

2.3.4 nn.Conv2d()

nn.Conv2d 的作用是对输入的二维数据（如图像）进行卷积操作，输出经过卷积处理后的特征图。卷积操作可以帮助网络学习到数据的局部特征，如边缘、纹理等。

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros')

• 参数说明
• in_channels (int): 输入数据的通道数。例如，对于RGB图像，in_channels 应为 3。
• out_channels (int): 卷积层输出的通道数（即卷积核的数量）。
• kernel_size (int or tuple): 卷积核的大小。如果是整数，则表示卷积核是正方形的；如果是元组，则表示卷积核的高度和宽度。
• stride (int or tuple, 可选): 卷积核的步幅。默认值为 1。
• padding (int, tuple or str, 可选): 输入数据的填充。默认值为 0。
• dilation (int or tuple, 可选): 卷积核元素之间的间距。默认值为 1。
• groups (int, 可选): 控制输入和输出通道的连接。默认值为 1。
• bias (bool, 可选): 如果设置为 True，将会给输出添加一个可学习的偏置。默认值为 True。
• padding_mode (str, 可选): 填充模式。可选值为 ‘zeros’, ‘reflect’, ‘replicate’ 或 ‘circular’。默认值为 ‘zeros’。
  输出张量的形状可以通过以下公式计算:
• input:$(N,C_{in},H_{in},W_{in})$
• output:$(N,C_{out},H_{out},W_{out})$
  $$H_{out}=\frac{H_{in}+2\ast padding[0]-dilation[0]\ast (kernel\_size[0]-1)}{stride[0]}$$
  $$W_{out}=\frac{H_{in}+2\ast padding[1]-dilation[1]\ast (kernel\_size[1]-1)}{stride[1]}$$

import torch
import torch.nn as nn

# 创建一个 Conv2d 对象
conv_layer = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)

# 打印 Conv2d 对象的参数
print(conv_layer)

# 创建一个随机输入张量，形状为 (batch_size, in_channels, height, width)
input_tensor = torch.randn(1, 3, 32, 32)

# 通过卷积层前向传播输入张量
output_tensor = conv_layer(input_tensor)

# 打印输出张量的形状
print(output_tensor.shape)

对上述示例输出形状计算：

• 输入张量形状（1,3，32,32）
• 卷积核大小为3*3
• 步幅为1
• 填充为1
  输出高度
  $$H_{out}=\frac{32-2\ast 1+3-1}{1}=32$$
  输出宽度
  $$W_{out}=\frac{32-2\ast 1+3-1}{1}=32$$

2.3.5 stack

torch.stack 是 PyTorch 中的一个函数，用于沿新维度连接一系列张量。它的作用类似于 torch.cat，但不同的是，torch.cat 是在现有维度上进行连接，而 torch.stack 会在指定的维度上插入一个新的维度，然后在这个新维度上进行连接。

torch.stack(tensors, dim=0)

参数

• tensors (sequence of Tensors): 要连接的张量序列。
• dim (int): 新插入维度的索引位置。默认值为 0。

Tensor1.shape	Tensor2.shape	dim	out
(3,3)	(3,3)	0	(2,2,3)
(3,3)	(3,3)	1	(3,2,3)
(3,3)	(3,3)	2	(3,3,2)

沿着维度0进行stack

import torch

# 创建两个相同形状的张量
x = torch.arange(9).reshape(3,3)
y = torch.randn(3,3)
# 沿着0维度
z = torch.stack([x,y],0)
z
tensor([[[ 0.0000,  1.0000,  2.0000],
         [ 3.0000,  4.0000,  5.0000],
         [ 6.0000,  7.0000,  8.0000]],

        [[ 0.8259, -1.7941,  0.8862],
         [ 0.6030, -0.7413,  0.7847],
         [-0.0850,  0.7196, -0.7993]]])
z.shape
torch.Size([2, 3, 3])

沿着维度1进行stack

z1 = torch.stack((x,y),1)
z1
tensor([[[ 0.0000,  1.0000,  2.0000],
         [ 0.8259, -1.7941,  0.8862]],

        [[ 3.0000,  4.0000,  5.0000],
         [ 0.6030, -0.7413,  0.7847]],

        [[ 6.0000,  7.0000,  8.0000],
         [-0.0850,  0.7196, -0.7993]]])
z1.shape
torch.Size([3, 2, 3])

沿着维度2进行stack

z2 = torch.stack((x,y),2)
z2
tensor([[[ 0.0000,  0.8259],
         [ 1.0000, -1.7941],
         [ 2.0000,  0.8862]],

        [[ 3.0000,  0.6030],
         [ 4.0000, -0.7413],
         [ 5.0000,  0.7847]],

        [[ 6.0000, -0.0850],
         [ 7.0000,  0.7196],
         [ 8.0000, -0.7993]]])
z2.shape
torch.Size([3, 3, 2])

2.3.6 cat

torch.cat 是 PyTorch 中的一个函数，用于沿已有的维度连接一系列张量。与 torch.stack 不同的是，torch.cat 不会在连接过程中创建新的维度，而是直接在指定的维度上进行连接。

torch.cat(tensors, dim=0)

• 参数
• tensors (sequence of Tensors): 要连接的张量序列，这些张量在除 dim 维之外的其他维度上必须具有相同的形状。
• dim (int): 指定在该维度上连接张量。默认值为 0。

Tensor1.shape	Tensor2.shape	dim	out
(3,3)	(3,3)	0	(6,3)
(3,3)	(3,3)	1	(3,6)

沿着维度0进行cat

c0 = torch.cat((x,y),0)
c0
tensor([[ 0.0000,  1.0000,  2.0000],
        [ 3.0000,  4.0000,  5.0000],
        [ 6.0000,  7.0000,  8.0000],
        [ 0.8259, -1.7941,  0.8862],
        [ 0.6030, -0.7413,  0.7847],
        [-0.0850,  0.7196, -0.7993]])
c0.shape
torch.Size([6, 3])

沿着维度1进行cat

c1 =torch.cat((x,y),1)
c1
tensor([[ 0.0000,  1.0000,  2.0000,  0.8259, -1.7941,  0.8862],
        [ 3.0000,  4.0000,  5.0000,  0.6030, -0.7413,  0.7847],
        [ 6.0000,  7.0000,  8.0000, -0.0850,  0.7196, -0.7993]])
c1.shape
torch.Size([3, 6])

2.3.7 完整代码

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

conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
X = torch.rand((8,8))
print(comp_conv2d(conv2d, X).shape)

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

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

def corr2d_multi_in(X, K):
    return sum(corr2d(x,k) for x,k in zip(X, K))

X = torch.tensor([[[0.0,1.0,2.0],[3.0,4.0,5.0],[6.0,7.0,8.0]],[[1.0,2.0,3.0],
                [4.0,5.0,6.0],[7.0,8.0,9.0]]])
K = torch.tensor([[[0.0, 1.0],[2.0, 3.0]],[[1.0,2.0],[3.0,4.0]]])
print(corr2d_multi_in(X, K))

def corr2d_multi_in_out(X, K):
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)

K = torch.stack((K, K+1, K+2), 0)
print(K.shape)
print(corr2d_multi_in_out(X,K))