簡單CNN
知識回顧
數據增強
卷積神經網絡定義的寫法
batch歸一化：調整一個批次的分布，常用與圖像數據
特征圖：只有卷積操作輸出的才叫特征圖
調度器：直接修改基礎學習率
卷積操作常見流程如下：
1. 輸入 → 卷積層 → Batch歸一化層（可選） → 池化層 → 激活函數 → 下一層
Flatten -> Dense (with Dropout，可選) -> Dense (Output)
簡單 CNN
1. 數據增強
數據增強就像是在餐廳的食材上應用各種處理方法，以增加菜品的多樣性和豐富性。例如，可以通過旋轉、翻轉、裁剪等方法來擴充食材的種類和形態，使模型在訓練過程中看到更多的“菜品”變化，從而提高模型的泛化能力。
2. 卷積神經網絡定義的寫法
卷積神經網絡（CNN）的定義就像是餐廳的高級菜譜，其中包含了多種復雜的烹飪步驟和技巧。CNN 通過卷積層、池化層、激活函數等組件來提取圖像的特征，從而實現對圖像的分類或識別。
3. Batch 歸一化
Batch 歸一化就像是在廚房中對食材進行標準化處理，確保每一批次的食材在烹飪前都有相同的均值和方差。這有助于加快模型的訓練速度，并提高模型的穩定性。
4. 特征圖
特征圖就像是廚師在烹飪過程中創建的中間產物，這些中間產物包含了食材經過初步處理后的信息。在 CNN 中，特征圖是由卷積層生成的，它們捕捉了圖像的不同特征，如邊緣、紋理等。
5. 調度器
調度器就像是餐廳的經理，根據餐廳的運營情況（如顧客流量、食材供應等）動態調整廚師的工作強度和節奏。在訓練模型時，調度器會根據訓練進度動態調整學習率，以加快收斂速度并提高模型性能。
6. 卷積操作常見流程
卷積操作的常見流程可以比喻為餐廳制作一道復雜菜品的步驟：
輸入：就像廚師接到顧客的訂單，開始準備食材。
卷積層：廚師對食材進行初步處理，如切割、攪拌等，提取出食材的基本特征。
Batch 歸一化層（可選）：廚師對處理后的食材進行標準化，確保每一批次的食材質量一致。
池化層：廚師對食材進行進一步處理，如濃縮、提純等，減少數據量并突出重要特征。
激活函數：廚師根據菜譜添加特定的調料，使菜品具有獨特的風味，激活函數為模型引入非線性。
下一層：處理后的食材傳遞給下一位廚師，進行下一步烹飪。
7. Flatten -> Dense (with Dropout，可選) -> Dense (Output)
Flatten：將多維的特征圖展平成一維向量，類似于將復雜菜品的所有成分混合在一起，形成一個統一的混合物。
Dense (with Dropout)：對混合物進行進一步加工，添加 Dropout 就像是在烹飪過程中隨機丟棄一些成分，以防止過度依賴某些特定成分（防止過擬合）。
Dense (Output)：最終輸出菜品，類似于將所有成分組合成一個完整的菜品，呈現給顧客。
作業：嘗試手動修改下不同的調度器和CNN的結構，觀察訓練的差異。
?
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)
# 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（如果可用）
# 5. 定義損失函數和優化器
criterion = nn.CrossEntropyLoss() # 交叉熵損失函數，適用于多分類任務
optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam優化器，學習率0.001
# 引入學習率調度器，在訓練過程中動態調整學習率--訓練初期使用較大的 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
# 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")
1. 數據預處理和增強
訓練集數據增強：使用了隨機裁剪、隨機水平翻轉、隨機顏色抖動和隨機旋轉等操作來擴充訓練數據的多樣性，幫助模型更好地泛化。
測試集預處理：僅進行了標準化處理，以保持數據的一致性。
2. 數據加載
使用 DataLoader 將 CIFAR-10 數據集加載為批次數據，方便模型訓練和測試。
3. CNN 模型定義
卷積塊：包括卷積層、批量歸一化層、ReLU 激活函數和最大池化層，用于提取圖像特征。
全連接層：將卷積層提取的特征展平后，通過全連接層進行分類，最后輸出分類結果。
4. 模型訓練
損失函數：使用交叉熵損失函數，適用于多分類任務。
優化器：使用 Adam 優化器，學習率為 0.001。
學習率調度器：使用 ReduceLROnPlateau 調度器，根據驗證損失動態調整學習率。
5. 訓練和測試函數
訓練函數：記錄每個 iteration 的損失，并在每個 epoch 結束后計算訓練和測試的準確率及損失。
測試函數：在測試集上評估模型的性能。
6. 結果可視化
繪制損失曲線：展示每個 iteration 的訓練損失變化。
繪制準確率和損失曲線：展示每個 epoch 的訓練和測試準確率及損失變化。
7. 執行訓練和測試
設置訓練輪次為 20，開始訓練模型，并在訓練結束后輸出最終的測試準確率。
這段代碼通過 CNN 模型在 CIFAR-10 數據集上實現了圖像分類任務，包含了數據預處理、模型定義、訓練、測試和結果可視化的完整流程。通過數據增強和學習率調度等技巧，提高了模型的泛化能力和訓練效果。
