【PyTorch项目实战】卷积（Convolution ） + 反卷积（Deconvolution）

• 卷积（Convolution）：是一种通过滑动窗口（卷积核）遍历整个图像，对每个像素进行加权求和的操作。
  • 应用：
    • 滤波器：如高斯滤波减少图像中的噪声、锐化滤波增强图像中的高频信息。
    • 边缘检测：如Sobel、Canny突出图像中的边缘。
• 反卷积（Deconvolution）：是卷积的逆运算，旨在通过迭代优化方法从模糊图像中恢复原始图像，减少模糊和失真。
  • 常见算法：
    • Richardson-Lucy 反卷积：基于最大似然估计（MLE），通过迭代更新图像估计值来优化恢复效果。
    • Wiener 反卷积：在频域中应用 Wiener 滤波，利用噪声功率谱进行去模糊。
    • 盲反卷积（Blind Deconvolution）：同时估计模糊核（PSF）和原始图像，适用于未知模糊情况。

彻底搞懂CNN中的卷积和反卷积
GIF制作：卷积动画 + 转置卷积动画 + 膨胀卷积动画

一、卷积（Convolution）

卷积（Convolution）是一种数学操作，通常用于信号处理、图像处理和深度学习中，用于处理二维或多维数据。

# 输入图像（input）：下-蓝色区域(5, 5)
# 卷积核（kernel）：下-移动阴影区域(4, 4)
# 填充（padding）：下-白色区域（padding=2）。表示在输入图像边界填充的圈数，通常采用全0填充。
# 步长（stride）：下-卷积核每次滑动的长度

# 卷积核对应的卷积结果：上-移动阴影区域(1, 1)
# 输出图像（output）：上-绿色区域(6, 6)

基于核函数的卷积操作

基于核函数的卷积操作（例如：高斯滤波）

二、反卷积（Deconvolution） —— 别名：去卷积（Deconvolution）、转置卷积（Transpose Convolution）、分数步幅卷积（Fractionally Strided Convolution）

（1）转置卷积算法：torch.nn.ConvTranspose2d()

基础版本：前处理 + 超参

• 卷积（Convolution）：卷积是通过一个卷积核（滤波器）在图像上滑动，对每个位置的局部区域进行加权和操作，从而生成一个新的输出图像。这个操作通常用于提取特征（例如边缘、纹理等）。卷积操作会压缩图像的空间分辨率，通常通过 步幅（stride） 来减少图像的尺寸。为了避免图像尺寸的变化，通常会使用 填充（padding），例如零填充（Zero Padding），使得输入图像在边缘部分也可以进行卷积。

• 转置卷积（Transpose Convolution）：转置卷积（又叫反卷积）并不是卷积的真正逆运算，而是通过插入零的方式，在输入图像中增加空白像素来扩展输入图像尺寸，然后对其进行卷积操作，最终输出较大的图像。

转置卷积的工作原理：

• 将输入数据插入零：转置卷积通过插入零（也称为零填充）扩展图像的尺寸。
• 卷积操作：然后使用一个卷积核对这个扩展后的数据进行卷积操作。
• 输出更高分辨率的特征图：最终生成一个更高分辨率的图像。

转置卷积的应用场景：

• 生成对抗网络（GAN）：用于生成图像或图像的上采样。
• 图像超分辨率：将低分辨率图像恢复为高分辨率图像。
• 语义分割：在分割网络中恢复细粒度的预测图像。

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import cv2
import numpy as np


def load_image(image_path):
    """加载并预处理图像（灰度或彩色）"""
    img = cv2.imread(image_path)  # 读取图像
    img = img[0:200, 0:200]
    if img.shape[2] == 3:
        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # 转换为灰度图
    # img = cv2.resize(img, (64, 64))  # 调整图像大小为 64x64
    img = np.expand_dims(img, axis=0)  # 添加批次维度
    img = np.expand_dims(img, axis=0)  # 添加通道维度（如果是灰度图）
    img = torch.tensor(img, dtype=torch.float32)  # 转换为 tensor
    img /= 255.0  # 归一化至 [0, 1]
    return img


if __name__ == '__main__':
    # （1）加载图像
    input_image = load_image('image.jpg')
    print("Input size: ", input_image.shape)  # torch.Size([1, 1, 245, 612])

    # （2）创建并执行转置卷积层
    conv_transpose = nn.ConvTranspose2d(
        in_channels=1,          # 输入通道数，1代表灰度图，3代表RGB图
        out_channels=1,         # 输出通道数
        kernel_size=3,          # 卷积核大小
        stride=2,               # 步幅
        padding=0,              # 填充
        output_padding=0        # 输出填充
    )
    output_image = conv_transpose(input_image)
    print("Output size: ", output_image.shape)  # torch.Size([1, 1, 491, 1225])
    """####################################################################################
    Output Size = Stride × (Input Size − 1) + Kernel Size − 2 × Padding + Output Padding
                = 2 × (245 − 1) + 3 − 2 × 0 + 0 = 491
                = 2 × (612 − 1) + 3 − 2 × 0 + 0 = 1225
    ####################################################################################"""

    # （3）可视化图像
    plt.subplot(1, 2, 1), plt.imshow(input_image[0, 0].detach().numpy(), cmap='gray' if input_image.shape[1] == 1 else None), plt.title('Input Image'), plt.axis('off')
    plt.subplot(1, 2, 2), plt.imshow(output_image[0, 0].detach().numpy(), cmap='gray' if input_image.shape[1] == 1 else None), plt.title('Output Image'), plt.axis('off')
    plt.show()

"""####################################################################################
函数作用：二维转置卷积操作。将低维特征图上采样，生成高维特征图。
函数说明：
class torch.nn.ConvTranspose2d(
    in_channels: int,
    out_channels: int,
    kernel_size: Union[int, tuple[int, int]],
    stride: Union[int, tuple[int, int]] = 1,
    padding: Union[int, tuple[int, int]] = 0,
    output_padding: Union[int, tuple[int, int]] = 0,
    groups: int = 1,
    bias: bool = True,
    dilation: Union[int, tuple[int, int]] = 1,
    padding_mode: str = 'zeros',
    device: Any = None,
    dtype: Any = None
) -> None

输入参数：       
        in_channels：        输入张量的通道数。例如，输入图像是 RGB 图像，则通道数为 3；如果输入是灰度图，则为 1。
        out_channels：       输出张量的通道数，即卷积操作后的输出深度。通常根据需要的特征数来设置。
        kernel_size：        卷积核的大小。可以是一个整数（表示高度和宽度相同的卷积核），也可以是一个元组，指定高和宽的不同大小。例如 (3, 3) 或 3。
        stride：             步幅，用于控制上采样的倍数。步幅越大，输出的尺寸会越大。可以是一个整数或一个元组 (height, width)，分别控制高度和宽度方向的步幅。
        padding：            输入的填充大小。可以是一个整数或一个元组 (height, width)。填充是为了保证卷积核能够覆盖图像的边界区域，避免丢失图像边缘的信息。

        output_padding：     输出填充，用于调节输出尺寸的参数。通常在应用转置卷积时，可以使用 output_padding 来确保输出尺寸与期望的尺寸匹配。
        groups：             分组卷积的分组数。用于深度可分离卷积等特定情况，通常保持为 1。分组卷积允许每个输入通道和输出通道分别进行卷积，从而减少参数数量。
        bias：               是否使用偏置项。如果为 True，则每个输出通道会添加一个可学习的偏置。
        dilation：           卷积核的膨胀大小，通常用于增加卷积的感受野。通过膨胀卷积核，可以增加卷积核元素之间的间距，从而扩展感受区域，增加对远距离像素的感知能力。
        padding_mode：       填充模式，控制填充的方式。常见的填充方式包括："zeros"（默认值）、"reflect"、"replicate" 和 "circular"。
        device：             指定计算张量所使用的设备，如 'cpu' 或 'cuda'（GPU）。如果为 None，则默认使用当前默认设备。
        dtype：              指定张量的数据类型，如 torch.float32 或 torch.float64。如果为 None，则默认使用当前默认数据类型。
####################################################################################"""

增强版本：网络深度 + 残差网络 + 正则化

为了增强反卷积的效果，你可以：

• 增加网络的深度，使用更复杂的网络结构。
• 加入正则化项，如 TV 正则化、Wiener 滤波，避免噪声放大。
• 采用批量归一化和残差网络，提高网络的稳定性和效果。
• 合理设置卷积核和步幅，确保特征不丢失且计算效率合理。

import torch
import torch.nn as nn
import torch.nn.functional as F
from skimage.restoration import denoise_tv_chambolle
import matplotlib.pyplot as plt
import numpy as np
import cv2


def set_seed(seed=0):
    """设置随机种子，确保可复现"""
    torch.manual_seed(seed)  # 设置PyTorch在CPU上的随机种子，确保所有随机操作（如权重初始化、数据加载等）可复现

    # 设置CUDA的随机种子（用于GPU计算）
    torch.cuda.manual_seed(seed)  # 为当前设备设置种子
    torch.cuda.manual_seed_all(seed)  # 为所有GPU设备设置种子（如果使用多个GPU）

    import random
    random.seed(seed)  # 设置Python标准库中的random模块的随机种子

    import numpy as np
    np.random.seed(seed)  # 设置NumPy的随机数生成器种子

    torch.backends.cudnn.deterministic = True  # 让PyTorch的卷积操作变得确定性（即每次运行时结果相同）
    torch.backends.cudnn.benchmark = False  # 禁用CuDNN的自动优化，CuDNN会根据输入数据的形状和其他条件选择最优的计算算法（这通常会提高性能）。


# TV 正则化
def tv_regularization(image, weight=0.1):
    """应用 TV 正则化来去除噪声并保留边缘细节"""
    return denoise_tv_chambolle(image, weight=weight)


# 残差块
class ResidualBlock(nn.Module):
    def __init__(self, in_channels):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)
        self.relu = nn.ReLU()

    def forward(self, x):
        residual = x
        x = self.relu(self.conv1(x))
        x = self.conv2(x)
        x += residual  # 加入残差
        return self.relu(x)


# 增强生成网络
class EnhancedGenerator(nn.Module):
    def __init__(self, in_channels=3, out_channels=3):
        super(EnhancedGenerator, self).__init__()

        # 卷积层
        self.conv1 = nn.Conv2d(in_channels, 64, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
        self.conv3 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)

        # 残差块
        self.resblock1 = ResidualBlock(256)
        self.resblock2 = ResidualBlock(256)

        # 转置卷积层（上采样）
        self.deconv1 = nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1)
        self.deconv2 = nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1)
        self.deconv3 = nn.ConvTranspose2d(64, out_channels, kernel_size=4, stride=2, padding=1)

        # 批量归一化
        self.bn1 = nn.BatchNorm2d(64)
        self.bn2 = nn.BatchNorm2d(128)
        self.bn3 = nn.BatchNorm2d(256)

    def forward(self, x):
        # 卷积过程
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = F.relu(self.bn3(self.conv3(x)))

        # 残差块
        x = self.resblock1(x)
        x = self.resblock2(x)

        # 转置卷积过程
        x = F.relu(self.deconv1(x))
        x = F.relu(self.deconv2(x))
        x = self.deconv3(x)

        # 应用 TV 正则化
        x = tv_regularization(x.squeeze().cpu().detach().numpy(), weight=0.1)
        x = torch.tensor(x, dtype=torch.float32).unsqueeze(0).unsqueeze(0)  # 转换为 Tensor

        return x

def load_image(image_path):
    """加载并预处理图像（灰度或彩色）"""
    img = cv2.imread(image_path)  # 读取图像
    print(f"Loaded image shape: {img.shape}")  # Loaded image shape: (245, 612, 3)

    img = img[0:200, 0:200]  # 截取图像区域
    if img.shape[2] == 3:
        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # 转换为灰度图

    # img = cv2.resize(img, (200, 200))  # 调整图像大小为 200x200
    # img = np.transpose(img, (2, 0, 1))  # 将通道维度放在第一个维度
    img = np.expand_dims(img, axis=0)  # 添加批次维度
    img = np.expand_dims(img, axis=0)  # 添加通道维度（如果是灰度图）
    img = torch.tensor(img, dtype=torch.float32) / 255.0  # 转换为 tensor 并归一化至 [0, 1]
    return img


if __name__ == '__main__':
    set_seed(5)  # 设置固定种子
    """
    由于卷积层的权重是随机初始化的，因此每次训练开始时，权重会有所不同。这种随机性会影响到模型的训练结果。
    在默认情况下，PyTorch 会自动使用一些初始化方法来为转置卷积层的权重赋予随机值（权重+偏置），具体取决于卷积核的类型。
    """

    # 加载图像
    input_image = load_image('image.jpg')
    print("Input size: ", input_image.shape)  # Input size:  torch.Size([1, 3, 200, 200])

    # 创建模型
    model = EnhancedGenerator(in_channels=1, out_channels=1)

    # 前向传播
    output_image = model(input_image) * 255
    print("Output size: ", output_image.shape)  # Output size:  torch.Size([1, 3, 1600, 1600])

    # 显示结果
    plt.subplot(1, 2, 1), plt.imshow(input_image[0, 0].detach().numpy(), cmap='gray' if input_image.shape[1] == 1 else None), plt.title('Input Image'), plt.axis('off')
    plt.subplot(1, 2, 2), plt.imshow(output_image[0, 0].detach().numpy(), cmap='gray' if input_image.shape[1] == 1 else None), plt.title('Output Image'), plt.axis('off')
    plt.show()

（2）RL反卷积算法（Richardson-Lucy）

基础版本：迭代去噪

增强版本：滤波 + 迭代终止准则 + 正则化 + 多分辨率