?

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

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

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

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

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

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

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

resnet結構解析

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

?

mport 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)

先通過預訓練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))

cbam的放置位置

我們知道，加載預訓練模型的時候，需要加載好預訓練的模型架構，然后加載預訓練的權重。如果修改模型的架構，比如在中間插入某個模塊或層，很可能導致他后續預訓練的權重失效。那么如何解決這個問題呢？

一種很容易被想到的思想是：cbam可以放置在全連接層之前，這是最簡單的想法。保留了原始的信息。可以理解為在模型做出最終分類決策之前，對提取到的最高階特征圖做一次最后的“精煉”和“校準”。

但是這么做有一個弊端，注意力機制只在最后起作用，無法幫助網絡在中間層構建出更好的、帶有注意力信息的特征。前面的所有卷積塊依然是“盲目”地提取特征。這就像一個學生直到做完整張試卷才開始劃重點，而不是每做完一道題就總結一次。

但是你要注意，最后的卷積形式是 卷積--激活--池化--全連接，如果你放置前全連接前的話，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. 不破壞預訓練權重：原始殘差塊的預訓練權重得以完整保留，我們只是在其后增加了一個新的、需要從頭學習的模塊。

mport 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)

## 訓練策略

差異化學習率

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

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

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

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

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

?

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

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 參數。

在訓練這里，我們采用2種訓練策略

### 差異化學習率

把我們的模型想象成一個公司團隊來執行新項目 (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分類）構建新的、專屬的物體概念。

總結表格

| 層級 (Layer Level) | 對應層 (Corresponding Layers) | 學習特征 (Learned Features) | 任務相關性 | 微調策略 |

| :--- | :--- | :--- | :--- | :--- |

| **底層 (Low-Level)** | `conv1`, `layer1`, `layer2` | 邊緣、顏色、紋理、方向等**通用基礎特征** | 低 (Universal) | **后期解凍或保持凍結** (保護通用知識) |

| **高層 (High-Level)** | `layer3`, `layer4` | 物體部件、復雜形狀、**特定物體的概念** | 高 (Task-Specific) | **優先解凍** (適應新任務) |

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

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")

torch.save(model.state_dict(), 'resnet18_cbam_finetuned.pth')
print("模型已保存為: resnet18_cbam_finetuned.pth")