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

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

面試情境

你正在設計一個即時推薦系統，模型需要在 < 20ms 內回應，訓練資料有 5 億筆互動記錄，特徵空間包含 1 萬維稀疏向量。面試官問：「你會如何設計神經網路架構？選擇什麼激活函數、正則化策略、和最佳化器？當模型在驗證集準確率停滯在 78% 時，你的診斷流程是什麼？」

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

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

真實問題是這樣出現的：

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

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

本文的工程目標：

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

二、三個演進階段（POC / MVP / Scale）

神經網路的部署不是一蹴而就，從研究原型到生產規模，架構在每個階段都有根本性的不同。

╔══════════════════════════════════════════════════════════════════╗
║  Phase 1：POC（< 10K 用戶，日推論 < 100K 次）                    ║
╚══════════════════════════════════════════════════════════════════╝

目標：驗證概念，快速迭代

┌────────────────────────────────────────────────────────┐
│  輸入特徵（手動工程）                                    │
│       │                                                │
│       ▼                                                │
│  ┌──────────────┐                                      │
│  │  2–3 層 MLP  │  ReLU 激活 + Dropout(0.3)            │
│  │  隱藏維度 128 │                                      │
│  └──────┬───────┘                                      │
│         │                                              │
│         ▼                                              │
│  ┌──────────────┐                                      │
│  │  輸出層      │  Sigmoid / Softmax                   │
│  └──────────────┘                                      │
│         │                                              │
│         ▼                                              │
│  Flask / FastAPI（單機，同步推論）                       │
└────────────────────────────────────────────────────────┘

• 新增組件：簡單 MLP、Adam 最佳化器、CSV 訓練資料管線
• 成本：單機 GPU（RTX 3090，約 $500 硬體或 $0.5/hr 雲端）
• 可接受的妥協：批次訓練（非線上學習）、無模型版本管理、手動部署
• 遺留問題：無法處理高並發、無監控、模型重現性差

╔══════════════════════════════════════════════════════════════════╗
║  Phase 2：MVP（10K–200K 用戶，日推論 1M–20M 次）                 ║
╚══════════════════════════════════════════════════════════════════╝

目標：生產安全，團隊可操作

┌───────────────────────────────────────────────────────────────┐
│  特徵工程服務（Feature Store）                                  │
│       │                                                       │
│       ▼                                                       │
│  ┌─────────────┐      ┌─────────────────┐                    │
│  │ 訓練管線     │      │  模型倉庫        │                    │
│  │ MLflow 追蹤  │─────▶│  (S3 + 版本標籤) │                   │
│  └─────────────┘      └────────┬────────┘                    │
│                                │                              │
│                                ▼                              │
│  ┌──────────────────────────────────────┐                    │
│  │  推論服務（TorchServe / Triton）      │                    │
│  │  ├── 模型：4–6 層 MLP，維度 512      │                    │
│  │  ├── BatchNorm + Dropout             │                    │
│  │  ├── ONNX 匯出（推論延遲 -40%）      │                    │
│  │  └── 水平擴展 × 3 副本               │                    │
│  └──────────────────────────────────────┘                    │
│       │                                                       │
│       ▼                                                       │
│  Prometheus + Grafana（延遲、準確率監控）                       │
└───────────────────────────────────────────────────────────────┘

• 新增組件：Feature Store、MLflow、ONNX、容器化部署
• 成本：3× A10G GPU 推論節點（約 $2,000/月）
• 解決問題：模型可重現、推論延遲 < 15ms P99、A/B 測試支援
• 遺留問題：訓練仍為批次，特徵更新延遲 ~1hr

╔══════════════════════════════════════════════════════════════════╗
║  Phase 3：Scale（200K–1M+ 用戶，日推論 100M+ 次）                ║
╚══════════════════════════════════════════════════════════════════╝

目標：企業級，自動擴展，成本最佳化

┌──────────────────────────────────────────────────────────────────┐
│  即時特徵管線（Kafka + Flink，延遲 < 500ms）                      │
│       │                                                          │
│       ▼                                                          │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │  分散式訓練叢集                                           │    │
│  │  ├── 資料並行（DDP，8× A100 80GB）                       │    │
│  │  ├── 梯度壓縮（PowerSGD，通訊量 -80%）                   │    │
│  │  └── 混合精度（FP16 前向 + FP32 梯度累積）               │    │
│  └──────────────────┬──────────────────────────────────────┘    │
│                     │                                            │
│                     ▼                                            │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │  模型服務層                                               │    │
│  │  ├── Triton Inference Server（動態批次，GPU 利用率 85%+） │    │
│  │  ├── TensorRT 量化（INT8，延遲 -60%，精度損失 < 0.5%）   │    │
│  │  ├── KV Cache 熱門特徵（Redis，命中率 > 70%）            │    │
│  │  └── 自動擴縮（HPA，延遲 P99 > 18ms 觸發擴容）          │    │
│  └─────────────────────────────────────────────────────────┘    │
│       │                                                          │
│       ▼                                                          │
│  Shadow Mode 上線 → Canary 5% → 全量發布                         │
└──────────────────────────────────────────────────────────────────┘

• 新增組件：DDP 分散式訓練、TensorRT、動態批次、Shadow Mode 部署
• 成本：8× A100 訓練（約 $15,000/月）+ 推論叢集（約 $8,000/月）
• 解決問題：訓練時間從 48hr 降至 6hr、推論延遲 < 8ms P99、零停機部署

三個階段的關鍵差異總結：

Phase 1 → Phase 2 的觸發條件： 當推論請求超過 10 QPS，或模型更新頻率需要自動化時。
Phase 2 → Phase 3 的觸發條件： 當推論延遲 P99 > 20ms，或訓練資料超過 5,000 萬筆時。

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

感知機（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 實作核心（非框架）：

 1# 反向傳播核心：這是框架背後在做的事
 2def backward(self, x, y, cache):
 3    a1, z1, a2, z2, out = cache
 4    batch_size = x.shape[0]
 5
 6    # 輸出層梯度
 7    delta_out = out - y                          # shape: (B, 1)
 8
 9    # 第二層梯度
10    dW2 = a2.T @ delta_out / batch_size          # (H, 1)
11    db2 = delta_out.mean(axis=0)
12
13    # 通過 ReLU 反向
14    delta2 = (delta_out @ self.W2.T) * (z2 > 0) # ReLU 次梯度
15
16    # 第一層梯度
17    dW1 = x.T @ delta2 / batch_size
18    db1 = delta2.mean(axis=0)
19
20    return {'W1': dW1, 'b1': db1, 'W2': dW2, 'b2': db2}

五、激活函數選擇：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-2} + (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 少 1/3（節省約 33%）
• 在 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（6 個決策表含 flip condition）

決策 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：Adam vs SGD

選擇        選 Adam 的理由                   選 SGD 的理由
──────────────────────────────────────────────────────────────
Adam        稀疏特徵（推薦、NLP）             圖像分類最終精度更高
            快速收斂，原型驗證效率高           泛化到分布外資料通常更好
            超參數不敏感（β₁,β₂ 幾乎不需調）  理論理解更成熟

Flip Condition：
- 需要快速原型或特徵稀疏 → Adam/AdamW
- 追求最高泛化精度的 CV 任務（ImageNet 級別）→ SGD + Cosine Annealing

決策 3：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 或移除

決策 4：ReLU vs GELU

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

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

決策 5：FP32 vs FP16 訓練

選擇        優勢                              風險
─────────────────────────────────────────────────────────────
FP32        數值穩定，無特殊處理              記憶體用量 2× FP16
            適合調試、小模型                  訓練速度慢（無 Tensor Core 加速）

FP16 混合精度  訓練速度 +60–80%              梯度下溢（需 GradScaler）
(AMP)        記憶體 -50%，可訓練更大批次     某些操作仍需 FP32（BN 統計量）

Flip Condition：
- 模型 < 10M 參數且訓練資料 < 1M → FP32（省去複雜度）
- 模型 > 10M 參數或批次記憶體受限 → AMP（torch.cuda.amp）

決策 6：He 初始化 vs Xavier 初始化

選擇            適用激活函數          數學依據
──────────────────────────────────────────────────────────
He (Kaiming)    ReLU, Leaky ReLU     Var(w) = 2/n_in
                                      考慮 ReLU 丟棄一半信號
Xavier          Sigmoid, Tanh         Var(w) = 2/(n_in + n_out)
                                      假設激活函數對稱且近線性

Flip Condition：
- 網路使用 ReLU 系列 → He 初始化（使用 Xavier 會導致梯度消失）
- 網路使用 Sigmoid/Tanh → Xavier 初始化

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

以下數字來自真實生產環境中從傳統 ML 遷移至深度學習的案例分析：

推薦系統（電商場景）

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

關鍵閾值

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

十、面試答題要點

面試情境重述： 即時推薦系統，< 20ms 回應，5 億訓練資料，1 萬維稀疏特徵，驗證集準確率卡在 78%。

「我會設計一個 6 層 MLP，架構為 [10000 → 1024 → 512 → 256 → 128 → 64 → 1]，使用 SiLU 激活函數（比 ReLU 在稀疏輸入上梯度更穩定）、LayerNorm（而非 BatchNorm，因為批次大小在推論時為 1）、AdamW 最佳化器（lr=1e-3, λ=1e-4）。輸入層加 Embedding 將稀疏向量壓縮至 256 維，再進入 MLP 主幹，這樣參數量從 10B 降至 300M，訓練時間從估計 7 天降至 18 小時。驗證集停在 78% 的診斷流程：首先看訓練集準確率——若訓練集 95% 則是過擬合（加 Dropout(0.3) 和更強 L2），若訓練集也 78% 則是欠擬合（加寬隱藏層或增加特徵）；同時檢查梯度 norm——若層間梯度差異 > 100× 表示有消失/爆炸問題，需要調整初始化或加殘差連接。推論方面，用 ONNX 匯出 + TorchScript 可將延遲從 25ms 降至 12ms，再用 TensorRT INT8 量化可達 8ms，滿足 < 20ms 的需求，精度損失 < 0.3%。」*

十一、系列導航

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

← Phase 2 Part 2｜特徵工程與資料管線：從原始資料到可訓練特徵

• 特徵選擇（SHAP、互資訊、Boruta）
• 資料不平衡處理（SMOTE、Class Weight、Focal Loss）
• 離線特徵管線（Spark）vs 線上特徵服務（Redis Feature Store）

Phase 3 Part 2 →｜卷積神經網路與視覺模型：從 LeNet 到 ResNet 的工程演化

• 卷積操作的第一原理（感受野、步幅、填充）
• ResNet 殘差連接解決梯度消失的數學原因
• 遷移學習實戰：5,000 張圖片微調到 97% 準確率的完整流程
• 部署：ONNX → TensorRT → 邊緣裝置推論

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

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