day41 簡單CNN

DAY 41

首先回顧下昨天的代碼。

# 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]#         # 第一層全連接 + 激活 + Dropout
#         x = self.layer1(x)   # 線性變換: [batch_size, 3072] → [batch_size, 512]
#         x = self.relu1(x)    # 應用ReLU激活函數
#         x = self.dropout1(x) # 訓練時隨機丟棄部分神經元輸出#         # 第二層全連接 + 激活 + Dropout
#         x = 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.0
#         correct = 0
#         total = 0#         for batch_idx, (data, target) in enumerate(train_loader):
#             data, target = data.to(device), target.to(device)  # 移至GPU#             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 * 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 = 0
#         correct_test = 0
#         total_test = 0#         with 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_test#         print(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把所有的像素全部展平了（這是全局的信息），無法布置到局部的信息，所以引入了卷積神經網絡。（在之前的復試班已經交代清楚了，如果不清楚什么是卷積神經網絡，請自行學習下相關概念）

復試班的計算機視覺部分的講義
https://docs.qq.com/doc/DTFNucmRzc3RlRk5k

卷積層是特征提取器，池化層是特征壓縮器。他們二者都是在做下采樣操作。

一、數據增強

在圖像數據預處理環節，為提升數據多樣性，可采用數據增強（數據增廣）策略。該策略通常不改變單次訓練的樣本總數，而是通過對現有圖像進行多樣化變換，使每次訓練輸入的樣本呈現更豐富的形態差異，從而有效擴展模型訓練的樣本空間多樣性。

常見的修改策略包括以下幾類

幾何變換：如旋轉、縮放、平移、剪裁、裁剪、翻轉
像素變換：如修改顏色、亮度、對比度、飽和度、色相、高斯模糊（模擬對焦失敗）、增加噪聲、馬賽克
語義增強（暫時不用）：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），想象把一堆雜亂無章、分布不同的數據規整到一個標準的樣子。

使各層輸入分布穩定，讓數據處于激活函數比較合適的區域，緩解梯度消失 / 爆炸問題;
因為數據分布穩定了，所以允許使用更大的學習率，提升訓練效率。

階段	均值/方差來源	參數更新
訓練階段	基于當前批次數據計算	實時更新 $g amma$ 、 $b e t a$
推理階段	使用訓練集的全局統計量（如滑動平均后的均值和方差）	不更新參數，直接使用固定值

深度學習的歸一化有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: 4/20 | Batch: 100/782 | 單Batch損失: 0.9720 | 累計平均損失: 1.0294
Epoch: 4/20 | Batch: 200/782 | 單Batch損失: 0.8490 | 累計平均損失: 1.0056
Epoch: 4/20 | Batch: 300/782 | 單Batch損失: 0.8739 | 累計平均損失: 1.0080
Epoch: 4/20 | Batch: 400/782 | 單Batch損失: 1.0302 | 累計平均損失: 1.0010
Epoch: 4/20 | Batch: 500/782 | 單Batch損失: 0.8582 | 累計平均損失: 0.9978
Epoch: 4/20 | Batch: 600/782 | 單Batch損失: 0.9711 | 累計平均損失: 0.9919
Epoch: 4/20 | Batch: 700/782 | 單Batch損失: 1.1013 | 累計平均損失: 0.9867
Epoch 4/20 完成 | 訓練準確率: 65.27% | 測試準確率: 70.09%
Epoch: 5/20 | Batch: 100/782 | 單Batch損失: 0.9645 | 累計平均損失: 0.9266
Epoch: 5/20 | Batch: 200/782 | 單Batch損失: 0.8740 | 累計平均損失: 0.9289
Epoch: 5/20 | Batch: 300/782 | 單Batch損失: 0.6668 | 累計平均損失: 0.9330
Epoch: 5/20 | Batch: 400/782 | 單Batch損失: 0.7205 | 累計平均損失: 0.9237
Epoch: 5/20 | Batch: 500/782 | 單Batch損失: 0.7613 | 累計平均損失: 0.9267
Epoch: 5/20 | Batch: 600/782 | 單Batch損失: 0.8715 | 累計平均損失: 0.9249
Epoch: 5/20 | Batch: 700/782 | 單Batch損失: 0.8809 | 累計平均損失: 0.9238
Epoch 5/20 完成 | 訓練準確率: 67.36% | 測試準確率: 73.07%
Epoch: 6/20 | Batch: 100/782 | 單Batch損失: 1.0395 | 累計平均損失: 0.8839
Epoch: 6/20 | Batch: 200/782 | 單Batch損失: 0.5908 | 累計平均損失: 0.8858
Epoch: 6/20 | Batch: 300/782 | 單Batch損失: 0.8197 | 累計平均損失: 0.8773
Epoch: 6/20 | Batch: 400/782 | 單Batch損失: 0.9143 | 累計平均損失: 0.8805
Epoch: 6/20 | Batch: 500/782 | 單Batch損失: 0.6592 | 累計平均損失: 0.8791
Epoch: 6/20 | Batch: 600/782 | 單Batch損失: 0.8603 | 累計平均損失: 0.8803
Epoch: 6/20 | Batch: 700/782 | 單Batch損失: 0.7836 | 累計平均損失: 0.8758
Epoch 6/20 完成 | 訓練準確率: 69.02% | 測試準確率: 74.49%
Epoch: 7/20 | Batch: 100/782 | 單Batch損失: 0.9777 | 累計平均損失: 0.8221
Epoch: 7/20 | Batch: 200/782 | 單Batch損失: 0.5531 | 累計平均損失: 0.8389
Epoch: 7/20 | Batch: 300/782 | 單Batch損失: 0.8878 | 累計平均損失: 0.8372
Epoch: 7/20 | Batch: 400/782 | 單Batch損失: 0.9071 | 累計平均損失: 0.8341
Epoch: 7/20 | Batch: 500/782 | 單Batch損失: 0.9706 | 累計平均損失: 0.8354
Epoch: 7/20 | Batch: 600/782 | 單Batch損失: 0.7465 | 累計平均損失: 0.8392
Epoch: 7/20 | Batch: 700/782 | 單Batch損失: 0.8258 | 累計平均損失: 0.8384
Epoch 7/20 完成 | 訓練準確率: 70.61% | 測試準確率: 75.70%
Epoch: 8/20 | Batch: 100/782 | 單Batch損失: 0.7482 | 累計平均損失: 0.8113
Epoch: 8/20 | Batch: 200/782 | 單Batch損失: 1.0628 | 累計平均損失: 0.8161
Epoch: 8/20 | Batch: 300/782 | 單Batch損失: 0.6425 | 累計平均損失: 0.8091
Epoch: 8/20 | Batch: 400/782 | 單Batch損失: 0.6645 | 累計平均損失: 0.8119
Epoch: 8/20 | Batch: 500/782 | 單Batch損失: 0.9698 | 累計平均損失: 0.8114
Epoch: 8/20 | Batch: 600/782 | 單Batch損失: 0.8171 | 累計平均損失: 0.8092
Epoch: 8/20 | Batch: 700/782 | 單Batch損失: 0.5730 | 累計平均損失: 0.8091
Epoch 8/20 完成 | 訓練準確率: 71.69% | 測試準確率: 75.77%
Epoch: 9/20 | Batch: 100/782 | 單Batch損失: 0.6812 | 累計平均損失: 0.7839
Epoch: 9/20 | Batch: 200/782 | 單Batch損失: 0.6213 | 累計平均損失: 0.7773
Epoch: 9/20 | Batch: 300/782 | 單Batch損失: 0.6202 | 累計平均損失: 0.7801
Epoch: 9/20 | Batch: 400/782 | 單Batch損失: 0.7608 | 累計平均損失: 0.7788
Epoch: 9/20 | Batch: 500/782 | 單Batch損失: 0.7099 | 累計平均損失: 0.7773
Epoch: 9/20 | Batch: 600/782 | 單Batch損失: 0.9552 | 累計平均損失: 0.7807
Epoch: 9/20 | Batch: 700/782 | 單Batch損失: 1.0857 | 累計平均損失: 0.7789
Epoch 9/20 完成 | 訓練準確率: 72.65% | 測試準確率: 76.66%
Epoch: 10/20 | Batch: 100/782 | 單Batch損失: 0.6953 | 累計平均損失: 0.7518
Epoch: 10/20 | Batch: 200/782 | 單Batch損失: 0.7940 | 累計平均損失: 0.7524
Epoch: 10/20 | Batch: 300/782 | 單Batch損失: 0.6605 | 累計平均損失: 0.7592
Epoch: 10/20 | Batch: 400/782 | 單Batch損失: 0.7158 | 累計平均損失: 0.7589
Epoch: 10/20 | Batch: 500/782 | 單Batch損失: 0.9239 | 累計平均損失: 0.7603
Epoch: 10/20 | Batch: 600/782 | 單Batch損失: 0.6219 | 累計平均損失: 0.7591
Epoch: 10/20 | Batch: 700/782 | 單Batch損失: 0.7067 | 累計平均損失: 0.7616
Epoch 10/20 完成 | 訓練準確率: 73.45% | 測試準確率: 77.76%
Epoch: 11/20 | Batch: 100/782 | 單Batch損失: 0.6258 | 累計平均損失: 0.7486
Epoch: 11/20 | Batch: 200/782 | 單Batch損失: 0.7494 | 累計平均損失: 0.7435
Epoch: 11/20 | Batch: 300/782 | 單Batch損失: 0.5150 | 累計平均損失: 0.7344
Epoch: 11/20 | Batch: 400/782 | 單Batch損失: 0.8871 | 累計平均損失: 0.7405
Epoch: 11/20 | Batch: 500/782 | 單Batch損失: 0.8450 | 累計平均損失: 0.7468
Epoch: 11/20 | Batch: 600/782 | 單Batch損失: 0.8056 | 累計平均損失: 0.7457
Epoch: 11/20 | Batch: 700/782 | 單Batch損失: 0.7246 | 累計平均損失: 0.7459
Epoch 11/20 完成 | 訓練準確率: 73.87% | 測試準確率: 78.38%
Epoch: 12/20 | Batch: 100/782 | 單Batch損失: 0.5204 | 累計平均損失: 0.7148
Epoch: 12/20 | Batch: 200/782 | 單Batch損失: 0.5951 | 累計平均損失: 0.7225
Epoch: 12/20 | Batch: 300/782 | 單Batch損失: 0.7636 | 累計平均損失: 0.7265
Epoch: 12/20 | Batch: 400/782 | 單Batch損失: 0.6297 | 累計平均損失: 0.7272
Epoch: 12/20 | Batch: 500/782 | 單Batch損失: 0.8493 | 累計平均損失: 0.7292
Epoch: 12/20 | Batch: 600/782 | 單Batch損失: 0.7699 | 累計平均損失: 0.7305
Epoch: 12/20 | Batch: 700/782 | 單Batch損失: 0.6529 | 累計平均損失: 0.7296
Epoch 12/20 完成 | 訓練準確率: 74.55% | 測試準確率: 76.79%
Epoch: 13/20 | Batch: 100/782 | 單Batch損失: 0.5745 | 累計平均損失: 0.7004
Epoch: 13/20 | Batch: 200/782 | 單Batch損失: 0.8640 | 累計平均損失: 0.7071
Epoch: 13/20 | Batch: 300/782 | 單Batch損失: 0.6741 | 累計平均損失: 0.7106
Epoch: 13/20 | Batch: 400/782 | 單Batch損失: 0.8896 | 累計平均損失: 0.7060
Epoch: 13/20 | Batch: 500/782 | 單Batch損失: 0.8342 | 累計平均損失: 0.7090
Epoch: 13/20 | Batch: 600/782 | 單Batch損失: 0.8003 | 累計平均損失: 0.7141
Epoch: 13/20 | Batch: 700/782 | 單Batch損失: 0.6725 | 累計平均損失: 0.7171
Epoch 13/20 完成 | 訓練準確率: 74.96% | 測試準確率: 78.93%
Epoch: 14/20 | Batch: 100/782 | 單Batch損失: 0.8466 | 累計平均損失: 0.6924
Epoch: 14/20 | Batch: 200/782 | 單Batch損失: 0.6238 | 累計平均損失: 0.6910
Epoch: 14/20 | Batch: 300/782 | 單Batch損失: 0.5831 | 累計平均損失: 0.6976
Epoch: 14/20 | Batch: 400/782 | 單Batch損失: 0.5050 | 累計平均損失: 0.6955
Epoch: 14/20 | Batch: 500/782 | 單Batch損失: 0.7194 | 累計平均損失: 0.6999
Epoch: 14/20 | Batch: 600/782 | 單Batch損失: 0.6703 | 累計平均損失: 0.7050
Epoch: 14/20 | Batch: 700/782 | 單Batch損失: 0.8495 | 累計平均損失: 0.7042
Epoch 14/20 完成 | 訓練準確率: 75.38% | 測試準確率: 78.84%
Epoch: 15/20 | Batch: 100/782 | 單Batch損失: 0.7210 | 累計平均損失: 0.6652
Epoch: 15/20 | Batch: 200/782 | 單Batch損失: 0.5969 | 累計平均損失: 0.6760
Epoch: 15/20 | Batch: 300/782 | 單Batch損失: 0.8509 | 累計平均損失: 0.6744
Epoch: 15/20 | Batch: 400/782 | 單Batch損失: 0.5876 | 累計平均損失: 0.6786
Epoch: 15/20 | Batch: 500/782 | 單Batch損失: 0.6123 | 累計平均損失: 0.6769
Epoch: 15/20 | Batch: 600/782 | 單Batch損失: 0.6984 | 累計平均損失: 0.6775
Epoch: 15/20 | Batch: 700/782 | 單Batch損失: 0.9048 | 累計平均損失: 0.6794
Epoch 15/20 完成 | 訓練準確率: 76.22% | 測試準確率: 79.55%
Epoch: 16/20 | Batch: 100/782 | 單Batch損失: 0.7686 | 累計平均損失: 0.6652
Epoch: 16/20 | Batch: 200/782 | 單Batch損失: 0.7474 | 累計平均損失: 0.6642
Epoch: 16/20 | Batch: 300/782 | 單Batch損失: 0.6650 | 累計平均損失: 0.6691
Epoch: 16/20 | Batch: 400/782 | 單Batch損失: 0.6138 | 累計平均損失: 0.6667
Epoch: 16/20 | Batch: 500/782 | 單Batch損失: 0.7242 | 累計平均損失: 0.6657
Epoch: 16/20 | Batch: 600/782 | 單Batch損失: 0.8668 | 累計平均損失: 0.6686
Epoch: 16/20 | Batch: 700/782 | 單Batch損失: 0.6780 | 累計平均損失: 0.6692
Epoch 16/20 完成 | 訓練準確率: 76.64% | 測試準確率: 79.35%
Epoch: 17/20 | Batch: 100/782 | 單Batch損失: 0.6456 | 累計平均損失: 0.6715
Epoch: 17/20 | Batch: 200/782 | 單Batch損失: 0.7984 | 累計平均損失: 0.6564
Epoch: 17/20 | Batch: 300/782 | 單Batch損失: 0.5901 | 累計平均損失: 0.6669
Epoch: 17/20 | Batch: 400/782 | 單Batch損失: 0.7480 | 累計平均損失: 0.6685
Epoch: 17/20 | Batch: 500/782 | 單Batch損失: 0.6480 | 累計平均損失: 0.6680
Epoch: 17/20 | Batch: 600/782 | 單Batch損失: 0.4323 | 累計平均損失: 0.6652
Epoch: 17/20 | Batch: 700/782 | 單Batch損失: 0.7612 | 累計平均損失: 0.6666
Epoch 17/20 完成 | 訓練準確率: 76.61% | 測試準確率: 79.48%
Epoch: 18/20 | Batch: 100/782 | 單Batch損失: 0.7169 | 累計平均損失: 0.6318
Epoch: 18/20 | Batch: 200/782 | 單Batch損失: 0.5123 | 累計平均損失: 0.6400
Epoch: 18/20 | Batch: 300/782 | 單Batch損失: 0.5666 | 累計平均損失: 0.6527
Epoch: 18/20 | Batch: 400/782 | 單Batch損失: 0.6704 | 累計平均損失: 0.6524
Epoch: 18/20 | Batch: 500/782 | 單Batch損失: 0.5147 | 累計平均損失: 0.6497
Epoch: 18/20 | Batch: 600/782 | 單Batch損失: 0.7104 | 累計平均損失: 0.6504
Epoch: 18/20 | Batch: 700/782 | 單Batch損失: 0.7000 | 累計平均損失: 0.6522
Epoch 18/20 完成 | 訓練準確率: 77.18% | 測試準確率: 80.24%
Epoch: 19/20 | Batch: 100/782 | 單Batch損失: 0.6252 | 累計平均損失: 0.6400
Epoch: 19/20 | Batch: 200/782 | 單Batch損失: 0.7233 | 累計平均損失: 0.6400
Epoch: 19/20 | Batch: 300/782 | 單Batch損失: 1.0744 | 累計平均損失: 0.6423
Epoch: 19/20 | Batch: 400/782 | 單Batch損失: 0.5730 | 累計平均損失: 0.6506
Epoch: 19/20 | Batch: 500/782 | 單Batch損失: 0.4767 | 累計平均損失: 0.6506
Epoch: 19/20 | Batch: 600/782 | 單Batch損失: 0.7195 | 累計平均損失: 0.6502
Epoch: 19/20 | Batch: 700/782 | 單Batch損失: 0.6597 | 累計平均損失: 0.6491
Epoch 19/20 完成 | 訓練準確率: 77.50% | 測試準確率: 81.04%
Epoch: 20/20 | Batch: 100/782 | 單Batch損失: 0.6868 | 累計平均損失: 0.6206
Epoch: 20/20 | Batch: 200/782 | 單Batch損失: 0.4731 | 累計平均損失: 0.6264
Epoch: 20/20 | Batch: 300/782 | 單Batch損失: 0.6690 | 累計平均損失: 0.6332
Epoch: 20/20 | Batch: 400/782 | 單Batch損失: 0.3314 | 累計平均損失: 0.6360
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%

[外鏈圖片轉存中…(img-JRpQ3oI7-1752682402060)]

[外鏈圖片轉存中…(img-Aorbt800-1752682402060)]

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

以CIFAR-10為例，假設兩者均使用2層隱藏層：

模型結構	參數規模	特征提取方式	計算效率	典型準確率
MLP	3072→1024→512→10 ≈370萬參數	全連接，無空間感知	每次計算需遍歷所有參數	50-55%
CNN（簡單）	3×3卷積→池化→全連接 ≈10萬參數	局部感知+權值共享	卷積核復用計算，效率高	70-80%