概念位置

LLM 中 activation function 主要出現在 FFN 內、夾在兩個矩陣乘法之間：

1FFN: input → W_up (linear) → activation → W_down (linear) → output
2                              ↑
3                       這裡是 activation function

主流 LLM 用的 activation function 演化：

SwiGLU / GeGLU 是「gated」變體、用兩條線性投影相乘、表達能力比單一 activation 強、是現代 LLM 主流。

設計責任

讀 paper / model card 看到 SwiGLU、ReLU、GELU 等詞、知道它們是 FFN 內部的選擇、影響模型表達能力跟訓練穩定性、不影響「模型怎麼用 / 怎麼 inference」這類使用者面議題。寫 code 場景的判讀：模型用什麼 activation 由模型作者決定、使用者通常不用調；但若要 fine-tune 或自己訓模型、activation 選擇是設計決策之一。

概念位置

Backpropagation 是訓練 loop 的中段、夾在 forward pass 跟權重更新之間：

1[forward pass]：input → layer1 → layer2 → ... → output → loss
2                                                          ↓
3[backpropagation]：把 loss 對最後一層權重的偏微分算出來
4                  ←─ chain rule ─ 再往前傳播一層、算前一層的 gradient
5                  ←─ chain rule ─ ...一路傳回輸入層
6                                                          ↓
7[optimizer step]：每個權重 w 用對應的 gradient 更新

關鍵特性：

1. 計算成本 ≈ forward pass 的 2~3 倍：每個 layer 都要存 forward 階段的中間值（activation）、反向時拿來算 gradient。所以訓練比推論貴一個量級。
2. 記憶體佔用 = forward 階段 activation 的累計：這是訓練比推論吃 VRAM 的主因、不是「權重變大」、是「activation 要存著」。
3. 數值穩定性敏感：long chain 的 chain rule 容易導致 gradient 爆炸或消失、見 gradient 卡。

設計責任

推論階段完全不用 backpropagation。理解這點能解釋幾個現象：為什麼同樣模型訓練要 8 卡 H100 一週、推論單卡就跑得動（差幾十倍的計算與記憶體需求）；為什麼 LoRA / QLoRA 等 parameter-efficient fine-tuning 能大幅降低訓練成本（凍住大部分權重、只對少數 LoRA 矩陣做 backpropagation）；為什麼 inference framework（llama.cpp、vLLM）跟 training framework（PyTorch、JAX）的設計重點完全不同。

概念位置

Cross-entropy 在 next-token prediction 訓練裡的具體計算：

1模型預測：p = softmax(logits)  ← shape: (vocab_size,)
2真實答案：y = one-hot(true_token)  ← shape: (vocab_size,)、只有真實 token 那位是 1
3
4cross-entropy = -sum(y_i × log(p_i))
5              = -log(p_true_token)  ← 因為 y 是 one-hot、只剩這項

所以實作上 cross-entropy 就退化成「真實 token 預測機率的負對數」、機率越接近 1、loss 越接近 0；機率越接近 0、loss 越接近 ∞。

跟相關概念的關係：

設計責任

讀 LLM 訓練 / paper 時看到「training loss」幾乎都是 cross-entropy。實務判讀：cross-entropy 直接代表「模型對真實 token 的預測機率有多差」、loss = 2 大致對應「真實 token 被預測機率 ≈ 0.135」（exp(-2)）。模型在 pretrain 階段 cross-entropy 從約 11（純隨機）降到約 2-3（成熟模型）、SFT 階段再略降。

概念位置

Dot product 在 LLM 中的核心應用：

幾何直覺：

1兩個向量方向接近時：dot product 大（正值大）
2兩個向量垂直時：    dot product = 0
3兩個向量方向相反時：dot product 大負值
4
5a · b = |a| × |b| × cos(θ)
6                          ↑
7                  θ 是兩向量夾角

LLM 推論性能上、dot product 是「matrix multiplication 的基本單元」、整個 forward pass 可以看成大量 dot product 的批次運算；這是為什麼 GPU / Apple Silicon Neural Engine 都針對 dot product 做硬體優化。

設計責任

讀 attention / RAG 相關內容看到「inner product」「dot product」「QK^T」就是這個運算。寫 code 場景的判讀：用 vector database 時、選 distance metric 看：cosine 適合未 normalized 的 embedding、dot product 適合 L2-normalized 的 embedding（兩者結果同、後者較快）；attention 的 KV cache 量化（K=Q8 / V=Q4）對品質的不對稱影響、根本原因是 K 用於 dot product（誤差累積快）、V 用於加權平均（誤差被平均化）。

概念位置

Entropy 跟 LLM 相關概念的關係：

1Entropy(P) = -sum P log P                  ← 一個分佈自身的不確定性
2Cross-entropy(P, Q) = -sum P log Q         ← 用分佈 Q 編碼 P 的成本
3KL(P ‖ Q) = Cross-entropy(P, Q) - Entropy(P) ← 兩個分佈的差距

Entropy 在 LLM 中的具體意義：

範例：vocab = 128K、uniform 分佈的 entropy = log(128K) ≈ 11.76（接近 12）；成熟模型在文本上的平均 entropy 約 2-3。

設計責任

Entropy 本身在 LLM 訓練 / 推論很少直接出現、但理解它能解釋一些現象：perplexity = exp(cross-entropy) 是模型平均不確定性的指數形式；temperature 控制 sampling entropy（高 T → 高 entropy → 多樣輸出）；某些評估方法（如 entropy-based uncertainty estimation）會看模型輸出分佈的 entropy 來判讀「模型有多確定」。

概念位置

主流浮點格式的位元分配：

關鍵 trade-off：

1. FP16 精度好、範圍窄：尾數多、表達小範圍內細節準；但指數少、容易 overflow（gradient 爆炸時）/ underflow（gradient 接近 0 時）。
2. BF16 範圍跟 fp32 一樣大、精度差：指數位跟 fp32 同（8 位）、訓練時的 dynamic range 跟 fp32 接近、不會 overflow；但尾數少、精度差。實測對訓練影響小、所以是現代 LLM 訓練主流。
3. FP8 是新興格式：H100 / B200 等新 GPU 原生支援、訓練 / 推論都能加速、但精度損失需要 careful loss scaling。

LLM 工作流的精度選擇：

設計責任

讀 paper / config 看到 mixed_precision: bf16、torch_dtype: bfloat16 就是 BF16 訓練。寫 code 場景的判讀：本機跑 GGUF Q4_K_M 模型、內部運算的 activation 仍是 fp16 / bf16、只有權重儲存是 4-bit；KV cache 預設也是 fp16、量化 KV cache 是進階優化（K=Q8 / V=Q4）。

概念位置

Gradient 連接「loss」跟「該怎麼更新權重」兩件事、是 backpropagation 算出來的東西、也是 SGD / Adam 等 optimizer 消費的輸入：

1[forward pass] → 算出 loss
2                    ↓
3[backpropagation] → 算出 gradient（每個權重一個值）
4                    ↓
5[optimizer] → 用 gradient 更新權重：w_new = w_old - lr × gradient

Gradient 在 LLM 訓練中的兩個常見問題：

設計責任

推論階段（拿訓練好的模型生 token）不需要算 gradient、只有 forward pass；gradient 只在訓練 / fine-tuning 階段出現。所以本地跑 LLM 寫 code 的場景不會碰到 gradient、但讀懂訓練流程、理解「為什麼 SFT / RLHF 需要 GPU、推論不一定要」這類判讀就要先理解 gradient 的角色。

概念位置

兩種失敗模式的訊號跟處理：

數學直覺（簡化）：

1深 N 層的 chain rule：
2∂loss/∂W_input = ∂loss/∂out × ∂out/∂h_N × ∂h_N/∂h_{N-1} × ... × ∂h_1/∂W_input
3                                └──────────── N 個 factor 連乘 ──────────────┘
4
5若每個 factor ≈ 0.5、N=100：累乘 ≈ 0.5^100 ≈ 0       → vanishing
6若每個 factor ≈ 1.5、N=100：累乘 ≈ 1.5^100 ≈ 4e17    → explosion

Residual connection 讓 gradient 有「捷徑」可走、不全靠 chain rule 一層層乘、是深層 Transformer 訓得起來的核心結構之一。

設計責任

讀訓練 log 看到 loss: nan、grad_norm: inf 就是 explosion；看到 loss 平穩、幾個 epoch 都不降就是可能的 vanishing。寫 code 場景幾乎不會碰到（推論不算 gradient）、但自己 fine-tune 時要會判讀。LLM 用的 SwiGLU / GELU 都是 saturation 較不嚴重的 activation、加上 residual + pre-norm、現代 Transformer 訓 100+ 層相對穩定。

概念位置

KL divergence 在 LLM 中的兩個主要角色：

1. 跟 cross-entropy 的關係：

   1cross-entropy(P, Q) = entropy(P) + KL(P ‖ Q)

   訓練時 P（真實分佈）固定、entropy(P) 是常數、所以「minimize cross-entropy」等於「minimize KL」。

2. RLHF / DPO 的「KL 約束」：

   alignment 階段不能只 maximize reward、否則模型會「為了 reward 把語言能力毀掉」。所以加 KL 約束：

   1objective = E[reward] - β × KL(π_new ‖ π_ref)
   2                         └─ 不讓新模型偏離 ref（通常是 SFT 後的 base）太遠 ─┘

   β 控制「reward 追求」vs「不偏離原始模型」的平衡。

跟相關概念的對比：

設計責任

讀 alignment paper 看到 β、KL penalty、KL coefficient 等詞、知道這些是控制「模型在追 reward 時偏離 base 多遠的容忍度」。β 太小、模型容易 reward hacking（找 reward 高但實質爛的輸出）；β 太大、模型動不了、reward 升不上去。DPO 把 KL 約束內嵌進 loss、不像 RLHF 需要顯式 KL term、是 DPO 比 RLHF 簡單的原因之一。

概念位置

Logit 在 LLM 輸出 pipeline 的位置：

1最後一層 Transformer 輸出 hidden state
2   ↓ output projection（linear layer）
3logits（shape: vocab_size、實數、可正可負）
4   ↓ logit warping / masking（可選、用於控制輸出）
5   ↓ /temperature
6   ↓ softmax
7probability distribution
8   ↓ sampling（greedy / top-k / top-p）
9next token

操作 logit 的常見技巧：

設計責任

理解 logit 後可以判讀 sampling 階段的控制粒度：所有「不重訓模型、影響輸出」的技巧（temperature、structured output、constrained generation、logit bias）本質上都是「在 softmax 前後動 logit」、不是動模型權重。這也是為什麼同一個模型用不同 sampling 設定能產生差很多的輸出。

概念位置

LLM 各訓練階段用不同的 loss function：

評估時用的指標（perplexity、accuracy、BLEU 等）跟訓練 loss 是不同概念：loss 是「訓練要 minimize 的東西」、指標是「給人看模型好不好的數字」、兩者不一定一致（loss 降但指標不一定升、反之亦然）。

設計責任

選 loss function 等於選「訓練要把模型推往哪個方向」。Cross-entropy 推「機率分佈接近真實 token」、reward model 推「人類偏好高的回應」、DPO 推「偏好回應 vs 拒絕回應的對比」— 每種 loss 對應的模型行為不同。讀 paper 看到「我們用 X loss」、要回問「這 loss 把模型推往哪個方向」、才能判斷模型訓練出來的特性是否符合預期。

概念位置

LLM 中 matmul 出現的關鍵位置：

關鍵尺寸規則：左矩陣 column 數 = 右矩陣 row 數、即 (m × k) @ (k × n) = (m × n)。Dimension mismatch 是訓練 / 推論最常見的 PyTorch 報錯之一。

為什麼 matmul 是 memory bandwidth bound

LLM 推論每生一個 token、要把整份模型權重從記憶體讀到處理器一次（每個權重在當輪 forward pass 的某個 matmul 都用得到）；現代 GPU / Apple Silicon 的算力遠超頻寬、所以「讀權重要多久」變主要瓶頸。這就是為什麼：

• 31B 模型 Q4_K_M 約 18GB、M4 Max 頻寬 546 GB/s、理論上限 ≈ 30 tok/s
• 量化 加速主要是「權重變小、每秒能讀過更多次完整模型」
• Batching / speculative decoding 加速主要是「一次讀權重、攤平到多個 token」

設計責任

讀 paper / model card 看到模型參數量、可以反推總 matmul 工作量；看到 inference benchmark 看到 tok/s、可以用「模型大小 / memory bandwidth」算理論上限對照。寫 code 場景無需直接寫 matmul、但理解這個運算的成本結構、能看懂量化 / batching / speculative decoding 等加速技巧為什麼有效。

概念位置

Perplexity 跟 cross-entropy 的關係：

換算範例（base e）：

Perplexity 主要用於：

• 預訓練評估：在 held-out 語料上算 perplexity、衡量基礎建模能力。
• 量化品質衡量：fp16 vs Q4 vs Q3 模型的 perplexity 差異、看量化造成多少品質損失。
• 領域 benchmark：在特定領域語料（code、math、医學文獻）上算 perplexity、評估模型對該領域的熟悉度。

設計責任

Perplexity 是 base model 評估標準、但對 instruction-tuned / chat 模型用處有限（chat 模型輸出風格已偏離 raw text、perplexity 不一定降）。對寫 code 場景的判讀：看到 paper 報 perplexity 是評估 pretrain 品質的訊號、實際聊天 / coding 能力要看 SWE-bench、MMLU、HumanEval 等任務式 benchmark。

概念位置

LLM 中 softmax 出現的兩個位置：

1位置 1：Attention 內部
2  Q · K^T → 一堆 score
3  softmax(scores) → attention weight（總和 1）
4  weight · V → output
5
6位置 2：每次 token 生成的最後一步
7  最後一層 hidden → logit（每個 vocab token 一個實數分數）
8  softmax(logits / temperature) → 機率分佈
9  從這個分佈 sample 出下一個 token

兩個位置的關鍵差異：

Temperature 在 sampling 端跟 softmax 結合：softmax(logits / T)、T 越小分佈越尖（接近 greedy）、T 越大分佈越平（接近隨機）。

設計責任

理解 softmax 後可以判讀幾件事：temperature 為什麼影響輸出多樣性（改的是 softmax 前的縮放）、為什麼 logit bias / logit warping 等技巧能控制輸出（直接動 softmax 的輸入）、為什麼 structured output 的 grammar-constrained sampling 是「把不合法 token 的機率歸零」（在 softmax 後或前做 masking）。

概念位置

LLM 中常見的 tensor 維度：

關鍵運算：

1. Reshape：改 shape 但不變資料總量、如 (batch, seq, hidden) → (batch * seq, hidden)。
2. Transpose / permute：交換維度順序、attention 計算前後常用。
3. Broadcasting：不同 shape 的 tensor 自動擴展配對、如 (seq, hidden) + (hidden,)。
4. Indexing / slicing：抽出子 tensor、如 tensor[:, -1, :] 取最後一個 token 的 hidden。

設計責任

讀 PyTorch / MLX 推論 / 訓練 code 看到 torch.Tensor、mx.array、tf.Tensor 等就是這個型別、所有 LLM 運算都建在它上面。寫 code 場景的判讀：報錯訊息看到 shape mismatch / size of dimension X 通常是 tensor 維度配錯；KV cache 內部存的就是 4D tensor (num_layers, 2, batch, num_kv_heads, seq, head_dim) 之類的結構、量化 KV cache 就是改這個 tensor 的 dtype。

概念位置

主流 norm 的定義與用途：

L2 norm 在 LLM 中的關鍵應用：

1. Cosine similarity：cos(a, b) = (a · b) / (||a||₂ × ||b||₂)、衡量兩個向量的方向相似度、是 RAG / semantic search 的核心指標。
2. Embedding model 正規化：通常把 embedding 正規化到 L2 norm = 1、之後 cosine similarity 退化成單純內積（dot product）、計算更快。
3. Gradient clipping：訓練時若 gradient 的 L2 norm 超過閾值（如 1.0）、整體縮放回去、避免 explosion。
4. Layer normalization：RMSNorm 用 L2 norm（root mean square）做正規化。

設計責任

讀 RAG / embedding 教學看到「normalize embeddings」「cosine similarity」就是 L2 相關運算。寫 code 場景的判讀：用 vector database 時、若 embedding 已 L2-normalized、距離指標選 dot product 比 cosine 快（結果相同）；訓練 / fine-tune 自己 model 時、gradient_clip: 1.0 是常見預設、防止 gradient 偶發爆炸。

本章整理這條鏈上的核心概念。每個概念給出定義、在 LLM 中的位置、實務上會在哪裡遇到。

本章目標

讀完本章後、你應該能：

1. 解釋 LLM 輸出層為什麼用 softmax、不用其他正規化方式。
2. 看到 temperature=0.2 設定時、知道它在調機率分佈的什麼。
3. 看到 benchmark 報告 perplexity 數字時、知道它衡量什麼。
4. 理解 cross-entropy 為什麼是 LLM 訓練的標準 loss function。

機率分佈：把可能性量化

機率分佈（probability distribution）的核心定義是「對所有可能事件指派一個機率值、總和為 1、每個值在 0 到 1 之間」。LLM 中的核心場景：對詞彙表中每個 token 指派一個機率、總和為 1。

詞彙表大小（vocabulary size）通常幾萬到十幾萬：

模型最後一層的輸出是「對這 N 個 token 的機率分佈」、N 是 vocab size。每生一個新 token、就 sample 一次這個分佈。

Logit：softmax 之前的原始分數

Logit 的核心定義是「模型最後一層輸出的原始分數、還沒正規化成機率」。每個 token 對應一個 logit、可以是任意實數（包括負數）。

Logits 的形狀是 (vocab_size,)、例如 Gemma 4 的 logits 是長度 256,000 的向量。直接看 logits 沒意義、需要轉成機率分佈才能 sample。

Softmax：把 logits 轉成機率分佈

Softmax 的核心定義是「把任意實數向量轉成合法的機率分佈」的函式：

1softmax(x)ᵢ = exp(xᵢ) / Σⱼ exp(xⱼ)

幾何意義：先用 exp 把所有 logit 變成正數（強化大值、壓抑負值）、再除以總和讓總和為 1。結果是合法的機率分佈：每個值在 (0, 1) 之間、總和為 1。

為什麼用 softmax 而非其他正規化（如 xᵢ / Σ xⱼ）：

1. 處理負數：直接歸一化遇到負 logit 會壞掉；exp 把所有值變正。
2. 強化對比：exp 放大差距、讓「最有可能的 token」拿到更大的機率比例。
3. 數學性質好：softmax 的導數形式漂亮、方便 backprop 計算 gradient。

實務上會在這幾個地方遇到 softmax：

• 輸出層：把 logits 轉成「下個 token 的機率分佈」。
• Attention：把 attention scores（內積結果）轉成「注意力權重分佈」。詳見 3.2 attention 機制。

Temperature：調整分佈的尖銳度

Temperature（溫度）的核心定義是「softmax 之前先除以一個正數、調整輸出分佈的尖銳度」：

1softmax_with_temperature(x, T)ᵢ = exp(xᵢ / T) / Σⱼ exp(xⱼ / T)

T 對分佈的影響：

實務經驗：

• 寫 code 場景用 T = 0.2 ~ 0.4、讓回答穩定、減少 hallucination。
• 創意寫作用 T = 0.7 ~ 1.0、保留多樣性。
• 確定性場景（測試、reproducible 評估）用 T = 0（實作上 T=0 是除以零、伺服器退化為 argmax / greedy）。

實務常見的 temperature 邊界：

• T 跟 top-p 同用：兩者相乘的效果非線性、高 T + 低 top-p 反而讓「機率被攤平但只挑前幾名」、出現語義跳動。多數設定固定其中一個、調另一個。
• Reasoning model 上 T 反效果：o1 / DeepSeek-R1 等內建 chain-of-thought 的模型、官方建議 T = 0 或 1.0、調 T 會破壞 reasoning trace 的連貫性。
• 過低 T（< 0.1）的副作用：模型容易掉進 repetition loop（連續重複同一句）、要搭配 repetition penalty 才穩。

LM Studio 跟其他推論伺服器的 temperature 設定背後就是這個公式。

Top-K 與 Top-P sampling

Sampling 策略決定「從機率分佈挑下一個 token」的具體方法。主流選擇：

Top-P sampling 的細節：先依機率排序、累加直到超過閾值 P（如 0.9）、只 sample 這些 token、其他丟掉。Token 多樣性自動依分佈尖銳度調整、比固定 K 彈性。完整 sampling 策略（含 repetition penalty、min-p、frequency penalty 等）見 3.5 sampling 策略。

Cross-Entropy：訓練 LLM 的 loss function

Cross-entropy（交叉熵）的核心定義是「衡量兩個機率分佈的差距」。形式：

1H(p, q) = -Σᵢ p(xᵢ) log q(xᵢ)

p 是真實分佈、q 是模型預測分佈。LLM 預訓練 / 一般 SFT 場景下 p 是 one-hot（正確 token 機率 1、其他 0）、q 是模型 softmax 輸出；label smoothing / distillation / soft target 等場景 p 是平滑分佈、cross-entropy 仍適用、形式上需保留完整 sum。LLM 訓練的 one-hot 場景下 cross-entropy loss 簡化為：

1loss = -log(q(正確 token))

幾何意義：模型給正確 token 的機率越高、loss 越低。完美預測時 loss → 0、完全錯時 loss → ∞。

為什麼用 cross-entropy 而非其他 loss：

1. 跟 softmax 配合好：兩者組合的 gradient 形式漂亮、訓練穩定。
2. 直接最佳化機率：跟模型輸出的本質一致、不用引入額外轉換。
3. 資訊論依據：cross-entropy 等於「假設真實分佈是 p、用 q 編碼平均要多少 bits」。

Perplexity：模型品質的標準指標

Perplexity（困惑度）的核心定義是「e 的 cross-entropy 次方」、衡量模型預測下一個 token 的不確定性：

1perplexity = exp(cross-entropy)

幾何意義：「平均來說、模型猶豫在幾個 token 之間」。

• Perplexity = 10：模型平均要在 10 個 token 中挑、不確定性中等。
• Perplexity = 2：模型很有信心、平均在 2 個 token 中挑。
• Perplexity = vocab_size：模型完全沒學到、隨機猜。

實務上 perplexity 是預訓練模型品質的標準評估指標。GPT-3 paper 報告各種任務的 perplexity；本地模型對比常引用 WikiText / C4 等 benchmark 上的 perplexity 數字。

Perplexity 跟 SWE-bench 等任務 benchmark 是兩個維度：前者衡量「模型預測下一個 token 的不確定性」、後者衡量「實際解問題的能力」。能力強的模型 perplexity 通常較低、但不是線性關係。

Perplexity 的三個常見判讀陷阱：

• 跨 tokenizer 不可比：兩個模型 vocab 不同、平均 token 長度不同、perplexity 數值不在同一座標。判讀訊號：比較數字前先確認 tokenizer 是否相同；不同就改用 byte-level perplexity 或實際任務 benchmark。
• Domain mismatch：在 WikiText 上 perplexity 低、不代表 coding 任務也強。Perplexity 反映「訓練 / 評估資料分佈」的擬合度、跨 domain 引用需附 corpus 名稱。
• Context 長度影響：較長 context 通常 perplexity 較低（前文越多越好預測下一字）、引用數字時要附 context window 設定。

KL Divergence：兩個分佈的距離

KL divergence（Kullback-Leibler divergence、KL 散度）的核心定義是「衡量分佈 q 偏離分佈 p 的程度」：

1KL(p || q) = Σᵢ p(xᵢ) log(p(xᵢ) / q(xᵢ))

性質：

• KL(p || q) ≥ 0、等號成立當且僅當 p = q。
• 不對稱：KL(p || q) ≠ KL(q || p) 一般而言。
• 跟 cross-entropy 關係：H(p, q) = H(p) + KL(p || q)、其中 H(p) 是 p 自身的 entropy。

LLM 中 KL divergence 的用途：

• RLHF：把 fine-tune 後的模型機率分佈跟原 pre-trained 模型對齊、避免 fine-tune 過頭偏離原模型太多。
• Knowledge distillation：把大模型的分佈傳給小模型、小模型最小化 KL(大模型 || 小模型)。
• DPO / 各種 alignment 方法：用 KL constraint 控制 policy 偏移量。

Entropy：分佈的不確定性

Entropy（熵）的核心定義是「機率分佈本身的不確定性」：

1H(p) = -Σᵢ p(xᵢ) log p(xᵢ)

幾何意義：「平均來說、用 p 編碼一個 sample 要多少 bits」。

• 確定分佈（one-hot）：entropy = 0、沒有不確定性。
• Uniform 分佈：entropy = log(N)、最大不確定性。

Entropy、cross-entropy、KL divergence 三者關係：

1H(p, q) = H(p) + KL(p || q)

Cross-entropy 等於「真實分佈的 entropy」加上「模型預測偏離真實的 KL distance」。訓練 LLM 是最小化 H(p, q)、等同於最小化 KL(p || q)、因為 H(p) 是常數（資料本身的不確定性）。

下一章

想看完整資訊論推導（Shannon’s coding theorem、mutual information 等）、見 2.4 公開課推薦 的 MIT 6.050J / Stanford EE376A 等資源。

下一章：2.2 微積分與最佳化。

寫 code 場景的使用者通常無需親自訓練、但理解這條鏈能解釋「為什麼 fine-tuning 要這麼多 GPU」「為什麼 learning rate 是關鍵 hyperparameter」「為什麼 gradient explosion 是常見問題」。本章整理核心概念、不展開完整推導。

本章目標

讀完本章後、你應該能：

1. 解釋 gradient 在訓練中扮演的角色。
2. 看到「learning rate = 1e-4」設定時、知道它控制什麼。
3. 區分 SGD、Adam、AdamW 在訓練 LLM 時的取捨。
4. 看到 gradient explosion / vanishing 報告時、知道發生在哪一層。

偏導數與 gradient：往哪個方向走 loss 變小

偏導數（partial derivative）的核心定義是「對多變數函式中的一個變數微分、其他變數視為常數」。記號 ∂f / ∂xᵢ。

Gradient（梯度）的核心定義是「所有偏導數打包成的向量」：

1∇f = (∂f/∂x₁, ∂f/∂x₂, ..., ∂f/∂xₙ)

幾何意義：gradient 指向「函式增加最快的方向」、長度等於該方向的變化率。要讓函式變小、就往 gradient 的反方向走。

LLM 訓練的核心步驟：

1. 把訓練資料丟進模型、跑 forward pass、得到預測。
2. 算 loss（預測跟真實答案的差距）。
3. 對所有權重算 gradient：∇_W loss。
4. 更新權重：W ← W - α · ∇_W loss（α 是 learning rate）。
5. 回到第 1 步、重複數百萬次。

第 4 步的更新公式就是 gradient descent。整個流程的關鍵在 gradient 怎麼算出來。

Chain rule：把 gradient 從輸出傳到所有權重

Chain rule（連鎖律）的核心定義是「複合函式的導數等於各層導數的乘積」。一變數情況：

1若 z = f(g(x))、則 dz/dx = (df/dg) × (dg/dx)

多變數情況推廣到 chain rule 的矩陣形式（Jacobian）。

LLM 有數十億參數、每個參數都要算 gradient。Chain rule 讓「從 loss 倒推每個權重的 gradient」變成可計算的問題：

1loss
2 ↑ ∂loss/∂output
3output (last layer)
4 ↑ ∂output/∂layer_N_input × chain rule
5layer N
6 ↑ ...
7layer 1
8 ↑ ∂layer_1_input/∂W₁
9weights W₁

每層算「local gradient」（output 對 input 的導數）、chain rule 把它們乘起來、最終得到 loss 對每個權重的 gradient。這個流程叫 backpropagation（反向傳播）。

詳細展開見 3.0 神經網路基礎。

Learning Rate：每步走多遠

Learning rate（學習率）的核心定義是「gradient descent 每步更新的幅度」、記號 α 或 η。權重更新：

1W_new = W_old - learning_rate × gradient

Learning rate 的影響：

LLM 訓練常用 learning rate：

• 預訓練（pre-training）：1e-4 ~ 3e-4、有 warmup 後線性衰減
• Fine-tuning：1e-5 ~ 5e-5、較小避免破壞 pre-trained 權重
• LoRA：1e-4 ~ 1e-3、只更新少量參數可較大

Learning rate 是訓練 LLM 最關鍵的 hyperparameter、設錯時整個訓練容易失敗、實務上極難救回。實務上常用 learning rate scheduler 動態調整：warmup + cosine decay 是最主流的組合。

SGD：最基本的最佳化演算法

SGD（Stochastic Gradient Descent、隨機梯度下降）的核心定義是「每次只用一小批資料（mini-batch）算 gradient、更新權重」。對應 vanilla gradient descent（用全部資料算一次）的計算成本問題：

• Batch GD：每步用全部訓練資料、gradient 準但每步成本高、適合小資料集
• SGD（mini-batch）：每步用 32 ~ 256 筆、gradient 有 noise 但平均下來方向對、適合大資料集

LLM 預訓練資料動輒 TB 級、每步只能用 mini-batch；每個 token 算一次 forward + backward、跑數兆 token、總更新數十萬到數百萬步。

Vanilla SGD 在 LLM 場景的缺點：

1. 對 learning rate 敏感、不同 layer / 不同參數可能需要不同 learning rate。
2. 在「狹長 loss surface」上震盪、收斂慢。
3. 不利用過去 gradient 資訊。

SGD-with-momentum 在 vanilla SGD 上補了「過去 gradient 累積成 velocity」、處理震盪問題、在 vision（ResNet、ImageNet 訓練）跟小規模 fine-tune 仍是合理選擇；Adam / AdamW 在 LLM 預訓練成主流的原因是「自適應 learning rate + per-parameter scale」更能對付 Transformer 的高維、稀疏 gradient 結構、大規模 transformer 預訓練幾乎全部用 AdamW。

Adam 與 AdamW：適應性最佳化

Adam（Adaptive Moment Estimation）的核心定義是「每個參數有自己的有效 learning rate、根據過去 gradient 的一階矩跟二階矩自動調整」。簡化版本：

1m_t = β₁ × m_{t-1} + (1 - β₁) × gradient   ← 一階矩（gradient 的指數移動平均）
2v_t = β₂ × v_{t-1} + (1 - β₂) × gradient²  ← 二階矩（gradient 平方的指數移動平均）
3update = learning_rate × m_t / (sqrt(v_t) + ε)

直覺：

• 一階矩 m：類似動量、讓更新方向有慣性、減少震盪。
• 二階矩 v：估計 gradient 大小、把更新除以 sqrt(v)、自動調整每個參數的有效步幅。
• 結果：高 gradient 的參數步小、低 gradient 的參數步大、整體穩定收斂。

AdamW 是 Adam 的改進版、把 weight decay（L2 正則化）跟 gradient update 解耦。大規模 transformer 預訓練幾乎都用 AdamW、vanilla Adam 已退出 LLM 主流（SGD-with-momentum 在 vision 跟小規模 fine-tune 仍適用）。

代價：Adam / AdamW 需要為每個參數額外存 m（一階矩、gradient 的指數移動平均）跟 v（二階矩、gradient 平方的指數移動平均）、記憶體成本是 SGD 的 3 倍。31B 模型用 AdamW 訓練的 optimizer state 約佔 200GB+ 記憶體、拆解如下（mixed-precision training、batch=1024 / 不含 activation checkpoint 的典型配置）：

• fp32 master weights：31B × 4 bytes ≈ 124 GB
• m（一階矩）：31B × 4 bytes ≈ 124 GB
• v（二階矩）：31B × 4 bytes ≈ 124 GB
• 總計約 372 GB optimizer state、加上 activation 與 gradient buffer 後實際需求更高

對比推論時 Gemma 4 31B Q4 量化版約 18GB（含 KV cache、見 0.5 Apple Silicon 記憶體預算）、訓練需求是推論的 20 倍以上。這就是為什麼訓練 LLM 需要大量 GPU、推論可以在個人 Mac 上跑。

Gradient Explosion 與 Vanishing

Gradient explosion（梯度爆炸）的核心問題是「gradient 經過多層 chain rule 累積、變成天文數字、權重更新後完全爆掉」。常見於深度網路、特別是 RNN。

Gradient vanishing（梯度消失）的反面問題是「gradient 經過多層後變得幾乎為 0、深層 layer 學不到東西」。常見於用 sigmoid / tanh activation 的深度網路。

Transformer 為什麼能訓練深層網路：

1. Residual connection：跨層加上 x + f(x)、給 gradient 一條短路、避免 vanishing。
2. Layer normalization：每層 activation 重新正規化、避免數值爆炸。
3. 適當的權重初始化：Xavier / Kaiming 初始化讓初始 forward pass 不爆。
4. Gradient clipping：訓練時把 gradient 的 norm 截斷在閾值內、避免 explosion。

詳細展開見 3.3 Transformer 架構。

Backpropagation：chain rule 在多層網路上的演算法名

Backpropagation（反向傳播）就是前面 chain rule 段講的「∂loss/∂W 倒推流程」在實作上的演算法名稱、不是另一個獨立概念。整體流程：forward pass 算 output 與 loss、backward pass 用 chain rule 從 loss 逐層倒推每個權重的 gradient、framework（PyTorch / MLX）的 autograd 自動完成 backward、開發者只需寫 forward。Autograd 跟 chain rule / backprop 是同個概念在不同抽象層級的展開。

為什麼推論不需要 backprop

寫 code 場景用 LLM 是「推論」而非「訓練」。推論只跑 forward pass、不算 gradient、不更新權重。所以：

1. 記憶體需求低得多：推論不用存中間 activation（forward pass 結束就可丟）、不用存 optimizer state。Gemma 4 31B 推論約 18GB、訓練同個模型可能要 200GB+。
2. 算力需求低得多：推論一個 token 要 1 次 forward pass、訓練一個 token 要 forward + backward = 約 3 次 forward 的成本。
3. 沒有 learning rate / optimizer 等 hyperparameter：推論只有 temperature、top-p 等 sampling 參數。

這就是為什麼 32GB Mac 可以推論 31B 模型、訓練同個模型要動用整個 H100 cluster。

下一章

想看完整最佳化理論（凸最佳化、二階方法、Hessian、Newton’s method 等）、見 2.4 公開課推薦 的 Stanford EE364 / CS229 等課程。

下一章：2.3 數值精度與量化的數學依據。

本章拆開「浮點數的位元結構」、「不同 format 的取捨」、「量化的數學流程」三件事、讓 Q4_K_M、bf16、fp16、int8 等術語從口號變成可推導的工程選擇。

本章目標

讀完本章後、你應該能：

1. 解釋 fp32、bf16、fp16 三者的位元結構差異。
2. 看到「Q4 量化」時、知道是把每個權重壓成 4 bits。
3. 推算 31B 模型用不同精度的記憶體佔用。
4. 解釋為什麼 Q3 衰減品質遠大於 Q4 → Q5。

浮點數的位元結構

浮點數（floating point）的核心定義是「用「符號 + 指數 + 尾數」三段位元表示實數」。IEEE 754 標準：

1value = (-1)^sign × 1.mantissa × 2^(exponent - bias)

各 format 的位元分配：

關鍵觀察：

1. fp32 vs bf16 vs fp16：

   • fp32 是基準、訓練最穩、推論最浪費。
   • bf16 跟 fp32 同 exponent 範圍、不會 overflow、但 mantissa 較少、精度低。
   • fp16 範圍小（±65,504）、訓練容易 overflow、需要 loss scaling。

2. 訓練主流選 bf16：保留 fp32 的範圍、用 fp16 的位元數、避免 overflow / underflow 問題。Apple Silicon、NVIDIA Ampere+ 都原生支援 bf16。

3. 推論常見更低精度：fp16、int8、int4 在推論時夠用；訓練多數情境精度不足、需要更高 format 或特殊技巧（loss scaling、mixed precision）。

bf16 為什麼比 fp16 更適合 LLM 訓練

bf16（brain float 16、Google Brain 提出）跟 fp16 都是 16 bits、但結構不同：

• fp16：sign 1 + exponent 5 + mantissa 10
• bf16：sign 1 + exponent 8 + mantissa 7

fp16 的 exponent 只有 5 bits、能表達的最大值 65,504、最小正值約 6e-5。LLM 訓練中的 gradient 經常超出這個範圍：

• Gradient 太大 → overflow → NaN → 訓練崩潰。
• Gradient 太小 → underflow → 變 0 → 那個權重學不到東西。

要用 fp16 訓練、得加 loss scaling（把 loss 乘一個大數、讓 gradient 落在 fp16 範圍內、最後再除回去）、流程複雜。

bf16 的 exponent 8 bits、跟 fp32 同範圍、在 LLM gradient 的典型範圍內不會 overflow / underflow（fp32 的全範圍 ±3.4e38 仍可能 overflow、但 LLM 場景遠超這個值的機率極低）。代價是 mantissa 只剩 7 bits、精度更低。對 LLM 訓練來說、範圍比精度重要（gradient 的方向比精確值關鍵）。

硬體前提：bf16 訓練主流是 NVIDIA Ampere（A100、2020+）跟 Apple Silicon、舊 GPU（Pascal、Volta）只有 fp16 硬體加速、用 bf16 會走 software fallback、性能差。

所以 2026 年主流選擇：

• 訓練：bf16（forward + backward）+ fp32（master copy of weights）
• 推論：bf16 或更低（fp16、int8、int4）

量化：把權重從 bf16 壓到 Q4 / Q8

量化（quantization）的核心定義是「把連續的浮點數值 map 到離散的整數值」。最簡單的對稱量化：

1給定一組權重 W ∈ ℝⁿ：
2
31. 算 scale = max(|W|) / (2^(bits-1) - 1)
4   例如 4-bit、scale = max(|W|) / 7
52. 把每個 wᵢ 量化成整數 qᵢ = round(wᵢ / scale)
63. 還原時：w̃ᵢ = qᵢ × scale

幾何意義：把連續實數軸切成 2^bits 個格子、每個權重 snap 到最近的格子。bits 越少、格子越粗、量化誤差越大。

各量化等級的格子數：

K-quants：更聰明的量化

GGUF 的 K-quants 比樸素量化更聰明：

1. Block-wise quantization：權重切成小 block（例如 32 個權重一組）、每個 block 各自的 scale。讓 scale 適應 local 數值範圍、減少全域量化誤差。
2. Mixed precision：不同 layer 用不同 bits。LLM 中某些 layer（如 attention output、embedding）對品質影響大、用較高 bits（Q5）；其他用較低 bits（Q4）。整體平均落在「Q4_K_M」這個標籤。

「Q4_K_M」拆解：

• Q4：平均約 4 bits / 權重
• K：K-quants（block-wise、混合精度）
• M：medium variant、不同 layer 用不同 bits 的具體配方（也有 S small、L large 等變體）

實際每個權重的 bits 不剛好是 4、會稍高一點（Q4_K_M 取中值約 4.5 bits / 權重、實際隨模型架構與 attention layer 比例落在 4.4 ~ 4.8 之間、Hugging Face 上具體檔案大小可能跟下方表格估算差 5 ~ 10%）。

模型大小推算

知道每個權重幾 bits 後、可以推算模型佔用：

1模型大小（GB）= 參數數 × bits / 8 / 1024^3

例子：

加上 metadata、tokenizer、KV cache 等 overhead、實際記憶體佔用會比表上多 10 ~ 30%。

量化在哪一步損失資訊

量化的品質損失來自三個位置：

1. Rounding error：把連續實數 snap 到離散格子、每個權重產生一個小誤差。Block size 越大、scale 越粗、誤差越大。
2. Clipping：若 max(|W|) 估錯（例如忽略 outlier）、超出範圍的權重被 clip 到範圍內、損失大值資訊。K-quants 用 block-wise 解決 outlier 影響。
3. Layer-wise 累積：每個 layer 的量化誤差會經過後續 layer 放大或累積；某些 layer（如 attention 的 output projection）對誤差特別敏感。Mixed precision 對這些 layer 保留較高 bits。

實務上：

• Q4_K_M 在 31B 模型上品質衰減約 1 ~ 2%（用 perplexity 衡量）、實用上幾乎察覺不到。
• Q3 在 31B 模型上衰減約 5 ~ 10%、coding 任務開始失誤。
• Q2 衰減 20%+、實用情境受限、多半用於極端硬體預算的實驗。

為什麼 31B Q4 常勝 70B Q3

模型大小與量化等級的乘積決定實際品質。31B Q4 跟 70B Q3 的記憶體佔用接近（16GB vs 25GB）、但實際表現常常 31B Q4 勝：

• 70B Q3 的量化誤差累積在每一層、深網路放大誤差。
• 31B Q4 誤差較小、雖然參數量較少但能力穩定。

這就是 模型選型 的核心啟示：「夠大」跟「夠好」是兩件事、優先選穩定量化等級、把激進量化留給有預算驗證的場景。

推論時的數值精度

寫 code 場景的推論大致流程：

1. 權重儲存：Q4_K_M 格式（4.5 bits / 權重）。
2. 推論時 dequantize：每次用到權重時、暫時 unpack 回 fp16 / bf16 跟 input 做矩陣乘法。
3. Activation 維持 fp16 / bf16：樸素 Q4_K_M 的預設行為是不量化 activation、避免進一步損失精度。進階場景（KV cache 量化 K=Q8 / V=Q4、AWQ、GPTQ 等 activation-aware 量化）會例外處理、需依框架文件配置。

所以「Q4 模型」內部運算精度其實是 fp16 / bf16、只有「儲存」是 4 bits。這是為什麼量化主要省記憶體與頻寬、不省算力（算力差距小）。

下一章

想看完整數值分析（IEEE 754 細節、條件數、誤差傳播等）、見 2.4 公開課推薦 的相關資源。

下一章：2.4 想學更深：推薦公開課程。

選課的原則：先從跟 LLM 連結最緊密的開始、由近至遠。3Blue1Brown 的視覺化系列適合入門複習、MIT / Stanford 的正式課程適合認真打底、Karpathy 的 YouTube 系列適合「想直接看 LLM 怎麼從零實作」（需要階段 1 ~ 3 的數學基礎才能順暢跟上、所以排在路線後段）。

路線總覽

階段 1：3Blue1Brown 的視覺化系列（YouTube 免費）

Grant Sanderson 的 3Blue1Brown 頻道是入門 / 複習數學概念最有效率的選擇。動畫品質高、講解直觀、每集 15 ~ 30 分鐘。

為什麼從這裡開始：3Blue1Brown 的影片不依賴背景知識、用視覺直觀傳達核心概念、適合在進入正式課之前對齊直覺。看完 Essence of Linear Algebra 跟 Neural Networks 兩個系列、本模組大部分概念都能 grasp 到直覺層。

階段 2：線性代數正式課

MIT 18.06 Linear Algebra by Gilbert Strang（OCW 免費）

教授 Gilbert Strang 的線性代數課是公開課的金標準、涵蓋向量空間、特徵值、SVD、最小平方等完整內容。課程網站包含影片、講義、作業、教科書。

• 教科書：Introduction to Linear Algebra by Gilbert Strang（也有 PDF 可下載）
• 課程連結：ocw.mit.edu 站內搜尋 18.06 或 18.06SC
• 時長：18 ~ 35 講、每講 50 分鐘、約 30 小時
• 適合：認真打底、想做完整作業
• 跟本模組關係：完整補完 2.0 的數學深度

MIT 18.06SC Linear Algebra（Self-Paced 版本）

同樣 Gilbert Strang、但設計成自學版本、有 problem sessions 補講解。建議自學選擇這版而非原始 18.06。

階段 3：機率論 + 統計

Harvard Stat 110 Probability by Joe Blitzstein（YouTube 免費）

Harvard 教授 Joe Blitzstein 的機率論課、是 LLM 機率基礎最完整的公開課。涵蓋條件機率、貝氏定理、各種分佈、generating function、Markov chain 等。

• 課程連結：projects.iq.harvard.edu/stat110（YouTube 有對應錄影）
• 教科書：Introduction to Probability by Blitzstein & Hwang
• 時長：35 講、每講 50 分鐘、約 30 小時
• 適合：想懂機率論完整體系
• 跟本模組關係：補完 2.1 的數學深度

MIT 6.041 Probabilistic Systems Analysis（OCW 免費）

工程取向、比 Stat 110 更貼近應用。涵蓋 Bayes、Markov、隨機過程等。適合工程師背景的讀者。

Stanford CS109 Probability for Computer Scientists

Stanford 的 CS 系開設、機率論 + 程式應用、適合想直接看「機率在 ML 中怎麼用」的讀者。課程材料在 Stanford CS109 網站。

階段 4：資訊論

MIT 6.050J Information and Entropy（OCW 免費）

涵蓋 entropy、cross-entropy、KL divergence、Shannon coding theorem、channel capacity 等資訊論完整基礎。

• 教科書：Information Theory, Inference, and Learning Algorithms by David MacKay（也免費 PDF）
• 適合：想懂 2.1 中 entropy / KL 的數學起源
• 跟 LLM 的連結：cross-entropy 為什麼是訓練 LLM 的標準 loss、perplexity 的資訊論意義

Stanford EE376A Information Theory

Stanford 的 EE 系開設、跟通訊工程結合、適合 EE 背景讀者。

階段 5：最佳化

Stanford EE364A Convex Optimization by Stephen Boyd（YouTube + 教科書免費）

凸最佳化的金標準課程。涵蓋 gradient descent、Lagrangian、duality、KKT 條件等。雖然 LLM 訓練是非凸最佳化、但凸最佳化的觀念是基礎。

• 教科書：Convex Optimization by Boyd & Vandenberghe（線上 PDF 免費）
• 適合：想懂 SGD、Adam、Lagrangian 等最佳化技術的數學起源
• 跟本模組關係：補完 2.2 的最佳化理論深度

階段 6：深度學習與 LLM

MIT 6.S191 Introduction to Deep Learning（每年更新、YouTube 免費）

MIT 的入門 deep learning 課、每年寒假開課並錄影上傳、涵蓋 RNN、Transformer、Diffusion、LLM。

• 課程連結：introtodeeplearning.com
• 時長：每集 1 小時、約 7 ~ 10 集
• 適合：deep learning 全面 overview、跟最新主題對齊

Stanford CS229 Machine Learning by Andrew Ng（Stanford Online + YouTube）

ML 基礎金標準、涵蓋 linear regression、logistic regression、SVM、CNN、強化學習等。雖然較舊（沒有最新 Transformer）、但基礎扎實。CS229 的免費影片版在 Stanford Online 跟 YouTube（cs229.stanford.edu 有講義跟舊版錄影連結）；OCW 沒有 CS229 官方版本。

• 新版：Coursera 上有付費版「Machine Learning Specialization」、更新且互動性強
• 適合：想完整懂 ML 數學基礎

Stanford CS224N Natural Language Processing with Deep Learning

NLP + Transformer 的標杆課程。涵蓋 word embedding、RNN、attention、Transformer、BERT、GPT 等。每年更新材料。

• 適合：3.2 attention 機制 與 3.3 Transformer 架構 的最佳補完
• 連結：Stanford CS224N 課程網站、YouTube 有錄影

Stanford CS25 Transformers United

Stanford 的 Transformer 專題課、每集邀請業界與學界專家、涵蓋 Transformer 在不同領域的應用與進展。

• 適合：想跟最新 Transformer 研究進度
• 連結：YouTube 上搜尋「Stanford CS25」

Stanford CS336 Language Modeling from Scratch（2024 新開、後續每年更新）

Stanford 新開的 LLM 從零訓練課程、涵蓋資料、tokenization、模型架構、訓練、評估、部署整條鏈。課程材料逐年更新、引用時請註明你看的是哪一年的版本（2026 年後內容可能跟本章引用時有差異）。

• 適合：想懂 LLM 完整 lifecycle
• 連結：Stanford CS336 課程網站

階段 7：直接動手實作

Andrej Karpathy 的 Neural Networks: Zero to Hero（YouTube 免費）

OpenAI 前研究員 Andrej Karpathy 的系列影片、從手刻 micrograd 到實作 GPT-2、是「想動手懂 LLM」的最佳路徑。每集 1 ~ 4 小時、邊講邊寫 code。

• 核心集數：
  • Micrograd（自己刻 autograd）
  • Makemore 系列（從 bigram 到 Transformer）
  • Let’s build GPT（從零實作 GPT-2）
  • Let’s reproduce GPT-2（更完整的訓練 pipeline）
  • Let’s build the GPT Tokenizer（BPE 詳細實作）
• 適合：完成階段 1-3、想直接接觸完整系統實作
• 連結：YouTube 搜尋「Karpathy zero to hero」

Hugging Face NLP Course

Hugging Face 官方教材、涵蓋 Transformers library、tokenizer、訓練、推論、deployment。實作取向、適合工程師。

• 連結：huggingface.co/learn

書籍補充

這幾本書的官方免費 PDF 來源（避免落到盜版站）：

• Mathematics for Machine Learning：mml-book.github.io
• Deep Learning（Goodfellow）：deeplearningbook.org
• Information Theory, Inference, and Learning Algorithms：inference.org.uk/mackay/itila/
• Convex Optimization（Boyd）：stanford.edu/~boyd/cvxbook/
• The Elements of Statistical Learning：hastie.su.domains/ElemStatLearn/

何時不適用本路線

本路線假設「想紮實打底數學跟 LLM 內部、之後做研究或寫 LLM-related code」。以下情境的路線需求不同：

建議的時間投入

機會成本提醒：本系列文章在「Mac 上跑本地 LLM 寫 code」場景中、不需要完整跑完上述課程。3Blue1Brown 三系列 + Karpathy zero-to-hero 已經涵蓋「能讀懂 LLM paper、能看懂模型架構討論」的程度、約 6 ~ 10 週投入。想做研究或自己訓練模型、再進入 MIT / Stanford 正式課程。

下一個模組

下一個模組：模組三 LLM 的理論基礎、把本模組的數學工具拼成完整的 LLM 運作機制。

本章假設你看過向量這個詞、知道矩陣有 row 跟 column、但忘記中間細節。每個概念給出定義、在 LLM 中的角色、實務上會怎麼遇到它。

本章目標

讀完本章後、你應該能：

1. 用向量描述「token 在語意空間中的位置」。
2. 用矩陣乘法解釋「模型一個 layer 在做什麼」。
3. 估算「31B 模型佔多少記憶體」（除了量化外的計算依據）。
4. 看到「dimension mismatch」錯誤時、知道是維度沒對齊。

向量：有方向有長度的數列

向量（vector）的核心定義是「有序的數字序列」。在 LLM 中、每個 token 對應一個向量、稱為 embedding；向量的維度（dimension）通常是幾百到幾千、例如 Gemma 4 的 hidden size 約 4096。

向量可以幾何解釋成「N 維空間中的一個箭頭」、方向跟長度都重要：

• 方向：表示「token 的語意特徵」。語意相近的 token（如 cat 跟 kitten）向量方向接近、語意無關的（如 cat 跟 algorithm）方向遠。
• 長度（norm）：表示「token 在這個維度上的強度」、計算方式有 L1（絕對值總和）、L2（平方和開根號、最常用）、L∞（最大絕對值）等。

實務上會遇到向量的地方：

• Embedding 模型 把文字轉成向量、Continue.dev 的 @codebase 用這個機制找相關片段。
• KV cache 存的就是每個 token 在每個 layer 算出來的向量。
• 模型內部所有 token 都以向量形式流動、token 本身的整數 ID 只在輸入跟輸出端用到。

內積：衡量兩個向量的相關性

內積（dot product / inner product）的核心定義是「兩個向量對應位置相乘再相加」。a · b = a₁b₁ + a₂b₂ + ... + aₙbₙ。

內積的幾何意義是「投影」：a 在 b 方向上的長度乘以 b 的長度。對 LLM 而言、它最重要的用途是衡量兩個向量的相似度：

• 兩個向量方向接近、內積大（正值）。
• 兩個向量垂直、內積為 0。
• 兩個向量方向相反、內積大負值。

Attention 機制就是用內積算「當前 token 該關注前面哪幾個 token」：

1attention_score = query · key  ← 內積

每一對 (query, key) 算一次內積、得到一個分數；分數高表示「這個 token 該注意那個位置」。詳細展開見 3.2 attention 機制。

Norm：向量的長度

Norm（範數）的核心定義是「衡量向量大小的純量值」。最常用的 L2 norm（也叫 Euclidean norm）：

1||v||₂ = sqrt(v₁² + v₂² + ... + vₙ²)

LLM 中 norm 的用途：

• Layer normalization：每個 layer 結束後把 activation（每層輸出的數值、見 3.0 神經網路基礎）重新正規化、避免數值爆炸或消失。
• Embedding normalization：embedding 模型常把向量正規化到 L2 norm = 1、讓內積等同於 cosine similarity。
• Gradient clipping：訓練時若 gradient（訓練階段更新權重用的方向、詳見 2.2 微積分與最佳化）的 norm 太大、截斷到合理範圍、避免訓練不穩。

Cosine similarity（餘弦相似度）= 兩個向量的內積除以兩者 norm 的乘積、結果落在 -1 到 1 之間、是 RAG / semantic search 最常用的相似度指標。實務上常先把 embedding 正規化到 L2 norm = 1、之後 cosine similarity 退化為單純內積、可直接套用 dot-product 比對。

使用 cosine similarity 時的兩個邊界：

• Anisotropy（向量集中在某方向）：訓練不充分或 embedding 維度太低時、所有向量會擠在一個窄錐裡、cosine 分數普遍偏高、相對排序失準。判讀訊號：抽樣 100 對隨機 query、cosine score 平均 > 0.7。修法：換較強的 embedding model、或對 embedding 做 mean-centering / whitening。
• 不同 embedding space 不可比：nomic、OpenAI、bge 訓練 objective 不同、向量空間不同源、跨模型算 cosine 沒意義。修法：同一個 retrieval pipeline 鎖一個 embedding model、換模型時整批重算 index。

矩陣：把向量打包成 2D 結構

矩陣（matrix）的核心定義是「向量的有序集合、以 2D table 形式組織」。一個 m × n 矩陣有 m row、n column；每個 row 或 column 可以視為向量。

LLM 中的矩陣到處都是：

• 權重矩陣：每個 linear layer 對應一個權重矩陣 W、shape 是 (input_dim, output_dim)。
• Batched inputs：把多個 token 的 embedding 打包成 (seq_len, embed_dim) 矩陣、一次處理。
• Attention scores：每對 (query, key) 算內積、得到 (seq_len, seq_len) 矩陣。

模型權重數量的算法：把所有 layer 的權重矩陣大小加總、就是 31B / 70B 等參數規模。例如一個 hidden size = 4096 的 linear layer、權重矩陣大小 4096 × 4096 = 16,777,216、約 16.8M 參數。31B 模型的數字推導：~1800 個這個量級的權重矩陣相加（attention 的 Q / K / V / O 矩陣 + FFN 的兩個矩陣 × 數十個 transformer block）、總和約 31B 個參數；bf16 每權重 2 bytes、整份權重約 62GB；Q4 量化後每權重 0.5 bytes、約 18GB。完整的記憶體預算判讀見 0.5 Apple Silicon 記憶體預算。

矩陣乘法：LLM 推論的核心運算

矩陣乘法（matrix multiplication）的核心定義是「左矩陣的 row 跟右矩陣的 column 做內積、結果填進對應位置」。對 A (m × k) 跟 B (k × n) 相乘、得到 C (m × n)、其中 C[i][j] = A 的第 i row 跟 B 的第 j column 的內積。

LLM 推論的每個 layer 都是矩陣乘法 + 非線性 activation。例如一個 feed-forward 層的計算是：

1output = activation(input @ W₁) @ W₂

其中 @ 是矩陣乘法、W₁、W₂ 是權重矩陣。一個 31B 模型跑一次 forward pass、會做數百次矩陣乘法、總運算量是「token 數 × 模型參數數 × 2」的量級。

矩陣乘法的維度規則：左矩陣的 column 數要等於右矩陣的 row 數。(m × k) @ (k × n) = (m × n)。遇到 dimension mismatch 錯誤的定位流程：讀 traceback 找到 mat1 / mat2 各自的 shape、檢查倒數第二維（左）跟倒數第一維（右）是否相等；常見來源是 batch dim 沒 squeeze、或 transpose 順序錯。理論上限 ≈ 30 tok/s 是 dense 模型 + 單請求 + 無 batching / 無 speculative decoding 的純 memory-bound 情境下的估算、實際數字隨量化、framework、batch 配置浮動。

為什麼這對 memory bandwidth 重要

Memory bandwidth 是 LLM 推論的真實瓶頸、原因落在矩陣乘法本身：

• 每生成一個新 token、需要把整個模型權重（所有矩陣）從記憶體讀到處理器一次。
• 算力（FLOPs）在現代 GPU / Apple Silicon 上充足、瓶頸落在「讀權重要多久」。
• 31B 模型約 18GB（Q4 量化）、M4 Max 頻寬 546 GB/s、理論上限 ≈ 30 tok/s。

這就是為什麼 量化 能加速：權重變小、每秒能讀過更多次完整模型、tok/s 變高。也是為什麼 speculative decoding 能加速：一次 forward pass 就把權重讀過一次、驗證多個 token、攤平單 token 成本。

張量（Tensor）：多維度的矩陣

張量（tensor）的核心定義是「N 維陣列、矩陣是 N=2 的特例」。LLM 內部常用 3D / 4D tensor：

• 3D：(batch_size, seq_len, hidden_dim)、表示「N 個句子、每個句子 M 個 token、每個 token 是 D 維向量」。
• 4D：(batch_size, num_heads, seq_len, head_dim)、表示 multi-head attention 的並行計算結構。

PyTorch、MLX 等 framework 的核心型別都叫 Tensor、所有運算（矩陣乘法、norm、softmax 等）都對 tensor 做。

下一章

想看完整推導跟練習、見 2.4 公開課推薦 的 MIT 18.06、3Blue1Brown 線性代數系列等資源。

下一章：2.1 機率與資訊論。