知識回顧
- 數據增強
- 卷積神經網絡定義的寫法
- batch歸一化：調整一個批次的分布，常用與圖像數據
- 特征圖：只有卷積操作輸出的才叫特征圖
- 調度器：直接修改基礎學習率
卷積操作常見流程如下：
1. 輸入 → 卷積層 → Batch歸一化層（可選） → 池化層 → 激活函數 → 下一層
- Flatten -> Dense (with Dropout，可選) -> Dense (Output)
先看一下昨天的代碼
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 # 解決負號顯示問題# 1. 數據預處理
transform = transforms.Compose([transforms.ToTensor(), # 轉換為張量transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # 標準化處理
])# 2. 加載CIFAR-10數據集
train_dataset = datasets.CIFAR10(root='./data',train=True,download=True,transform=transform
)test_dataset = datasets.CIFAR10(root='./data',train=False,transform=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. 定義MLP模型（適應CIFAR-10的輸入尺寸）
class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.flatten = nn.Flatten() # 將3x32x32的圖像展平為3072維向量self.layer1 = nn.Linear(3072, 512) # 第一層：3072個輸入，512個神經元self.relu1 = nn.ReLU()self.dropout1 = nn.Dropout(0.2) # 添加Dropout防止過擬合self.layer2 = nn.Linear(512, 256) # 第二層：512個輸入，256個神經元self.relu2 = nn.ReLU()self.dropout2 = nn.Dropout(0.2)self.layer3 = nn.Linear(256, 10) # 輸出層：10個類別def forward(self, x):# 第一步：將輸入圖像展平為一維向量x = self.flatten(x) # 輸入尺寸: [batch_size, 3, 32, 32] → [batch_size, 3072]# 第一層全連接 + 激活 + Dropoutx = self.layer1(x) # 線性變換: [batch_size, 3072] → [batch_size, 512]x = self.relu1(x) # 應用ReLU激活函數x = self.dropout1(x) # 訓練時隨機丟棄部分神經元輸出# 第二層全連接 + 激活 + Dropoutx = self.layer2(x) # 線性變換: [batch_size, 512] → [batch_size, 256]x = self.relu2(x) # 應用ReLU激活函數x = self.dropout2(x) # 訓練時隨機丟棄部分神經元輸出# 第三層（輸出層）全連接x = self.layer3(x) # 線性變換: [batch_size, 256] → [batch_size, 10]return x # 返回未經過Softmax的logits# 檢查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 初始化模型
model = MLP()
model = model.to(device) # 將模型移至GPU（如果可用）criterion = nn.CrossEntropyLoss() # 交叉熵損失函數
optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam優化器# 5. 訓練模型（記錄每個 iteration 的損失）
def train(model, train_loader, test_loader, criterion, optimizer, device, epochs):model.train() # 設置為訓練模式# 記錄每個 iteration 的損失all_iter_losses = [] # 存儲所有 batch 的損失iter_indices = [] # 存儲 iteration 序號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 / total# 測試階段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_testprint(f'Epoch {epoch+1}/{epochs} 完成 | 訓練準確率: {epoch_train_acc:.2f}% | 測試準確率: {epoch_test_acc:.2f}%')# 繪制所有 iteration 的損失曲線plot_iter_losses(all_iter_losses, iter_indices)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. 執行訓練和測試
epochs = 20 # 增加訓練輪次以獲得更好效果
print("開始訓練模型...")
final_accuracy = train(model, train_loader, test_loader, criterion, optimizer, device, epochs)
print(f"訓練完成！最終測試準確率: {final_accuracy:.2f}%")# 保存模型
torch.save(model.state_dict(), 'cifar10_mlp_model.pth')
# print("模型已保存為: cifar10_mlp_model.pth")可以看到即使在深度神經網絡情況下，準確率仍舊較差，這是因為特征沒有被有效提取----真正重要的是特征的提取和加工過程。MLP把所有的像素全部展平了（這是全局的信息），無法布置到局部的信息，所以引入了卷積神經網絡。
卷積層是特征提取器，池化層是特征壓縮器。他們二者都是在做下采樣操作。
一、數據增強
在圖像數據預處理環節，為提升數據多樣性，可采用數據增強（數據增廣）策略。該策略通常不改變單次訓練的樣本總數，而是通過對現有圖像進行多樣化變換，使每次訓練輸入的樣本呈現更豐富的形態差異，從而有效擴展模型訓練的樣本空間多樣性。
常見的修改策略包括以下幾類
- 幾何變換：如旋轉、縮放、平移、剪裁、裁剪、翻轉
- 像素變換：如修改顏色、亮度、對比度、飽和度、色相、高斯模糊（模擬對焦失敗）、增加噪聲、馬賽克
- 語義增強（暫時不用）：mixup，對圖像進行結構性改造、cutout隨機遮擋等
此外，在數據極少的場景長，常常用生成模型來擴充數據集，如GAN、VAE等。
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)#使用設備: cuda
#Files already downloaded and verified注意數據增強一般是不改變每個批次的數據量，是對原始數據修改后替換原始數據。其中該數據集事先知道其均值和標準差，如果不知道，需要提前計算下。
二、 CNN模型
卷積的本質：通過卷積核在輸入通道上的滑動乘積，提取跨通道的空間特征。所以只需要定義幾個參數即可
- 卷積核大小：卷積核的大小，如3x3、5x5、7x7等。
- 輸入通道數：輸入圖片的通道數，如1（單通道圖片）、3（RGB圖片）、4（RGBA圖片）等。
- 輸出通道數：卷積核的個數，即輸出的通道數。如本模型中通過 32→64→128 逐步增加特征復雜度
- 步長（stride）：卷積核的滑動步長，默認為1。
# 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（如果可用）上述定義CNN模型中：
- 使用三層卷積+池化結構提取圖像特征
- 每層卷積后添加BatchNorm加速訓練并提高穩定性
- 使用Dropout減少過擬合
可以把全連接層前面的不理解為神經網絡的一部分，單純理解為特征提取器，他們的存在就是幫助模型進行特征提取的。
2.1 batch歸一化
Batch 歸一化是深度學習中常用的一種歸一化技術，加速模型收斂并提升泛化能力。通常位于卷積層后。
卷積操作常見流程如下：
- 輸入 → 卷積層 → Batch歸一化層（可選） → 池化層 → 激活函數 → 下一層
- Flatten -> Dense (with Dropout，可選) -> Dense (Output)
其中，BatchNorm 應在池化前對空間維度的特征完成歸一化，以確保歸一化統計量基于足夠多的樣本（空間位置），避免池化導致的統計量偏差
旨在解決深度神經網絡訓練中的內部協變量偏移問題：深層網絡中，隨著前層參數更新，后層輸入分布會發生變化，導致模型需要不斷適應新分布，訓練難度增加。就好比你在學新知識，知識體系的基礎一直在變，你就得不斷重新適應，模型訓練也是如此，這就導致訓練變得困難，這就是內部協變量偏移問題。
通過對每個批次的輸入數據進行標準化（均值為 0、方差為 1），想象把一堆雜亂無章、分布不同的數據規整到一個標準的樣子。
- 使各層輸入分布穩定，讓數據處于激活函數比較合適的區域，緩解梯度消失 / 爆炸問題;
- 因為數據分布穩定了，所以允許使用更大的學習率，提升訓練效率。
| 階段 | 均值/方差來源 | 參數更新 |
|---|---|---|
| 訓練階段 | 基于當前批次數據計算 | 實時更新?gammagamma、betabeta |
| 推理階段 | 使用訓練集的全局統計量（如滑動平均后的均值和方差） | 不更新參數，直接使用固定值 |
深度學習的歸一化有2類：
- Batch Normalization：一般用于圖像數據，因為圖像數據通常是批量處理，有相對固定的 Batch Size ，能利用 Batch 內數據計算穩定的統計量（均值、方差 ）來做歸一化。
- Layer Normalization：一般用于文本數據，本數據的序列長度往往不同，像不同句子長短不一，很難像圖像那樣固定 Batch Size 。如果用 Batch 歸一化，不同批次的統計量波動大，效果不好。層歸一化是對單個樣本的所有隱藏單元進行歸一化，不依賴批次。
ps：這個操作在結構化數據中其實是叫做標準化，但是在深度學習領域，習慣把這類對網絡中間層數據進行調整分布的操作都叫做歸一化 。
2.2 特征圖
卷積層輸出的叫做特征圖，通過輸入尺寸和卷積核的尺寸、步長可以計算出輸出尺寸。可以通過可視化中間層的特征圖，理解 CNN 如何從底層特征（如邊緣）逐步提取高層語義特征（如物體部件、整體結構）。MLP是不輸出特征圖的，因為他輸出的一維向量，無法保留空間維度
特征圖就代表著在之前特征提取器上提取到的特征，可以通過 Grad-CAM方法來查看模型在識別圖像時，特征圖所對應的權重是多少。-----深度學習可解釋性
我們在后續介紹。下面接著訓練CNN模型
2.3 調度器
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）
)ReduceLROnPlateau調度器適用于當監測的指標（如驗證損失）停滯時降低學習率。是大多數任務的首選調度器，尤其適合驗證集波動較大的情況
這種學習率調度器的方法相較于之前只有單純的優化器，是一種超參數的優化方法，它通過調整學習率來優化模型。
常見的優化器有 adam、SGD、RMSprop 等，而除此之外學習率調度器有 lr_scheduler.StepLR、lr_scheduler.ExponentialLR、lr_scheduler.CosineAnnealingLR 等。
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)
# 每5個epoch，LR = LR × 0.1 scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[10, 20, 30], gamma=0.5)
# 當epoch=10、20、30時，LR = LR × 0.5 scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, eta_min=0.0001)
# LR在[0.0001, LR_initial]之間按余弦曲線變化，周期為2×T_max 可以把優化器和調度器理解為調參手段，學習率是參數
注意，優化器如adam雖然也在調整學習率，但是他的調整是相對值，計算步長后根據基礎學習率來調整。但是調度器是直接調整基礎學習率。
# 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 = 20 # 增加訓練輪次以獲得更好效果
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")開始使用CNN訓練模型...
Epoch: 1/20 | Batch: 100/782 | 單Batch損失: 1.6939 | 累計平均損失: 2.0402
Epoch: 1/20 | Batch: 200/782 | 單Batch損失: 1.7632 | 累計平均損失: 1.9162
Epoch: 1/20 | Batch: 300/782 | 單Batch損失: 1.6051 | 累計平均損失: 1.8418
Epoch: 1/20 | Batch: 400/782 | 單Batch損失: 1.6624 | 累計平均損失: 1.7934
Epoch: 1/20 | Batch: 500/782 | 單Batch損失: 1.7259 | 累計平均損失: 1.7492
Epoch: 1/20 | Batch: 600/782 | 單Batch損失: 1.3839 | 累計平均損失: 1.7149
Epoch: 1/20 | Batch: 700/782 | 單Batch損失: 1.7046 | 累計平均損失: 1.6879
Epoch 1/20 完成 | 訓練準確率: 38.46% | 測試準確率: 54.70%
Epoch: 2/20 | Batch: 100/782 | 單Batch損失: 1.5352 | 累計平均損失: 1.4148
Epoch: 2/20 | Batch: 200/782 | 單Batch損失: 1.3239 | 累計平均損失: 1.3802
Epoch: 2/20 | Batch: 300/782 | 單Batch損失: 1.4556 | 累計平均損失: 1.3511
Epoch: 2/20 | Batch: 400/782 | 單Batch損失: 1.2608 | 累計平均損失: 1.3269
Epoch: 2/20 | Batch: 500/782 | 單Batch損失: 0.9699 | 累計平均損失: 1.3041
Epoch: 2/20 | Batch: 600/782 | 單Batch損失: 1.1444 | 累計平均損失: 1.2882
Epoch: 2/20 | Batch: 700/782 | 單Batch損失: 1.0800 | 累計平均損失: 1.2723
Epoch 2/20 完成 | 訓練準確率: 54.43% | 測試準確率: 65.78%
Epoch: 3/20 | Batch: 100/782 | 單Batch損失: 1.4134 | 累計平均損失: 1.1310
Epoch: 3/20 | Batch: 200/782 | 單Batch損失: 1.1853 | 累計平均損失: 1.1286
Epoch: 3/20 | Batch: 300/782 | 單Batch損失: 1.3804 | 累計平均損失: 1.1145
Epoch: 3/20 | Batch: 400/782 | 單Batch損失: 0.9816 | 累計平均損失: 1.1048
Epoch: 3/20 | Batch: 500/782 | 單Batch損失: 1.0868 | 累計平均損失: 1.1030
Epoch: 3/20 | Batch: 600/782 | 單Batch損失: 1.0686 | 累計平均損失: 1.0918
Epoch: 3/20 | Batch: 700/782 | 單Batch損失: 0.7925 | 累計平均損失: 1.0868
Epoch 3/20 完成 | 訓練準確率: 61.76% | 測試準確率: 69.60%
...
Epoch: 20/20 | Batch: 500/782 | 單Batch損失: 0.8277 | 累計平均損失: 0.6376
Epoch: 20/20 | Batch: 600/782 | 單Batch損失: 0.7361 | 累計平均損失: 0.6385
Epoch: 20/20 | Batch: 700/782 | 單Batch損失: 0.5281 | 累計平均損失: 0.6383
Epoch 20/20 完成 | 訓練準確率: 77.61% | 測試準確率: 80.98%訓練完成！最終測試準確率: 80.98%
以CIFAR-10為例，假設兩者均使用2層隱藏層：
| 模型結構 | 參數規模 | 特征提取方式 | 計算效率 | 典型準確率 |
|---|---|---|---|---|
| MLP | 3072→1024→512→10 ≈370萬參數 | 全連接，無空間感知 | 每次計算需遍歷所有參數 | 50-55% |
| CNN（簡單） | 3×3卷積→池化→全連接 ≈10萬參數 | 局部感知+權值共享 | 卷積核復用計算，效率高 | 70-80% |
@浙大疏錦行
)
