訓練曲線怎麼讀：
訓練 0.81、驗證 0.72，這個差距代表什麼

這節只講這段程式真的會用到的語法，例子全部取自本題。中間有兩支動畫：先用「練習卷和模擬考」看懂兩條線在比什麼，最後打開記憶體，看 fit 交回來的東西真正長什麼樣子；每支動畫前後都有文字說明。

第 3 支動畫（四個選項的曲線，各真的訓練一次）放在 §4，和學習曲線判讀器一起看。

{'accuracy':     [0.47, 0.65, …],   # 訓練準確率，每輪一個
 'loss':         [ …              ],   # 訓練損失
 'val_accuracy': [0.63, 0.69, …],   # 驗證準確率
 'val_loss':     [ …              ]}   # 驗證損失

history.history['accuracy']
#  ↑       ↑         ↑
#  名牌    屬性      鍵
#  （你取的變數名，指向 History 物件）
#          （History 物件身上，名叫 history 的那個字典）
#                    （字典裡的一個鍵 → 拿到 list）

h = model.fit(...)              # 名牌改叫 h
h.history['accuracy']           # 一樣拿得到
h.epoch                         # [0, 1, …, 9]：每一輪的編號（另一個屬性）
h.params                        # {'verbose': …, 'epochs': 10, 'steps': 1563}

plt.plot(history.history['accuracy'], 'bo-', label='Train Accuracy')
#        ↑ 資料（一個 list）              ↑ 格式   ↑ 圖例上的名字

把 6 個觀念串起來：本題的「類別 → 物件 → 方法」路線

把觀念合起來：Python 執行 compile、fit、plot 時，記憶體裡發生什麼

訓練時一定會看到的五個名詞

訓練、驗證、測試：三份資料各管什麼

一輪（epoch）裡面發生的事

注意 ③ 和 ④ 的量法不一樣：訓練分數是「邊學邊算」的平均，而且量的時候 Dropout 正在隨機關掉神經元；驗證分數是一輪結束後、模型最完整的狀態下重新考一次。這就是前幾輪驗證分數常常比訓練分數還高的原因，§4 有實測。

學習曲線的四種典型樣子（§4 都有實測）

下面每一組都是在本機真的訓練出來的（TensorFlow 2.20、Keras 3.13.1、CPU）：同一份 CIFAR-10、同一份驗證資料、同一個亂數種子，每次只改一個設定，對應題目的四個選項。考卷那張圖也放進來對照。所有數字都是 history 裡實際記下來的值。

實測一：前幾輪，驗證為什麼反而比訓練高？

勾選判讀器上方的方框，會多一條綠色虛線：每一輪結束後，拿 1 萬張訓練圖片用推論模式（Dropout 關掉、BN 用累積的平均，也就是和驗證同一把尺）重新量一次準確率。考題設定那一次的實測：

用同一把尺量，訓練資料每一輪都比驗證高。所以「驗證比訓練高」不是模型在沒看過的圖上比較厲害，而是 fit 記下的訓練分數打了兩次折：① 它是這一輪 1,563 批一路累積的平均，前面還沒學好的批次也算進去；② 量的時候 Dropout 正在隨機關掉神經元。反過來看最後一輪：用同一把尺，訓練 0.898、驗證 0.817，真正的落差是 0.081，比圖上看到的 0.036 還大。

實測二：同一支程式再跑一次，曲線就不一樣

權重的初始值、每一輪打亂資料的順序、Dropout 每次關掉哪些神經元，全都是隨機的，所以每次訓練的曲線都會有些不同。考卷那一次在橫軸 6 驗證掉到 0.72、下一輪又回到 0.80；本頁這一次沒有掉。單一輪的起伏不能當成結論，要看整條曲線的趨勢。

實測三：批次太大那一組，驗證為什麼有 3 輪卡在 0.10？

batch_size=1024 時，訓練準確率照常上升（第 3 輪 0.571），驗證準確率卻停在 0.10，正好是 10 類亂猜的水準；連訓練資料用推論模式重量也只有 0.10。所以這不是「背了訓練資料」。用同樣設定再訓練 3 輪，同一個模型、同一份驗證資料，換兩種模式考：

模型其實學會了，問題出在 BatchNormalization 推論時用的移動平均。它每一步只更新一點點（momentum=0.99：新平均 = 0.99 × 舊平均 + 0.01 × 這一批的平均），起始值是平均 0、變異數 1。batch_size=1024 一輪只有 49 步，3 輪才 147 步，起始值還佔 0.99¹⁴⁷ ≈ 23%，統計值還沒追上；到第 10 輪（490 步）驗證就回到 0.583。所以「批次太大」也可能讓兩條線分開，但長相完全不同：驗證貼在 0.10，訓練資料用推論模式量也一樣低。考卷的圖兩條線前 6 輪一起上升、緊緊靠著，不是這一種。

動畫 3：四個選項的曲線，各真的訓練一次

記一張表就夠：四個選項的曲線長相（全部實測）

把第 46、47 題的程式和本頁補出來的訓練、畫圖接起來，就是一支完整、可以直接跑的程式。下面這份在本機實際跑過（TensorFlow 2.20、Keras 3.13.1、CPU），輸出和圖都是那一次的結果。複製到 Google Colab 也能直接執行（建議開 GPU）；第一次執行會下載約 170 MB 的 CIFAR-10。

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt

tf.keras.utils.set_random_seed(42)        # 固定亂數，讓結果比較能重現

# ---- 第 46 題：載入與前處理 ----
(x_train, y_train), (x_test, y_test) = datasets.cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# ---- 第 47 題：建模型 ----
model = models.Sequential([
    layers.Input(shape=(32, 32, 3)),
    layers.Conv2D(32, kernel_size=(3,3), padding="same", activation="relu"),
    layers.BatchNormalization(),
    layers.Conv2D(32, (3,3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2,2)),
    layers.Dropout(0.25),

    layers.Conv2D(64, (3,3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(64, (3,3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2,2)),
    layers.Dropout(0.25),

    layers.Conv2D(128, (3,3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(128, (3,3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2,2)),
    layers.Dropout(0.25),

    layers.Flatten(),
    layers.Dense(256, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

# ---- 第 48 題：訓練＋畫圖（考卷沒印，這裡補上） ----
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

history = model.fit(x_train, y_train,
                    epochs=10,
                    validation_data=(x_test, y_test),
                    verbose=2)                 # 每輪印一行

acc = history.history['accuracy']
val = history.history['val_accuracy']
print('鍵：', list(history.history.keys()))
print('索引 6（第 7 輪）：訓練', round(acc[6], 4), '驗證', round(val[6], 4))
print('每輪差距（訓練 − 驗證）：', [round(a - v, 3) for a, v in zip(acc, val)])

plt.plot(acc, 'bo-', label='Train Accuracy')
plt.plot(val, 'ro-', label='Validation Accuracy')
plt.title('Training and Validation Accuracy for CIFAR-10 with CNN')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.grid(True, linestyle='--')
plt.savefig('cifar10_curve.png', dpi=120)   # 要存檔，寫在 show 之前
plt.show()

實際跑出來的結果

Epoch 1/10
1563/1563 - 34s - 21ms/step - accuracy: 0.4850 - loss: 1.4934 - val_accuracy: 0.5888 - val_loss: 1.1906
Epoch 2/10
1563/1563 - 32s - 20ms/step - accuracy: 0.6605 - loss: 0.9694 - val_accuracy: 0.6586 - val_loss: 0.9676
Epoch 3/10
1563/1563 - 32s - 20ms/step - accuracy: 0.7147 - loss: 0.8212 - val_accuracy: 0.7328 - val_loss: 0.7728
Epoch 4/10
1563/1563 - 32s - 21ms/step - accuracy: 0.7463 - loss: 0.7296 - val_accuracy: 0.7255 - val_loss: 0.8106
Epoch 5/10
1563/1563 - 33s - 21ms/step - accuracy: 0.7743 - loss: 0.6533 - val_accuracy: 0.7293 - val_loss: 0.8236
Epoch 6/10
1563/1563 - 33s - 21ms/step - accuracy: 0.7957 - loss: 0.5909 - val_accuracy: 0.7799 - val_loss: 0.6552
Epoch 7/10
1563/1563 - 33s - 21ms/step - accuracy: 0.8134 - loss: 0.5394 - val_accuracy: 0.7911 - val_loss: 0.6178
Epoch 8/10
1563/1563 - 32s - 21ms/step - accuracy: 0.8286 - loss: 0.5024 - val_accuracy: 0.7976 - val_loss: 0.6141
Epoch 9/10
1563/1563 - 32s - 21ms/step - accuracy: 0.8411 - loss: 0.4638 - val_accuracy: 0.7909 - val_loss: 0.6434
Epoch 10/10
1563/1563 - 33s - 21ms/step - accuracy: 0.8488 - loss: 0.4307 - val_accuracy: 0.8330 - val_loss: 0.5135
鍵： ['accuracy', 'loss', 'val_accuracy', 'val_loss']
索引 6（第 7 輪）：訓練 0.8134 驗證 0.7911
每輪差距（訓練 − 驗證）： [-0.104, 0.002, -0.018, 0.021, 0.045, 0.016, 0.022, 0.031, 0.05, 0.016]

• 每一輪的那一行怎麼讀：1563/1563 是這一輪跑完的步數（50,000 ÷ 32 進位）；32s - 20ms/step 是這一輪花的時間和每一步的平均時間（本機 CPU）；後面四個數字就是 history 裡 4 個 list 在這一輪新增的值。
• 這次的曲線更像考卷：驗證在橫軸 3、4 和 8 都掉了一下，最後一輪又跳到 0.833。單一輪的起伏很常見，要看整條趨勢。
• 第 1 輪驗證比訓練高 0.104：原因就是 §4 實測一，訓練分數是一路累積的平均，而且 Dropout 開著。
• 和 §4「考題設定」那次用同一個亂數種子，數字還是不一樣：TensorFlow 在 CPU 上的平行運算不保證每次結果完全相同。要完全重現，得另外呼叫 tf.config.experimental.enable_op_determinism()（會變慢）。
• plt.show() 會停住程式：在一般的 .py 程式裡，它會跳出一個圖的視窗，程式停在這一行，要把視窗關掉才會結束；本頁驗證時就是這樣。在 Colab、Jupyter 裡，圖會直接顯示在儲存格下方。

加一個 EarlyStopping：驗證變差就自動停下

es = tf.keras.callbacks.EarlyStopping(monitor='val_loss',          # 盯著驗證 loss
                                      patience=3,                  # 連續 3 輪沒進步就停
                                      restore_best_weights=True)   # 權重退回最好的那一輪
history = model.fit(x_train, y_train,
                    epochs=50,                                     # 上限給大一點，交給它決定
                    validation_data=(x_test, y_test),
                    callbacks=[es])

EarlyStopping 和 History 一樣是 callback，每一輪結束時被 Keras 叫起來檢查一次。把 §4「拿掉正則化」那次真實的驗證 loss 一輪一輪交給 Keras 的 EarlyStopping 物件檢查（沒有重新訓練）：它在橫軸 6 停下（stopped_epoch = 6），權重退回橫軸 3（best_epoch = 3），正好是驗證 loss 最低的那一輪。那次訓練在橫軸 3 之後的 16 輪，驗證 loss 沒有一輪比橫軸 3 好；EarlyStopping 會省下最後 13 輪，留下最好的那一份權重。