Python訓練第四十一天

DAY 41 簡單CNN

知識回顧

數據增強
卷積神經網絡定義的寫法
batch歸一化：調整一個批次的分布，常用與圖像數據
特征圖：只有卷積操作輸出的才叫特征圖
調度器：直接修改基礎學習率

卷積操作常見流程如下：

1. 輸入 → 卷積層 → Batch歸一化層（可選） → 池化層 → 激活函數 → 下一層

Flatten -> Dense (with Dropout，可選) -> Dense (Output)

一、數據增強

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

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

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)
#使用設備: cpu
#Files already downloaded and verified

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

二、 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. 因為數據分布穩定了，所以允許使用更大的學習率，提升訓練效率。

深度學習的歸一化有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）
)

ReduceLROnPlateau調度器適用于當監測的指標（如驗證損失）停滯時降低學習率。是大多數任務的首選調度器，尤其適合驗證集波動較大的情況

這種學習率調度器的方法相較于之前只有單純的優化器，是一種超參數的優化方法，它通過調整學習率來優化模型。

常見的優化器有 adam、SGD、RMSprop 等，而除此之外學習率調度器有 lr_scheduler.StepLR、lr_scheduler.ExponentialLR、lr_scheduler.CosineAnnealingLR 等。

可以把優化器和調度器理解為調參手段，學習率是參數

注意，優化器如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")

作業

import numpy as np
from tensorflow import keras
from tensorflow.keras import layers# 加載和預處理數據
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 28, 28, 1).astype("float32") / 255.0
x_test = x_test.reshape(-1, 28, 28, 1).astype("float32") / 255.0
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)# 定義簡單的 CNN 模型
def simple_cnn():model = keras.Sequential([layers.Conv2D(16, (3, 3), activation='relu', input_shape=(28, 28, 1)),layers.MaxPooling2D((2, 2)),layers.Flatten(),layers.Dense(128, activation='relu'),layers.Dense(10, activation='softmax')])return model# 定義復雜的 CNN 模型
def complex_cnn():model = keras.Sequential([layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),layers.MaxPooling2D((2, 2)),layers.Conv2D(64, (3, 3), activation='relu'),layers.MaxPooling2D((2, 2)),layers.Flatten(),layers.Dense(256, activation='relu'),layers.Dense(128, activation='relu'),layers.Dense(10, activation='softmax')])return model# 定義不同的優化器
optimizers = {'SGD': keras.optimizers.SGD(learning_rate=0.01),'Adam': keras.optimizers.Adam(learning_rate=0.001)
}# 訓練不同的模型和優化器組合
epochs = 5
batch_size = 64for model_name, model_fn in [('Simple CNN', simple_cnn), ('Complex CNN', complex_cnn)]:for optimizer_name, optimizer in optimizers.items():model = model_fn()model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])print(f"Training {model_name} with {optimizer_name} optimizer:")history = model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, y_test))train_loss = history.history['loss']train_acc = history.history['accuracy']val_loss = history.history['val_loss']val_acc = history.history['val_accuracy']print(f"Training Loss: {train_loss}")print(f"Training Accuracy: {train_acc}")print(f"Validation Loss: {val_loss}")print(f"Validation Accuracy: {val_acc}")

@浙大疏錦行