当前位置：首页 > news >正文

Python训练第四十六天

news 来源：原创 2025/6/7 6:04:37

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

知识点回顾：

不同CNN层的特征图：不同通道的特征图
什么是注意力：注意力家族，类似于动物园，都是不同的模块，好不好试了才知道。
通道注意力：模型的定义和插入的位置
通道注意力后的特征图和热力图

一、什么是注意力

本质从onehot-elmo-selfattention-encoder-bert这就是一条不断提取特征的路。各有各的特点，也可以说由弱到强。

其中注意力机制是一种让模型学会「选择性关注重要信息」的特征提取器，就像人类视觉会自动忽略背景，聚焦于图片中的主体（如猫、汽车）。

transformer中的叫做自注意力机制，他是一种自己学习自己的机制，他可以自动学习到图片中的主体，并忽略背景。我们现在说的很多模块，比如通道注意力、空间注意力、通道注意力等等，都是基于自注意力机制的。

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

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

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

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

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

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

二、特征图的提取

2.1 简单CNN的训练

昨天我已经介绍了cnn，为了好演示，我就重新训练了之前的cnn代码，你可以直接加载之前保存好的权重试试，一般重新训练1-2轮就会恢复效果。

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]（batch_size=批量大小，3=通道数，32x32=图像尺寸）# ---------- 卷积块1处理 ----------x = self.conv1(x)       # 卷积后尺寸：[batch_size, 32, 32, 32]（padding=1保持尺寸）x = self.bn1(x)         # 批量归一化，不改变尺寸x = self.relu1(x)       # 激活函数，不改变尺寸x = self.pool1(x)       # 池化后尺寸：[batch_size, 32, 16, 16]（32→16是因为池化窗口2x2）# ---------- 卷积块2处理 ----------x = self.conv2(x)       # 卷积后尺寸：[batch_size, 64, 16, 16]（padding=1保持尺寸）x = self.bn2(x)x = self.relu2(x)x = self.pool2(x)       # 池化后尺寸：[batch_size, 64, 8, 8]# ---------- 卷积块3处理 ----------x = self.conv3(x)       # 卷积后尺寸：[batch_size, 128, 8, 8]（padding=1保持尺寸）x = self.bn3(x)x = self.relu3(x)x = self.pool3(x)       # 池化后尺寸：[batch_size, 128, 4, 4]# ---------- 展平与全连接层 ----------# 将多维特征图展平为一维向量：[batch_size, 128*4*4] = [batch_size, 2048]x = x.view(-1, 128 * 4 * 4)  # -1自动计算批量维度，保持批量大小不变x = self.fc1(x)           # 全连接层：2048→512，尺寸变为[batch_size, 512]x = self.relu3(x)         # 激活函数（复用relu3，与卷积块3共用）x = self.dropout(x)       # Dropout随机丢弃神经元，不改变尺寸x = self.fc2(x)           # 全连接层：512→10，尺寸变为[batch_size, 10]（未激活，直接输出logits）return x  # 输出未经过Softmax的logits，适用于交叉熵损失函数# 初始化模型
model = CNN()
model = model.to(device)  # 将模型移至GPU（如果可用）criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器# 引入学习率调度器，在训练过程中动态调整学习率--训练初期使用较大的 LR 快速降低损失，训练后期使用较小的 LR 更精细地逼近全局最优解。
# 在每个 epoch 结束后，需要手动调用调度器来更新学习率，可以在训练过程中调用 scheduler.step()
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,        # 指定要控制的优化器（这里是Adam）mode='min',       # 监测的指标是"最小化"（如损失函数）patience=3,       # 如果连续3个epoch指标没有改善，才降低LRfactor=0.5        # 降低LR的比例（新LR = 旧LR × 0.5）
)
# 5. 训练模型（记录每个 iteration 的损失）
def train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs):model.train()  # 设置为训练模式# 记录每个 iteration 的损失all_iter_losses = []  # 存储所有 batch 的损失iter_indices = []     # 存储 iteration 序号# 记录每个 epoch 的准确率和损失train_acc_history = []test_acc_history = []train_loss_history = []test_loss_history = []for epoch in range(epochs):running_loss = 0.0correct = 0total = 0for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)  # 移至GPUoptimizer.zero_grad()  # 梯度清零output = model(data)  # 前向传播loss = criterion(output, target)  # 计算损失loss.backward()  # 反向传播optimizer.step()  # 更新参数# 记录当前 iteration 的损失iter_loss = loss.item()all_iter_losses.append(iter_loss)iter_indices.append(epoch * len(train_loader) + batch_idx + 1)# 统计准确率和损失running_loss += iter_loss_, predicted = output.max(1)total += target.size(0)correct += predicted.eq(target).sum().item()# 每100个批次打印一次训练信息if (batch_idx + 1) % 100 == 0:print(f'Epoch: {epoch+1}/{epochs} | Batch: {batch_idx+1}/{len(train_loader)} 'f'| 单Batch损失: {iter_loss:.4f} | 累计平均损失: {running_loss/(batch_idx+1):.4f}')# 计算当前epoch的平均训练损失和准确率epoch_train_loss = running_loss / len(train_loader)epoch_train_acc = 100. * correct / totaltrain_acc_history.append(epoch_train_acc)train_loss_history.append(epoch_train_loss)# 测试阶段model.eval()  # 设置为评估模式test_loss = 0correct_test = 0total_test = 0with torch.no_grad():for data, target in test_loader:data, target = data.to(device), target.to(device)output = model(data)test_loss += criterion(output, target).item()_, predicted = output.max(1)total_test += target.size(0)correct_test += predicted.eq(target).sum().item()epoch_test_loss = test_loss / len(test_loader)epoch_test_acc = 100. * correct_test / total_testtest_acc_history.append(epoch_test_acc)test_loss_history.append(epoch_test_loss)# 更新学习率调度器scheduler.step(epoch_test_loss)print(f'Epoch {epoch+1}/{epochs} 完成 | 训练准确率: {epoch_train_acc:.2f}% | 测试准确率: {epoch_test_acc:.2f}%')# 绘制所有 iteration 的损失曲线plot_iter_losses(all_iter_losses, iter_indices)# 绘制每个 epoch 的准确率和损失曲线plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)return epoch_test_acc  # 返回最终测试准确率# 6. 绘制每个 iteration 的损失曲线
def plot_iter_losses(losses, indices):plt.figure(figsize=(10, 4))plt.plot(indices, losses, 'b-', alpha=0.7, label='Iteration Loss')plt.xlabel('Iteration（Batch序号）')plt.ylabel('损失值')plt.title('每个 Iteration 的训练损失')plt.legend()plt.grid(True)plt.tight_layout()plt.show()# 7. 绘制每个 epoch 的准确率和损失曲线
def plot_epoch_metrics(train_acc, test_acc, train_loss, test_loss):epochs = range(1, len(train_acc) + 1)plt.figure(figsize=(12, 4))# 绘制准确率曲线plt.subplot(1, 2, 1)plt.plot(epochs, train_acc, 'b-', label='训练准确率')plt.plot(epochs, test_acc, 'r-', label='测试准确率')plt.xlabel('Epoch')plt.ylabel('准确率 (%)')plt.title('训练和测试准确率')plt.legend()plt.grid(True)# 绘制损失曲线plt.subplot(1, 2, 2)plt.plot(epochs, train_loss, 'b-', label='训练损失')plt.plot(epochs, test_loss, 'r-', label='测试损失')plt.xlabel('Epoch')plt.ylabel('损失值')plt.title('训练和测试损失')plt.legend()plt.grid(True)plt.tight_layout()plt.show()# 8. 执行训练和测试
epochs = 50  # 增加训练轮次为了确保收敛
print("开始使用CNN训练模型...")
final_accuracy = train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs)
print(f"训练完成！最终测试准确率: {final_accuracy:.2f}%")# # 保存模型
# torch.save(model.state_dict(), 'cifar10_cnn_model.pth')
# print("模型已保存为: cifar10_cnn_model.pth")

可以看到测试集一定程度上收敛了，在85%左右（还可以继续训练的），我们后续和加了通道注意力的该模型作对比，这也意味着我们进入到了消融实验的部分了。过去我们都是在同一个数据集上对比不同的模型的差异，或者同一个模型不同参数下的差异，这种实验叫做对比实验。在同一个数据集上，对同一个模型进行模块的增加和减少，这种实验我们称之为消融实验。通过消融实验，研究者能更清晰地理解模型各部分的作用，而对比实验则用于评估模型的整体竞争力。两者常结合使用，以全面验证模型设计的合理性。

2.2 特征图可视化

为了方便观察，我们先尝试提取下特征图。特征图本质就是不同的卷积核的输出，浅层指的是离输入图近的卷积层，浅层卷积层的特征图通常较大，而深层特征图会经过多次下采样，尺寸显著缩小，尺寸差异过大时，小尺寸特征图在视觉上会显得模糊或丢失细节。步骤逻辑如下：

1. 初始化设置：

将模型设为评估模式，准备类别名称列表（如飞机、汽车等）。

2. 数据加载与处理：

从测试数据加载器中获取图像和标签。

仅处理前 `num_images` 张图像（如2张）。

3. 注册钩子捕获特征图：

为指定层（如 `conv1`, `conv2`, `conv3`）注册前向钩子。

钩子函数将这些层的输出（特征图）保存到字典中。

4. 前向传播与特征提取：

模型处理图像，触发钩子函数，获取并保存特征图。

移除钩子，避免后续干扰。

5. 可视化特征图：

对每张图像：

恢复原始像素值并显示。

为每个目标层创建子图，展示前 `num_channels` 个通道的特征图（如9个通道）。

每个通道的特征图以网格形式排列，显示通道编号。

关键细节

特征图布局：原始图像在左侧，各层特征图按顺序排列在右侧。

通道选择：默认显示前9个通道（按重要性或索引排序）。

显示优化：

使用 `inset_axes` 在大图中嵌入小网格，清晰展示每个通道。

层标题与通道标题分开，避免重叠。

反标准化处理恢复图像原始色彩。

def visualize_feature_maps(model, test_loader, device, layer_names, num_images=3, num_channels=9):"""可视化指定层的特征图（修复循环冗余问题）参数:model: 模型test_loader: 测试数据加载器layer_names: 要可视化的层名称（如['conv1', 'conv2', 'conv3']）num_images: 可视化的图像总数num_channels: 每个图像显示的通道数（取前num_channels个通道）"""model.eval()  # 设置为评估模式class_names = ['飞机', '汽车', '鸟', '猫', '鹿', '狗', '青蛙', '马', '船', '卡车']# 从测试集加载器中提取指定数量的图像（避免嵌套循环）images_list, labels_list = [], []for images, labels in test_loader:images_list.append(images)labels_list.append(labels)if len(images_list) * test_loader.batch_size >= num_images:break# 拼接并截取到目标数量images = torch.cat(images_list, dim=0)[:num_images].to(device)labels = torch.cat(labels_list, dim=0)[:num_images].to(device)with torch.no_grad():# 存储各层特征图feature_maps = {}# 保存钩子句柄hooks = []# 定义钩子函数，捕获指定层的输出def hook(module, input, output, name):feature_maps[name] = output.cpu()  # 保存特征图到字典# 为每个目标层注册钩子，并保存钩子句柄for name in layer_names:module = getattr(model, name)hook_handle = module.register_forward_hook(lambda m, i, o, n=name: hook(m, i, o, n))hooks.append(hook_handle)# 前向传播触发钩子_ = model(images)# 正确移除钩子for hook_handle in hooks:hook_handle.remove()# 可视化每个图像的各层特征图（仅一层循环）for img_idx in range(num_images):img = images[img_idx].cpu().permute(1, 2, 0).numpy()# 反标准化处理（恢复原始像素值）img = img * np.array([0.2023, 0.1994, 0.2010]).reshape(1, 1, 3) + np.array([0.4914, 0.4822, 0.4465]).reshape(1, 1, 3)img = np.clip(img, 0, 1)  # 确保像素值在[0,1]范围内# 创建子图num_layers = len(layer_names)fig, axes = plt.subplots(1, num_layers + 1, figsize=(4 * (num_layers + 1), 4))#1：行数；num_layers + 1:列数；4 * (num_layers + 1)：宽度；# 显示原始图像axes[0].imshow(img)axes[0].set_title(f'原始图像\n类别: {class_names[labels[img_idx]]}')axes[0].axis('off')# 显示各层特征图for layer_idx, layer_name in enumerate(layer_names):fm = feature_maps[layer_name][img_idx]  # 取第img_idx张图像的特征图fm = fm[:num_channels]  # 仅取前num_channels个通道num_rows = int(np.sqrt(num_channels))num_cols = num_channels // num_rows if num_rows != 0 else 1# 创建子图网格layer_ax = axes[layer_idx + 1]layer_ax.set_title(f'{layer_name}特征图 \n')# 加个换行让文字分离上去layer_ax.axis('off')  # 关闭大子图的坐标轴# 在大子图内创建小网格for ch_idx, channel in enumerate(fm):ax = layer_ax.inset_axes([ch_idx % num_cols / num_cols, #内嵌子图的 x 坐标（相对于父图的比例）。(num_rows - 1 - ch_idx // num_cols) / num_rows, #内嵌子图的 y 坐标（相对于父图的比例）1/num_cols, 1/num_rows])#1/num_cols ：内嵌子图的宽度（相对于父图的比例），即每个内嵌子图的宽度是父图宽度的 1/num_cols#1/num_rows ：内嵌子图的高度（相对于父图的比例），即每个内嵌子图的高度是父图高度的 1/num_rows 。ax.imshow(channel.numpy(), cmap='viridis')#cmap='viridis' ：指定颜色映射。 viridis 是一种连续的颜色映射，从深蓝色到亮黄色，常用于可视化数值数据。ax.set_title(f'通道 {ch_idx + 1}')ax.axis('off')plt.tight_layout()plt.show()# 调用示例（按需修改参数）
layer_names = ['conv1', 'conv2', 'conv3']
visualize_feature_maps(model=model,test_loader=test_loader,device=device,layer_names=layer_names,num_images=5,  # 可视化5张测试图像 → 输出5张大图num_channels=9   # 每张图像显示前9个通道的特征图
)

上面的图为提取CNN不同卷积层输出的特征图，我们以第五张图片-青蛙进行解读。

由于经过了不断的下采样，特征变得越来越抽象，人类已经无法理解。

核心作用

通过可视化特征图，可直观观察：

浅层卷积层（如 `conv1`）如何捕获边缘、纹理等低级特征。

深层卷积层（如 `conv3`）如何组合低级特征形成语义概念（如物体部件）。

模型对不同类别的关注区域差异（如鸟类的羽毛纹理 vs. 飞机的金属光泽）。

conv1 特征图（浅层卷积）

特点：

保留较多原始图像的**细节纹理**（如植物叶片、青蛙身体的边缘轮廓）。

通道间差异相对小，每个通道都能看到类似原始图像的基础结构（如通道 1 - 9 都能识别边缘、纹理）。

意义：

提取**低级特征**（边缘、颜色块、简单纹理），是后续高层特征的“原材料”。

类似人眼初步识别图像的轮廓和基础结构。

conv2 特征图（中层卷积）

特点：

空间尺寸（高、宽）比 conv1 更小（因卷积/池化下采样），但**语义信息更抽象**。

通道间差异更明显：部分通道开始聚焦**局部关键特征**（如通道 5、8 中黄色高亮区域，可能对应青蛙身体或植物的关键纹理）。

意义：

对 conv1 的低级特征进行**组合与筛选**，提取**中级特征**（如局部形状、纹理组合）。

类似人眼从“边缘轮廓”过渡到“识别局部结构”（如青蛙的身体块、植物的叶片簇）。

conv3 特征图（深层卷积）

特点：

空间尺寸进一步缩小，**抽象程度最高**，肉眼难直接对应原始图像细节。

通道间差异极大，部分通道聚焦**全局语义特征**（如通道 4、7 中黄色区域，可能对应模型判断“青蛙”类别的关键特征）。

意义：

对 conv2 的中级特征进行**全局整合**，提取**高级语义特征**（如物体类别相关的抽象模式）。

类似人眼最终“识别出这是青蛙”的关键依据，模型通过这些特征判断类别。

特征逐层抽象：从“看得见的细节”（conv1）→ “局部结构”（conv2）→ “类别相关的抽象模式”（conv3），模型通过这种方式实现从“看图像”到“理解语义”的跨越。

通道分工明确：不同通道在各层聚焦不同特征（如有的通道负责边缘，有的负责颜色，有的负责全局语义），共同协作完成分类任务。

下采样的作用：通过缩小空间尺寸，换取更高的语义抽象能力（“牺牲细节，换取理解”）。

三、通道注意力

现在我们引入通道注意力，来观察精度是否有变化，并且进一步可视化。

想要把通道注意力插入到模型中，关键步骤如下：

1. 定义注意力模块

2. 重写之前的模型定义部分，确定好模块插入的位置

3.1 通道注意力的定义

# ===================== 新增：通道注意力模块（SE模块） =====================
class ChannelAttention(nn.Module):"""通道注意力模块(Squeeze-and-Excitation)"""def __init__(self, in_channels, reduction_ratio=16):"""参数:in_channels: 输入特征图的通道数reduction_ratio: 降维比例，用于减少参数量"""super(ChannelAttention, self).__init__()# 全局平均池化 - 将空间维度压缩为1x1，保留通道信息self.avg_pool = nn.AdaptiveAvgPool2d(1)# 全连接层 + 激活函数，用于学习通道间的依赖关系self.fc = nn.Sequential(# 降维：压缩通道数，减少计算量nn.Linear(in_channels, in_channels // reduction_ratio, bias=False),#in_channels ：输入特征的维度。#in_channels // reduction_ratio ：输出特征的维度。#bias=False ：一个布尔值，用于指定是否在线性变换中使用偏置项。设置为 False 表示不使用偏置项，nn.ReLU(inplace=True),# 升维：恢复原始通道数nn.Linear(in_channels // reduction_ratio, in_channels, bias=False),# Sigmoid将输出值归一化到[0,1]，表示通道重要性权重nn.Sigmoid())def forward(self, x):"""参数:x: 输入特征图，形状为 [batch_size, channels, height, width]返回:加权后的特征图，形状不变"""batch_size, channels, height, width = x.size()# 1. 全局平均池化：[batch_size, channels, height, width] → [batch_size, channels, 1, 1]avg_pool_output = self.avg_pool(x)# 2. 展平为一维向量：[batch_size, channels, 1, 1] → [batch_size, channels]avg_pool_output = avg_pool_output.view(batch_size, channels)# 3. 通过全连接层学习通道权重：[batch_size, channels] → [batch_size, channels]channel_weights = self.fc(avg_pool_output)# 4. 重塑为二维张量：[batch_size, channels] → [batch_size, channels, 1, 1]channel_weights = channel_weights.view(batch_size, channels, 1, 1)# 5. 将权重应用到原始特征图上（逐通道相乘）return x * channel_weights  # 输出形状：[batch_size, channels, height, width]

通道注意力模块的核心原理

1. Squeeze（压缩）：

- 通过全局平均池化将每个通道的二维特征图（H×W）压缩为一个标量，保留通道的全局信息。

- 物理意义：计算每个通道在整个图像中的 “平均响应强度”，例如，“边缘检测通道” 在有物体边缘的图像中响应值会更高。

2. Excitation（激发）：

- 通过全连接层 + Sigmoid 激活，学习通道间的依赖关系，输出 0-1 之间的权重值。

- 物理意义：让模型自动判断哪些通道更重要（权重接近 1），哪些通道可忽略（权重接近 0）。

3. Reweight（重加权）：

- 将学习到的通道权重与原始特征图逐通道相乘，增强重要通道，抑制不重要通道。

- 物理意义：类似人类视觉系统聚焦于关键特征（如猫的轮廓），忽略无关特征（如背景颜色）

通道注意力插入后，参数量略微提高，增加了特征提取能力。

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

class CNN(nn.Module):def __init__(self):super(CNN, self).__init__()  # ---------------------- 第一个卷积块 ----------------------self.conv1 = nn.Conv2d(3, 32, 3, padding=1)self.bn1 = nn.BatchNorm2d(32)self.relu1 = nn.ReLU()# 新增：插入通道注意力模块（SE模块）self.ca1 = ChannelAttention(in_channels=32, reduction_ratio=16)  self.pool1 = nn.MaxPool2d(2, 2)  # ---------------------- 第二个卷积块 ----------------------self.conv2 = nn.Conv2d(32, 64, 3, padding=1)self.bn2 = nn.BatchNorm2d(64)self.relu2 = nn.ReLU()# 新增：插入通道注意力模块（SE模块）self.ca2 = ChannelAttention(in_channels=64, reduction_ratio=16)  self.pool2 = nn.MaxPool2d(2)  # ---------------------- 第三个卷积块 ----------------------self.conv3 = nn.Conv2d(64, 128, 3, padding=1)self.bn3 = nn.BatchNorm2d(128)self.relu3 = nn.ReLU()# 新增：插入通道注意力模块（SE模块）self.ca3 = ChannelAttention(in_channels=128, reduction_ratio=16)  self.pool3 = nn.MaxPool2d(2)  # ---------------------- 全连接层（分类器） ----------------------self.fc1 = nn.Linear(128 * 4 * 4, 512)self.dropout = nn.Dropout(p=0.5)self.fc2 = nn.Linear(512, 10)def forward(self, x):# ---------- 卷积块1处理 ----------x = self.conv1(x)       x = self.bn1(x)         x = self.relu1(x)       x = self.ca1(x)  # 应用通道注意力x = self.pool1(x)       # ---------- 卷积块2处理 ----------x = self.conv2(x)       x = self.bn2(x)         x = self.relu2(x)       x = self.ca2(x)  # 应用通道注意力x = self.pool2(x)       # ---------- 卷积块3处理 ----------x = self.conv3(x)       x = self.bn3(x)         x = self.relu3(x)       x = self.ca3(x)  # 应用通道注意力x = self.pool3(x)       # ---------- 展平与全连接层 ----------x = x.view(-1, 128 * 4 * 4)  x = self.fc1(x)           x = self.relu3(x)         x = self.dropout(x)       x = self.fc2(x)           return x  # 重新初始化模型，包含通道注意力模块
model = CNN()
model = model.to(device)  # 将模型移至GPU（如果可用）criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器# 引入学习率调度器，在训练过程中动态调整学习率--训练初期使用较大的 LR 快速降低损失，训练后期使用较小的 LR 更精细地逼近全局最优解。
# 在每个 epoch 结束后，需要手动调用调度器来更新学习率，可以在训练过程中调用 scheduler.step()
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,        # 指定要控制的优化器（这里是Adam）mode='min',       # 监测的指标是"最小化"（如损失函数）patience=3,       # 如果连续3个epoch指标没有改善，才降低LRfactor=0.5        # 降低LR的比例（新LR = 旧LR × 0.5）
)

# 训练模型（复用原有的train函数）
print("开始训练带通道注意力的CNN模型...")
final_accuracy = train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs=50)
print(f"训练完成！最终测试准确率: {final_accuracy:.2f}%")

在同样50个epoch后精度略有提升

我们关注的不只是精度的差异，还包含了同精度下训练时长的差异等，在大规模数据集上推理时长、训练时长都非常重要。因为资源是有限的。

可视化部分同理，在训练完成后通过钩子函数取出权重or梯度，即可进行特征图的可视化、Grad-CAM可视化、注意力热图可视化

# 可视化空间注意力热力图（显示模型关注的图像区域）
def visualize_attention_map(model, test_loader, device, class_names, num_samples=3):"""可视化模型的注意力热力图，展示模型关注的图像区域"""model.eval()  # 设置为评估模式with torch.no_grad():for i, (images, labels) in enumerate(test_loader):if i >= num_samples:  # 只可视化前几个样本breakimages, labels = images.to(device), labels.to(device)# 创建一个钩子，捕获中间特征图activation_maps = []def hook(module, input, output):activation_maps.append(output.cpu())# 为最后一个卷积层注册钩子（获取特征图）hook_handle = model.conv3.register_forward_hook(hook)# 前向传播，触发钩子outputs = model(images)# 移除钩子hook_handle.remove()# 获取预测结果_, predicted = torch.max(outputs, 1)# 获取原始图像img = images[0].cpu().permute(1, 2, 0).numpy()# 反标准化处理img = img * np.array([0.2023, 0.1994, 0.2010]).reshape(1, 1, 3) + np.array([0.4914, 0.4822, 0.4465]).reshape(1, 1, 3)img = np.clip(img, 0, 1)# 获取激活图（最后一个卷积层的输出）feature_map = activation_maps[0][0].cpu()  # 取第一个样本# 计算通道注意力权重（使用SE模块的全局平均池化）channel_weights = torch.mean(feature_map, dim=(1, 2))  # [C]# 按权重对通道排序sorted_indices = torch.argsort(channel_weights, descending=True)# 创建子图fig, axes = plt.subplots(1, 4, figsize=(16, 4))# 显示原始图像axes[0].imshow(img)axes[0].set_title(f'原始图像\n真实: {class_names[labels[0]]}\n预测: {class_names[predicted[0]]}')axes[0].axis('off')# 显示前3个最活跃通道的热力图for j in range(3):channel_idx = sorted_indices[j]# 获取对应通道的特征图channel_map = feature_map[channel_idx].numpy()# 归一化到[0,1]channel_map = (channel_map - channel_map.min()) / (channel_map.max() - channel_map.min() + 1e-8)# 调整热力图大小以匹配原始图像from scipy.ndimage import zoomheatmap = zoom(channel_map, (32/feature_map.shape[1], 32/feature_map.shape[2]))# 显示热力图axes[j+1].imshow(img)axes[j+1].imshow(heatmap, alpha=0.5, cmap='jet')axes[j+1].set_title(f'注意力热力图 - 通道 {channel_idx}')axes[j+1].axis('off')plt.tight_layout()plt.show()# 调用可视化函数
visualize_attention_map(model, test_loader, device, class_names, num_samples=3)