CBAM生成对抗网络：从原理到实战的深度解析

1次阅读

共计 3723 个字符，预计需要花费 10 分钟才能阅读完成。

生成对抗网络（GAN）在图像生成领域已经取得了显著的成功，但传统 GAN 存在一些明显的局限性。其中最主要的问题包括训练不稳定和模式崩溃（Mode Collapse）。训练不稳定指的是生成器和判别器之间的博弈难以达到平衡，常常导致一方压倒另一方；模式崩溃则是指生成器倾向于生成有限的几种样本，缺乏多样性。

为了解决这些问题，研究人员引入了注意力机制。注意力机制能够帮助模型聚焦于图像中最相关的部分，从而提升生成图像的质量和多样性。CBAM（Convolutional Block Attention Module）作为一种轻量级的注意力模块，能够有效结合通道注意力和空间注意力，为 GAN 的性能提升提供了新的思路。

在注意力机制的选择上，CBAM 与其他主流方案（如 SE 模块和 Non-local 模块）相比具有独特的优势：

SE 模块 ：仅关注通道注意力，忽略了空间信息。
Non-local 模块 ：虽然能捕捉长距离依赖，但计算复杂度较高。
CBAM：结合了通道注意力和空间注意力，计算效率高且易于集成到现有网络中。

CBAM 与 GAN 的结合方式通常是在生成器和判别器的卷积层后插入 CBAM 模块，通过动态调整特征图的权重，增强模型对关键区域的关注。

CBAM 由两部分组成：通道注意力模块（Channel Attention Module, CAM）和空间注意力模块（Spatial Attention Module, SAM）。

通道注意力 ：通过全局平均池化和全局最大池化提取通道级特征，然后通过一个共享的多层感知机（MLP）生成通道权重。
空间注意力 ：在通道维度上应用平均池化和最大池化，然后将结果拼接并通过卷积层生成空间权重。

以下是 CBAM 模块的 PyTorch 实现代码：

import torch
import torch.nn as nn

class CBAM(nn.Module):
    def __init__(self, channels, reduction_ratio=16):
        super(CBAM, self).__init__()
        self.channel_attention = ChannelAttention(channels, reduction_ratio)
        self.spatial_attention = SpatialAttention()

    def forward(self, x):
        x = self.channel_attention(x) * x
        x = self.spatial_attention(x) * x
        return x

class ChannelAttention(nn.Module):
    def __init__(self, channels, reduction_ratio=16):
        super(ChannelAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)
        self.mlp = nn.Sequential(nn.Linear(channels, channels // reduction_ratio),
            nn.ReLU(),
            nn.Linear(channels // reduction_ratio, channels)
        )

    def forward(self, x):
        avg_out = self.mlp(self.avg_pool(x).squeeze(-1).squeeze(-1))
        max_out = self.mlp(self.max_pool(x).squeeze(-1).squeeze(-1))
        channel_weights = torch.sigmoid(avg_out + max_out).unsqueeze(-1).unsqueeze(-1)
        return channel_weights

class SpatialAttention(nn.Module):
    def __init__(self, kernel_size=7):
        super(SpatialAttention, self).__init__()
        self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size // 2)

    def forward(self, x):
        avg_out = torch.mean(x, dim=1, keepdim=True)
        max_out, _ = torch.max(x, dim=1, keepdim=True)
        spatial_weights = torch.sigmoid(self.conv(torch.cat([avg_out, max_out], dim=1)))
        return spatial_weights

以下是一个完整的 CBAM-GAN 实现示例，包含数据预处理和训练循环：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 定义生成器和判别器
class Generator(nn.Module):
    def __init__(self, latent_dim, img_channels):
        super(Generator, self).__init__()
        self.main = nn.Sequential(nn.ConvTranspose2d(latent_dim, 512, 4, 1, 0, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            CBAM(512),
            # 更多层...
        )

class Discriminator(nn.Module):
    def __init__(self, img_channels):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(nn.Conv2d(img_channels, 64, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2),
            CBAM(64),
            # 更多层...
        )

# 数据预处理
transform = transforms.Compose([transforms.Resize(64),
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
dataloader = DataLoader(dataset, batch_size=128, shuffle=True)

# 初始化模型和优化器
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
G = Generator(100, 1).to(device)
D = Discriminator(1).to(device)

optimizer_G = optim.Adam(G.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = optim.Adam(D.parameters(), lr=0.0002, betas=(0.5, 0.999))

# 训练循环
for epoch in range(100):
    for i, (real_imgs, _) in enumerate(dataloader):
        real_imgs = real_imgs.to(device)
        # 训练判别器
        # 训练生成器
        # 更新参数

在 CelebA 数据集上的实验表明，CBAM-GAN 相比传统 GAN 在生成质量上有显著提升。定量评估使用 FID（Frechet Inception Distance）和 IS（Inception Score）指标：