從經典案例學習 CNN：手寫數字辨識完整實戰指南

MNIST 資料集
├── 訓練集 (60,000 張)
│   ├── 數字 0: 5,923 張
│   ├── 數字 1: 6,742 張
│   ├── 數字 2: 5,958 張
│   ├── 數字 3: 6,131 張
│   ├── 數字 4: 5,842 張
│   ├── 數字 5: 5,421 張
│   ├── 數字 6: 5,918 張
│   ├── 數字 7: 6,265 張
│   ├── 數字 8: 5,851 張
│   └── 數字 9: 5,949 張
│
└── 測試集 (10,000 張)
    ├── 數字 0: 980 張
    ├── 數字 1: 1,135 張
    ├── 數字 2: 1,032 張
    ├── 數字 3: 1,010 張
    ├── 數字 4: 982 張
    ├── 數字 5: 892 張
    ├── 數字 6: 958 張
    ├── 數字 7: 1,028 張
    ├── 數字 8: 974 張
    └── 數字 9: 1,009 張

# 在 Colab 中視覺化 MNIST
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
import numpy as np

# 載入資料
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 顯示資料集資訊
print("=" * 60)
print("MNIST 資料集資訊")
print("=" * 60)
print(f"訓練集影像形狀: {X_train.shape}")  # (60000, 28, 28)
print(f"訓練集標籤形狀: {y_train.shape}")  # (60000,)
print(f"測試集影像形狀: {X_test.shape}")   # (10000, 28, 28)
print(f"測試集標籤形狀: {y_test.shape}")   # (10000,)
print(f"像素值範圍: {X_train.min()} ~ {X_train.max()}")
print(f"資料類型: {X_train.dtype}")

# 統計每個類別的數量
print("\n訓練集各類別分布:")
unique, counts = np.unique(y_train, return_counts=True)
for digit, count in zip(unique, counts):
    print(f"  數字 {digit}: {count:,} 張")

# 視覺化範例
fig, axes = plt.subplots(5, 10, figsize=(15, 8))
fig.suptitle('MNIST 手寫數字範例 (每行一個數字)', fontsize=16)

for i in range(10):  # 10 個數字
    # 找出該數字的索引
    indices = np.where(y_train == i)[0]

    for j in range(5):  # 每個數字顯示 5 個範例
        idx = indices[j]
        ax = axes[j, i]
        ax.imshow(X_train[idx], cmap='gray')
        ax.axis('off')
        if j == 0:
            ax.set_title(f'數字 {i}', fontsize=12, fontweight='bold')

plt.tight_layout()
plt.show()

# 顯示單張影像的細節
print("\n" + "=" * 60)
print("單張影像詳細資訊")
print("=" * 60)
sample_idx = 0
print(f"標籤: {y_train[sample_idx]}")
print(f"影像形狀: {X_train[sample_idx].shape}")
print(f"像素矩陣 (部分):")
print(X_train[sample_idx][:5, :5])  # 顯示左上角 5×5 區域

============================================================
MNIST 資料集資訊
============================================================
訓練集影像形狀: (60000, 28, 28)
訓練集標籤形狀: (60000,)
測試集影像形狀: (10000, 28, 28)
測試集標籤形狀: (10000,)
像素值範圍: 0 ~ 255
資料類型: uint8

訓練集各類別分布:
  數字 0: 5,923 張
  數字 1: 6,742 張
  數字 2: 5,958 張
  數字 3: 6,131 張
  數字 4: 5,842 張
  數字 5: 5,421 張
  數字 6: 5,918 張
  數字 7: 6,265 張
  數字 8: 5,851 張
  數字 9: 5,949 張

1998  LeNet-5         99.05%  (卷積神經網路)
2012  超越人類         99.20%
2013  DropConnect      99.79%  (正規化技術)
2016  達到極限         99.79%  (接近理論上限)

人類表現: 約 99.8%
理論上限: 約 99.8% (部分影像連人類也難以辨識)

from tensorflow.keras.datasets import mnist

# 自動下載並載入
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 優點：一行搞定、自動快取、格式統一

from torchvision import datasets

# 下載訓練集
train_dataset = datasets.MNIST(
    root='./data',      # 儲存路徑
    train=True,         # 訓練集
    download=True       # 自動下載
)

# 下載測試集
test_dataset = datasets.MNIST(
    root='./data',
    train=False,
    download=True
)

官方網站: http://yann.lecun.com/exdb/mnist/

檔案列表:
- train-images-idx3-ubyte.gz  (訓練影像)
- train-labels-idx1-ubyte.gz  (訓練標籤)
- t10k-images-idx3-ubyte.gz   (測試影像)
- t10k-labels-idx1-ubyte.gz   (測試標籤)

CIFAR-10 資料集
├── 訓練集 (50,000 張，5 個批次)
│   ├── data_batch_1: 10,000 張
│   ├── data_batch_2: 10,000 張
│   ├── data_batch_3: 10,000 張
│   ├── data_batch_4: 10,000 張
│   └── data_batch_5: 10,000 張
│
└── 測試集 (10,000 張)
    └── test_batch: 10,000 張

每個類別:
├── 訓練集: 5,000 張 (完全平衡)
└── 測試集: 1,000 張 (完全平衡)

# 在 Colab 中視覺化 CIFAR-10
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import cifar10
import numpy as np

# 載入資料
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

# 類別名稱
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
               'dog', 'frog', 'horse', 'ship', 'truck']
class_names_zh = ['飛機', '汽車', '鳥', '貓', '鹿',
                  '狗', '青蛙', '馬', '船', '卡車']

# 顯示資料集資訊
print("=" * 60)
print("CIFAR-10 資料集資訊")
print("=" * 60)
print(f"訓練集影像形狀: {X_train.shape}")  # (50000, 32, 32, 3)
print(f"訓練集標籤形狀: {y_train.shape}")  # (50000, 1)
print(f"測試集影像形狀: {X_test.shape}")   # (10000, 32, 32, 3)
print(f"測試集標籤形狀: {y_test.shape}")   # (10000, 1)
print(f"像素值範圍: {X_train.min()} ~ {X_train.max()}")
print(f"資料類型: {X_train.dtype}")
print(f"影像通道數: {X_train.shape[3]} (RGB)")

# 統計每個類別的數量
y_train_flat = y_train.flatten()
print("\n訓練集各類別分布:")
unique, counts = np.unique(y_train_flat, return_counts=True)
for digit, count in zip(unique, counts):
    print(f"  {class_names[digit]:12s} ({class_names_zh[digit]}): {count:,} 張")

# 視覺化：每個類別顯示 10 個範例
fig, axes = plt.subplots(10, 10, figsize=(15, 15))
fig.suptitle('CIFAR-10 影像範例 (每行一個類別)', fontsize=16)

for i in range(10):  # 10 個類別
    # 找出該類別的索引
    indices = np.where(y_train_flat == i)[0]

    for j in range(10):  # 每個類別顯示 10 個範例
        idx = indices[j]
        ax = axes[i, j]
        ax.imshow(X_train[idx])
        ax.axis('off')
        if j == 0:
            ax.set_ylabel(f'{class_names[i]}\n{class_names_zh[i]}',
                         fontsize=10, fontweight='bold')

plt.tight_layout()
plt.show()

# 顯示單張影像的細節
print("\n" + "=" * 60)
print("單張影像詳細資訊")
print("=" * 60)
sample_idx = 0
print(f"標籤: {y_train[sample_idx][0]} ({class_names[y_train[sample_idx][0]]})")
print(f"影像形狀: {X_train[sample_idx].shape}")
print(f"RGB 三個通道的像素範圍:")
print(f"  R 通道: {X_train[sample_idx][:,:,0].min()} ~ {X_train[sample_idx][:,:,0].max()}")
print(f"  G 通道: {X_train[sample_idx][:,:,1].min()} ~ {X_train[sample_idx][:,:,1].max()}")
print(f"  B 通道: {X_train[sample_idx][:,:,2].min()} ~ {X_train[sample_idx][:,:,2].max()}")

# 計算並顯示資料集統計資訊
print("\n資料集統計資訊 (用於標準化):")
mean_r = X_train[:,:,:,0].mean() / 255
mean_g = X_train[:,:,:,1].mean() / 255
mean_b = X_train[:,:,:,2].mean() / 255
std_r = X_train[:,:,:,0].std() / 255
std_g = X_train[:,:,:,1].std() / 255
std_b = X_train[:,:,:,2].std() / 255

print(f"  均值 (Mean): [{mean_r:.4f}, {mean_g:.4f}, {mean_b:.4f}]")
print(f"  標準差 (Std): [{std_r:.4f}, {std_g:.4f}, {std_b:.4f}]")

============================================================
CIFAR-10 資料集資訊
============================================================
訓練集影像形狀: (50000, 32, 32, 3)
訓練集標籤形狀: (50000, 1)
測試集影像形狀: (10000, 32, 32, 3)
測試集標籤形狀: (10000, 1)
像素值範圍: 0 ~ 255
資料類型: uint8
影像通道數: 3 (RGB)

訓練集各類別分布:
  airplane     (飛機): 5,000 張
  automobile   (汽車): 5,000 張
  bird         (鳥): 5,000 張
  cat          (貓): 5,000 張
  deer         (鹿): 5,000 張
  dog          (狗): 5,000 張
  frog         (青蛙): 5,000 張
  horse        (馬): 5,000 張
  ship         (船): 5,000 張
  truck        (卡車): 5,000 張

資料集統計資訊 (用於標準化):
  均值 (Mean): [0.4914, 0.4822, 0.4465]
  標準差 (Std): [0.2470, 0.2435, 0.2616]

from tensorflow.keras.datasets import cifar10

# 自動下載並載入
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

# 注意：標籤形狀是 (50000, 1)，需要 flatten
y_train = y_train.flatten()  # (50000,)

from torchvision import datasets, transforms

# 下載訓練集
train_dataset = datasets.CIFAR10(
    root='./data',
    train=True,
    download=True,
    transform=transforms.ToTensor()
)

# 下載測試集
test_dataset = datasets.CIFAR10(
    root='./data',
    train=False,
    download=True,
    transform=transforms.ToTensor()
)

官方網站: https://www.cs.toronto.edu/~kriz/cifar.html

Python 版本:
- cifar-10-python.tar.gz  (163 MB)

內容:
- data_batch_1 ~ 5 (訓練集)
- test_batch (測試集)
- batches.meta (元資料)

2012  AlexNet 風格      ~80%   (深度 CNN)
2014  VGGNet             ~92%   (更深的網路)
2015  ResNet             ~93%   (殘差連接)
2016  DenseNet           ~96%   (密集連接)
2019  EfficientNet       ~98%   (複合縮放)
2020  Vision Transformer ~99%+  (Transformer)

人類表現: 約 94%

# ============ Keras 風格 ============
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, Flatten

# 使用 Sequential API（適合線性堆疊）
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    Flatten(),
    Dense(10, activation='softmax')
])

# 編譯模型（一次設定所有訓練參數）
model.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# 訓練（一行搞定）
history = model.fit(X_train, y_train, epochs=10, batch_size=32)


# ============ PyTorch 風格 ============
import torch
import torch.nn as nn

# 繼承 nn.Module（更靈活、物件導向）
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3)
        self.fc1 = nn.Linear(26*26*32, 10)  # 需要手動計算維度

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = x.view(x.size(0), -1)  # Flatten
        x = self.fc1(x)
        return x

model = SimpleCNN()

# 需要分別定義損失函數和優化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 需要手寫訓練迴圈
for epoch in range(10):
    for batch_x, batch_y in train_loader:
        optimizer.zero_grad()
        output = model(batch_x)
        loss = criterion(output, batch_y)
        loss.backward()
        optimizer.step()

# CPU 版本
pip install tensorflow

# GPU 版本（自動包含 CUDA）
pip install tensorflow[and-cuda]

# 驗證安裝
python -c "import tensorflow as tf; print(tf.__version__)"

# 訪問 https://pytorch.org/ 根據系統選擇安裝指令

# 範例（CUDA 11.8）：
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# CPU 版本：
pip3 install torch torchvision torchaudio

# 驗證安裝
python -c "import torch; print(torch.__version__); print(torch.cuda.is_available())"

# Colab 已預裝 TensorFlow 和 PyTorch
# 直接檢查版本即可

import tensorflow as tf
import torch

print(f"TensorFlow version: {tf.__version__}")
print(f"PyTorch version: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")

# ============================================
# 儲存格 0: 環境檢查
# ============================================
import tensorflow as tf
import torch
import sys

print("=" * 60)
print("環境資訊")
print("=" * 60)
print(f"Python 版本: {sys.version.split()[0]}")
print(f"TensorFlow 版本: {tf.__version__}")
print(f"PyTorch 版本: {torch.__version__}")

print("\n" + "=" * 60)
print("GPU 資訊")
print("=" * 60)

# TensorFlow GPU
tf_gpus = tf.config.list_physical_devices('GPU')
print(f"TensorFlow 可用 GPU: {len(tf_gpus)}")
if tf_gpus:
    for gpu in tf_gpus:
        print(f"  - {gpu}")

# PyTorch GPU
print(f"\nPyTorch CUDA 可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"PyTorch GPU 型號: {torch.cuda.get_device_name(0)}")
    print(f"PyTorch GPU 記憶體: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")

# 記憶體資訊
print("\n" + "=" * 60)
print("系統資源")
print("=" * 60)
!nvidia-smi --query-gpu=name,memory.total,memory.free --format=csv

============================================================
環境資訊
============================================================
Python 版本: 3.10.12
TensorFlow 版本: 2.15.0
PyTorch 版本: 2.1.0+cu118

============================================================
GPU 資訊
============================================================
TensorFlow 可用 GPU: 1
  - PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')

PyTorch CUDA 可用: True
PyTorch GPU 型號: Tesla T4
PyTorch GPU 記憶體: 14.75 GB

============================================================
系統資源
============================================================
name, memory.total [MiB], memory.free [MiB]
Tesla T4, 15102 MiB, 15099 MiB

# ============================================
# 儲存格 1: 掛載 Google Drive
# ============================================
from google.colab import drive
import os

# 掛載 Drive
drive.mount('/content/drive')

# 建立專案資料夾
project_folder = '/content/drive/MyDrive/CNN_Tutorial'
os.makedirs(project_folder, exist_ok=True)

print(f"✓ Google Drive 已掛載")
print(f"✓ 專案資料夾: {project_folder}")

# 切換工作目錄
os.chdir(project_folder)
print(f"✓ 當前工作目錄: {os.getcwd()}")

# ============================================
# MNIST + LeNet-5 完整實作（Keras/TensorFlow）
# 執行環境：Google Colab
# 預期訓練時間：2-3 分鐘（GPU）
# 預期準確率：>98.5%
# ============================================

# ========== 儲存格 1: 導入套件 ==========
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix, classification_report

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint

# 檢查 TensorFlow 版本和 GPU
print(f"TensorFlow 版本: {tf.__version__}")
print(f"GPU 可用: {len(tf.config.list_physical_devices('GPU')) > 0}")

# 設定隨機種子（可重現結果）
np.random.seed(42)
tf.random.set_seed(42)

# ========== 儲存格 2: 載入並視覺化資料 ==========
print("載入 MNIST 資料集...")
(X_train, y_train), (X_test, y_test) = mnist.load_data()

print(f"訓練集形狀: {X_train.shape}")  # (60000, 28, 28)
print(f"測試集形狀: {X_test.shape}")    # (10000, 28, 28)

# 視覺化前 25 張影像
fig, axes = plt.subplots(5, 5, figsize=(10, 10))
for i, ax in enumerate(axes.flat):
    ax.imshow(X_train[i], cmap='gray')
    ax.set_title(f'Label: {y_train[i]}')
    ax.axis('off')
plt.suptitle('MNIST 訓練集範例', fontsize=16)
plt.tight_layout()
plt.show()

# ========== 儲存格 3: 資料預處理 ==========
def preprocess_data(X_train, y_train, X_test, y_test):
    """
    預處理 MNIST 資料
    1. Padding: 28x28 → 32x32 (LeNet-5 原始設計)
    2. 增加通道維度: (32, 32) → (32, 32, 1)
    3. 正規化: [0, 255] → [0, 1]
    4. One-Hot 編碼標籤
    """
    # 1. Padding
    X_train_pad = np.pad(X_train, ((0,0), (2,2), (2,2)), mode='constant', constant_values=0)
    X_test_pad = np.pad(X_test, ((0,0), (2,2), (2,2)), mode='constant', constant_values=0)

    # 2. Reshape: 增加通道維度
    X_train_pad = X_train_pad.reshape(-1, 32, 32, 1)
    X_test_pad = X_test_pad.reshape(-1, 32, 32, 1)

    # 3. 正規化
    X_train_pad = X_train_pad.astype('float32') / 255.0
    X_test_pad = X_test_pad.astype('float32') / 255.0

    # 4. One-Hot 編碼
    y_train_cat = to_categorical(y_train, 10)
    y_test_cat = to_categorical(y_test, 10)

    print("資料預處理完成！")
    print(f"  訓練集形狀: {X_train_pad.shape}")
    print(f"  標籤形狀: {y_train_cat.shape}")
    print(f"  像素值範圍: [{X_train_pad.min():.2f}, {X_train_pad.max():.2f}]")

    return X_train_pad, y_train_cat, X_test_pad, y_test_cat

X_train_proc, y_train_proc, X_test_proc, y_test_proc = preprocess_data(
    X_train, y_train, X_test, y_test
)

# ========== 儲存格 4: 建立 LeNet-5 模型 ==========
def create_lenet5(input_shape=(32, 32, 1), num_classes=10):
    """
    LeNet-5 架構
    - 論文: LeCun et al. (1998)
    - 架構: C1 → S2 → C3 → S4 → Flatten → FC1 → FC2 → Output
    """
    model = Sequential(name='LeNet-5')

    # 卷積層 C1: 32x32x1 → 28x28x6
    # 註：原始 LeNet-5 使用 tanh（1998 年標準），現代 CNN 主流使用 ReLU（收斂更快、避免梯度消失）
    model.add(Conv2D(6, (5, 5), activation='tanh', input_shape=input_shape, name='C1'))

    # 池化層 S2: 28x28x6 → 14x14x6
    # 註：原始 LeNet-5 使用 AveragePooling，現代 CNN 主流使用 MaxPooling（保留最顯著特徵）
    model.add(AveragePooling2D((2, 2), strides=2, name='S2'))

    # 卷積層 C3: 14x14x6 → 10x10x16
    model.add(Conv2D(16, (5, 5), activation='tanh', name='C3'))

    # 池化層 S4: 10x10x16 → 5x5x16
    model.add(AveragePooling2D((2, 2), strides=2, name='S4'))

    # 展平: 5x5x16 → 400
    model.add(Flatten(name='Flatten'))

    # 全連接層 C5: 400 → 120
    model.add(Dense(120, activation='tanh', name='C5'))

    # 全連接層 F6: 120 → 84
    model.add(Dense(84, activation='tanh', name='F6'))

    # 輸出層: 84 → 10
    model.add(Dense(num_classes, activation='softmax', name='Output'))

    return model

# 建立模型
model = create_lenet5()

# 顯示模型架構
model.summary()

# ========== 儲存格 5: 編譯模型 ==========
model.compile(
    optimizer=Adam(learning_rate=0.001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

print("✓ 模型編譯完成")

# ========== 儲存格 6: 設定 Callbacks ==========
callbacks = [
    # Early Stopping: 驗證損失 5 個 epoch 沒改善就停止
    EarlyStopping(
        monitor='val_loss',
        patience=5,
        restore_best_weights=True,
        verbose=1
    ),

    # 學習率衰減: 驗證損失 3 個 epoch 沒改善就降低學習率
    ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.5,
        patience=3,
        min_lr=1e-6,
        verbose=1
    ),

    # 儲存最佳模型
    ModelCheckpoint(
        'best_lenet5.h5',
        monitor='val_accuracy',
        save_best_only=True,
        verbose=1
    )
]

# ========== 儲存格 7: 訓練模型 ==========
print("開始訓練...")
print("=" * 60)

history = model.fit(
    X_train_proc, y_train_proc,
    batch_size=128,
    epochs=20,
    validation_split=0.1,  # 10% 作為驗證集
    callbacks=callbacks,
    verbose=1
)

print("\n✓ 訓練完成！")

# ========== 儲存格 8: 評估模型 ==========
print("\n" + "=" * 60)
print("在測試集上評估模型")
print("=" * 60)

test_loss, test_accuracy = model.evaluate(X_test_proc, y_test_proc, verbose=0)
print(f"測試集損失: {test_loss:.4f}")
print(f"測試集準確率: {test_accuracy*100:.2f}%")

# ========== 儲存格 9: 視覺化訓練歷史 ==========
fig, axes = plt.subplots(1, 2, figsize=(15, 5))

# 準確率
axes[0].plot(history.history['accuracy'], 'b-', label='訓練準確率', linewidth=2)
axes[0].plot(history.history['val_accuracy'], 'r-', label='驗證準確率', linewidth=2)
axes[0].set_title('LeNet-5 訓練準確率', fontsize=14, fontweight='bold')
axes[0].set_xlabel('Epoch')
axes[0].set_ylabel('準確率')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 損失
axes[1].plot(history.history['loss'], 'b-', label='訓練損失', linewidth=2)
axes[1].plot(history.history['val_loss'], 'r-', label='驗證損失', linewidth=2)
axes[1].set_title('LeNet-5 訓練損失', fontsize=14, fontweight='bold')
axes[1].set_xlabel('Epoch')
axes[1].set_ylabel('損失值')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# ========== 儲存格 10: 混淆矩陣 ==========
# 預測
y_pred = model.predict(X_test_proc, verbose=0)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true_classes = np.argmax(y_test_proc, axis=1)

# 計算混淆矩陣
cm = confusion_matrix(y_true_classes, y_pred_classes)

# 繪製
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=range(10), yticklabels=range(10))
plt.title('LeNet-5 混淆矩陣', fontsize=16, fontweight='bold')
plt.xlabel('預測標籤')
plt.ylabel('真實標籤')
plt.show()

# 分類報告
print("\n分類報告:")
print(classification_report(y_true_classes, y_pred_classes,
                           target_names=[f'數字 {i}' for i in range(10)]))

# ========== 儲存格 11: 預測範例視覺化 ==========
# 隨機選擇 20 張測試影像
indices = np.random.choice(len(X_test), 20, replace=False)

fig, axes = plt.subplots(4, 5, figsize=(15, 12))
for i, ax in enumerate(axes.flat):
    idx = indices[i]

    # 原始影像（28x28，移除 padding）
    img = X_test[idx]

    # 預測
    img_proc = X_test_proc[idx:idx+1]
    pred = model.predict(img_proc, verbose=0)
    pred_class = np.argmax(pred)
    true_class = y_test[idx]
    confidence = pred[0][pred_class] * 100

    # 顯示
    ax.imshow(img, cmap='gray')
    color = 'green' if pred_class == true_class else 'red'
    ax.set_title(
        f'真實: {true_class} | 預測: {pred_class}\n信心度: {confidence:.1f}%',
        color=color, fontsize=9
    )
    ax.axis('off')

plt.suptitle('LeNet-5 預測結果（綠色=正確，紅色=錯誤）',
             fontsize=16, fontweight='bold')
plt.tight_layout()
plt.show()

print("\n✓ 所有程式碼執行完成！")

X_train_pad = np.pad(X_train, ((0,0), (2,2), (2,2)), mode='constant', constant_values=0)

y_train_cat = to_categorical(y_train, 10)

原始標籤: 5
One-Hot:  [0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
          └─────────────┬─────────────┘
                      索引 5 為 1

Epoch 1-5:  lr = 0.001 (初始)
Epoch 6-8:  lr = 0.001 (驗證損失持續改善)
Epoch 9-11: lr = 0.001 (驗證損失停滯)
Epoch 12:   lr = 0.0005 (觸發衰減)
Epoch 15:   lr = 0.00025 (再次衰減)

Epoch 1/20
422/422 [==============================] - 3s 6ms/step - loss: 0.3421 - accuracy: 0.8945 - val_loss: 0.1234 - val_accuracy: 0.9632
Epoch 2/20
422/422 [==============================] - 2s 5ms/step - loss: 0.0981 - accuracy: 0.9701 - val_loss: 0.0789 - val_accuracy: 0.9758
...
Epoch 10/20
422/422 [==============================] - 2s 5ms/step - loss: 0.0145 - accuracy: 0.9954 - val_loss: 0.0412 - val_accuracy: 0.9875

Epoch 10: ReduceLROnPlateau reducing learning rate to 0.0005000000237487257.

============================================================
在測試集上評估模型
============================================================
測試集損失: 0.0389
測試集準確率: 98.76%

              precision    recall  f1-score   support

      數字 0       0.99      0.99      0.99       980
      數字 1       0.99      1.00      0.99      1135
      數字 2       0.99      0.98      0.98      1032
      數字 3       0.98      0.99      0.99      1010
      數字 4       0.99      0.98      0.99       982
      數字 5       0.98      0.99      0.98       892
      數字 6       0.99      0.99      0.99       958
      數字 7       0.98      0.99      0.99      1028
      數字 8       0.99      0.98      0.98       974
      數字 9       0.98      0.98      0.98      1009

    accuracy                           0.99     10000

CPU (batch_size=128):  約 10-15 分鐘
GPU (batch_size=128):  約 2-3 分鐘  ← 快 5 倍
GPU (batch_size=256):  約 1-2 分鐘  ← 快 8 倍

# 減少 batch_size
history = model.fit(..., batch_size=64)  # 從 128 減到 64

# 或清空 GPU 記憶體
from tensorflow.keras import backend as K
K.clear_session()