可以看到即使在深度神經網絡情況下，準確率仍舊較差，這是因為特征沒有被有效提取----真正重要的是特征的提取和加工過程。MLP把所有的像素全部展平了（這是全局的信息），無法布置到局部的信息，所以引入了卷積神經網絡。（在之前的復試班已經交代清楚了，如果不清楚什么是卷積神經網絡，請自行學習下相關概念）

復試班的計算機視覺部分的講義
https://docs.qq.com/doc/DTFNucmRzc3RlRk5k
卷積層是特征提取器，池化層是特征壓縮器。他們二者都是在做下采樣操作。

注意點:機器視覺不是計算機視覺
● 計算機視覺(CV):更偏向于科學研究領域,目標是讓計算機能夠像人眼一樣“看懂”和“理解”圖
像和視頻。它是一個更廣泛、更基礎的學科。

● 機器視覺(MV):更偏向于工程應用領域,特別是工業自動化。目標是利用視覺技術替代人眼
進行測量、檢測、引導和識別等特定任務。 ---- 工廠流水線工人.

2.2 圖像的張量表示
(N,C,H,W)是PyTorch 中表示張量維度的默認約定，其中:
●N 代表批量大小(Batch Size):這是指在每一次訓練或推理過程中，一次性處理的樣本數量。
●c 代表通道數(Number of Channels):這是指輸入數據的通道數量，通常用于表示顏色通道(比如在圖像處理中的紅色、綠色、藍色通道，即 RGB)，或者在卷積神經網絡中的特征通道數。
●H 代表高度(Height):這是輸入數據的高度的像素數
●w 代表寬度(Width):這是輸入數據的寬度像素數
例如，如果你有一個批量大小為 32 的彩色圖像數據集，每個圖像的尺寸為 128x128 像素，那么你的輸入數據的形狀就可以表示為(32，3，128，128)，其中N=32、c=3、H=128、 w=128。

2.6 數據增強操作
又叫數據增廣，數據增強能夠有效擴充數據集的規模和多樣性，進而提升模型的泛化能力與魯棒性。通過對原始圖像數據集進行一系列的數據增強變換，生成大量的新圖像數據
數據增強的主要目的并不是直接增加數據集的樣本數目，而是通過對現有樣本進行各種變換（如旋轉、翻轉、裁剪等），生成更多的數據變體，從而增加數據的多樣性，提高模型的泛化能力。
寫入循環中，每次訓練時，模型看到的都是經過隨機變換的新樣本。也就是訓練時，數據增強不會直接增加數據集的樣本數目，而是在每次訓練時動態生成新的數據變體。
常見的修改策略包括以下幾類

1. 幾何變換：如旋轉、縮放、平移、剪裁、裁剪、翻轉
2. 像素變換：如修改顏色、亮度、對比度、飽和度、色相、高斯模糊（模擬對焦失敗）、增加噪聲、馬賽克
3. 語義增強（暫時不用）：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)

注意數據增強一般是不改變每個批次的數據量，是對原始數據修改后替換原始數據。其中該數據集事先知道其均值和標準差，如果不知道，需要提前計算下。

二、 CNN模型

卷積的本質：通過卷積核在輸入通道上的滑動乘積，提取跨通道的空間特征。所以只需要定義幾個參數即可

1. 卷積核大小：卷積核的大小，如3x3、5x5、7x7等。
2. 輸入通道數：輸入圖片的通道數，如1（單通道圖片）、3（RGB圖片）、4（RGBA圖片）等。
3. 輸出通道數：卷積核的個數，即輸出的通道數。如本模型中通過 32→64→128 逐步增加特征復雜度
4. 步長（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模型中：

1. 使用三層卷積+池化結構提取圖像特征
2. 每層卷積后添加BatchNorm加速訓練并提高穩定性
3. 使用Dropout減少過擬合

可以把全連接層前面的不理解為神經網絡的一部分，單純理解為特征提取器，他們的存在就是幫助模型進行特征提取的。

2.1 batch歸一化

Batch 歸一化是深度學習中常用的一種歸一化技術，加速模型收斂并提升泛化能力。通常位于卷積層后。

卷積操作常見流程如下：

1. 輸入 → 卷積層 → Batch歸一化層（可選） → 池化層 → 激活函數 → 下一層
2. Flatten -> Dense (with Dropout，可選) -> Dense (Output)

其中，BatchNorm 應在池化前對空間維度的特征完成歸一化，以確保歸一化統計量基于足夠多的樣本（空間位置），避免池化導致的統計量偏差

旨在解決深度神經網絡訓練中的內部協變量偏移問題：深層網絡中，隨著前層參數更新，后層輸入分布會發生變化，導致模型需要不斷適應新分布，訓練難度增加。就好比你在學新知識，知識體系的基礎一直在變，你就得不斷重新適應，模型訓練也是如此，這就導致訓練變得困難，這就是內部協變量偏移問題。

通過對每個批次的輸入數據進行標準化（均值為 0、方差為 1），想象把一堆雜亂無章、分布不同的數據規整到一個標準的樣子。

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

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

深度學習的歸一化有2類：

1. Batch Normalization：一般用于圖像數據，因為圖像數據通常是批量處理，有相對固定的 Batch Size ，能利用 Batch 內數據計算穩定的統計量（均值、方差 ）來做歸一化。
2. 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）
)

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