卷积操作#

一、torch.nn中Convolution Layers函数的介绍#

1. 参数介绍#

nn.Conv1d: Conv取自Convolution的前四个字母，1d代表的是一个一维操作。
nn.Conv2d: 2d表示是一个二维的操作，比如图像就是一个二维的。
其余参数不常用，见官网文档：torch.nn — PyTorch 2.0 documentation

2. torch.nn和torch.nn.functional的区别#

torch.nn是对torch.nn.functional的一个封装，让使用torch.nn.functional里面的包的时候更加方便
torch.nn包含了torch.nn.functional，打个比方，torch.nn.functional相当于开车的时候齿轮的运转，torch.nn相当于把车里的齿轮都封装好了，为我们提供一个方向盘
如果只是简单应用，会torch.nn就好了。但要细致了解卷积操作，需要深入了解torch.nn.functional
打开torch.nn.functional的官方文档，可以看到许多跟卷积相关的操作：torch.nn.functional — PyTorch 2.0 documentation

二、torch.nn.functional.conv2d 介绍#

官网文档：torch.nn.functional.conv2d — PyTorch 2.0 documentation

Copy
torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

1. 参数详解#

input: 输入，数据类型为tensor，形状尺寸规定为：(minibatch, 几个通道(in_channels), 高, 宽)
weight: 权重。更专业地来说可以叫卷积核，形状尺寸规定为：(输出的通道(out_channel), $\frac{i n_c h a n n e l}{g r o u p s}$ (groups一般取1), 高, 宽 )
bias: 偏置。
strids: 步幅。
padding: 填充。

2. 举例讲解参数strids#

（1）理论#

输入一个5×5的图像，其中的数字代表在每个像素中的颜色显示。卷积核设置为3×3的大小。

strids参数的输入格式是单个数或者形式为 (sH,sW) 的元组，可以理解成：比如输入单个数：strids=1，每次卷积核在图像中向上下或左右移1位；如果输入strids=(2,3)，那么每次卷积核在图像中左右移动（横向移动）时，是移动2位，在图像中上下移动（纵向移动）时，是移动3位。
本例设置strids=1

第一次移位：

基于上述的假设，在做卷积的过程中，需要将卷积核将图像的前三行和前三列进行匹配：
在匹配过后，进行卷积计算：对应位相乘然后相加，即

$1 \times 1 + 2 \times 2 + 0 \times 1 + 0 \times 0 + 1 \times 1 + 2 \times 0 + 1 \times 2 + 2 \times 1 + 1 \times 0 = 10$
上面的得出的 $10$ 可以赋值给矩阵，然后作为一个输出
之后卷积核可以在图像中进行一个移位，可以向旁边走1位或2位，如下图（向右走2位）。具体走多少位由strids参数决定，比如strids=2，那就是走2位。本例设置stride=1。

第二次移位：

向右移动一位，进行卷积计算：

$2 \times 1 + 0 \times 2 + 3 \times 1 + 1 \times 0 + 2 \times 1 + 3 \times 0 + 2 \times 2 + 1 \times 1 + 0 \times 0 = 12$
$12$ 可以赋值给矩阵，然后作为一个输出

第三次移位：

向右移动一位，进行卷积计算：

$0 \times 1 + 3 \times 2 + 1 \times 1 + 2 \times 0 + 3 \times 1 + 1 \times 0 + 1 \times 2 + 0 \times 1 + 0 \times 0 = 12$
$12$ 可以赋值给矩阵，然后作为一个输出
第三次移位后，发现卷积核已经没办法向右移位，进行匹配了。所以我们在纵向上，向下走：

第四次移位：

在最开始的位置上，向下移动一位，进行卷积计算：

$0 \times 1 + 1 \times 2 + 2 \times 1 + 1 \times 0 + 2 \times 1 + 1 \times 0 + 5 \times 2 + 2 \times 1 + 2 \times 0 = 18$
$18$ 可以赋值给矩阵，然后作为一个输出

第五次移位：

在上面的基础上，向右移一位，进行卷积计算：

$1 \times 1 + 2 \times 2 + 3 \times 1 + 2 \times 0 + 1 \times 1 + 0 \times 0 + 2 \times 2 + 3 \times 1 + 1 \times 0 = 16$
$16$ 可以赋值给矩阵，然后作为一个输出

以此类推，走完整个图像，最后输出的矩阵如下图。这个矩阵是卷积后的输出。

（2）程序操作#

将上面的过程写到程序内：

Copy
import torch
import torch.nn.functional as F

# 构造输入图像（input参数输入的数据类型为tensor,并且为2维）
input=torch.tensor([[1,2,0,3,1],
                    [0,1,2,3,1],
                    [1,2,1,0,0],
                    [5,2,3,1,1],
                    [2,1,0,1,1]])

# 构造卷积核（数据类型也是tensor，并且为2维）
kernel=torch.tensor([[1,2,1],
                     [0,1,0],
                     [2,1,0]])

#查看尺寸,输出后发现并不符合参数输入的尺寸标准，所以需要进一步转换数据
print(input.shape) #[Run]  torch.Size([5, 5])
print(kernel.shape) #[Run]  torch.Size([3, 3])

#转换input、kernel数据
input=torch.reshape(input,(1,1,5,5))  #torch.reshape(tensor数据,想变成的格式尺寸(batch=1,通道=1,5×5))
kernel=torch.reshape(kernel,(1,1,3,3))

#查看尺寸,输出后发现符合参数输入的尺寸标准
print(input.shape) #[Run]  torch.Size([1, 1, 5, 5])
print(kernel.shape) #[Run]  torch.Size([1, 1, 3, 3])

# 进行卷积操作
#stride=1,输出结果与上面矩阵一致
output=F.conv2d(input,kernel,stride=1)
print(output)
"""
[Run]
tensor([[[[10, 12, 12],
          [18, 16, 16],
          [13,  9,  3]]]])
"""

#stride=2
output2=F.conv2d(input,kernel,stride=2)
print(output2)
"""
[Run]
tensor([[[[10, 12],
          [13,  3]]]])
"""

3. 举例讲解参数padding#

padding的作用是在输入图像的左右两边进行填充，padding的值决定填充的大小有多大，它的输入形式为一个整数或者一个元组 ( padH, padW )，其中，padH=高，padW=宽。默认padding=0，即不进行填充。

（1）理论#

仍输入上述的5×5的图像，并设置padding=1，那么输入图像将会变成下图，即图像的上下左右都会拓展一个像素，然后这些空的地方像素（里面填充的数据）都默认为0。
按上面的顺序进行卷积计算，第一次移位时在左上角3×3的位置，卷积计算公式变为：

$0 \times 1 + 0 \times 2 + 0 \times 1 + 0 \times 0 + 1 \times 1 + 2 \times 0 + 0 \times 2 + 0 \times 1 + 1 \times 0 = 1$
以此类推，完成后面的卷积计算，并输出矩阵

（2）程序操作#

在上面的代码后，加入这串代码，以验证padding的操作：

Copy
output3=F.conv2d(input,kernel,stride=1,padding=1)
print(output3)
"""
[Run]
tensor([[[[ 1,  3,  4, 10,  8],
          [ 5, 10, 12, 12,  6],
          [ 7, 18, 16, 16,  8],
          [11, 13,  9,  3,  4],
          [14, 13,  9,  7,  4]]]])
"""