How LLM Inference Works, Clearly Explained.

Cover Image

原始來源與檔名：2026-06-30T094045+0800-How LLM Inference Works, Clearly Explained..md

SOURCE | 資訊源評估

NAPKIN | 餐巾纸

餐巾纸公式

LLM Inference Bottleneck = Prefill (Compute-bound, 影響 TTFT) + Decode (Memory-bound, 影響 ITL)

LLM 推理效能調優並非單一問題，處理 Prompt 依賴 GPU 算力，而生成 Token 則依賴記憶體頻寬。

一句话

LLM 推理不是黑盒子，而是一場資源爭奪戰：先用算力平行處理完 Prompt (Prefill)，再受限於記憶體頻寬，逐個擠出字詞 (Decode)。

餐巾纸草图

[ Input: "How does inference work?" ]
       |
       v
+-----------------------------------+
| PREFILL PHASE (Compute-Bound)     | -> All tokens processed in parallel.
| High GPU Utilization              | -> Target: Optimize TTFT
+-----------------------------------+
       | (Outputs first token & KV Cache)
       v
+-----------------------------------+
| DECODE PHASE (Memory-Bound)       | -> Token by token. Reads KV Cache.
| Low GPU Compute, High Mem B/W     | -> Target: Optimize ITL
+-----------------------------------+
       |
       v
[ Output: "Inference is..." ]

ROUND 1: SKELETON | 骨架掃描

“這篇文章在說什麼”

章节骨架

  1. Tokenization & Embedding: 將文字轉化為向量與位置編碼。
  2. Transformer Layers: 自注意力機制 (Attention) 與前饋網路 (FFN) 的運作。
  3. Prefill: 平行處理 Prompt，受限於 GPU 算力 (TTFT)。
  4. Decode: 逐字生成，受限於記憶體頻寬 (ITL)。
  5. KV Cache & Optimizations: KV Cache 的重要性、記憶體消耗，以及量化、Continuous Batching 等伺服器端優化技術。

ROUND 2: DISSECTION | 血肉解剖

“憑什麼這麼說”

論證鏈

長 Prompt 需要龐大的矩陣相乘 --> 這是 Compute-bound (算力密集) --> 影響 TTFT (首字延遲)
生成新 Token 需要讀取龐大的歷史 KV 權重 --> 算力閒置，但記憶體頻寬滿載 --> 這是 Memory-bound (記憶體頻寬密集) --> 影響 ITL (字間延遲)
因此，優化長文本輸入需要提升算力，優化長文本輸出需要更快的記憶體或更小的 Cache (如 DeepSeek V4)。

关键证据

  1. Prefill 階段的虛擬碼顯示 Q, K, V = project(hidden) 是一次性處理所有 Token 的大矩陣乘法，GPU 使用率高。
  2. Decode 階段的虛擬碼顯示 token = sample(...) 是在迴圈中逐次執行，且需要載入過往所有的 K_all, V_all，導致運算量小但記憶體搬運量大。
  3. 一個 13B 參數模型，每個 Token 的 KV Cache 約佔 1MB；4K 上下文就會消耗 4GB VRAM，這證明了長上下文為何如此昂貴且會排擠 Batch Size。

隐形假设与边界

ROUND 3: SOUL | 靈魂提取

“還能怎麼用”

留白提問 (Guided Reflection)

跨域映射

DEEP READ | 精讀指引 (Must-Read Segments)

[!IMPORTANT] 學習的本質需要「認知阻力」。請親自回到原文閱讀以下核心段落，感受原始論述的阻力，不要只依賴 AI 的總結。

  1. Prefill: the compute-bound phase & Decode: the memory-bound phase: 這是全篇最核心的洞見。理解 TTFT 與 ITL 到底被硬體的哪個部分卡住，是從「呼叫 API 的使用者」進化為「AI 架構師」的必經之路。
  2. Redesigning attention around the cache: 介紹 DeepSeek V4 如何從演算法層面直接壓縮 KV Cache（CSA 與 HCA）。這段展示了業界正在如何對抗記憶體牆 (Memory Wall)。

How LLM Inference Works, Clearly Explained. (Architectural Deep Dive)

前言/背景

本文深入剖析了大型語言模型 (LLM) 在執行 generate() 時的底層運作機制。多數開發者將 LLM 視為黑盒子，但實際上，LLM 的推理 (Inference) 過程在同一張 GPU 上分為兩個截然不同、受限於不同硬體資源的運算階段：處理輸入的 Prefill 階段與生成輸出的 Decode 階段。理解這些機制，是進行模型部署與效能優化 (如降低延遲、提升吞吐量) 的先決條件。

章節詳細總結

Tokenization and embedding (分詞與嵌入)

LLM 無法直接處理文字，必須先透過 Tokenizer (如 BPE) 將原始文字轉換為整數 ID。每個 ID 會映射到一個 Embedding Table (形狀為 [vocab_size, hidden_dim])，轉換成高維度向量 (如 4,096 維)。

prompt = "How does inference work?"
ids = tokenizer.encode(prompt) # ids -> [2437, 1374, 32278, 670, 30]
vectors = embedding_table[ids]   # shape: [num_tokens, 4096]

現代架構通常採用旋轉位置編碼 (RoPE, Rotary Position Embeddings)，透過旋轉向量來注入位置資訊，而非直接加上一個位置向量。

Transformer layers (Transformer 網路層)

嵌入後的序列會通過多層 Transformer Layer (通常 32 至 80+ 層)。每層包含兩個核心操作：

  1. Self-attention (自注意力機制)：計算每個 Token 的 Q (Query)、K (Key)、V (Value)。Token 的 Q 與其他所有 Token 的 K 進行內積運算，得出注意力分數 (Attention Scores)，決定該 Token 需要混入多少其他 Token 的 V。 
    Q, K, V  = x @ Wq, x @ Wk, x @ Wv
scores = (Q @ K.T) / sqrt (d_k)
weights = softmax(scaled) # one row per token, sums to 1
attn_output  = weights @ V
  2. Feed-forward network (FFN)：使用 MLP 獨立處理每個 Token 的向量。Attention 負責在不同位置間傳遞資訊，FFN 負責轉換資訊。

Prefill: the compute-bound phase (Prefill：算力密集的輸入階段)

當處理 Prompt 時，LLM 會在一次 Pass 中「平行」處理所有的 Input Tokens。因為是巨大的矩陣對矩陣乘法，這個階段受到 GPU 算力 (Arithmetic throughput) 的限制，GPU 使用率極高。 這階段決定了 TTFT (Time to First Token，首字延遲)。同時，這階段會將每一層計算出的 K 與 V 存入 GPU 記憶體中，形成 KV Cache。

# Prefill: process the whole prompt in one shot
hidden = embed(prompt_tokens) + positions
for layer in model.layers:
    Q, K, V = project(hidden)             # for ALL tokens at once
    hidden  = attention(Q, K, V) + hidden
    hidden  = feedforward(hidden) + hidden
    cache_kv(layer, K, V)                 # save for later
first_token = sample(project_to_vocab(hidden[-1]))

Decode: the memory-bound phase (Decode：記憶體頻寬密集的輸出階段)

產生第一個 Token 後，模型切換為「逐字生成」。此時，只需要計算「新 Token」的 Q，並與已經存在 KV Cache 中的歷史 K/V 進行注意力運算。 雖然每次運算的數學量極小，但 GPU 為了這小小的運算，必須從記憶體中搬運所有的模型權重矩陣以及龐大的歷史 KV Cache。因此，瓶頸瞬間從算力轉移到了 GPU 記憶體頻寬 (Memory bandwidth)，GPU 算力利用率通常會暴跌至 30% 以下。這階段決定了 ITL (Inter-Token Latency，字間延遲)。

# Decode: one token per iteration
token = first_token
steps = 0
while token != STOP and steps < MAX_STEPS:
    x = embed(token) + position(steps)
    for layer in model.layers:
        q, k, v = project(x)
        K_all, V_all = caches[layer].append(k, v) # 載入歷史 Cache 並加上新的
        x = layer.forward(q, K_all, V_all, x)
    token = sample(project_to_vocab(x))
    steps += 1
    yield token

The KV cache & Redesigning attention (KV Cache 與演算法層面的重構)

KV Cache 避免了 O(N²) 的重複運算，但代價是巨大的記憶體消耗。一個 13B 模型，每個 Token 約需 1MB Cache。4K Context 就要 4GB VRAM，這會排擠可用於 Batching 的記憶體。 DeepSeek V4 等新架構試圖從根本解決此問題，採用：

Quantization & Serving infrastructure (量化與伺服器基礎設施)

總結與結論