nn.Conv2d是PyTorch中的一个类，用于实现二维卷积操作。它可以对输入的多个二维平面进行卷积操作，生成输出的二维平面。在卷积神经网络中，nn.Conv2d通常与其他层结合使用，例如池化层、批归一化层、激活函数等，以构建一个完整的深度卷积神经网络。

函数原型解析

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

• in_channels：输入图像的通道数。
• out_channels：经过卷积运算产生的通道数。
• kernel_size：卷积核大小，整数或元组类型。
• stride：卷积运算的步幅，整数或元组类型，默认为1。
• padding：边界填充值，整数或元组类型，默认为0。
• padding_mode：填充方式，zeros、reflect、replicate、circular，默认是zeros。其中，
• zeros：零填充，在张量边界全部填充0。
• reflect：镜像填充，以矩阵边缘为对称轴，将反方向的对称元素填充到最外围。
• replicate：复制填充，使用输入边界的复制值填充张量。
• circular：循环填充，重复矩阵边界另一侧的元素。
• dilation：控制点之间的距离，默认为1。若大于1，则该运算又被称为扩张卷积运算，如下图所示。

• groups：控制输入和输出之间的连接，默认是1。
• groups=1

conv = torch.nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, groups=1, bias=False)
out = conv(input)

其中，卷积核shape为6x3x3x3 「(out_channels * in_channels * kernel_size * kernel_size)」groups为1，表示将in_channels所有通道作为1组，与每一个3x3x3卷积核卷积，共6个3x3x3卷积核，输出6个通道特征。 以第一个3x3x3卷积核与input第一个样本的第一个kernel窗口卷积为例，计算过程如下：

【卷积核3x3x3】 【第一个3x3x3卷积核与第一个样本kernel窗口卷积结果】

[[[-0.1146, -0.0763, -0.0392], -0.1146*141 - 0.0763*138 - 0.0392*143 +
[ 0.0143, 0.0109, 0.0747], 0.0143*138 + 0.0109*139 + 0.0747*143 +
[ 0.1792, 0.1717, 0.0782]], 0.1792*135 + 0.1717*137 + 0.0782*138 +

[[-0.0677, -0.0513, -0.0867], -0.0677*138 - 0.0513*135 - 0.0867*139 +
[-0.1899, -0.1886, -0.1195], -0.1899*135 - 0.1886*136 - 0.1195*139 +
[-0.1306, -0.0011, 0.0604]], -0.1306*132 - 0.0011*134 + 0.0604*135 +

[[-0.1809, -0.1719, 0.0385], -0.1809*109 - 0.1719*106 + 0.0385*113 +
[-0.1059, -0.1535, -0.1849], -0.1059*106 - 0.1535*107 - 0.1849*113 +
[ 0.1027, 0.0132, 0.0144]]], 0.1027*111 + 0.0132*113 + 0.0144*116 = -132.636

• groups非1，以groups=3为例。

conv = torch.nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, groups=3, bias=False)
out = conv(input)

此时输入通道被分为3组。每个通道为1组，卷积核shape为6x1x3x3，每一组对应2个1x3x3卷积核，分别与该组通道独立卷积，不采取求和操作，输出2个通道特征。 以前两个1x3x3卷积核与第1组输入第一个kernel窗口卷积为例，计算过程如下：

【卷积核 两个 1x3x3】 【输出】

第一个： 第一个通道第一个值：
[[ 0.2868, 0.1139, -0.0515], 0.2868*141 + 0.1139*138 - 0.0515*143 +
[-0.3059, 0.0081, -0.2814], -0.3059*138 + 0.0081*139 - 0.2814*143 +
[-0.1271, -0.2342, -0.1725]] -0.1271*135 - 0.2342*137 - 0.1725*138 = -105.5849

第二个： 第二个通道第二个值：
[[ 0.1897, -0.3158, 0.2214], 0.1897*141 - 0.3158*138 + 0.2214*143 +
[ 0.0774, 0.1155, 0.1251], 0.0774*138 + 0.1155*139 + 0.1251*143 +
[ 0.2186, 0.0368, 0.2127]] 0.2186*135 + 0.0368*137 + 0.2127*138 = 123.3577

• groups必须可以整除in_channels和out_channels。
• bias：是否有偏置项，默认True，即默认存在偏置项。
• 输入的数组数据类型必须是TensorFloat32类型。

计算方法

输出图像的高、宽

假设输入input：(N,Cin,Hin,Win)，输出output：(N,Cout,Hout,Wout)，其中

• N：每个batch中图像数量batch_size。
• Ci：每个图像样本的通道数。
• Hi：每个图像的高度。
• Wi：每个图像的宽度。

以输入图像shape=(2,3,4,5)为例，

进一步计算输出图像的宽高：

卷积层的权重

卷积层的权重可通过Conv2d.weight提取，输出的权重数组尺寸为：

并且初始化权重分部服从均匀分布：

卷积层的偏置参数

卷积层的偏置参数可以通过Conv2d.bias提取(前提bias=True)，输出的数组尺寸与out_channels大小一样，初始化分部与weight权重分部一样。

同时，卷积层参数也可以通过.parameters()方法获取。

代码示例

一般卷积运算

这段代码演示了使用PyTorch进行基本的二维卷积运算的过程。

# 从torch.nn模块中导入nn
import torch.nn as nn
# 导入torch，以便使用Tensor相关的功能
import torch
# 使用torch.arange(49)生成一个包含49个连续整数（默认从0开始）的张量
# 通过.view(1, 1, 7, 7)将其形状调整为一个批次大小为1、通道数为1、高度和宽度均为7的四维张量，模拟一个单通道的7x7像素图像
img=torch.arange(49,dtype=torch.float32).view(1,1,7,7)
# 使用nn.Conv2d定义一个二维卷积层，参数分别为：
## in_channels=1：输入图像的通道数，这里为1，意味着这是一个灰度图像
## out_channels=1：输出特征图的通道数，这里也设为1，表示输出也是一个单通道的特征图
## kernel_size=2：卷积核的大小为2x2，即卷积核的高度和宽度都是2
conv=nn.Conv2d(in_channels=1,out_channels=1,kernel_size=2)
# 通过conv(img)执行卷积操作
img_2=conv(img)
print('卷积运算前：\n',img)
print(img.shape)
print('卷积运算后：\n',img_2)
print(img_2.shape)

卷积核大小为2，卷积后图像尺寸变为6x6。

输出卷积运算参数

import torch.nn as nn
conv=nn.Conv2d(in_channels=1,out_channels=1,kernel_size=2)
print(conv.weight)
print(conv.bias)
print(type(conv.weight))

卷积层参数尺寸

import torch.nn as nn
'''
创建一个nn.Conv2d实例，参数如下：

in_channels=64：输入通道数，这里是64，表示输入是一张64通道的图像。
out_channels=128：输出通道数，这里是128，表示输出是一张128通道的图像。
kernel_size=[5, 3]：卷积核的大小，这里是一个包含两个值的列表，表示沿宽度和高度的卷积核大小分别为5和3。
padding=2：填充大小，设置为2，意味着在输入的每个边缘填充2个像素，以保持输出尺寸不变。
'''
conv=nn.Conv2d(in_channels=64,out_channels=128,kernel_size=[5,3],padding=2)
'''
打印卷积层的权重张量 conv.weight 的形状。
这个张量表示卷积核的权重，其形状为 (out_channels, in_channels, kernel_size[0], kernel_size[1])，
在本例中为 (128, 64, 5, 3)
'''
print(conv.weight.shape)
print(conv.bias.shape)

填充方式

这里为了消除卷积运算对原图的影响，假设卷积核大小kernel_size=1，不设置偏置项，并且为了凸显填充后的效果，将padding设为2。

零填充

import torch.nn as nn
import torch

conv_1=nn.Conv2d(in_channels=1,out_channels=1,kernel_size=1,bias=False,padding=2,padding_mode='zeros')
conv_1.weight=nn.Parameter(torch.ones((1,1,1,1)))

img=torch.arange(25,dtype=torch.float32).reshape(1,1,5,5)
img_1=conv_1(img)
print(img)
print(img.shape)
print(img_1)
print(img_1.shape)

镜像填充

import torch.nn as nn
import torch

conv_2=nn.Conv2d(in_channels=1,out_channels=1,kernel_size=1,bias=False,padding=2,padding_mode='reflect')
conv_2.weight=nn.Parameter(torch.ones((1,1,1,1)))

img=torch.arange(25,dtype=torch.float32).reshape(1,1,5,5)
img_1=conv_2(img)
print(img)
print(img.shape)
print(img_1)
print(img_1.shape)

复制填充

import torch.nn as nn
import torch

conv_3=nn.Conv2d(in_channels=1,out_channels=1,kernel_size=1,bias=False,padding=2,padding_mode='replicate')
conv_3.weight=nn.Parameter(torch.ones((1,1,1,1)))

img=torch.arange(25,dtype=torch.float32).reshape(1,1,5,5)
img_1=conv_3(img)
print(img)
print(img.shape)
print(img_1)
print(img_1.shape)

循环填充

import torch.nn as nn
import torch
conv_4=nn.Conv2d(in_channels=1,out_channels=1,kernel_size=1,bias=False,padding=2,padding_mode='circular')
conv_4.weight=nn.Parameter(torch.ones((1,1,1,1)))

img=torch.arange(25,dtype=torch.float32).reshape(1,1,5,5)
img_1=conv_4(img)
print(img)
print(img.shape)
print(img_1)
print(img_1.shape)