P16周：DenseNet+SE-Net实战_猴痘病毒

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊

一、 前期准备

1. 导入库

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib
import os,PIL,random,pathlib
import torch.nn.functional as F
from PIL import Image
import matplotlib.pyplot as plt
#隐藏警告
import warnings

2.导入数据

data_dir = './data/4-data/'
data_dir = pathlib.Path(data_dir)
#print(data_dir)
data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[2] for path in data_paths]
#print(classeNames)
total_datadir = './data/4-data/'


train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

total_data = datasets.ImageFolder(total_datadir,transform=train_transforms)

3.划分数据集

train_size = int(0.8 * len(total_data))
test_size  = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                          batch_size=batch_size,
                                          shuffle=True,
                                          num_workers=1)

二、模型设计

1. 神经网络的搭建

class SqueezeExcitation(nn.Module):
    def __init__(self, in_channels, reduced_dim):
        super(SqueezeExcitation, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc1 = nn.Linear(in_channels, reduced_dim)
        self.fc2 = nn.Linear(reduced_dim, in_channels)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        batch_size, channels, _, _ = x.size()
        squeeze = self.avg_pool(x).view(batch_size, channels)
        excitation = self.fc1(squeeze)
        excitation = self.relu(excitation)
        excitation = self.fc2(excitation)
        excitation = self.sigmoid(excitation).view(batch_size, channels, 1, 1)
        scaled = x * excitation
        return scaled


class ConvBlock(nn.Module):
    def __init__(self, input_channels, growth_rate):
        super(ConvBlock, self).__init__()
        self.norm1 = nn.BatchNorm2d(input_channels)
        self.conv1 = nn.Conv2d(input_channels, 4 * growth_rate, kernel_size=1, bias=False)
        self.norm2 = nn.BatchNorm2d(4 * growth_rate)
        self.conv2 = nn.Conv2d(4 * growth_rate, growth_rate, kernel_size=3, padding=1, bias=False)

    def forward(self, x):
        out = self.conv1(F.relu(self.norm1(x)))
        out = self.conv2(F.relu(self.norm2(out)))
        return torch.cat([x, out], 1)


class DenseBlock(nn.Module):
    def __init__(self, num_layers, input_channels, growth_rate):
        super(DenseBlock, self).__init__()
        layers = []
        for i in range(num_layers):
            layers.append(ConvBlock(input_channels + i * growth_rate, growth_rate))
        self.layers = nn.Sequential(*layers)

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


class TransitionBlock(nn.Module):
    def __init__(self, input_channels, output_channels):
        super(TransitionBlock, self).__init__()
        self.norm = nn.BatchNorm2d(input_channels)
        self.conv = nn.Conv2d(input_channels, output_channels, kernel_size=1, bias=False)
        self.pool = nn.AvgPool2d(2, stride=2)

    def forward(self, x):
        x = self.conv(F.relu(self.norm(x)))
        return self.pool(x)


class DenseNet121(nn.Module):
    def __init__(self, num_classes=4, growth_rate=32):
        super(DenseNet121, self).__init__()
        self.growth_rate = growth_rate

        # Initial convolution
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.norm1 = nn.BatchNorm2d(64)
        self.pool = nn.MaxPool2d(3, stride=2, padding=1)

        # Dense blocks
        self.dense1 = DenseBlock(6, 64, growth_rate)
        self.trans1 = TransitionBlock(64 + 6 * growth_rate, 128)

        self.dense2 = DenseBlock(12, 128, growth_rate)
        self.trans2 = TransitionBlock(128 + 12 * growth_rate, 256)

        self.dense3 = DenseBlock(24, 256, growth_rate)
        self.trans3 = TransitionBlock(256 + 24 * growth_rate, 512)

        self.dense4 = DenseBlock(16, 512, growth_rate)

        # SE Module
        final_channels = 512 + 16 * growth_rate
        self.se = SqueezeExcitation(final_channels, 16)

        # Final layers
        self.norm_final = nn.BatchNorm2d(final_channels)
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(final_channels, num_classes)

    def forward(self, x):
        x = F.relu(self.norm1(self.conv1(x)))
        x = self.pool(x)

        x = self.dense1(x)
        x = self.trans1(x)

        x = self.dense2(x)
        x = self.trans2(x)

        x = self.dense3(x)
        x = self.trans3(x)

        x = self.dense4(x)
        x = self.se(x)

        x = F.relu(self.norm_final(x))
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)
        return x

2.设置损失值等超参数

model = DenseNet121(num_classes=len(classeNames)).to(device)
#print(device)

loss_fn = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4 # 学习率
opt = torch.optim.SGD(model.parameters(),lr=learn_rate)
epochs = 20
train_loss = []
train_acc = []
test_loss = []
test_acc = []

3. 设置训练函数

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片
    num_batches = len(dataloader)  # 批次数目，1875（60000/32）

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)

        # 计算预测误差
        pred = model(X)  # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()  # 反向传播
        optimizer.step()  # 每一步自动更新

        # 记录acc与loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss

4. 设置测试函数

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 测试集的大小，一共10000张图片
    num_batches = len(dataloader)  # 批次数目，313（10000/32=312.5，向上取整）
    test_loss, test_acc = 0, 0

    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

5. 创建导入本地图片预处理模块

def predict_one_image(image_path, model, transform, classes):

    test_img = Image.open(image_path).convert('RGB')
    # plt.imshow(test_img)  # 展示预测的图片

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)

    model.eval()
    output = model(img)

    _, pred = torch.max(output, 1)
    pred_class = classes[pred]
    print(f'预测结果是：{pred_class}')

6. 主函数

if __name__ == '__main__':
    for epoch in range(epochs):
        model.train()
        epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

        model.eval()
        epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

        train_acc.append(epoch_train_acc)
        train_loss.append(epoch_train_loss)
        test_acc.append(epoch_test_acc)
        test_loss.append(epoch_test_loss)

        template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}')
        print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss))
    print('Done')

    warnings.filterwarnings("ignore")  # 忽略警告信息
    plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
    plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
    plt.rcParams['figure.dpi'] = 100  # 分辨率

    epochs_range = range(epochs)

    plt.figure(figsize=(12, 3))
    plt.subplot(1, 2, 1)

    plt.plot(epochs_range, train_acc, label='Training Accuracy')
    plt.plot(epochs_range, test_acc, label='Test Accuracy')
    plt.legend(loc='lower right')
    plt.title('Training and Validation Accuracy')

    plt.subplot(1, 2, 2)
    plt.plot(epochs_range, train_loss, label='Training Loss')
    plt.plot(epochs_range, test_loss, label='Test Loss')
    plt.legend(loc='upper right')
    plt.title('Training and Validation Loss')
    plt.show()

    classes = list(total_data.class_to_idx)
    predict_one_image(image_path='./data/4-data/Monkeypox/M01_01_00.jpg',
                      model=model,
                      transform=train_transforms,
                      classes=classes)

结果

Epoch: 1, Train_acc:46.4%, Train_loss:0.725, Test_acc:46.6%，Test_loss:0.700
Epoch: 2, Train_acc:51.8%, Train_loss:0.689, Test_acc:54.3%，Test_loss:0.672
Epoch: 3, Train_acc:57.5%, Train_loss:0.671, Test_acc:61.3%，Test_loss:0.658
Epoch: 4, Train_acc:62.9%, Train_loss:0.659, Test_acc:63.2%，Test_loss:0.648
Epoch: 5, Train_acc:65.4%, Train_loss:0.651, Test_acc:64.6%，Test_loss:0.641
Epoch: 6, Train_acc:65.0%, Train_loss:0.648, Test_acc:65.0%，Test_loss:0.634
Epoch: 7, Train_acc:66.8%, Train_loss:0.642, Test_acc:67.1%，Test_loss:0.633
Epoch: 8, Train_acc:66.1%, Train_loss:0.636, Test_acc:66.2%，Test_loss:0.624
Epoch: 9, Train_acc:65.8%, Train_loss:0.636, Test_acc:66.7%，Test_loss:0.623
Epoch:10, Train_acc:67.0%, Train_loss:0.627, Test_acc:66.0%，Test_loss:0.622
Done
Done

三、DenseNet系列算法中插入SE-Net通道注意力机制

---

1. 技术原理

• DenseNet的核心思想：
  通过密集连接（Dense Connection），使每一层的输入来自前面所有层的输出，实现特征复用和梯度高效传播，缓解梯度消失问题。
• SE-Net的核心思想：
  通过Squeeze-and-Excitation模块动态调整通道权重，增强重要通道的响应，抑制无关通道。具体步骤包括：
  1. Squeeze：全局平均池化（Global Average Pooling）压缩空间信息，生成通道描述向量。
  2. Excitation：通过全连接层（或瓶颈结构）学习通道间非线性关系，生成通道权重。
  3. Scale：将权重与原特征图相乘，完成通道加权。

---

2. 插入SE模块的实现方式

在DenseNet中插入SE模块的常见位置包括：

• 在每个Dense Block内部：
  在Dense Block的每个卷积层后插入SE模块（例如在每个Conv+BN+ReLU后），增强局部特征的通道注意力。
• 在相邻Dense Block之间：
  在Transition Layer（包含池化和1×1卷积）后插入SE模块，对全局特征进行通道重标定。
• 混合插入策略：
  根据计算资源权衡，选择性地在关键位置插入SE模块（例如仅在某些Dense Block中使用）。

---

3. 优势分析

1. 增强特征选择能力：
   SE模块通过通道注意力机制，使DenseNet更关注对当前任务重要的特征通道，抑制冗余信息，尤其适合密集连接中特征高度复用的情况。
2. 提升模型鲁棒性：
   在复杂场景（如遮挡、噪声）下，通道注意力能动态调整特征权重，提升模型对关键区域的敏感性。
3. 兼容性强：
   SE模块是轻量级的，增加的参数量和计算量较小（主要来自全连接层），适合嵌入到DenseNet的密集连接结构中。
4. 可解释性改进：
   通道权重可视化可帮助理解模型关注的特征类型。

---

4. 本文实现的方式

在提供的代码中，SE-Net通道注意力模块（SqueezeExcitation）被插入在最后一个Dense Block的输出之后，具体位置如下图所示：

[DenseBlock1] → [Transition1] → [DenseBlock2] → [Transition2] → [DenseBlock3] → [Transition3] → [DenseBlock4] → [SE模块] → [全局池化+分类头]

关键实现分析

（1） SE模块插入位置

• 位置：仅在网络的最后一个Dense Block（dense4）的输出后插入SE模块。
• 作用范围：仅对最终输出的特征图进行通道权重调整，影响分类前的特征表示。
• 对应代码片段：

  class DenseNet121(nn.Module):
      def __init__(self, num_classes=4, growth_rate=32):
          # ...（前面的层定义）
          # 最后一个Dense Block的输出通道数计算
          final_channels = 512 + 16 * growth_rate
          # SE模块插入在此处
          self.se = SqueezeExcitation(final_channels, 16)
  
      def forward(self, x):
          # ...（前向传播到最后一个Dense Block）
          x = self.dense4(x)
          x = self.se(x)  # 应用SE模块
          # ...（后续分类头）
  

（2） SE模块设计

• 实现细节：
  • 使用全局平均池化（AdaptiveAvgPool2d(1)）压缩空间维度。
  • 两个全连接层（fc1和fc2）生成通道权重，reduction_ratio=16。
  • 通过Sigmoid激活生成权重后，对原特征图进行通道加权。
• 代码验证：

  class SqueezeExcitation(nn.Module):
      def __init__(self, in_channels, reduced_dim):
          super().__init__()
          self.avg_pool = nn.AdaptiveAvgPool2d(1)
          self.fc1 = nn.Linear(in_channels, reduced_dim)
          self.fc2 = nn.Linear(reduced_dim, in_channels)
          self.relu = nn.ReLU()
          self.sigmoid = nn.Sigmoid()
  
      def forward(self, x):
          batch_size, channels = x.size(0), x.size(1)
          squeeze = self.avg_pool(x).view(batch_size, channels)
          excitation = self.relu(self.fc1(squeeze))
          excitation = self.sigmoid(self.fc2(excitation))
          excitation = excitation.view(batch_size, channels, 1, 1)
          return x * excitation
  

（3） 与DenseNet原结构的对比

• 原版DenseNet-121流程：

  [DenseBlock1] → [Transition1] → [DenseBlock2] → [Transition2] → [DenseBlock3] → [Transition3] → [DenseBlock4] → [分类头]
  

• SE插入后的流程：

  [DenseBlock1] → [Transition1] → ... → [DenseBlock4] → [SE模块] → [分类头]
  

---

插入方式的优缺点

✅ 优势

1. 计算成本低：
   仅添加一个SE模块，参数量增加极小（例如final_channels=1024时，SE模块参数量为 1024 + (1024//16)*1024 ≈ 65K），对整体计算量影响较小。
2. 分类任务适配性：
   最终特征图包含高层语义信息，通过SE模块增强关键通道，可能直接提升分类精度。
3. 实现简单：
   无需修改Dense Block内部结构，代码侵入性低。

❌ 局限性

1. 局部特征未被优化：
   SE模块仅作用于最后一层，无法对中间层的特征通道进行动态调整，忽略了DenseNet中多层特征复用的特性。
2. 通道冗余风险：
   深层特征可能因密集连接积累大量冗余通道，仅末端调整可能无法充分抑制噪声。
3. 轻量化改进空间：
   若在多个Dense Block后插入SE模块（如每个Transition后），可能进一步提升性能，但需权衡计算开销。

---

总结

在DenseNet中插入SE模块是一种低成本、高收益的改进策略，通过通道注意力机制增强模型的特征选择能力，尤其适合需要高精度但对计算资源不敏感的场景。实际应用中需根据任务需求权衡计算开销和性能提升，并通过消融实验确定最佳插入位置和参数配置。