【Python打卡Day50】預訓練模型與CBAM注意力@浙大疏錦行

現在我們思考下，是否可以對于預訓練模型增加模塊來優化其效果，這里我們會遇到一個問題:

預訓練模型的結構和權重是固定的，如果修改其中的模型結構，是否會大幅影響其性能。其次是訓練的時候如何訓練才可以更好的避免破壞原有的特征提取器的參數。

所以今天的內容，我們需要回答2個問題。

1. resnet18中如何插入cbam模塊？

2. 采用什么樣的預訓練策略，能夠更好的提高效率？

可以很明顯的想到，如果是resnet18+cbam模塊，那么大多數地方的代碼都是可以復用的，模型定義部分需要重寫。先繼續之前的代碼

所以很容易的想到之前第一次使用resnet的預訓練策略：先凍結預訓練層，然后訓練其他層。之前的其它層是全連接層（分類頭），現在其它層還包含了每一個殘差塊中的cbam注意力層。

一、resnet結構解析

先復用下數據預處理+定義cbam的代碼，然后看下resnet內部的結構是什么，這決定我們如何插入模塊

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# 定義通道注意力
class ChannelAttention(nn.Module):def __init__(self, in_channels, ratio=16):"""通道注意力機制初始化參數:in_channels: 輸入特征圖的通道數ratio: 降維比例，用于減少參數量，默認為16"""super().__init__()# 全局平均池化，將每個通道的特征圖壓縮為1x1，保留通道間的平均值信息self.avg_pool = nn.AdaptiveAvgPool2d(1)# 全局最大池化，將每個通道的特征圖壓縮為1x1，保留通道間的最顯著特征self.max_pool = nn.AdaptiveMaxPool2d(1)# 共享全連接層，用于學習通道間的關系# 先降維（除以ratio），再通過ReLU激活，最后升維回原始通道數self.fc = nn.Sequential(nn.Linear(in_channels, in_channels // ratio, bias=False),  # 降維層nn.ReLU(),  # 非線性激活函數nn.Linear(in_channels // ratio, in_channels, bias=False)   # 升維層)# Sigmoid函數將輸出映射到0-1之間，作為各通道的權重self.sigmoid = nn.Sigmoid()def forward(self, x):"""前向傳播函數參數:x: 輸入特征圖，形狀為 [batch_size, channels, height, width]返回:調整后的特征圖，通道權重已應用"""# 獲取輸入特征圖的維度信息，這是一種元組的解包寫法b, c, h, w = x.shape# 對平均池化結果進行處理：展平后通過全連接網絡avg_out = self.fc(self.avg_pool(x).view(b, c))# 對最大池化結果進行處理：展平后通過全連接網絡max_out = self.fc(self.max_pool(x).view(b, c))# 將平均池化和最大池化的結果相加并通過sigmoid函數得到通道權重attention = self.sigmoid(avg_out + max_out).view(b, c, 1, 1)# 將注意力權重與原始特征相乘，增強重要通道，抑制不重要通道return x * attention #這個運算是pytorch的廣播機制## 空間注意力模塊
class SpatialAttention(nn.Module):def __init__(self, kernel_size=7):super().__init__()self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2, bias=False)self.sigmoid = nn.Sigmoid()def forward(self, x):# 通道維度池化avg_out = torch.mean(x, dim=1, keepdim=True)  # 平均池化：(B,1,H,W)max_out, _ = torch.max(x, dim=1, keepdim=True)  # 最大池化：(B,1,H,W)pool_out = torch.cat([avg_out, max_out], dim=1)  # 拼接：(B,2,H,W)attention = self.conv(pool_out)  # 卷積提取空間特征return x * self.sigmoid(attention)  # 特征與空間權重相乘## CBAM模塊
class CBAM(nn.Module):def __init__(self, in_channels, ratio=16, kernel_size=7):super().__init__()self.channel_attn = ChannelAttention(in_channels, ratio)self.spatial_attn = SpatialAttention(kernel_size)def forward(self, x):x = self.channel_attn(x)x = self.spatial_attn(x)return ximport 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}")# 數據預處理（與原代碼一致）
train_transform = transforms.Compose([transforms.RandomCrop(32, padding=4),transforms.RandomHorizontalFlip(),transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),transforms.RandomRotation(15),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))
])# 加載數據集（與原代碼一致）
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transform)
test_dataset = datasets.CIFAR10(root='./data', train=False, transform=test_transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

使用設備: cuda

先通過預訓練resnet18來查看模型結構

import torch
import torchvision.models as models
from torchinfo import summary #之前的內容說了，推薦用他來可視化模型結構，信息最全# 加載 ResNet18（預訓練）
model = models.resnet18(pretrained=True)
model.eval()# 輸出模型結構和參數概要
summary(model, input_size=(1, 3, 224, 224))

==========================================================================================
Layer (type:depth-idx) ? ? ? ? ? ? ? ? ? Output Shape ? ? ? ? ? ? ?Param #
==========================================================================================
ResNet ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? [1, 1000] ? ? ? ? ? ? ? ? --
├─Conv2d: 1-1 ? ? ? ? ? ? ? ? ? ? ? ? ? ?[1, 64, 112, 112] ? ? ? ? 9,408
├─BatchNorm2d: 1-2 ? ? ? ? ? ? ? ? ? ? ? [1, 64, 112, 112] ? ? ? ? 128
├─ReLU: 1-3 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?[1, 64, 112, 112] ? ? ? ? --
├─MaxPool2d: 1-4 ? ? ? ? ? ? ? ? ? ? ? ? [1, 64, 56, 56] ? ? ? ? ? --
├─Sequential: 1-5 ? ? ? ? ? ? ? ? ? ? ? ?[1, 64, 56, 56] ? ? ? ? ? --
│ ? ?└─BasicBlock: 2-1 ? ? ? ? ? ? ? ? ? [1, 64, 56, 56] ? ? ? ? ? --
│ ? ?│ ? ?└─Conv2d: 3-1 ? ? ? ? ? ? ? ? ?[1, 64, 56, 56] ? ? ? ? ? 36,864
│ ? ?│ ? ?└─BatchNorm2d: 3-2 ? ? ? ? ? ? [1, 64, 56, 56] ? ? ? ? ? 128
│ ? ?│ ? ?└─ReLU: 3-3 ? ? ? ? ? ? ? ? ? ?[1, 64, 56, 56] ? ? ? ? ? --
│ ? ?│ ? ?└─Conv2d: 3-4 ? ? ? ? ? ? ? ? ?[1, 64, 56, 56] ? ? ? ? ? 36,864
│ ? ?│ ? ?└─BatchNorm2d: 3-5 ? ? ? ? ? ? [1, 64, 56, 56] ? ? ? ? ? 128
│ ? ?│ ? ?└─ReLU: 3-6 ? ? ? ? ? ? ? ? ? ?[1, 64, 56, 56] ? ? ? ? ? --
│ ? ?└─BasicBlock: 2-2 ? ? ? ? ? ? ? ? ? [1, 64, 56, 56] ? ? ? ? ? --
│ ? ?│ ? ?└─Conv2d: 3-7 ? ? ? ? ? ? ? ? ?[1, 64, 56, 56] ? ? ? ? ? 36,864
│ ? ?│ ? ?└─BatchNorm2d: 3-8 ? ? ? ? ? ? [1, 64, 56, 56] ? ? ? ? ? 128
│ ? ?│ ? ?└─ReLU: 3-9 ? ? ? ? ? ? ? ? ? ?[1, 64, 56, 56] ? ? ? ? ? --
│ ? ?│ ? ?└─Conv2d: 3-10 ? ? ? ? ? ? ? ? [1, 64, 56, 56] ? ? ? ? ? 36,864
│ ? ?│ ? ?└─BatchNorm2d: 3-11 ? ? ? ? ? ?[1, 64, 56, 56] ? ? ? ? ? 128
│ ? ?│ ? ?└─ReLU: 3-12 ? ? ? ? ? ? ? ? ? [1, 64, 56, 56] ? ? ? ? ? --
├─Sequential: 1-6 ? ? ? ? ? ? ? ? ? ? ? ?[1, 128, 28, 28] ? ? ? ? ?--
│ ? ?└─BasicBlock: 2-3 ? ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-13 ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?73,728
│ ? ?│ ? ?└─BatchNorm2d: 3-14 ? ? ? ? ? ?[1, 128, 28, 28] ? ? ? ? ?256
│ ? ?│ ? ?└─ReLU: 3-15 ? ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-16 ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?147,456
│ ? ?│ ? ?└─BatchNorm2d: 3-17 ? ? ? ? ? ?[1, 128, 28, 28] ? ? ? ? ?256
│ ? ?│ ? ?└─Sequential: 3-18 ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?8,448
│ ? ?│ ? ?└─ReLU: 3-19 ? ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?--
│ ? ?└─BasicBlock: 2-4 ? ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-20 ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?147,456
│ ? ?│ ? ?└─BatchNorm2d: 3-21 ? ? ? ? ? ?[1, 128, 28, 28] ? ? ? ? ?256
│ ? ?│ ? ?└─ReLU: 3-22 ? ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-23 ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?147,456
│ ? ?│ ? ?└─BatchNorm2d: 3-24 ? ? ? ? ? ?[1, 128, 28, 28] ? ? ? ? ?256
│ ? ?│ ? ?└─ReLU: 3-25 ? ? ? ? ? ? ? ? ? [1, 128, 28, 28] ? ? ? ? ?--
├─Sequential: 1-7 ? ? ? ? ? ? ? ? ? ? ? ?[1, 256, 14, 14] ? ? ? ? ?--
│ ? ?└─BasicBlock: 2-5 ? ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-26 ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?294,912
│ ? ?│ ? ?└─BatchNorm2d: 3-27 ? ? ? ? ? ?[1, 256, 14, 14] ? ? ? ? ?512
│ ? ?│ ? ?└─ReLU: 3-28 ? ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-29 ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?589,824
│ ? ?│ ? ?└─BatchNorm2d: 3-30 ? ? ? ? ? ?[1, 256, 14, 14] ? ? ? ? ?512
│ ? ?│ ? ?└─Sequential: 3-31 ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?33,280
│ ? ?│ ? ?└─ReLU: 3-32 ? ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?--
│ ? ?└─BasicBlock: 2-6 ? ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-33 ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?589,824
│ ? ?│ ? ?└─BatchNorm2d: 3-34 ? ? ? ? ? ?[1, 256, 14, 14] ? ? ? ? ?512
│ ? ?│ ? ?└─ReLU: 3-35 ? ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-36 ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?589,824
│ ? ?│ ? ?└─BatchNorm2d: 3-37 ? ? ? ? ? ?[1, 256, 14, 14] ? ? ? ? ?512
│ ? ?│ ? ?└─ReLU: 3-38 ? ? ? ? ? ? ? ? ? [1, 256, 14, 14] ? ? ? ? ?--
├─Sequential: 1-8 ? ? ? ? ? ? ? ? ? ? ? ?[1, 512, 7, 7] ? ? ? ? ? ?--
│ ? ?└─BasicBlock: 2-7 ? ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-39 ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?1,179,648
│ ? ?│ ? ?└─BatchNorm2d: 3-40 ? ? ? ? ? ?[1, 512, 7, 7] ? ? ? ? ? ?1,024
│ ? ?│ ? ?└─ReLU: 3-41 ? ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-42 ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?2,359,296
│ ? ?│ ? ?└─BatchNorm2d: 3-43 ? ? ? ? ? ?[1, 512, 7, 7] ? ? ? ? ? ?1,024
│ ? ?│ ? ?└─Sequential: 3-44 ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?132,096
│ ? ?│ ? ?└─ReLU: 3-45 ? ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?--
│ ? ?└─BasicBlock: 2-8 ? ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-46 ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?2,359,296
│ ? ?│ ? ?└─BatchNorm2d: 3-47 ? ? ? ? ? ?[1, 512, 7, 7] ? ? ? ? ? ?1,024
│ ? ?│ ? ?└─ReLU: 3-48 ? ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?--
│ ? ?│ ? ?└─Conv2d: 3-49 ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?2,359,296
│ ? ?│ ? ?└─BatchNorm2d: 3-50 ? ? ? ? ? ?[1, 512, 7, 7] ? ? ? ? ? ?1,024
│ ? ?│ ? ?└─ReLU: 3-51 ? ? ? ? ? ? ? ? ? [1, 512, 7, 7] ? ? ? ? ? ?--
├─AdaptiveAvgPool2d: 1-9 ? ? ? ? ? ? ? ? [1, 512, 1, 1] ? ? ? ? ? ?--
├─Linear: 1-10 ? ? ? ? ? ? ? ? ? ? ? ? ? [1, 1000] ? ? ? ? ? ? ? ? 513,000
==========================================================================================
Total params: 11,689,512
Trainable params: 11,689,512
Non-trainable params: 0
Total mult-adds (Units.GIGABYTES): 1.81
==========================================================================================
Input size (MB): 0.60
Forward/backward pass size (MB): 39.75
Params size (MB): 46.76
Estimated Total Size (MB): 87.11
==========================================================================================

1.1 ResNet-18流程

經典的 ResNet-18 模型可以將其看作一個處理流水線，圖像數據從一端進去，分類結果從另一端出來。整個過程可以分為三個主要部分：

輸入預處理 (Stem)：對應層級為?Conv2d: 1-1?到?MaxPool2d: 1-4。主要作用是對輸入圖像進行初步的特征提取，并通過池化操作將特征圖尺寸減半，為后續處理做準備。
核心特征提取：對應層級為四個?Sequential?模塊 (1-5?到?1-8)。這是網絡的主體，由多個殘差塊（BasicBlock）堆疊而成，負責從淺到深、從粗到細地學習圖像特征。
分類輸出 (Head)：對應層級為?AdaptiveAvgPool2d: 1-9?和?Linear: 1-10。主要作用是將最終的特征圖（feature map）轉換成一個特征向量，并通過全連接層映射到最終的 1000 個類別上

假設輸入圖像尺寸為 `[1, 3, 224, 224]` (Batch, Channels, Height, Width)，具體shape變化如下

1.2 basic block

這里我們先介紹下basic block，他是殘差網絡最重要的思想，在 ResNet 出現之前，人們普遍認為神經網絡越深，性能就越好。但實踐發現，當網絡堆疊到一定深度后，再增加層數，模型的準確率反而會下降。這種現象不叫“過擬合”（Overfitting），因為不光是測試集，連訓練集上的準確率都在下降。這被稱為 “網絡退化”（Degradation）問題。

本質是因為卷積和池化都是在做下采樣的過程，越深雖然能夠提取越重要的信息，但是很多重要的信息都被丟棄了。它意味著，讓一個很深的網絡去學習一個簡單的恒等變換（即輸出 = 輸入）都非常困難。

BasicBlock 的設計者何愷明博士等人提出了一個絕妙的想法：與其讓網絡層直接學習一個目標映射 H(x)，不如讓它學習這個映射與輸入 x 之間的“差值”，即殘差（Residual）F(x) = H(x) - x。這樣，原始的目標映射就變成了 H(x) = F(x) + x

這個簡單的改動為什么如此強大？

簡化學習目標：想象一個極端情況，如果某一層的最佳狀態就是“什么都不做”（即恒等變換 H(x)=x），那么網絡只需要讓殘差部分 F(x) 的輸出為 0 即可。讓權重趨向于 0 比讓一堆非線性層擬合一個恒等變換要容易得多。

信息高速公路： + x 這部分操作被稱為“快捷連接”（Shortcut Connection）或“跳躍連接”（Skip Connection）。它像一條高速公路，允許輸入信息 x 直接“跳”到更深的層，避免了在層層傳遞中信息丟失或梯度消失的問題。

一個標準的 BasicBlock 通常包含兩條路徑

????????1. 主路 (Main Path)：這是學習“殘差” F(x) 的部分。在 ResNet-18 中，它由兩個 3x3 的卷積層構成。

Conv2d: 3-1 (3x3 卷積)-->BatchNorm2d: 3-2 (批歸一化)-->ReLU: 3-3 (激活函數)-->Conv2d: 3-4 (3x3 卷積)-->BatchNorm2d: 3-5 (批歸一化)

????????2. 捷徑 (Shortcut Path)：這就是 + x 的部分，直接將輸入 x 傳遞過來。

最后，將主路的輸出和捷徑的輸出按元素相加，再經過一個 ReLU 激活函數，得到整個 BasicBlock 的最終輸出。

二、 cbam的放置位置

實際上，被公認為正確的做法是，在每一個殘差塊的輸出上應用CBAM注意力。你可能會想，這樣不是會影響后續的輸出，尤其最開始注意力權重交叉的話，很可能導致后續預訓練層的權重沒有價值了。

實際，CBAM模塊自身的結構——初始狀態接近“直通”，這是最核心的技術原因導致可以采用這個結構。CBAM模塊的最終操作是：return x * self.sigmoid(attention)。這里的 x 是原始特征；attention 是學到的注意力圖。

1. 初始狀態分析：在一個模塊被隨機初始化（還未開始訓練）時，其內部的卷積層和全連接層的權重都非常小，接近于0。因此，計算出的 attention 圖的值也都會非常接近0。

2. Sigmoid函數的特性：當輸入為0時，sigmoid(0) 的輸出是 0.5。這意味著在訓練剛開始的第一步，CBAM模塊的操作近似于 x * 0.5。它并沒有用一個完全隨機的、混亂的特征圖去替換原始特征 x。它只是將原始特征 x 按比例縮小了一半。

縮小0.5只是對特征數值尺度的縮放，它完整地保留了原始特征圖中的空間結構和相對關系。下游的預訓練層接收到的不再是“垃圾”，而是一個信號稍弱但結構完好的原始特征。這為后續的學習提供了一個非常穩定的起點。

如果CBAM無用：網絡可以通過學習，讓 attention 圖的值都趨近于一個常數，相當于一個固定的縮放。在更理想的情況下，如果能讓 attention 圖的值都趨近于 sigmoid 函數的反函數中對應輸出為1的值，那么CBAM就近似于一個“直通車”(x * 1 = x)，網絡可以選擇“忽略”它。

如果CBAM有用：網絡會迅速學會調整權重，讓 attention 圖中重要的地方值接近1，不重要的地方值接近0，從而實現特征的增強。

所以完全可以在不破壞其核心結構的情況下，將CBAM模塊無縫地“注入”到預訓練的ResNet中。這樣做的邏輯是：

1. 保留原始結構：原始的殘差塊負責提取核心特征。

2. 增強特征：緊隨其后的CBAM模塊對這些提取出的特征進行“精煉”，告訴模型應該“關注什么”（what - 通道注意力）和“在哪里關注”（where - 空間注意力）。

3. 不破壞預訓練權重：原始殘差塊的預訓練權重得以完整保留，我們只是在其后增加了一個新的、需要從頭學習的模塊。

import torch
import torch.nn as nn
from torchvision import models# 自定義ResNet18模型，插入CBAM模塊
class ResNet18_CBAM(nn.Module):def __init__(self, num_classes=10, pretrained=True, cbam_ratio=16, cbam_kernel=7):super().__init__()# 加載預訓練ResNet18self.backbone = models.resnet18(pretrained=pretrained) # 修改首層卷積以適應32x32輸入（CIFAR10）self.backbone.conv1 = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1, bias=False)self.backbone.maxpool = nn.Identity()  # 移除原始MaxPool層（因輸入尺寸小）# 在每個殘差塊組后添加CBAM模塊self.cbam_layer1 = CBAM(in_channels=64, ratio=cbam_ratio, kernel_size=cbam_kernel)self.cbam_layer2 = CBAM(in_channels=128, ratio=cbam_ratio, kernel_size=cbam_kernel)self.cbam_layer3 = CBAM(in_channels=256, ratio=cbam_ratio, kernel_size=cbam_kernel)self.cbam_layer4 = CBAM(in_channels=512, ratio=cbam_ratio, kernel_size=cbam_kernel)# 修改分類頭self.backbone.fc = nn.Linear(in_features=512, out_features=num_classes)def forward(self, x):# 主干特征提取x = self.backbone.conv1(x)x = self.backbone.bn1(x)x = self.backbone.relu(x)  # [B, 64, 32, 32]# 第一層殘差塊 + CBAMx = self.backbone.layer1(x)  # [B, 64, 32, 32]x = self.cbam_layer1(x)# 第二層殘差塊 + CBAMx = self.backbone.layer2(x)  # [B, 128, 16, 16]x = self.cbam_layer2(x)# 第三層殘差塊 + CBAMx = self.backbone.layer3(x)  # [B, 256, 8, 8]x = self.cbam_layer3(x)# 第四層殘差塊 + CBAMx = self.backbone.layer4(x)  # [B, 512, 4, 4]x = self.cbam_layer4(x)# 全局平均池化 + 分類x = self.backbone.avgpool(x)  # [B, 512, 1, 1]x = torch.flatten(x, 1)  # [B, 512]x = self.backbone.fc(x)  # [B, 10]return x# 初始化模型并移至設備
model = ResNet18_CBAM().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=3, factor=0.5)

三、訓練策略

3.1 差異化學習率

預訓練層（ResNet部分）：他們是經驗豐富的資深專家。他們已經很懂得如何處理特征，不需要大的改動。

新模塊（CBAM和分類頭）：他們是剛入職的實習生，一張白紙，需要快速學習。

你的訓練策略（優化器）就像是CEO，你會這樣分配任務：

給實習生（新模塊） 設置一個較高的學習率（比如1e-3），讓他們快速試錯，快速成長。

給專家（預訓練層） 設置一個極低的學習率（比如1e-5），告訴他們：“你們基本保持現狀，只需要根據實習生的表現做一些微小的調整即可。”

3.1.1例子

這里我們介紹一種比較適合這里的預訓練策略：

1.

階段 1（epoch 1-5）：

僅解凍分類頭（fc）和所有 CBAM 模塊，凍結 ResNet18 的主干卷積層（layer1-4）。

目標：先讓模型通過預訓練特征學習新任務的分類邊界，同時微調注意力模塊。

學習率：1e-3（較高學習率加速分類頭收斂）。

階段 2（epoch 6-20）：

解凍高層卷積層（layer3、layer4）+ 分類頭 + CBAM，凍結低層卷積層（layer1、layer2）。

目標：釋放高層語義特征（如 “物體類別” 相關層），適應新任務的抽象表示。

學習率：1e-4（降低學習率，避免破壞預訓練權重）。

階段 3（epoch 21-50）：

解凍所有層（包括低層卷積層 layer1、layer2），端到端微調。

目標：讓底層特征（如邊緣、紋理）與新任務對齊，提升特征表達能力。

學習率：1e-5（最小學習率，緩慢調整全局參數）。

2. CBAM 模塊集成

在每個殘差塊組（layer1-4）輸出后添加 CBAM，確保注意力機制作用于各階段特征圖，且不影響殘差塊內部的跳連接。

CBAM 參數默認使用ratio=16和kernel_size=7，可根據計算資源調整（如減小ratio以降低參數量）。

3. 學習率與優化器

使用Adam優化器，分階段手動調整學習率（也可配合自動調度器如CosineAnnealingLR）。

每次解凍新層時，學習率降低一個數量級，避免梯度沖擊預訓練權重。

預期效果與監控

階段 1：測試準確率應逐步提升至 20%-40%（擺脫隨機猜測），損失開始下降。

階段 2：準確率加速提升（利用高層特征），可能達到 60%-80%。

階段 3：準確率緩慢提升并收斂（底層特征微調），最終可能超過 85%（取決于 CIFAR10 的基線表現）。

監控重點：

若階段 1 準確率仍為 9%，檢查數據預處理或標簽是否正確。

若階段 2 后準確率停滯，嘗試增加正則化（如在 CBAM 后添加 Dropout）或調整 CBAM 參數。

兩種策惡略

差異化學習率

把我們的模型想象成一個公司團隊來執行新項目（CIFAR - 10 分類任務）。預訓練層（ResNet 部分）是經驗豐富的資深專家，他們已經很懂得如何處理通用圖像特征，不需要大的改動。新模塊（CBAM 和分類頭）是剛入職的實習生，對新任務一無所知，需要快速學習和試錯。

作為 CEO，我們的訓練策略是：給實習生設置一個較高的學習率（例如 1e - 3），讓他們快速成長；給專家設置一個極低的學習率（例如 1e - 5），告訴他們“保持現狀，根據實習生的表現稍作微調即可”。

三階段式解凍與微調（Progressive Unfreezing）

1. 階段一（Epoch 1 - 5）：預熱“實習生”?僅解凍分類頭（fc）和所有 CBAM 模塊，凍結 ResNet18 的所有主干卷積層（conv1，bn1，layer1 至 layer4）。目標是先利用強大的預訓練特征，讓模型快速學習新任務的分類邊界，同時讓注意力模塊找到初步的關注點。學習率為 1e - 3，使用較高學習率加速收斂。

2. 階段二（Epoch 6 - 20）：喚醒“高層專家”?在上一階段的基礎上，額外解凍高層語義相關的卷積層（layer3，layer4），底層特征提取層（conv1，bn1，layer1，layer2）仍然凍結。目標是釋放模型的高層特征提取能力，使其適應新任務的抽象概念（例如“鳥的輪廓”比“一條邊”更抽象）。學習率為 1e - 4，降低學習率，避免新解凍的層因梯度過大而破壞其寶貴的預訓練權重。

3. 階段三（Epoch 21 - 50）：全員協同微調?解凍模型的所有層，進行端到端微調，沒有凍結部分。目標是讓模型的底層特征（如邊緣、紋理）也與新任務進行對齊，做最后的精細化調整，提升整體性能。學習率為 1e - 5，使用最低的學習率，在整個模型上緩慢、穩定地進行全局優化。

在深度神經網絡里，信息流通常有這樣的描述：

????????靠近輸入圖像的層被叫做“底層”或者“淺層”，

????????靠近最終輸出（分類頭）的層則被稱為“高層”或者“深層”。

所以，“解凍高層卷積”指的就是解凍 layer3 和 layer4 這兩組殘差塊。

為了更直觀理解，我們可以把 ResNet18 的結構想象成一個處理流水線：

輸入圖像經過預處理層 conv1、bn1、relu，

接著依次經過 layer1、layer2、layer3、layer4，

再通過分類頭 avgpool、fc，最終得到輸出結果。

ResNet18 有 4 組核心的殘差塊，即 layer1、layer2、layer3、layer4，每組 layer 內部包含 2 個 BasicBlock，每個 BasicBlock 又包含 2 個卷積層。

在階段 2，我們會解凍 layer3 和 layer4 這兩組，同時讓 CBAM 模塊和 fc 層保持解凍狀態，而 layer1、layer2 以及最開始的 conv1 則繼續保持凍結。

為什么解凍后面（高層）而不解凍前面（底層）呢？這正是遷移學習和微調策略的精髓所在，核心原因是不同層級的卷積層學習到的特征類型不同。

我們可以用一個生動的比喻來理解，把神經網絡學習的過程看作一位畫家畫畫。

底層網絡（layer1、layer2）負責學習“筆觸和紋理”。這些靠近輸入的層，學習的是非常通用、基礎的視覺元素，就像畫家首先要學會畫直線、曲線、點、色彩塊、明暗漸變、材質紋理（如毛發、金屬）等。這些特征高度可復用，不管畫的是貓、汽車還是房子，基本筆觸和紋理都一樣。同理，無論是 ImageNet 還是 CIFAR - 10 中的圖片，都由這些基礎視覺元素構成。由于這些知識寶貴且通用，我們不希望輕易改動它，過早用少量新數據（CIFAR - 10）訓練它們，可能會破壞已經學得很好的通用知識。所以在微調初期，我們選擇凍結它們。

高層網絡（layer3、layer4）負責學習“構圖和概念”。這些靠近輸出的層，會將底層學到的基礎元素組合成更復雜、更具語義的部件或概念，就像畫家把線條和色塊組合成“眼睛”“車輪”“屋頂”，最終形成“一張貓臉”“一輛汽車的側面”這樣的整體概念。這些組合方式和最終概念與具體任務高度相關，比如在 ImageNet 上模型可能學會將“圓形”和“網格”組合成“籃球”，但在 CIFAR - 10 上，需要學習將“圓形”和“金屬光澤”組合成“汽車輪胎”。這部分知識最具“任務特異性”，最需要被重新訓練和調整。解凍 layer3 和 layer4，是為了讓模型能利用學好的基礎特征，為新任務（CIFAR - 10 分類）構建新的專屬物體概念。

下面是總結：

1. 底層 (Low-Level)
? ?對應層：conv1, layer1, layer2
? ?學習特征：邊緣、顏色、紋理、方向等通用基礎特征
? ?任務相關性：低 (Universal)
? ?微調策略：后期解凍或保持凍結 (保護通用知識)

2. 高層 (High-Level)
? 對應層：layer3, layer4
? ?學習特征：物體部件、復雜形狀、特定物體的概念
? ?任務相關性：高 (Task-Specific)
? ?-微調策略：優先解凍 (適應新任務)

這個總結清晰地展示了CNN不同層級的學習特征、任務相關性以及相應的微調策略。

因此，“先解凍高層，后解凍底層”的策略是一種高效且穩健的微調方法，它最大限度保留了預訓練模型的泛化能力，同時能精確讓模型適應新任務的特定需求。

import time# ======================================================================
# 4. 結合了分階段策略和詳細打印的訓練函數
# ======================================================================
def set_trainable_layers(model, trainable_parts):print(f"\n---> 解凍以下部分并設為可訓練: {trainable_parts}")for name, param in model.named_parameters():param.requires_grad = Falsefor part in trainable_parts:if part in name:param.requires_grad = Truebreakdef train_staged_finetuning(model, criterion, train_loader, test_loader, device, epochs):optimizer = None# 初始化歷史記錄列表，與你的要求一致all_iter_losses, iter_indices = [], []train_acc_history, test_acc_history = [], []train_loss_history, test_loss_history = [], []for epoch in range(1, epochs + 1):epoch_start_time = time.time()# --- 動態調整學習率和凍結層 ---if epoch == 1:print("\n" + "="*50 + "\n🚀 **階段 1：訓練注意力模塊和分類頭**\n" + "="*50)set_trainable_layers(model, ["cbam", "backbone.fc"])optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)elif epoch == 6:print("\n" + "="*50 + "\n?? **階段 2：解凍高層卷積層 (layer3, layer4)**\n" + "="*50)set_trainable_layers(model, ["cbam", "backbone.fc", "backbone.layer3", "backbone.layer4"])optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-4)elif epoch == 21:print("\n" + "="*50 + "\n🛰? **階段 3：解凍所有層，進行全局微調**\n" + "="*50)for param in model.parameters(): param.requires_grad = Trueoptimizer = optim.Adam(model.parameters(), lr=1e-5)# --- 訓練循環 ---model.train()running_loss, correct, total = 0.0, 0, 0for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)optimizer.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 - 1) * 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個batch打印一次if (batch_idx + 1) % 100 == 0:print(f'Epoch: {epoch}/{epochs} | Batch: {batch_idx+1}/{len(train_loader)} 'f'| 單Batch損失: {iter_loss:.4f} | 累計平均損失: {running_loss/(batch_idx+1):.4f}')epoch_train_loss = running_loss / len(train_loader)epoch_train_acc = 100. * correct / totaltrain_loss_history.append(epoch_train_loss)train_acc_history.append(epoch_train_acc)# --- 測試循環 ---model.eval()test_loss, correct_test, total_test = 0, 0, 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_loss_history.append(epoch_test_loss)test_acc_history.append(epoch_test_acc)# 打印每個epoch的最終結果print(f'Epoch {epoch}/{epochs} 完成 | 耗時: {time.time() - epoch_start_time:.2f}s | 訓練準確率: {epoch_train_acc:.2f}% | 測試準確率: {epoch_test_acc:.2f}%')# 訓練結束后調用繪圖函數print("\n訓練完成! 開始繪制結果圖表...")plot_iter_losses(all_iter_losses, iter_indices)plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)# 返回最終的測試準確率return epoch_test_acc# ======================================================================
# 5. 繪圖函數定義
# ======================================================================
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()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()# ======================================================================
# 6. 執行訓練
# ======================================================================
model = ResNet18_CBAM().to(device)
criterion = nn.CrossEntropyLoss()
epochs = 50print("開始使用帶分階段微調策略的ResNet18+CBAM模型進行訓練...")
final_accuracy = train_staged_finetuning(model, criterion, train_loader, test_loader, device, epochs)
print(f"訓練完成！最終測試準確率: {final_accuracy:.2f}%")# torch.save(model.state_dict(), 'resnet18_cbam_finetuned.pth')
# print("模型已保存為: resnet18_cbam_finetuned.pth")

訓練完成！最終測試準確率: 90.15%

可以看到準確率還在持續上升，說明模型還沒有收斂，對預訓練模型采用cbam注意力顯著增強了訓練精度

保存下目前的權重，未來可以繼續訓練。

四、作業：嘗試對vgg16+cbam進行微調策略

import torch
import torchvision.models as models
from torchinfo import summary # 創建模型實例
model = models.vgg16(pretrained=False)  # 不加載預訓練權重# 加載本地權重文件
weights_path = r'C:\anaconda\envs\DL2\vgg16-397923af.pth'  # PyTorch權重通常是.pth或.pt文件
state_dict = torch.load(weights_path)
model.load_state_dict(state_dict)model.eval()# 輸出模型結構和參數概要
summary(model, input_size=(1, 3, 224, 224))

import torch
import torch.nn as nn
from torchvision import models# CBAM模塊實現
class ChannelAttention(nn.Module):def __init__(self, in_channels, ratio=16):super(ChannelAttention, self).__init__()self.avg_pool = nn.AdaptiveAvgPool2d(1)self.max_pool = nn.AdaptiveMaxPool2d(1)self.fc = nn.Sequential(nn.Conv2d(in_channels, in_channels // ratio, 1, bias=False),nn.ReLU(inplace=True),nn.Conv2d(in_channels // ratio, in_channels, 1, bias=False),nn.Sigmoid())def forward(self, x):avg_out = self.fc(self.avg_pool(x))max_out = self.fc(self.max_pool(x))out = avg_out + max_outreturn x * outclass SpatialAttention(nn.Module):def __init__(self, kernel_size=7):super(SpatialAttention, self).__init__()assert kernel_size in (3, 7), 'kernel size must be 3 or 7'padding = 3 if kernel_size == 7 else 1self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)self.sigmoid = nn.Sigmoid()def forward(self, x):# 保存原始輸入original_x = x# 計算空間注意力圖avg_out = torch.mean(original_x, dim=1, keepdim=True)max_out, _ = torch.max(original_x, dim=1, keepdim=True)x_cat = torch.cat([avg_out, max_out], dim=1)attention = self.conv1(x_cat)attention_map = self.sigmoid(attention)# 將注意力圖應用到原始輸入上return original_x * attention_mapclass CBAM(nn.Module):def __init__(self, in_channels, ratio=16, kernel_size=7):super(CBAM, self).__init__()self.ca = ChannelAttention(in_channels, ratio)self.sa = SpatialAttention(kernel_size)def forward(self, x):x = self.ca(x)x = self.sa(x)return xdef forward(self, x):x = self.ca(x)x = self.sa(x)return x# 自定義VGG16模型，插入CBAM模塊
class VGG16_CBAM(nn.Module):def __init__(self, num_classes=10, pretrained=False, cbam_ratio=16, cbam_kernel=7):super().__init__()# 加載VGG16但不下載權重self.backbone = models.vgg16(pretrained=False)# 修改首層卷積以適應32x32輸入self.backbone.features[0] = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)# 添加CBAM模塊self.cbam_layer1 = CBAM(in_channels=64, ratio=cbam_ratio, kernel_size=cbam_kernel)self.cbam_layer2 = CBAM(in_channels=128, ratio=cbam_ratio, kernel_size=cbam_kernel)self.cbam_layer3 = CBAM(in_channels=256, ratio=cbam_ratio, kernel_size=cbam_kernel)self.cbam_layer4 = CBAM(in_channels=512, ratio=cbam_ratio, kernel_size=cbam_kernel)self.cbam_layer5 = CBAM(in_channels=512, ratio=cbam_ratio, kernel_size=cbam_kernel)# 關鍵修改：適配分類器輸入尺寸# 創建新的分類器self.classifier = nn.Sequential(nn.Linear(512, 4096),  # 關鍵修改：輸入512特征nn.ReLU(inplace=True),nn.Dropout(),nn.Linear(4096, 4096),nn.ReLU(inplace=True),nn.Dropout(),nn.Linear(4096, num_classes))# 替換原始分類器self.backbone.classifier = self.classifierdef forward(self, x):# 第一個卷積塊 + CBAMx = self.backbone.features[:4](x)  # [B, 64, 32, 32]x = self.cbam_layer1(x)# 第二個卷積塊 + CBAMx = self.backbone.features[4:9](x)  # [B, 128, 16, 16]x = self.cbam_layer2(x)# 第三個卷積塊 + CBAMx = self.backbone.features[9:16](x)  # [B, 256, 8, 8]x = self.cbam_layer3(x)# 第四個卷積塊 + CBAMx = self.backbone.features[16:23](x)  # [B, 512, 4, 4]x = self.cbam_layer4(x)# 第五個卷積塊 + CBAMx = self.backbone.features[23:30](x)  # [B, 512, 2, 2]x = self.cbam_layer5(x)# 分類部分x = self.backbone.features[30:](x)  # [B, 512, 1, 1]x = x.view(x.size(0), -1)x = self.backbone.classifier(x)  # [B, 10]return x# 初始化模型并移至設備
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = VGG16_CBAM().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam([{'params': model.backbone.features.parameters(), 'lr': 1e-5},{'params': list(model.cbam_layer1.parameters()) + list(model.cbam_layer2.parameters()) + list(model.cbam_layer3.parameters()) + list(model.cbam_layer4.parameters()) + list(model.cbam_layer5.parameters()) + list(model.backbone.classifier.parameters()), 'lr': 1e-3}
])
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=3, factor=0.5)# 三階段式解凍與微調
def train_model(model, train_loader, criterion, optimizer, scheduler, epochs):for epoch in range(epochs):model.train()running_loss = 0.0if epoch < 5:# 階段一（Epoch 1 - 5）：僅解凍分類頭和所有CBAM模塊for param in model.backbone.features.parameters():param.requires_grad = Falsefor param in list(model.cbam_layer1.parameters()) + list(model.cbam_layer2.parameters()) + \list(model.cbam_layer3.parameters()) + list(model.cbam_layer4.parameters()) + \list(model.cbam_layer5.parameters()) + list(model.backbone.classifier.parameters()):param.requires_grad = Trueelif epoch < 20:# 階段二（Epoch 6 - 20）：額外解凍高層卷積層for param in model.backbone.features[:23].parameters():param.requires_grad = Falsefor param in model.backbone.features[23:].parameters():param.requires_grad = Truefor param in list(model.cbam_layer1.parameters()) + list(model.cbam_layer2.parameters()) + \list(model.cbam_layer3.parameters()) + list(model.cbam_layer4.parameters()) + \list(model.cbam_layer5.parameters()) + list(model.backbone.classifier.parameters()):param.requires_grad = Trueelse:# 階段三（Epoch 21 - 50）：解凍所有層for param in model.parameters():param.requires_grad = Truefor inputs, labels in train_loader:inputs, labels = inputs.to(device), labels.to(device)optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()epoch_loss = running_loss / len(train_loader)print(f'Epoch {epoch + 1}/{epochs}, Loss: {epoch_loss:.4f}')scheduler.step(epoch_loss)# 假設已經有train_loader
# train_model(model, train_loader, criterion, optimizer, scheduler, 50)

import time# ======================================================================
# 4. 結合了分階段策略和詳細打印的訓練函數
# ======================================================================
def set_trainable_layers(model, trainable_parts):print(f"\n---> 解凍以下部分并設為可訓練: {trainable_parts}")for name, param in model.named_parameters():param.requires_grad = Falsefor part in trainable_parts:if part in name:param.requires_grad = Truebreakdef train_staged_finetuning(model, criterion, train_loader, test_loader, device, epochs):optimizer = None# 初始化歷史記錄列表，與你的要求一致all_iter_losses, iter_indices = [], []train_acc_history, test_acc_history = [], []train_loss_history, test_loss_history = [], []for epoch in range(1, epochs + 1):epoch_start_time = time.time()# --- 動態調整學習率和凍結層 ---if epoch == 1:print("\n" + "="*50 + "\n🚀 **階段 1：訓練注意力模塊和分類頭**\n" + "="*50)set_trainable_layers(model, ["cbam", "backbone.fc"])optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)elif epoch == 6:print("\n" + "="*50 + "\n?? **階段 2：解凍高層卷積層 (layer3, layer4)**\n" + "="*50)set_trainable_layers(model, ["cbam", "backbone.fc", "backbone.layer3", "backbone.layer4"])optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-4)elif epoch == 21:print("\n" + "="*50 + "\n🛰? **階段 3：解凍所有層，進行全局微調**\n" + "="*50)for param in model.parameters(): param.requires_grad = Trueoptimizer = optim.Adam(model.parameters(), lr=1e-5)# --- 訓練循環 ---model.train()running_loss, correct, total = 0.0, 0, 0for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)optimizer.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 - 1) * 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個batch打印一次if (batch_idx + 1) % 100 == 0:print(f'Epoch: {epoch}/{epochs} | Batch: {batch_idx+1}/{len(train_loader)} 'f'| 單Batch損失: {iter_loss:.4f} | 累計平均損失: {running_loss/(batch_idx+1):.4f}')epoch_train_loss = running_loss / len(train_loader)epoch_train_acc = 100. * correct / totaltrain_loss_history.append(epoch_train_loss)train_acc_history.append(epoch_train_acc)# --- 測試循環 ---model.eval()test_loss, correct_test, total_test = 0, 0, 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_loss_history.append(epoch_test_loss)test_acc_history.append(epoch_test_acc)# 打印每個epoch的最終結果print(f'Epoch {epoch}/{epochs} 完成 | 耗時: {time.time() - epoch_start_time:.2f}s | 訓練準確率: {epoch_train_acc:.2f}% | 測試準確率: {epoch_test_acc:.2f}%')# 訓練結束后調用繪圖函數print("\n訓練完成! 開始繪制結果圖表...")plot_iter_losses(all_iter_losses, iter_indices)plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)# 返回最終的測試準確率return epoch_test_acc# ======================================================================
# 5. 繪圖函數定義
# ======================================================================
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()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()# ======================================================================
# 6. 執行訓練
# ======================================================================
model = VGG16_CBAM().to(device)
criterion = nn.CrossEntropyLoss()
epochs = 50print("開始使用帶分階段微調策略的VGG16+CBAM模型進行訓練...")
final_accuracy = train_staged_finetuning(model, criterion, train_loader, test_loader, device, epochs)
print(f"訓練完成！最終測試準確率: {final_accuracy:.2f}%")