深度学习pytorch之简单方法自定义9种卷积即插即用

本文详细解析了 PyTorch 中 torch.nn.Conv2d 的核心参数，通过代码示例演示了如何利用这一基础函数实现多种卷积操作。涵盖的卷积类型包括：标准卷积、逐点卷积（1x1 卷积）、非对称卷积（长宽不等的卷积核）、空洞卷积（扩大感受野）、深度卷积（逐通道滤波）、组卷积（分组独立处理）、深度可分离卷积（深度+逐点组合）、转置卷积（上采样）和动态卷积（动态生成卷积核），帮助读者理解如何通过调整参数灵活构建卷积层，适应不同任务需求。
深度学习pytorch之22种损失函数数学公式和代码定义
深度学习pytorch之19种优化算法（optimizer）解析
深度学习pytorch之4种归一化方法（Normalization）原理公式解析和参数使用
深度学习pytorch之简单方法自定义多种卷积即插即用

基础函数torch.nn.Conv2d()

torch.nn.Conv2d()定义了一个用于量化的 2D 卷积层 Conv2d，其继承自 _ConvNd 类，专门用于处理量化输入信号。

class Conv2d(_ConvNd):
	def __init__(self, in_channels, out_channels, kernel_size, stride=1,
                 padding=0, dilation=1, groups=1, bias=True,
                 padding_mode='zeros', device=None, dtype=None):
                 ........


    def forward(self, input):
    			.........
      

在使用其定义常用卷积前，我们需要理解每一个参数的具体概念。

• in_channels (int):
  输入数据的通道数。比如在图像处理中，对于彩色图像通常是 3（RGB），对于灰度图像通常是 1。
• out_channels (int):
  输出数据的通道数，即卷积操作后得到的特征图的深度。通过改变输出通道数，可以改变卷积后的特征图的维度。
• kernel_size (int or tuple):
  卷积核的大小。可以是一个整数，表示卷积核是正方形的（例如，3 表示一个 3x3 的卷积核）；也可以是一个元组，表示非正方形卷积核（例如，(3, 5) 表示卷积核的高度为 3，宽度为 5）。
• stride (int or tuple, default=1):
  卷积操作的步幅。表示卷积核在输入图像上滑动的步长。可以是一个整数，表示水平和垂直方向的步幅相同；也可以是一个元组，表示水平和垂直方向的步幅不同（例如，(2, 1) 表示水平步幅为 2，垂直步幅为 1）。
• padding (int or tuple, default=0):
  填充（Padding）大小。填充是指在输入图像的边界加上额外的像素，防止卷积操作减少图像的空间尺寸。可以是一个整数，表示四个边的填充相同；也可以是一个元组，表示每个边的填充不同（例如，(2, 4) 表示上、下边的填充为 2，左、右边的填充为 4）。
• dilation (int or tuple, default=1):
  卷积核的膨胀因子。膨胀卷积是指在卷积核中插入“空洞”，即卷积核的元素之间的距离增大。可以是一个整数，表示膨胀因子在各个方向上相同；也可以是一个元组，表示膨胀因子在水平和垂直方向上不同。
• groups (int, default=1):
  卷积层的组数。groups 控制卷积核的分组方式。groups=1 表示标准卷积；groups 大于 1 时，表示分组卷积。
• bias (bool, default=True):
  是否使用偏置项。如果为 True，卷积层会学习偏置参数；如果为 False，卷积层没有偏置项。
• padding_mode (str, default=‘zeros’):
  填充模式。该参数控制如何填充输入图像的边界。仅支持 ‘zeros’ 模式，即使用零填充。
• device (torch.device, optional):
  用于指定模型所在的设备，通常是 ‘cpu’ 或 ‘cuda’。
• dtype (torch.dtype, optional):
  用于指定模型的张量数据类型。

接下来，我们根据各类卷积的概念，通过torch.nn.Conv2d()实现逐个定义。

1. 标准卷积（Standard Convolution）

标准卷积是最基本的卷积，使用的是常规的卷积层，没有分组和膨胀。

import torch
import torch.nn as nn

class StandardConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0):
        super(StandardConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)

    def forward(self, x):
        return self.conv(x)

# 示例：使用标准卷积
model_standard = StandardConv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
input_tensor = torch.randn(1, 3, 64, 64)  # 假设输入是 64x64 的 RGB 图像
output = model_standard(input_tensor)
print(output.shape)  # 输出大小

2. 逐点卷积（Pointwise Convolution）

逐点卷积是 1x1 卷积，它的作用是对每个像素进行线性变换，通常用于改变通道数（如通道数的升降）。

class PointwiseConv2d(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(PointwiseConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1)

    def forward(self, x):
        return self.conv(x)

# 示例：使用逐点卷积
model_pointwise = PointwiseConv2d(in_channels=3, out_channels=16)
output_pointwise = model_pointwise(input_tensor)
print(output_pointwise.shape)  # 输出大小

3. 非对称卷积（Asymmetric Convolution）

非对称卷积指的是卷积核的长宽比不相等，通常使用较长或较窄的卷积核。例如，3x1 或 1x5 的卷积核。

class AsymmetricConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=(3, 1)):
        super(AsymmetricConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=1, padding=(kernel_size[0]//2, kernel_size[1]//2))

    def forward(self, x):
        return self.conv(x)

# 示例：使用非对称卷积
model_asymmetric = AsymmetricConv2d(in_channels=3, out_channels=16, kernel_size=(3, 1))
output_asymmetric = model_asymmetric(input_tensor)
print(output_asymmetric.shape)  # 输出大小

4. 空洞卷积（Dilated Convolution）

空洞卷积（又叫扩展卷积、膨胀卷积）通过在卷积核之间插入“空洞”来扩大感受野。通过设置 dilation 参数来实现。

class DilatedConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=1, dilation=2):
        super(DilatedConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation=dilation)

    def forward(self, x):
        return self.conv(x)

# 示例：使用扩展卷积
model_dilated = DilatedConv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=2, dilation=2)
output_dilated = model_dilated(input_tensor)
print(output_dilated.shape)  # 输出大小

5. 深度卷积（Depthwise Convolution）

深度卷积是每个输入通道单独进行卷积。它的特点是 groups 参数等于 in_channels。

class DepthwiseConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0):
        super(DepthwiseConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, groups=in_channels)

    def forward(self, x):
        return self.conv(x)

# 示例：使用深度卷积
model_depthwise = DepthwiseConv2d(in_channels=3, out_channels=3, kernel_size=3, stride=1, padding=1)
output_depthwise = model_depthwise(input_tensor)
print(output_depthwise.shape)  # 输出大小

6. 组卷积（Group Convolution）

组卷积是将输入通道划分为若干组，每组使用不同的卷积核进行卷积。我们可以通过 groups 参数来设置。

class GroupConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, groups=2):
        super(GroupConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, groups=groups)

    def forward(self, x):
        return self.conv(x)

# 示例：使用组卷积
model_group = GroupConv2d(in_channels=6, out_channels=12, kernel_size=3, stride=1, padding=1, groups=3)
input_group = torch.randn(1, 6, 64, 64)  # 假设输入是 6 通道的图像
output_group = model_group(input_group)
print(output_group.shape)  # 输出大小

7. 深度可分离卷积（Depthwise + Pointwise Convolution）

深度可分离卷积由深度卷积（Depthwise Convolution）和逐点卷积（Pointwise Convolution）组合而成。深度卷积负责捕捉空间信息，逐点卷积用于改变通道数。

class SeparableConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):
        super(SeparableConv2d, self).__init__()
        self.depthwise_conv = nn.Conv2d(in_channels, in_channels, kernel_size, stride, padding, groups=in_channels)
        self.pointwise_conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)

    def forward(self, x):
        x = self.depthwise_conv(x)
        x = self.pointwise_conv(x)
        return x

# 示例：使用空间可分离卷积
model_separable = SeparableConv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
output_separable = model_separable(input_tensor)
print(output_separable.shape)  # 输出大小

8. 转置卷积（Transpose Convolution）

转置卷积（也叫反卷积）通常用于上采样。PyTorch 中使用 ConvTranspose2d 实现。

conv = nn.ConvTranspose2d(64, 32, kernel_size=4, stride=2, padding=1)

9. 动态卷积（Dynamic Convolution）

动态卷积是根据输入或时间步动态生成卷积核。这意味着卷积核在处理过程中是根据输入数据进行变化的，通常使用与输入张量的大小相关的方式来动态调整卷积核。

class DynamicConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3):
        super(DynamicConv2d, self).__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.kernel_size = kernel_size

    def forward(self, x):
        batch_size, _, height, width = x.size()
        # 根据输入动态生成卷积核（例如：使用全连接层生成卷积核）
        weight = torch.randn(batch_size, self.out_channels, self.in_channels, self.kernel_size, self.kernel_size).to(x.device)
        return torch.nn.functional.conv2d(x, weight, padding=self.kernel_size//2)

# 示例：使用动态卷积
model_dynamic = DynamicConv2d(in_channels=3, out_channels=16, kernel_size=3)
output_dynamic = model_dynamic(input_tensor)
print(output_dynamic.shape)  # 输出大小