AI 工程從零開始｜Phase 3：深度學習核心 — 從第一原理構建神經網路

大多數人學深度學習：model.fit() 呼叫一行，調調 learning rate，祈禱 loss 下降。 正確的方式是：從矩陣乘法開始，手算梯度，理解每個超參數的幾何意義—— 因為當模型在生產環境爆炸時，你唯一能依靠的，是對第一原理的理解。 框架可以抽象實作，但它無法替你理解為什麼。

這篇給已經會呼叫 model.fit()、但還沒有手算過一次梯度的工程師看。讀完你會能用純 NumPy 寫出一個可訓練的兩層網路，看懂反向傳播每一步在做什麼，並為一個「< 20ms 回應、1 萬維稀疏輸入」的即時推薦模型，有依據地選出激活函數、正則化策略與最佳化器——當驗證集準確率卡在 78% 不動時，也知道該從梯度 norm、BatchNorm 模式還是學習率排程開始診斷。

一、核心問題：為什麼要從第一原理理解神經網路

絕大多數工程師進入深度學習的路徑是：安裝 PyTorch，複製一段 ResNet 範例程式，調整幾個參數，模型能跑了就交差。這種「黑盒操作」在 Kaggle 比賽或 Demo 原型中勉強夠用，但在生產環境中，它會讓你付出慘痛代價。

真實問題是這樣出現的：

• 模型訓練時 loss 突然爆炸（NaN），你不知道是梯度消失還是梯度爆炸，因為你從未手算過梯度
• 推論延遲從 8ms 升到 150ms，但你不理解 BatchNorm 在推論階段的行為與訓練階段不同
• 模型在訓練集 95% 準確率，測試集 61%，你不知道該加 Dropout 還是 L2，還是兩者都要
• 換了 AdamW 替代 SGD 後，收斂快了但泛化變差，你不知道 weight decay 的幾何意義是什麼

從第一原理理解神經網路，解決的不是「能不能跑起來」，而是「出問題時能不能診斷並修復」。

本文的工程目標：

1. 理解神經網路的數學本質，能手算任意小型網路的前向與反向傳播
2. 能在沒有框架的情況下，用純 NumPy 實作一個可訓練的兩層網路
3. 掌握每個設計決策（激活函數、正則化、最佳化器）的量化 tradeoff
4. 能給出有數字支撐的架構決策，而非「視情況而定」

二、何時該升級：從淺層 MLP 到深層網路與分散式訓練的觸發條件

神經網路的深度與訓練基礎設施應該由症狀決定，而不是由「看起來夠先進」決定。一個 2–3 層、隱藏維度 128 的 MLP 配 ReLU + Dropout、Adam、批次訓練，足以驗證特徵有沒有訊號；它的代價是模型重現性差、沒有監控，也撐不住高並發。當推論請求超過 10 QPS，或模型更新頻率需要自動化時，就該把它升級成 4–6 層、維度 512、加上 BatchNorm 與 Dropout 的網路，並把實驗追蹤、ONNX 匯出（推論延遲約 -40%）與水平擴展補齊，讓 P99 延遲能壓在 15ms 內。

第二道門檻在訓練端：當推論延遲 P99 > 20ms，或訓練資料超過 5,000 萬筆、單機一輪訓練拉長到兩天，才值得引入資料並行（DDP）、混合精度（FP16 前向 + FP32 梯度累積）與 INT8 量化（延遲 -60%，精度損失 < 0.5%），並改以 Shadow Mode → Canary 的方式發布——此時成本從每月數千美元跳到數萬美元，所以要先確認 §九 的資料量閾值已經越過。

三、感知機到多層網路：通用近似定理

感知機（1958） 是神經網路的起點：一個線性分類器。

輸入 x₁, x₂ → 加權求和 → 階躍函數 → 輸出
z = w₁x₁ + w₂x₂ + b
ŷ = 1 if z ≥ 0, else 0

感知機的根本限制：無法學習 XOR 函數，因為 XOR 不是線性可分的。

通用近似定理（Universal Approximation Theorem） 告訴我們：

含有一個隱藏層、使用非線性激活函數的神經網路，可以以任意精度近似任何連續函數（在緊緻子集上）。

但「可以」不等於「容易學到」。關鍵在於：

• 深度比寬度更高效：近似同一函數，深層窄網路所需參數數量通常是淺層寬網路的指數分之一
• 非線性是核心：沒有非線性激活函數，多層堆疊等效於一層線性變換
• 深度的詛咒：層數增加帶來梯度消失問題，需要殘差連接（ResNet）或精心設計的初始化

感知機到多層網路的演進：

┌───────────────────────────────────────────────────────────────┐
│  感知機（線性邊界）                                             │
│                                                               │
│  ● ● ●      ○ ○                                              │
│  ● ●    ─────────    ○                                       │
│  ●          ○ ○ ○                                            │
│                                                               │
│  MLP（非線性邊界）                                             │
│                                                               │
│  ● ● ●      ○ ○                                              │
│  ●  ●   ╭─────╮  ○                                          │
│  ●   ●  ╰─────╯    ○                                        │
│         曲線決策邊界（XOR 可分）                               │
└───────────────────────────────────────────────────────────────┘

工程意義： 對於推薦系統中的 10,000 維稀疏輸入，用 4 層 [10000 → 512 → 256 → 128 → 1] 的網路，比用 1 層 [10000 → 10000 → 1] 節省 99% 參數，且泛化通常更好。

層深度與容量的量化關係：

• 1 層隱藏（128 神經元）：可近似平滑函數，但需要極寬（理論上無限）才能近似複雜函數
• 3 層隱藏（128 × 3）：可近似大多數現實中的分類邊界，是推薦系統的起始點
• 6 層隱藏（256 × 6）：可學習層次化特徵表示，適合複雜互動特徵建模
• 12 層以上：需要殘差連接避免梯度消失，訓練成本指數增加

Embedding 層的工程意義： 高維稀疏輸入（如 10K 維 one-hot 特徵）若直接進入 MLP，第一層參數量 = 10K × 512 = 5.12M。若先用 Embedding 壓縮至 64 維，再進 MLP，第一層參數量 = 64 × 512 = 32K，減少 160 倍，且學到了語意相似性。

四、反向傳播完整推導（含計算圖）

反向傳播本質是鏈式法則的系統化應用。以下用計算圖展示一個完整的前向/反向傳播。

網路結構： 2 輸入 → 2 隱藏 → 1 輸出（二元分類）

前向傳播計算圖：

  x₁ ─┐
       ├─► z₁ = w₁₁x₁ + w₂₁x₂ + b₁ ─► a₁ = ReLU(z₁) ─┐
  x₂ ─┤                                                   ├─► z₃ = v₁a₁ + v₂a₂ + b₃ ─► ŷ = σ(z₃)
       └─► z₂ = w₁₂x₁ + w₂₂x₂ + b₂ ─► a₂ = ReLU(z₂) ─┘

損失：L = -[y·log(ŷ) + (1-y)·log(1-ŷ)]   （二元交叉熵）

反向傳播推導：

Step 1：輸出層梯度

∂L/∂ŷ = -(y/ŷ) + (1-y)/(1-ŷ)
∂ŷ/∂z₃ = ŷ(1-ŷ)           （Sigmoid 導數）
∂L/∂z₃ = ŷ - y             （化簡後的優雅形式）

Step 2：隱藏層到輸出層的權重梯度

∂L/∂v₁ = ∂L/∂z₃ · a₁ = (ŷ - y) · a₁
∂L/∂v₂ = (ŷ - y) · a₂
∂L/∂b₃ = (ŷ - y)

Step 3：隱藏層梯度（通過 ReLU）

∂L/∂a₁ = ∂L/∂z₃ · v₁ = (ŷ - y) · v₁
∂L/∂z₁ = ∂L/∂a₁ · 1[z₁ > 0]   （ReLU 次梯度）

工程陷阱：

• 梯度消失：當層數 > 10 且使用 Sigmoid 時，梯度在每層乘以 ≤ 0.25，20 層後梯度縮小 10⁻¹²
• 梯度爆炸：當初始化不當或學習率過高，梯度指數增長，觸發 NaN
• 診斷方法：每 100 步記錄各層梯度 L2 norm；正常訓練時應在 0.01–10 之間

梯度流動監控的實作：

1# 訓練迴圈中插入監控（非框架內建，需手動加）
2for name, param in model.named_parameters():
3    if param.grad is not None:
4        grad_norm = param.grad.norm().item()
5        if grad_norm > 100:
6            print(f"警告：{name} 梯度爆炸，norm={grad_norm:.2f}")
7        if grad_norm < 1e-6:
8            print(f"警告：{name} 梯度消失，norm={grad_norm:.2e}")

數值穩定性的臨界點：

• 梯度 norm < 1e-6：梯度消失，該層幾乎不在學習
• 梯度 norm > 100：梯度爆炸風險，需要梯度裁剪（clip_grad_norm_(max_norm=1.0)）
• 損失出現 NaN：通常是梯度爆炸 + 不穩定的 log(0) 計算，需要在 log 中加 ε=1e-8

純 NumPy 實作核心（非框架）：

 1import numpy as np
 2
 3class TwoLayerNet:
 4    """x → Linear → ReLU → Linear → Sigmoid，二元分類，BCE loss"""
 5    def __init__(self, d_in, d_hidden, seed=0):
 6        rng = np.random.default_rng(seed)
 7        self.W1 = rng.normal(0, np.sqrt(2 / d_in), (d_in, d_hidden))   # He 初始化
 8        self.b1 = np.zeros(d_hidden)
 9        self.W2 = rng.normal(0, np.sqrt(1 / d_hidden), (d_hidden, 1))
10        self.b2 = np.zeros(1)
11
12    def forward(self, x):
13        z1 = x @ self.W1 + self.b1                   # (B, H) 隱藏層 pre-activation
14        a1 = np.maximum(z1, 0)                       # (B, H) ReLU
15        out = 1 / (1 + np.exp(-(a1 @ self.W2 + self.b2)))  # (B, 1) Sigmoid
16        return out, (z1, a1, out)
17
18    # 反向傳播核心：這是框架背後在做的事
19    def backward(self, x, y, cache):
20        z1, a1, out = cache
21        batch_size = x.shape[0]
22
23        # 輸出層梯度（Sigmoid + BCE 合併後恰好是 out - y）
24        delta_out = out - y                          # (B, 1)
25        dW2 = a1.T @ delta_out / batch_size          # (H, 1)
26        db2 = delta_out.mean(axis=0)
27
28        # 通過 ReLU 反向到隱藏層
29        delta1 = (delta_out @ self.W2.T) * (z1 > 0)  # (B, H) ReLU 次梯度
30        dW1 = x.T @ delta1 / batch_size              # (D, H)
31        db1 = delta1.mean(axis=0)
32        return {'W1': dW1, 'b1': db1, 'W2': dW2, 'b2': db2}
33
34    def train(self, x, y, lr=0.1, epochs=500):
35        for _ in range(epochs):
36            out, cache = self.forward(x)
37            for name, g in self.backward(x, y, cache).items():
38                setattr(self, name, getattr(self, name) - lr * g)   # SGD 更新
39        return self

五、激活函數選擇：Sigmoid / ReLU / GELU / SiLU

激活函數的選擇直接影響梯度流動、訓練速度和最終精度。

量化對比（ImageNet ResNet-50 基準）：

• ReLU：Top-1 準確率 76.1%，訓練時間基準 100%
• GELU：Top-1 準確率 76.9%，訓練時間 +3%（計算更複雜）
• SiLU：Top-1 準確率 77.2%，訓練時間 +5%

推薦系統稀疏特徵場景（CTR 預測，自有資料集）：

• ReLU + Embedding：AUC 0.782，訓練 3.2 小時/epoch
• SiLU + Embedding：AUC 0.791，訓練 3.5 小時/epoch（+9.3%）
• GELU + Embedding：AUC 0.789，訓練 3.6 小時/epoch
• 結論：稀疏特徵場景 SiLU 最佳，但提升幅度 < 1%，不值得在小規模場景額外增加複雜度

死亡 ReLU 問題： 當某個神經元的輸入永遠為負（常見於學習率過高或初始化不良），該神經元梯度永遠為 0，無法更新。實作監控：若某層 > 10% 神經元的激活值連續 1000 步為 0，需降低學習率或改用 Leaky ReLU。

激活函數的計算成本比較（單次前向傳播，批次 1024，維度 512）：

決策準則：

• 隱藏層預設：ReLU（計算最快，效果夠好）
• Transformer / 注意力機制：GELU（GPT-2/BERT 的標準選擇）
• 大型 MLP（> 4 層）：SiLU（梯度流動更穩定）
• 輸出層二元分類：Sigmoid（確保輸出是機率）
• 輸出層多類分類：Softmax（確保機率分布加總為 1）

六、正則化技術：Dropout / L2 / BatchNorm / LayerNorm

過擬合是神經網路最常見的失敗模式。以下是四種主要正則化技術的工程對比。

正則化技術的作用位置：

輸入 ──► [線性層] ──► [BatchNorm] ──► [激活] ──► [Dropout] ──► 輸出
                           │                          │
                    批次統計正規化              隨機丟棄神經元
                    (μ,σ 從批次計算)           (訓練時機率 p)

Dropout

在訓練時，以機率 p 隨機將神經元輸出設為 0。

1# 訓練模式：隨機 mask + 縮放
2mask = (np.random.rand(*x.shape) > p) / (1 - p)
3return x * mask
4
5# 推論模式：不丟棄，不縮放（inverted dropout 已在訓練時補償）
6return x

關鍵工程點：推論時必須關閉 Dropout（model.eval()）。 這是生產環境最常見的 Bug 之一——忘記切換模式導致推論結果隨機波動。

• p=0.1–0.2：輸入層附近（保留更多特徵資訊）
• p=0.3–0.5：深層隱藏層（強力正則化）
• p > 0.5：通常過強，導致欠擬合

L2 正則化（Weight Decay）

在損失函數中加入權重懲罰項：

L_total = L_task + λ · Σ‖w‖²

梯度更新時等效於每步對權重乘以 (1 - λ·lr)。幾何意義： 迫使權重向原點靠近，防止任何單一特徵主導預測。

• λ=1e-4：輕度正則化（推薦起點）
• λ=1e-2：強正則化（用於小資料集）
• λ > 0.1：通常過強，模型無法學習有意義的表示

BatchNorm vs LayerNorm

┌─────────────────────────────────────────────────────────────┐
│  BatchNorm（BN）：對批次維度正規化                            │
│                                                             │
│  輸入 X：shape (B, H)                                       │
│  μ = mean(X, axis=0)     # 對批次求均值，shape (H,)         │
│  σ² = var(X, axis=0)     # 對批次求方差                     │
│  X̂ = (X - μ) / √(σ²+ε)                                     │
│  輸出 = γ · X̂ + β        # 可學習縮放與偏移                │
│                                                             │
│  LayerNorm（LN）：對特徵維度正規化                            │
│                                                             │
│  μ = mean(X, axis=-1)    # 對每個樣本的特徵求均值            │
│  σ² = var(X, axis=-1)    # 對每個樣本求方差                 │
│  X̂ = (X - μ) / √(σ²+ε)                                     │
│  輸出 = γ · X̂ + β                                           │
└─────────────────────────────────────────────────────────────┘

BatchNorm 的致命陷阱：

1. 小批次失效：批次大小 < 8 時，批次統計不穩定，訓練崩潰
2. 推論行為不同：推論時使用訓練期間的移動平均統計量，不是當前批次
3. 分散式訓練中的 BN：每個 GPU 獨立計算統計量，需要 SyncBatchNorm 才能跨 GPU 正規化

LayerNorm 的優勢：

• 批次大小為 1 也能正常工作（適合 RNN、Transformer）
• 推論行為與訓練完全一致（無狀態依賴）
• 序列長度可變（NLP 任務的標準選擇）

七、最佳化器深度比較：SGD / Adam / AdamW / Lion

最佳化器決定梯度如何轉化為權重更新。不同最佳化器在不同問題規模下有顯著的效能差異。

SGD with Momentum

v_t = β·v_{t-1} + g_t
w_t = w_{t-1} - lr·v_t

• 動量 β=0.9：梯度指數移動平均，抑制震盪
• 泛化能力強：SGD 找到的極小值通常「更平坦」，泛化更好
• 缺點：需要手動調整學習率排程，對超參數敏感

Adam

m_t = β₁·m_{t-1} + (1-β₁)·g_t          # 一階矩（梯度均值）
v_t = β₂·v_{t-1} + (1-β₂)·g_t²          # 二階矩（梯度方差）
m̂_t = m_t / (1-β₁ᵗ)                     # 偏差修正
v̂_t = v_t / (1-β₂ᵗ)
w_t = w_{t-1} - lr · m̂_t / (√v̂_t + ε)

• 自適應學習率：稀疏梯度特徵得到更大更新（適合推薦系統的稀疏輸入）
• 預設值：β₁=0.9, β₂=0.999, ε=1e-8
• 問題：Weight decay 實作錯誤——Adam 的 L2 正則化與 SGD 的 weight decay 行為不同

AdamW（修正版）

Adam 在加入 L2 時，正則化被自適應縮放抵消了。AdamW 的修正：

w_t = w_{t-1} - lr · (m̂_t / (√v̂_t + ε) + λ·w_{t-1})
                                              ^^^^^^^^
                                        直接解耦 weight decay

這個細節在大型模型中影響顯著： BERT 使用 AdamW（非 Adam）訓練，準確率差異約 0.3–0.8%。

Lion（2023）

c_t = β₁·m_{t-1} + (1-β₁)·g_t
w_t = w_{t-1} - lr · (sign(c_t) + λ·w_{t-1})
m_t = β₂·m_{t-1} + (1-β₂)·g_t

• 只使用梯度符號，只需保存一個動量狀態：優化器狀態是 Adam 的一半（Adam 需保存 m 與 v 兩份）
• 在 Vision Transformer 上比 AdamW 準確率高 0.5–1.1%
• 對學習率更敏感（典型值比 Adam 小 3–10×）

量化對比示意（ResNet-50，ImageNet，100 epochs；示意估算，非實測數據）：

學習率排程（Learning Rate Schedule）的影響：

最佳化器的選擇必須配合學習率排程，否則最佳化器本身再好也難以發揮。

常見排程策略：

Step Decay：  lr ──── lr×0.1 ──────── lr×0.01 ─────→
              epoch 0      epoch 30          epoch 60

Cosine Annealing：
              lr ╲
                  ╲___╱‾‾‾╲___╱‾‾‾╲___
              週期性振盪，有助跳出局部最小值

Warmup + Cosine（Transformer 標準）：
              lr ╱‾‾‾╲_______________→
              前 N 步線性增加，之後 cosine 衰減
              N = total_steps × 0.03 ~ 0.1

量化對比（CTR 預測，AdamW，5M 訓練樣本）：

關鍵閾值： 當批次大小 > 1024 時，使用 Linear Warmup（前 1000 步）可避免大批次訓練初期的訓練不穩定，這是大批次訓練的標準做法（批次 256 以下通常不需要）。

八、為什麼選 X 不選 Y（3 個決策表含 flip condition）

SGD vs Adam、BatchNorm vs LayerNorm、Xavier vs He、FP32 vs FP16 的決策表見 Phase 1 Part 1 §八 ，此處只列本篇新增的決策（BatchNorm vs LayerNorm 保留，因為本篇補上了小批次與推論行為的翻轉條件）。

決策 1：BatchNorm vs LayerNorm

選擇          選 BatchNorm 的理由              不選的情境
─────────────────────────────────────────────────────────────
BatchNorm     批次大小 ≥ 32，CV 任務           NLP/序列模型，批次 < 8
              訓練穩定，收斂快 20–30%          分散式需 SyncBN 複雜度
              ResNet/CNN 的業界標準            推論行為與訓練不同（有坑）

LayerNorm     Transformer，批次可為 1          CV 任務通常不如 BN
              推論行為完全可預測               計算略慢（對 H 維度正規化）
              RNN/自迴歸模型必選               

Flip Condition：批次大小 < 8 或使用 Transformer → 強制 LayerNorm

決策 2：Dropout vs L2 正則化

選擇        適用情境                          不適用情境
─────────────────────────────────────────────────────────────
Dropout     過擬合主要在深層 MLP              BatchNorm 後 Dropout 效果衝突
            訓練資料 < 100K，泛化需求強       Transformer 中 Dropout 位置有講究
            能接受訓練時間延長 20–30%         

L2          需要可解釋性（權重小 = 特徵不重要）  稀疏特徵（L2 不產生稀疏解）
            與 AdamW 配合自然                  

Flip Condition：
- 兩者通常同時使用，Dropout(0.3) + L2(1e-4) 是推薦預設
- BatchNorm 存在時，可降低 Dropout 至 0.1 或移除

決策 3：ReLU vs GELU

選擇        選 ReLU 的理由                   選 GELU 的理由
────────────────────────────────────────────────────────────
ReLU        計算最快（一個 max 運算）          Transformer 標準（BERT/GPT）
            CNN/MLP 主力激活函數              平滑梯度，訓練更穩定
            硬體加速最友好                    大型模型精度略高（~0.5%）

Flip Condition：
- 模型參數 < 100M 且非 Transformer → ReLU
- Transformer 架構或模型 > 100M 參數 → GELU 或 SiLU

九、系統效應（有無深度學習的前後對比）

以下為兩個示意情境中從傳統 ML 遷移至深度學習的前後對比（示意估算，非實測數據）：

推薦系統（電商場景）

示意估算，非實測數據

圖像分類（缺陷檢測場景）

示意估算，非實測數據

關鍵閾值

• 資料量 < 1,000 樣本：深度學習通常不如傳統 ML，遷移學習是唯一例外
• 資料量 1,000–10,000：帶正則化的淺層 MLP 與傳統 ML 相當，Fine-tune 預訓練模型佔優
• 資料量 > 100,000：深度學習開始顯著超越傳統 ML，每 10× 資料量準確率約提升 3–5%
• 延遲要求 < 5ms：需要量化（INT8）+ 模型蒸餾，否則深度學習難以達標

十、系列導航

本文是「AI 工程從零開始」系列 Phase 3 的第 1 篇。

← Phase 2 Part 2 ｜集成學習與最佳化 — 超越單一模型的上限

• Random Forest、XGBoost、LightGBM、CatBoost
• Stacking 與模型融合
• Bayesian 超參數最佳化

Phase 4 Part 1 →｜電腦視覺基礎 — 從像素到 CNN 特徵

• 卷積操作的第一原理（感受野、步幅、填充）
• ResNet 殘差連接解決梯度消失的數學原因
• 遷移學習實戰

本文屬於「AI 工程從零開始」系列，按工程成熟度分階段介紹 AI 系統的設計與實作。

Tags：#AI #DeepLearning #NeuralNetworks #Backpropagation #PyTorch #RKK