DAY 45 通道注意力(SE注意力)

最新推荐文章于 2025-09-08 16:49:27 发布

原创

最新推荐文章于 2025-09-08 16:49:27 发布 · 1.5k 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#人工智能 #计算机视觉 #深度学习

3.2 模型的重新定义（通道注意力的插入）

知识点回顾：

不同CNN层的特征图：不同通道的特征图

什么是注意力：注意力家族，类似于动物园，都是不同的模块，好不好试了才知道。

通道注意力：模型的定义和插入的位置

通道注意力后的特征图和热力图

一、什么是注意力

之前复试班强化部分的transformer框架那节课已经介绍过注意力机制的由来，本质从onehot-elmo-selfattention-encoder-bert这就是一条不断提取特征的路。各有各的特点，也可以说由弱到强。

其中注意力机制是一种让模型学会「选择性关注重要信息」的特征提取器，就像人类视觉会自动忽略背景，聚焦于图片中的主体（如猫、汽车）。 transformer中的叫做自注意力机制，他是一种自己学习自己的机制，他可以自动学习到图片中的主体，并忽略背景。我们现在说的很多模块，比如通道注意力、空间注意力、通道注意力等等，都是基于自注意力机制的。

从数学角度看，注意力机制是对输入特征进行加权求和，输出=∑(输入特征×注意力权重)，其中注意力权重是学习到的。所以他和卷积很像，因为卷积也是一种加权求和。但是卷积是 “固定权重” 的特征提取（如 3x3 卷积核）--训练完了就结束了，注意力是 “动态权重” 的特征提取（权重随输入数据变化）---输入数据不同权重不同。

问：为什么需要多种注意力模块？

答：因为不同场景下的关键信息分布不同。例如，识别鸟类和飞机时，需关注 “羽毛纹理”“金属光泽” 等特定通道的特征，通道注意力可强化关键通道；而物体位置不确定时（如猫出现在图像不同位置），空间注意力能聚焦物体所在区域，忽略背景。复杂场景中，可能需要同时关注通道和空间（如混合注意力模块 CBAM），或处理长距离依赖（如全局注意力模块 Non-local）。

问：为什么不设计一个‘万能’注意力模块？

答：主要受效率和灵活性限制。专用模块针对特定需求优化计算，成本更低（如通道注意力仅需处理通道维度，无需全局位置计算）；不同任务的核心需求差异大（如医学图像侧重空间定位，自然语言处理侧重语义长距离依赖），通用模块可能冗余或低效。每个模块新增的权重会增加模型参数量，若训练数据不足或优化不当，可能引发过拟合。因此实际应用中需结合轻量化设计（如减少全连接层参数）、正则化（如 Dropout）或结构约束（如共享注意力权重）来平衡性能与复杂度。

通道注意力（Channel Attention）属于注意力机制（Attention Mechanism）的变体，而非自注意力（Self-Attention）的直接变体。可以理解为注意力是一个动物园算法，里面很多个物种，自注意力只是一个分支，因为开创了transformer所以备受瞩目。我们今天的内容用通道注意力举例

常见注意力模块的归类如下

注意力模块	所属类别	核心功能
自注意力（Self-Attention）	自注意力变体	建模同一输入内部元素的依赖（如序列位置、图像块）
通道注意力（Channel Attention）	普通注意力变体（全局上下文）	建模特征图通道间的重要性，通过全局池化压缩空间信息
空间注意力（Spatial Attention）	普通注意力变体（全局上下文）	建模特征图空间位置的重要性，关注“哪里”更重要
多头注意力（Multi-Head Attention）	自注意力/普通注意力的增强版	将query/key/value投影到多个子空间，捕捉多维度依赖
编码器-解码器注意力（Encoder-Decoder Attention）	普通注意力变体	建模编码器输出与解码器输入的跨模态交互（如机器翻译中句子与译文的对齐）

二、特征图的提取

2.1 简单CNN的训练


import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np

# 设置中文字体支持
plt.rcParams["font.family"] = ["SimHei"]
plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题

# 检查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")

# 1. 数据预处理
# 训练集：使用多种数据增强方法提高模型泛化能力
train_transform = transforms.Compose([
    # 随机裁剪图像，从原图中随机截取32x32大小的区域
    transforms.RandomCrop(32, padding=4),
    # 随机水平翻转图像（概率0.5）
    transforms.RandomHorizontalFlip(),
    # 随机颜色抖动：亮度、对比度、饱和度和色调随机变化
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
    # 随机旋转图像（最大角度15度）
    transforms.RandomRotation(15),
    # 将PIL图像或numpy数组转换为张量
    transforms.ToTensor(),
    # 标准化处理：每个通道的均值和标准差，使数据分布更合理
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

# 测试集：仅进行必要的标准化，保持数据原始特性，标准化不损失数据信息，可还原
test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

# 2. 加载CIFAR-10数据集
train_dataset = datasets.CIFAR10(
    root='./data',
    train=True,
    download=True,
    transform=train_transform  # 使用增强后的预处理
)

test_dataset = datasets.CIFAR10(
    root='./data',
    train=False,
    transform=test_transform  # 测试集不使用增强
)

# 3. 创建数据加载器
batch_size = 64
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
# 4. 定义CNN模型的定义（替代原MLP）
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()  # 继承父类初始化
        
        # ---------------------- 第一个卷积块 ----------------------
        # 卷积层1：输入3通道（RGB），输出32个特征图，卷积核3x3，边缘填充1像素
        self.conv1 = nn.Conv2d(
            in_channels=3,       # 输入通道数（图像的RGB通道）
            out_channels=32,     # 输出通道数（生成32个新特征图）
            kernel_size=3,       # 卷积核尺寸（3x3像素）
            padding=1            # 边缘填充1像素，保持输出尺寸与输入相同
        )
        # 批量归一化层：对32个输出通道进行归一化，加速训练
        self.bn1 = nn.BatchNorm2d(num_features=32)
        # ReLU激活函数：引入非线性，公式：max(0, x)
        self.relu1 = nn.ReLU()
        # 最大池化层：窗口2x2，步长2，特征图尺寸减半（32x32→16x16）
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)  # stride默认等于kernel_size
        
        # ---------------------- 第二个卷积块 ----------------------
        # 卷积层2：输入32通道（来自conv1的输出），输出64通道
        self.conv2 = nn.Conv2d(
            in_channels=32,      # 输入通道数（前一层的输出通道数）
            out_channels=64,     # 输出通道数（特征图数量翻倍）
            kernel_size=3,       # 卷积核尺寸不变
            padding=1            # 保持尺寸：16x16→16x16（卷积后）→8x8（池化后）
        )
        self.bn2 = nn.BatchNorm2d(num_features=64)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2)  # 尺寸减半：16x16→8x8
        
        # ---------------------- 第三个卷积块 ----------------------
        # 卷积层3：输入64通道，输出128通道
        self.conv3 = nn.Conv2d(
            in_channels=64,      # 输入通道数（前一层的输出通道数）
            out_channels=128,    # 输出通道数（特征图数量再次翻倍）
            kernel_size=3,
            padding=1            # 保持尺寸：8x8→8x8（卷积后）→4x4（池化后）
        )
        self.bn3 = nn.BatchNorm2d(num_features=128)
        self.relu3 = nn.ReLU()  # 复用激活函数对象（节省内存）
        self.pool3 = nn.MaxPool2d(kernel_size=2)  # 尺寸减半：8x8→4x4
        
        # ---------------------- 全连接层（分类器） ----------------------
        # 计算展平后的特征维度：128通道 × 4x4尺寸 = 128×16=2048维
        self.fc1 = nn.Linear(
            in_features=128 * 4 * 4,  # 输入维度（卷积层输出的特征数）
            out_features=512          # 输出维度（隐藏层神经元数）
        )
        # Dropout层：训练时随机丢弃50%神经元，防止过拟合
        self.dropout = nn.Dropout(p=0.5)
        # 输出层：将512维特征映射到10个类别（CIFAR-10的类别数）
        self.fc2 = nn.Linear(in_features=512, out_features=10)

    def forward(self, x):
        # 输入尺寸：[batch_size, 3, 32, 32]