從經典案例學習 CNN：實戰技巧與完整總結 (Part 4)

Epoch 1: Train Acc 65%, Test Acc 63%
Epoch 5: Train Acc 75%, Test Acc 72%
Epoch 10: Train Acc 76%, Test Acc 72%  ← 停滯
Epoch 20: Train Acc 76%, Test Acc 72%

# ===== 步驟 1: 檢查學習率 =====
# 畫出損失曲線，觀察震盪情況
plt.plot(history['loss'])
plt.title('訓練損失曲線')
plt.show()

# 如果損失劇烈震盪 → 學習率過大
# 如果損失幾乎不動 → 學習率過小

# ===== 步驟 2: 嘗試更大的學習率範圍 =====
# Learning Rate Finder
learning_rates = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1]
for lr in learning_rates:
    model = create_model()
    optimizer = Adam(lr=lr)
    # 訓練 2-3 個 epoch
    # 記錄最終損失

# ===== 步驟 3: 檢查模型容量 =====
# 計算訓練集和測試集的差距
train_acc = 76%
test_acc = 72%
gap = 4%

if gap < 5%:
    print("模型容量可能不足，試著加深/加寬網路")
else:
    print("模型容量充足，問題可能在學習率或資料")

# ===== 步驟 4: 視覺化預測 =====
# 看看錯誤的案例，是否有規律？
wrong_indices = np.where(y_pred != y_true)[0]
for idx in wrong_indices[:10]:
    plt.imshow(X_test[idx])
    plt.title(f"True: {y_true[idx]}, Pred: {y_pred[idx]}")
    plt.show()

Epoch 20: Train Acc 95%, Test Acc 75%  ← 差距 20%

# ===== 方案 1: 資料增強（最有效） =====
datagen = ImageDataGenerator(
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    zoom_range=0.15,
    shear_range=0.15
)

# ===== 方案 2: 加強 Dropout =====
model = Sequential([
    Conv2D(64, (3,3), activation='relu'),
    Dropout(0.3),  # 從 0.25 提高到 0.3-0.4
    # ...
    Dense(128, activation='relu'),
    Dropout(0.5),  # 全連接層用更高的 Dropout
    Dense(10, activation='softmax')
])

# ===== 方案 3: L2 正規化 =====
from tensorflow.keras.regularizers import l2

model.add(Dense(128, activation='relu',
                kernel_regularizer=l2(0.001)))  # L2 正規化

# PyTorch: 在優化器中設定 weight_decay
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)

# ===== 方案 4: 早停 =====
early_stop = EarlyStopping(
    monitor='val_loss',
    patience=10,         # 10 個 epoch 沒改善就停
    restore_best_weights=True
)

# ===== 方案 5: 減少模型大小 =====
# 將濾波器數量減半
# 原本: 64 → 128 → 256 → 512
# 改為: 32 → 64 → 128 → 256

# ===== 1. 確認 GPU 已啟用 =====
# TensorFlow
print(tf.config.list_physical_devices('GPU'))

# PyTorch
print(torch.cuda.is_available())

# 如果顯示 GPU 但沒加速，檢查資料是否在 GPU 上：
data = data.to(device)  # PyTorch
model = model.to(device)

# ===== 2. 增加 Batch Size =====
# GPU 記憶體允許的情況下，越大越快
BATCH_SIZE = 256  # 從 128 提高到 256
# 注意：Batch Size 提高可能需要調整學習率

# ===== 3. 使用 Mixed Precision 訓練 =====
# TensorFlow
from tensorflow.keras.mixed_precision import Policy
policy = Policy('mixed_float16')
tf.keras.mixed_precision.set_global_policy(policy)

# PyTorch
from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()

for data, target in train_loader:
    optimizer.zero_grad()
    with autocast():  # 自動混合精度
        output = model(data)
        loss = criterion(output, target)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

# 效果：速度提升 2-3 倍，記憶體減少 50%

# ===== 4. 優化 DataLoader =====
# 增加 num_workers
train_loader = DataLoader(
    train_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=4,      # 從 2 提高到 4
    pin_memory=True,    # 加速 CPU→GPU 傳輸
    persistent_workers=True  # PyTorch 1.7+
)

# ===== 5. 使用更快的優化器 =====
# AdamW 通常比 Adam 更快收斂
from tensorflow.keras.optimizers import AdamW  # Keras
import torch.optim as optim  # PyTorch
optimizer = optim.AdamW(model.parameters(), lr=0.001)

RuntimeError: CUDA out of memory. Tried to allocate 1.50 GiB
(GPU 0; 15.75 GiB total capacity; 14.23 GiB already allocated)

# ===== 方案 1: 減少 Batch Size（最有效） =====
BATCH_SIZE = 64  # 從 128 減到 64 或 32

# ===== 方案 2: 清空 GPU 快取 =====
import torch
torch.cuda.empty_cache()

# TensorFlow
from tensorflow.keras import backend as K
K.clear_session()

# ===== 方案 3: 使用梯度累積（保持有效 Batch Size） =====
# 模擬 batch_size=128 的效果
ACCUMULATION_STEPS = 4
effective_batch_size = 32  # 32 × 4 = 128

optimizer.zero_grad()
for i, (data, target) in enumerate(train_loader):
    output = model(data)
    loss = criterion(output, target) / ACCUMULATION_STEPS
    loss.backward()

    if (i + 1) % ACCUMULATION_STEPS == 0:
        optimizer.step()
        optimizer.zero_grad()

# ===== 方案 4: 減少模型大小 =====
# 將濾波器數量減半
# 或使用 DepthwiseSeparable Convolution

# ===== 方案 5: 使用 Gradient Checkpointing =====
# PyTorch
from torch.utils.checkpoint import checkpoint

def forward(self, x):
    x = checkpoint(self.block1, x)  # 重新計算而非儲存
    x = checkpoint(self.block2, x)
    return x

# ===== 診斷清單 =====
def diagnose_model(model, X_train, y_train, X_test, y_test):
    """診斷模型訓練問題"""

    print("=" * 70)
    print("模型診斷報告")
    print("=" * 70)

    # 1. 檢查資料範圍
    print(f"\n1. 資料範圍檢查:")
    print(f"   X_train: [{X_train.min():.4f}, {X_train.max():.4f}]")
    print(f"   ✓ 正常範圍: [0, 1] 或 [-1, 1]" if X_train.max() <= 1.5 else "   ✗ 可能需要正規化！")

    # 2. 檢查標籤格式
    print(f"\n2. 標籤格式檢查:")
    print(f"   y_train shape: {y_train.shape}")
    print(f"   y_train unique: {np.unique(y_train)}")

    # 3. 檢查類別平衡
    print(f"\n3. 類別平衡檢查:")
    unique, counts = np.unique(y_train, return_counts=True)
    max_count = counts.max()
    min_count = counts.min()
    imbalance_ratio = max_count / min_count
    print(f"   最多: {max_count}, 最少: {min_count}, 比例: {imbalance_ratio:.2f}")
    if imbalance_ratio > 3:
        print(f"   ⚠️ 類別不平衡！考慮使用加權損失")

    # 4. 過擬合檢測（需要訓練後）
    print(f"\n4. 過擬合檢測:")
    train_loss, train_acc = model.evaluate(X_train[:1000], y_train[:1000], verbose=0)
    test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
    gap = train_acc - test_acc
    print(f"   Train Acc: {train_acc*100:.2f}%")
    print(f"   Test Acc:  {test_acc*100:.2f}%")
    print(f"   Gap: {gap*100:.2f}%")

    if gap > 0.15:
        print(f"   ⚠️ 過擬合！建議:")
        print(f"      - 資料增強")
        print(f"      - 增加 Dropout")
        print(f"      - L2 正規化")
    elif gap < 0.05 and test_acc < 0.85:
        print(f"   ⚠️ 模型容量不足！建議:")
        print(f"      - 增加層數")
        print(f"      - 增加濾波器數量")

    # 5. 檢查梯度
    print(f"\n5. 梯度檢查:")
    # 訓練一個 batch
    sample_batch = X_train[:32]
    sample_labels = y_train[:32]

    with tf.GradientTape() as tape:
        predictions = model(sample_batch)
        loss = tf.keras.losses.categorical_crossentropy(sample_labels, predictions)

    gradients = tape.gradient(loss, model.trainable_variables)

    # 檢查是否有 NaN 或過大/過小的梯度
    for i, grad in enumerate(gradients):
        if grad is not None:
            grad_mean = tf.reduce_mean(tf.abs(grad)).numpy()
            if np.isnan(grad_mean):
                print(f"   ✗ 層 {i}: 梯度為 NaN！")
            elif grad_mean < 1e-8:
                print(f"   ⚠️ 層 {i}: 梯度過小 ({grad_mean:.2e}) - 可能梯度消失")
            elif grad_mean > 1e2:
                print(f"   ⚠️ 層 {i}: 梯度過大 ({grad_mean:.2e}) - 可能梯度爆炸")

    print("\n" + "=" * 70)

# 使用範例
diagnose_model(model, X_train, y_train_cat, X_test, y_test_cat)

# 視覺化過擬合/欠擬合
def plot_learning_curves(history):
    """視覺化學習曲線並診斷問題"""

    train_acc = history['accuracy']
    val_acc = history['val_accuracy']
    train_loss = history['loss']
    val_loss = history['val_loss']

    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))

    # 準確率
    ax1.plot(train_acc, 'b-', label='訓練', linewidth=2)
    ax1.plot(val_acc, 'r-', label='驗證', linewidth=2)
    ax1.set_title('準確率曲線', fontsize=14, fontweight='bold')
    ax1.set_xlabel('Epoch')
    ax1.set_ylabel('準確率')
    ax1.legend()
    ax1.grid(True, alpha=0.3)

    # 損失
    ax2.plot(train_loss, 'b-', label='訓練', linewidth=2)
    ax2.plot(val_loss, 'r-', label='驗證', linewidth=2)
    ax2.set_title('損失曲線', fontsize=14, fontweight='bold')
    ax2.set_xlabel('Epoch')
    ax2.set_ylabel('損失')
    ax2.legend()
    ax2.grid(True, alpha=0.3)

    # 診斷
    final_train_acc = train_acc[-1]
    final_val_acc = val_acc[-1]
    gap = final_train_acc - final_val_acc

    print("\n診斷結果:")
    print("=" * 50)

    if final_val_acc < 0.7:
        if gap < 0.05:
            print("❌ 欠擬合 (Underfitting)")
            print("   訓練和驗證準確率都很低，但差距小")
            print("\n建議:")
            print("   1. 增加模型容量（更多層/濾波器）")
            print("   2. 訓練更多 epochs")
            print("   3. 降低正規化強度")
            print("   4. 檢查學習率是否過小")
        else:
            print("⚠️ 欠擬合 + 輕微過擬合")
            print("   驗證準確率低，但訓練準確率更高")
            print("\n建議:")
            print("   1. 先解決欠擬合：增加模型容量")
            print("   2. 再處理過擬合：加資料增強")
    elif gap > 0.15:
        print("❌ 過擬合 (Overfitting)")
        print(f"   訓練準確率 {final_train_acc*100:.1f}%，驗證準確率 {final_val_acc*100:.1f}%")
        print(f"   差距 {gap*100:.1f}%")
        print("\n建議:")
        print("   1. 資料增強（最有效）")
        print("   2. 增加 Dropout (0.3-0.5)")
        print("   3. L2 正規化 (weight_decay=1e-4)")
        print("   4. 早停 (EarlyStopping)")
        print("   5. 減少模型容量")
    else:
        print("✅ 良好擬合 (Good Fit)")
        print(f"   訓練準確率 {final_train_acc*100:.1f}%，驗證準確率 {final_val_acc*100:.1f}%")
        print(f"   差距 {gap*100:.1f}%（健康範圍）")

    # 檢查驗證損失是否上升
    if len(val_loss) > 10:
        min_val_loss_epoch = np.argmin(val_loss)
        if min_val_loss_epoch < len(val_loss) - 5:
            print(f"\n⚠️ 驗證損失在 epoch {min_val_loss_epoch} 達到最低")
            print(f"   之後開始上升，建議在該點停止訓練")

    plt.tight_layout()
    plt.show()

# 使用範例
plot_learning_curves(history.history)

# ===== 策略 1: 學習率範圍測試 (Learning Rate Finder) =====
def find_learning_rate(model, train_loader, criterion, device):
    """找出最佳學習率範圍"""
    learning_rates = []
    losses = []

    # 測試從 1e-6 到 1 的學習率
    lr = 1e-6
    for batch_idx, (data, target) in enumerate(train_loader):
        if batch_idx > 100:  # 只測試 100 個 batch
            break

        data, target = data.to(device), target.to(device)

        # 更新學習率
        optimizer = optim.SGD(model.parameters(), lr=lr)

        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

        # 記錄
        learning_rates.append(lr)
        losses.append(loss.item())

        # 指數增長學習率
        lr *= 1.1

    # 視覺化
    plt.figure(figsize=(10, 6))
    plt.plot(learning_rates, losses)
    plt.xscale('log')
    plt.xlabel('Learning Rate')
    plt.ylabel('Loss')
    plt.title('Learning Rate Finder')
    plt.grid(True)
    plt.show()

    # 建議：選擇損失下降最快的點
    print("建議學習率:")
    min_loss_idx = np.argmin(losses)
    print(f"  最低損失點: {learning_rates[min_loss_idx]:.6f}")
    print(f"  建議值（除以10）: {learning_rates[min_loss_idx]/10:.6f}")

# ===== 策略 2: 學習率調度 =====
# 方案 A: Step Decay（階梯式衰減）
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
# 每 30 個 epoch，學習率乘以 0.1

# 方案 B: Exponential Decay（指數衰減）
scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95)
# 每個 epoch，學習率乘以 0.95

# 方案 C: Cosine Annealing（餘弦退火）
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100, eta_min=1e-6)
# 餘弦曲線，從 lr_max 降到 eta_min

# 方案 D: ReduceLROnPlateau（自適應）
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
    optimizer, mode='min', factor=0.5, patience=5, verbose=True
)
# 驗證損失 5 個 epoch 沒改善，學習率減半

# ===== 策略 3: Warm-up + Cosine Annealing =====
def lr_lambda(epoch):
    if epoch < 10:  # Warm-up
        return (epoch + 1) / 10
    else:  # Cosine Annealing
        progress = (epoch - 10) / (100 - 10)
        return 0.5 * (1 + np.cos(np.pi * progress))

scheduler = optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)

# Batch Size 對比實驗
batch_sizes = [32, 64, 128, 256, 512]

results = {}
for bs in batch_sizes:
    model = create_model()
    optimizer = Adam(lr=0.001)

    # 訓練 10 epochs
    # ...

    results[bs] = {
        'train_time': ...,
        'final_acc': ...,
        'memory_usage': ...
    }

# 結果範例（CIFAR-10）
"""
Batch Size | 訓練時間 | 準確率 | GPU 記憶體
-----------|---------|-------|----------
32         | 25 min  | 86.2% | 2.5 GB
64         | 15 min  | 86.5% | 3.8 GB
128        | 10 min  | 86.8% | 6.2 GB  ← 推薦
256        | 8 min   | 86.3% | 10.5 GB
512        | 7 min   | 85.1% | OOM     ← 過大導致泛化變差
"""

# ============================================
# 完整優化範例（PyTorch）
# 包含所有效能提升技巧
# ============================================

import torch
import torch.nn as nn
from torch.cuda.amp import autocast, GradScaler
from torch.utils.data import DataLoader

# ===== 1. 使用 Mixed Precision 訓練 =====
scaler = GradScaler()

# ===== 2. 優化 DataLoader =====
train_loader = DataLoader(
    train_dataset,
    batch_size=256,           # 較大 batch size
    shuffle=True,
    num_workers=4,            # 多執行緒
    pin_memory=True,          # 加速 CPU→GPU
    persistent_workers=True,  # 保持 workers 活著
    prefetch_factor=2         # 預載入
)

# ===== 3. 優化模型 =====
model = create_model()
model = model.to(device)

# 使用 torch.compile（PyTorch 2.0+）
model = torch.compile(model)  # 自動優化計算圖

# ===== 4. 優化優化器 =====
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001,
    betas=(0.9, 0.999),
    weight_decay=0.01,
    foreach=True  # 向量化操作（PyTorch 1.12+）
)

# ===== 5. 訓練迴圈（完整優化版） =====
model.train()

for epoch in range(num_epochs):
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device, non_blocking=True), target.to(device, non_blocking=True)

        # Mixed Precision
        with autocast():
            output = model(data)
            loss = criterion(output, target)

        # 反向傳播（Mixed Precision）
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()
        optimizer.zero_grad(set_to_none=True)  # 更快的梯度清空

# ===== 效能對比 =====
"""
優化前: 20 分鐘/epoch
優化後: 5 分鐘/epoch  ← 快 4 倍！

優化項目           | 提升
-------------------|------
Mixed Precision    | 2.5×
DataLoader 優化    | 1.3×
torch.compile      | 1.2×
綜合效果           | 4×
"""

# 使用預訓練模型（以 ResNet 為例）
from torchvision import models

# 載入預訓練模型
resnet = models.resnet18(pretrained=True)

# 凍結預訓練層
for param in resnet.parameters():
    param.requires_grad = False

# 替換最後一層
resnet.fc = nn.Linear(512, 10)  # CIFAR-10 有 10 類

# 只訓練最後一層
optimizer = optim.Adam(resnet.fc.parameters(), lr=0.001)

# 效果：
# - 訓練時間: 從 20 分鐘減少到 5 分鐘
# - 準確率: 從 87% 提升到 94%

# Mixup 範例
def mixup_data(x, y, alpha=0.2):
    lam = np.random.beta(alpha, alpha)
    index = torch.randperm(x.size(0))

    mixed_x = lam * x + (1 - lam) * x[index]
    y_a, y_b = y, y[index]

    return mixed_x, y_a, y_b, lam

# 訓練時使用
mixed_x, y_a, y_b, lam = mixup_data(x, y)
output = model(mixed_x)
loss = lam * criterion(output, y_a) + (1 - lam) * criterion(output, y_b)

Y[i,j] = Σₘ Σₙ X[i+m, j+n] × K[m,n] + b

其中:
- Y: 輸出特徵圖（Feature Map）
- X: 輸入影像
- K: 卷積核（Kernel）
- b: 偏差項（Bias）
- m,n: 卷積核的索引

# 輸入影像 (5×5)
X = [[1, 2, 3, 4, 5],
     [6, 7, 8, 9, 10],
     [11, 12, 13, 14, 15],
     [16, 17, 18, 19, 20],
     [21, 22, 23, 24, 25]]

# 卷積核 (3×3) - 邊緣偵測
K = [[-1, -1, -1],
     [-1,  8, -1],
     [-1, -1, -1]]

# 計算輸出的一個元素 Y[1,1]（無 padding）:
Y[1,1] = 1×(-1) + 2×(-1) + 3×(-1) +
         6×(-1) + 7×(8) + 8×(-1) +
         11×(-1) + 12×(-1) + 13×(-1)
       = -1 -2 -3 -6 +56 -8 -11 -12 -13
       = 0

輸出高度 = floor((H + 2P - K) / S) + 1
輸出寬度 = floor((W + 2P - K) / S) + 1

其中:
- H, W: 輸入高度和寬度
- K: 卷積核大小
- P: Padding（填充）
- S: Stride（步幅）
- floor: 向下取整

# 全連接層（假設輸入 32×32，輸出 64 個神經元）
參數量 = 32 × 32 × 64 + 64(bias) = 65,600

# 卷積層（64 個 3×3 濾波器，輸入通道 1）
參數量 = 3 × 3 × 1 × 64 + 64(bias) = 640

節省 = 65,600 / 640 = 102 倍！

# 輸入 (4×4)
X = [[1,  3,  2,  4],
     [5,  6,  7,  8],
     [3,  2,  1,  0],
     [1,  2,  3,  4]]

# Max Pooling 2×2, stride=2
# 將 4×4 分成 4 個 2×2 區域，取最大值

Y = [[max(1,3,5,6)=6,  max(2,4,7,8)=8],
     [max(3,2,1,2)=3,  max(1,0,3,4)=4]]

Y = [[6, 8],
     [3, 4]]

# 輸入相同
# Average Pooling 2×2

Y = [[avg(1,3,5,6)=3.75,  avg(2,4,7,8)=5.25],
     [avg(3,2,1,2)=2.00,  avg(1,0,3,4)=2.00]]

# 神經元的輸入始終 ≤ 0
x = -5  # 負輸入
output = max(0, x) = 0  # 輸出永遠是 0
gradient = 0  # 梯度永遠是 0

# 結果：神經元永遠無法更新（「死亡」）

1. 計算 mini-batch 均值:
   μ_B = (1/m) Σ xᵢ

2. 計算 mini-batch 方差:
   σ²_B = (1/m) Σ (xᵢ - μ_B)²

3. 正規化:
   x̂ᵢ = (xᵢ - μ_B) / √(σ²_B + ε)

4. 縮放與平移（可學習參數 γ, β）:
   yᵢ = γ × x̂ᵢ + β

# 訓練時（Dropout rate = 0.5）
# 隨機丟棄 50% 的神經元
input = [1.0, 2.0, 3.0, 4.0]
mask = [1, 0, 1, 0]  # 隨機生成
output = [1.0, 0, 3.0, 0]  # element-wise 乘法

# 測試時（不使用 Dropout）
output = [1.0, 2.0, 3.0, 4.0] × 0.5  # 縮放補償

L = -Σᵢ yᵢ × log(ŷᵢ)

其中:
- yᵢ: 真實標籤（One-Hot）
- ŷᵢ: 預測機率（Softmax 輸出）

# 真實標籤（類別 2）
y_true = [0, 0, 1, 0, 0]  # One-Hot

# 模型預測（經過 Softmax）
y_pred = [0.05, 0.10, 0.70, 0.10, 0.05]

# 交叉熵損失
Loss = -(0×log(0.05) + 0×log(0.10) + 1×log(0.70) + 0×log(0.10) + 0×log(0.05))
     = -log(0.70)
     = 0.357

# 如果預測很準確
y_pred_good = [0.01, 0.01, 0.96, 0.01, 0.01]
Loss = -log(0.96) = 0.041  ← 損失低

# 如果預測錯誤
y_pred_bad = [0.01, 0.01, 0.02, 0.01, 0.95]
Loss = -log(0.02) = 3.912  ← 損失高

θₜ₊₁ = θₜ - η × ∇L(θₜ)

其中:
- θ: 參數
- η: 學習率
- ∇L: 損失函數的梯度

vₜ = β × vₜ₋₁ + ∇L(θₜ)
θₜ₊₁ = θₜ - η × vₜ

效果: 累積過去的梯度，加速收斂

# 一階動量（梯度的指數移動平均）
mₜ = β₁ × mₜ₋₁ + (1-β₁) × ∇L(θₜ)

# 二階動量（梯度平方的指數移動平均）
vₜ = β₂ × vₜ₋₁ + (1-β₂) × (∇L(θₜ))²

# 偏差修正
m̂ₜ = mₜ / (1-β₁ᵗ)
v̂ₜ = vₜ / (1-β₂ᵗ)

# 參數更新
θₜ₊₁ = θₜ - η × m̂ₜ / (√v̂ₜ + ε)

其中: β₁=0.9, β₂=0.999, ε=10⁻⁸

對於複合函數 f(g(x))，導數為:
df/dx = (df/dg) × (dg/dx)

損失函數 L 對參數 W 的梯度:

L = Loss(Softmax(Dense(Flatten(Pool(Conv(X, W))))))

∂L/∂W = (∂L/∂Softmax) × (∂Softmax/∂Dense) × ... × (∂Conv/∂W)

Y = X ∗ K + b  (∗ 表示卷積)

1. 損失對輸出的梯度（從上一層傳來）:
   ∂L/∂Y

2. 損失對卷積核的梯度:
   ∂L/∂K = X ∗ (∂L/∂Y)

3. 損失對輸入的梯度（傳給下一層）:
   ∂L/∂X = (∂L/∂Y) ∗ K_rotated

其中 K_rotated 是 K 旋轉 180 度

# 前向傳播
X = [[1, 2],    K = [[1, 0],    Y = [[7, 10],
     [3, 4]]         [0, 1]]         [10, 11]]

# 反向傳播（假設 ∂L/∂Y = [[1, 1], [1, 1]]）
∂L/∂K = X ∗ (∂L/∂Y)
      = [[1×1+2×1+3×1+4×1, ...],  # 簡化
         [..., ...]]
      = [[10, 10],
         [10, 10]]

# 卷積核更新
K_new = K - learning_rate × ∂L/∂K

梯度下降: θₜ₊₁ = θₜ - η × ∇L(θₜ)

η 過大:
- 步長太大，跨過最優點
- 損失函數值劇烈震盪
- Loss: 0.5 → 1.2 → 0.3 → 2.1 (不穩定)

η 適中:
- 穩步向最優點前進
- Loss: 0.5 → 0.4 → 0.3 → 0.2 → 0.15 (穩定下降)

η 過小:
- 步長太小，移動緩慢
- Loss: 0.5 → 0.499 → 0.498 (幾乎不動)

梯度估計的方差:
Var(∇L) ∝ 1 / batch_size

Batch Size ↑ → Var ↓ → 梯度估計更準確
Batch Size ↓ → Var ↑ → 更多隨機性（有時是好事）

如果 Batch Size 增加 k 倍
則 Learning Rate 也應增加 k 倍

範例:
Batch Size 128, LR = 0.001
Batch Size 256, LR = 0.002  ← 2 倍
Batch Size 512, LR = 0.004  ← 4 倍

預期誤差 = Bias² + Variance + 不可約誤差

其中:
- Bias (偏差): 模型的平均預測與真實值的差距
- Variance (方差): 模型對訓練資料的敏感程度
- 不可約誤差: 資料本身的雜訊

線性模型（2D）: VC 維 = 3
  - 可以完美分類任意 3 個點
  - 無法保證分類 4 個點

深度神經網路: VC 維 ≈ O(W × log W)
  - W: 參數總數
  - 容量極大，容易過擬合

優化目標（無正規化）:
min L(θ) = Σᵢ Loss(f(xᵢ; θ), yᵢ)

優化目標（有正規化）:
min L(θ) + λ × R(θ)

其中:
- R(θ): 正規化項（如 ||θ||²）
- λ: 正規化強度

效果: 限制模型容量，防止過擬合

對於任意連續函數 f: [0,1]ⁿ → ℝ
存在神經網路 N(x)，使得:
|N(x) - f(x)| < ε  (對所有 x)

其中 ε 是任意小的正數

淺層網路（1 層隱藏層）:
表示能力 ∝ O(n)  (n: 神經元數)

深層網路（L 層）:
表示能力 ∝ O(nᴸ)  (指數增長！)

輸入影像
    ↓
第 1 層: 邊緣、角點
    ↓
第 2 層: 簡單形狀（圓形、方形）
    ↓
第 3 層: 物體部件（眼睛、鼻子、輪胎）
    ↓
第 4 層: 完整物體（臉、汽車）
    ↓
輸出: 分類結果

對於平移 τ:
f(T_τ(x)) ≈ f(x)

其中 T_τ 是平移操作

每個神經元與所有輸入連接
參數量 = 輸入數 × 輸出數

每個神經元只與局部感受野連接
參數量 = 卷積核大小 × 濾波器數

節省參數 = 1 - (K²/H×W) ≈ 99%
(K=3, H=W=32 的情況)

第 l 層的感受野:
RF_l = RF_{l-1} + (K_l - 1) × Π_{i=1}^{l-1} S_i

其中:
- K_l: 第 l 層的卷積核大小
- S_i: 第 i 層的步幅

輸入: 32×32
Conv1 (3×3, s=1) → RF = 3
Pool1 (2×2, s=2) → RF = 6
Conv2 (3×3, s=1) → RF = 10
Pool2 (2×2, s=2) → RF = 20
Conv3 (3×3, s=1) → RF = 28

最終感受野幾乎覆蓋整張影像！