Life of a Token：像調試代碼一樣看懂大模型如何生成 Token

作者 | 孫照杰

Life of a Token: LLM's Next-Token Pipeline

Chrome 團隊有一篇著名的Life of a Pixel，從一個

出發到屏幕像素，追蹤它在瀏覽器渲染管線中的旅程：DOM → Style → Layout → Paint → Raster → Composite，用每個階段串起引擎全貌。

我們做同樣的事，但追蹤的不是像素，是token。

Token 是 LLM 的最小處理單元：模型不看字符，不看單詞，只看 token。"The"是一個 token，" capital"是一個 token，"unbelievable"會被切成"un"+"believ"+"able"三個 token。Token 之于 LLM 管線，就像像素之于渲染管線。

我們追蹤的 Hello World 是："The capital of France is"

你一眼就知道答案：巴黎。讀完 Ch7，你會看到" Paris"以 74.67% 的概率斷崖領先，模型僅憑矩陣乘法與非線性變換，逐層把這個答案算了出來。

這篇文章沿著這條管線，帶你走完一個 token 從輸入到輸出的每一步。內容對非算法同學友好。

全文用 GPT-2 Small 做 trace——不是因為它強，而是因為它透明：架構與現代 LLM（GPT-4、LLaMA）完全同構，但參數少到可以在筆記本上秒級復現、逐層打印中間狀態。把它當成管線的最小可運行示例：理解了 12 層，擴展到 32 層只是數字放大。 復現環境：MacBook M4 Max / Python 3.12 / PyTorch 2.5.1 / Transformers 4.48.3 / tiktoken 0.8.0。

Before the Trace

打開你寫過的一個程序。邏輯在if/else里，數據在變量里，兩者界限分明。判斷用戶是否登錄？一個布爾值加一個條件分支。查找首都？一個 HashMap，key 是國家，value 是城市。

在大語言模型里，兩者是同一個東西。

一切皆浮點

打開 GPT-2 Small 的權重文件：1.24 億個浮點數。沒有if/else，沒有switch，沒有一行代碼說"如果問法國首都就回答巴黎"。翻遍每一個字節，找不到任何顯式的條件判斷。

那么，當你輸入"The capital of France is"，它怎么"知道"下一個詞是" Paris"？

答案反直覺：它不"知道"。1.24 億個浮點數排成矩陣，輸入 token 變成向量，流過 12 層矩陣乘法和非線性變換。終點恰好落在詞表空間中" Paris"的方向上，概率 74.67%，斷崖式領先。

沒有任何一個參數單獨"負責"這個答案，答案是數值路徑的終點。

整條管線可以看作一個跑在 GPU 上的程序：權重加載后常駐顯存，只讀不改，類似進程里的 .rodata 段；每次推理就是一次函數調用，輸入是 token 序列，輸出是下一個 token 的概率分布。

它和你寫的程序有什么區別？

推理系統的其余部分：采樣、終止判斷、KV Cache 管理，仍然是傳統的控制流代碼。

管線概覽

深入每一步之前，先看一眼完整管線。關注點不只是模型有哪些組件，更是數據在每一步的變換。

24 字節進去，膨脹到 15 KB（FP32），穿過 12 層矩陣乘法，坍縮回 1 個整數。

下面是整條管線的偽代碼。不必現在逐行讀，它是全文的"可執行目錄"，每行注釋標注了對應章節。先掃一遍建立全局印象，后面每讀完一章回來看對應的幾行，會越來越清晰：

記號約定：后文中方括號 [...] 有兩種含義： 1. 值（元素內容）：[464, 3139, 286, 4881, 318] — 數組里裝的東西，這里是 5 個具體的 Token ID。特征：數字大、不規律。 2. 形狀（shape）：float[1, 5, 768] — 多維數組的各維大小。特征：數字小、有結構。三個維度含義：[batch_size, seq_len, hidden_dim]，即 batch_size=1（單條請求）、seq_len=5（5 個 token）、hidden_dim=768（每個 token 的向量維度）。 全文 batch_size 始終為 1。遇到歧義處會加標注。

管線就位，把"The capital of France is"喂進去，看看會發生什么。

Tokenization：從文本到 Token ID

代碼的第一行是tokenizer.encode(text)，管線從這里開始。

GPU 的計算單元只做一件事：數值運算。矩陣乘法、向量加法、激活函數，全是數字。UTF-8 字符串？它看不懂。

所以第一步是把字符串變成整數序列，即Tokenization（分詞）：把連續文本切分為模型詞表中的離散單元，就像編譯器的 lexer 把源代碼切成 token 流。

最樸素的做法是按字符編碼，每個字符一個 ID，但一個詞動輒拆成 5–10 個 token，序列太長。按單詞編碼呢？英文有幾十萬個詞，詞表太大。

GPT-2 用的是Byte Pair Encoding（BPE），一種子詞分詞算法，在字符級和單詞級之間取平衡。訓練時反復合并高頻字節對來構建詞表（原理類似 gzip）。訓練完成后詞表凍結，本質上就是一個靜態 HashMap：token_string → token_id，50257 條記錄，只讀不改。推理時純查表。

50257 這個數字從哪來？它是 GPT-2 BPE 詞表的大小，訓練時由合并輪數決定，之后固定不變。后文會反復遇到這個數字：Embedding 矩陣有 50257 行（每個 token 一行），LM Head 輸出 50257 個 logit（每個候選詞一個分數），一頭一尾，同一個數字。

用 OpenAI 的tiktoken跑一遍：

    print(f"{t:>6d}  ->  {repr(enc.decode([t]))}")

5 個 token，5 個整數。注意" capital"的前導空格：BPE 把空格編碼為 token 的一部分，讓模型能區分詞首與詞中。

Embedding：Token ID 膨脹為向量

France的 Token ID 是 4881，capital是 3139，差了 1742，這能告訴你任何語義關系嗎？

不能，這個差值是詞表構建的偶然產物，跟語義沒有任何關系。要做數值運算（矩陣乘法、點積、加法），每個 token 必須從標量編號變成高維向量。這就是Embedding（詞嵌入），把離散 Token ID 映射到連續向量空間中的一個點，類似于把數據庫主鍵展開成一行特征向量。

編號不可算，向量可以

用顏色打個比方，Pantone 色號186 C（紅）和293 C（藍）。186 - 293 = -107，這個數字能告訴你紅和藍有什么關系嗎？什么都說不了。色號只是查詢代號，差值沒有語義。Token ID 也一樣，4881 - 3139毫無意義。

但 RGB 不同：(255, 0, 0)是紅，(0, 0, 255)是藍。現在你可以算距離、做混色、判斷相似度，因為每個分量都有意義（紅綠藍三個通道的亮度），它們構成一個可計算的向量空間。

Token ID → Embedding 做的就是這件事：把編號變成向量。只不過不是 3 維 RGB，而是 768 維（RGB 各維度有明確含義，Embedding 的 768 維沒有人工賦予的含義，它們是訓練過程中自動涌現的）。

GPT-2 Small 有一個 Embedding 矩陣wte，shape 為[50257, 768]，詞表中每個 token 一行（50257 行，Ch2 的詞表大?。啃?768 個浮點數。

768 這個數字是什么？它是 GPT-2 Small 的"隱藏維度"（hidden_dim），模型配置里寫死的超參數，決定了每個 token 用多少維的向量來表示。768 是全文出現頻率最高的數字：從 Embedding 查表到最后 LM Head 投影，所有中間狀態的向量寬度都是 768。你可以把它理解為這條管線里的"總線寬度"，貫穿始終。

把 Token ID 4881 送進去，取出第 4881 行，得到一個 768 維向量。操作本身極其簡單：查表，沒有計算，沒有學習，就是用整數做索引取出一行。在 GPU 上，這是一次純內存操作，nn.Embedding在推理時等價于一次gather。

但這張矩陣不是隨機的，它是訓練過程收斂后的結果。第 4881 行（" France"）和第 6342 行（" Paris"）在 768 維空間中的幾何關系，恰好編碼了"法國 - 首都 - 巴黎"這一知識?；氐轿覀兊淖粉檶ο螅? 個 Token ID 變成 5 個 768 維向量后，" France"和" capital"不再是差了 1742 的兩個整數，它們之間的方向和距離攜帶著語義信息。

知識是向量空間中的方向

RGB 的三個維度有明確的物理含義。相比之下，Embedding 的 768 維沒有任何一維叫"國籍"或"詞性"，單個維度沒有人類可讀的含義，但方向有。

最經典的例子：

背后的規律：語義關系在向量空間中表現為方向。"男性→女性"是一個方向，"國家→首都"又是一個方向。訓練過程不會"告訴"模型"把性別編碼成某個方向"，但統計壓力迫使它這么做：當模型必須從上下文預測下一個詞時，把同類關系安排到平行的向量位移上是最高效的信息壓縮方式。

研究者稱之為線性表征假說：概念在向量空間中對應一個方向，不是一個"存儲位置"。存在一個"法國方向"、一個"首都方向"，它們之間有可計算的幾何關系。

768 維夠編碼成千上萬個概念嗎？夠的。高維空間中"幾乎正交"的方向遠超 768 個，多個概念通過稀疏疊加（Superposition）共享同一組維度，只要它們不經常同時激活。代價是單個維度不再對應單一含義，這正是 Embedding 不像 RGB 那樣"每維語義透明"的原因。

768 維空間里的加減法

聽起來很抽象，用 GPT-2 的真實權重驗證一下

實驗 1：減掉"男性方向"、加上"女性方向"，queen出現在前幾名。實驗 2：把"日本→東京"的位移方向加到"法國"上，Paris也在前幾名。這些不是 Embedding 層刻意設計的功能，而是訓練過程中自然涌現的幾何結構，768 個維度里，加減法就是語義運算。

位置編碼：給向量加上門牌號

還有一個問題沒解決：" capital of France"和" France of capital"用了完全相同的 token，查出完全相同的向量，但語義天差地別。Embedding 查表是逐 token 獨立的：" France"在位置 3 和位置 0 查出來的向量完全一樣。模型怎么知道誰在前誰在后？

GPT-2 的解決方案直截了當：再加一個矩陣——位置編碼（Positional Encoding）是向 token 向量注入序列位置信息的機制，就像給數組元素同時記住值和下標。

GPT-2 的位置編碼矩陣wpeshape 為[1024, 768]，1024 是 GPT-2 的最大上下文窗口（位置編碼表只有 1024 行，輸入超過 1024 個 token 就沒有對應的位置向量，相當于數組越界），每個位置一個 768 維向量。Token Embedding 和 Position Embedding 逐元素相加：最終向量 =token_embedding[token_id] + position_embedding[position]

位置 0 的" The"和位置 3 的" The"雖然 Token ID 相同，但加上不同的位置向量后，它們在 768 維空間中的坐標不同，后續所有計算都能區分它們。

GPT-2 用絕對位置編碼；現代模型用 RoPE（旋轉位置編碼），通過旋轉矩陣將位置信息編碼到 Attention 的點積中，天然支持長度外推。機制不同但目標一致：讓模型區分同一個 token 在不同位置的出現。

Self-Attention：讓向量互相看見

從這里開始，token 進入 Transformer 的核心結構：Transformer Block（通常簡稱"層"）。GPT-2 Small 有 12 個 Block，編號 Layer 0 到 Layer 11，依次串聯。每個 Block 內部分兩步：① Self-Attention（跨位置信息路由）→② FFN（單位置知識注入）。我們當前在 Layer 0，從步驟 ① 開始。

為什么"互相看見"很重要？" capital"的向量里同時擠著"首都 / 大寫字母 / 資本 / 極刑"四種含義，僅憑自身無法消歧，必須看到" France"才知道該取"首都"。" is"必須看到整句話才能預測下一個詞。

Self-Attention（自注意力）就是做這件事的機制：每個位置發出一個查詢，檢索所有前序位置的相關信息，按相關性加權匯總，一個可學習的內部搜索引擎。

Q / K / V：一個向量的三種身份

搜索引擎有三個要素：查詢詞、索引、文檔內容。Self-Attention 也一樣，但每個位置同時扮演搜索者和被搜索者，因此需要三套獨立的表征。以" is"（位置 4）為例，它收集信息的過程可以拆成三個問題：

1. 我需要什么信息？（Query）——" is"的需求：我在"The ___ of ___ is"句式中，需要找到"主語是什么"和"在問什么屬性"

2. 每個 token 能提供什么線索？（Key）——" France"作為被搜索者的身份標簽：我是一個國家名

3. 每個 token 的實際內容是什么？（Value）——" France"作為信息載體：法國這個概念的全部語義信息

注意：Key 和 Value 不是同一個東西。Key是搜索結果的標題摘要，標明"我能回答什么問題"；Value是點進去之后的完整頁面內容。搜索靠標題匹配，但你真正要的是頁面里的信息。

為什么需要三個獨立的投影矩陣？因為同一個向量要同時扮演三種角色。" France"也是查詢者，它同樣要從別的 token 收集信息；但它的 Query（"我需要什么"）和它的 Key（"我能提供什么"）完全是兩件事。共用同一組參數會讓三種信號互相干擾，所以 $W_Q$、$W_K$、$W_V$ 各自把輸入投影到不同的子空間。

投影到多少維？GPT-2 Small 有 12 個并行的 Attention Head（下一節展開），768 維被均分給 12 個 Head，每個 Head 分到 64 維（768 ÷ 12 = 64，不是獨立超參數，而是均分的結果）。每個 Head 的投影矩陣為[768, 64]，把 768 維輸入投影到該 Head 自己的 64 維工作空間：

V = x · W_V    # [768] → [64]  "我的實際信息"

12 個 Head 各自輸出 64 維結果，拼接后恰好回到 768 維（12 × 64 = 768），維度先拆后拼，總量守恒。

上面說 " is" 的"需求"是找主語、找屬性，那這個需求哪來的？不是人為規定的，" is" 的向量本身并不知道該去匹配什么；是 在訓練中被反復調整，學會了把 " is" 投影到 64 維空間里的某個方向，恰好讓它和攜帶主語 / 屬性信息的 Key 點積最大、loss 最低。"找主語" "找屬性"并不是模型里的顯式指令，而是我們對訓練后形成方向的一種事后語義解讀。

4.2 Attention Score：從點積到權重

Q、K、V 就緒，下一步是打分：" is"的 Query 要和每個前序 token 的 Key 做點積，算出"該從誰那里拿多少信息"。

整個過程：Q·K 點積打分 → Mask 遮掉未來 → softmax 歸一化 → 加權求和 V。逐步展開。

Ch3 說過語義關系是向量空間中的方向。點積（dot product）度量的就是兩個向量方向的一致程度，逐維相乘再求和。方向越一致，點積越大；正交則趨近零。Ch3 的king ? man + woman ≈ queen用的是向量加減法，這里 Q·K 打分用的是點積，同一個空間，不同的幾何運算。

1. 點積打分與縮放：每對位置 的相關性分數：

除以 （ ，即每個 Head 的維度）是為了防止點積過大導致 softmax 飽和，這就是"ScaledDot-Product Attention"名字的由來。

1. Causal Mask（因果遮罩）：自回歸生成中，后續 token 尚未產生，不能引用——位置 只能看到位置 的 token。實現方式：將上三角的分數設為 ，softmax 后自然變成 0：

" is"（位置 4）能看到全部 5 個 token，"The"（位置 0）只能看到自己。重要推論：只有最后一個位置看到了完整上下文，這就是為什么最終預測只取最后一個位置的輸出（Ch.7 會回到這一點）。

3. softmax → 加權求和： Mask 之后，softmax 將分數歸一化為概率分布——這就是 Attention 權重。權重越高，從該位置收集的信息越多。最終，按權重對所有位置的 Value 加權求和，得到這個位置的 Attention 輸出。

整個 Attention 可以理解為一個可學習的信息路由網絡：投影矩陣是路由表，點積算出匹配分數，softmax 歸一化為權重，Value 加權求和完成信息搬運。用 SQL 類比（僅直覺對比）：SELECT weighted_avg(V) FROM all_previous_tokens WHERE dot(my_Q, their_K) IS HIGH

為什么點積能度量"語義相關性"？ 它本身不能，兩個隨機向量的點積是噪聲。讓點積有意義的是 和 這兩個投影矩陣：訓練過程迫使它們學會把語義相關的 Q 和 K 投影到相似方向上，點積自然就高。這不是數學天然做到的，是訓練出來的能力。

跑一遍：" is"到底在看誰？

原理講完了，拿 GPT-2 的真實權重跑一遍。

我們取 GPT-2 Layer 0 的Head 6，計算" is"（位置 4）的 Query 與每個 token 的 Key 的點積，經縮放和 softmax，看權重落在誰身上。為什么選 Head 6？12 個 Head 中它的語義路由模式最鮮明，下一節打印全部 12 個 Head 就能看到對比。

預期結果：" France"和" capital"拿走約 70% 的 Attention 權重，功能詞" of"和" is"自身加起來約 8%。

運行輸出（GPT-2）：

全是負數，完全正常。softmax 只看相對差距，不在乎絕對值正負。" France"的 ?5.20 和" capital"的 ?5.34 最接近零，遠領先于" of"的 ?24.02?？s放后經 softmax 歸一化：" France"35%，" capital"35%，"The"22%，內容詞并列第一，功能詞加起來約 8%。

權重確定了每個位置的信息配比。Head 6 的最終輸出 = 各位置 Value 向量的加權混合：

Head 6 把權重集中在" France"和" capital"上，路由模式明顯偏語義。但這只是 12 個 Head 中的一個。

Multi-Head：12 雙眼睛同時看

12 層 vs 12 頭，別搞混。GPT-2 Small 有 12 層（Transformer Block 的堆疊次數，決定模型深度）和 12 頭（同一層內并行的注意力子空間數）。兩者恰好相等只是該模型的配置巧合，沒有必須相等的理論要求。

一個 Head 只能學一種路由模式。GPT-2 Small 用 12 個 Attention Head 并行運行，即Multi-Head Attention（多頭注意力），每個 Head 用獨立的 、 、 （均為[768, 64]）學習不同的模式。12 雙眼睛同時盯著同一句話，各自在自己的 64 維子空間中捕捉不同信號。

打印 Layer 0 全部 12 個 Head 中，" is"對各 token 的 Attention 權重：

運行輸出（GPT-2）：

掃一眼右側標注的模式類型，12 個 Head 清晰地分成幾種路由模式：

• 自注意力型（Head 1 / 3 / 5）：80–98% 權重給了" is"自身，保留本位置原始信號，不從別處搬運。

• 首 token 偏好型（Head 0 / 2 / 9 / 10 / 11）：40–61% 權重給了"The"，Layer 0 中首 token 常充當"默認錨點"（后續層可能改寫這一偏好）。

• 內容路由型（Head 6）：" France"35% +" capital"35%，上一節展開的那個 Head，唯一明顯按語義打分的。

• 分散型（Head 4 / 7）：權重在各 token 間相對均勻，沒有突出的贏家。

Layer 0 多數 Head 仍在做位置級粗調，看自己或看句首，只有少數開始做語義路由。也正常：輸入還是靜態 Embedding，沒有足夠上下文支撐精細的語義匹配。更深層的 Head 會在前序各層積累的上下文基礎上，做更精確的路由。

注意：不要過度解讀單個 Head 的模式。實際中 Head 的行為高度重疊且隨輸入變化，沒有固定的"職責名"。但 Multi-Head 比 Single-Head 學到更豐富的路由模式，這一結論經過消融實驗驗證。

12 個 Head 各自輸出 64 維結果，拼接回 768 維，再過輸出投影矩陣 （[768, 768]）混合 ，Multi-Head Attention 到此完成。

那這些權重到底改變了什么？

效果：" capital"不再歧義

回到 Ch3 的" capital"：不管上下文是"France"還是"venture"，Embedding 層取出的都是同一個 768 維向量，"首都""資本""大寫"這些含義都疊在同一組坐標里。Embedding 本身不感知上下文，因此無法消歧。Attention 的作用就在這里：把上下文加進來，讓"首都"這個含義被進一步強化。

上一節 Head 6 已經展示了過程：" is"把 35% 的注意力分給" France"、35% 分給" capital"，從這兩個關鍵詞收集信號。Attention 按權重對 Value 加權求和，產生一個增量向量，通過殘差連接（Ch6 詳解）疊加到" is"的原向量上。" capital"和" France"的語義在" is"處融合，"首都"方向被增強，"資本"、"大寫"方向被稀釋。

Embedding 表本身沒有變，" capital" 在詞表第 3139 行的 768 個浮點數原封不動，變的是各位置上的向量：Attention 給每個位置都疊加了來自上下文的增量。

多義消歧不靠規則，靠 Attention 把正確的上下文路由到正確的位置，通過向量加法改變坐標。這就是「讓向量互相看見」的實際效果。

FFN：用上下文檢索知識

還在 Layer 0，Attention 完成了第一步，" is"的向量已聚合了" France"和" capital"的信號，模型"知道"了在問法國的首都。但搬運不等于回答：Attention 在位置間路由已有信息，本身不產生新知識。

答案藏在同一層的第二步——Feed-Forward Network（FFN）。分工很簡單：Attention 決定“看誰”，FFN 決定“看完之后想起什么”。前者跨位置路由，后者逐位置獨立加工；進了 FFN，token 之間不再通信。

別被它樸素的結構騙了：GPT-2 每層中 FFN 的參數量是 Attention 的兩倍；12 層總計，FFN 占模型約 2/3 的參數。大部分參數不在路由，在記憶。

FFN = Key-Value Memory

先給結論：FFN 是一張寫死在權重里的 Key-Value 查找表（Geva et al., 2021），共 3072 行，每行存一個"模式"（Key）和一個對應的"知識片段"（Value）。輸入向量和 3072 個模式逐一比對，命中的就把對應知識注入輸出。

具體三步：

第一步：匹配—和 3072 個模式逐一比對。權重矩陣 $W_1$（shape[768, 3072]）存著 3072 個 768 維"模式向量"。輸入向量x和它們逐一做點積，點積越大表示越匹配，得到 3072 個匹配分數。

# x: [768]  →  W?: [768, 3072]  →  scores: [3072]

3072 從哪來？3072 = 768 × 4。4× 擴展是 Transformer 原論文的設計慣例：中間層越寬 → 模式檢測器越多 → 知識容量越大，但參數量線性增長。4× 是論文作者在能力和成本之間取的平衡點，它是可調的超參數。

第二步：過濾—GELU 只放行命中的模式。3072 個分數里大部分為負，表示"不匹配"。GELU 激活函數充當門控：正分數基本放行，負分數壓到接近零——類似WHERE score > 0。實際激活非常稀疏，多數模式被拒之門外。

第三步：注入—把命中的知識寫入輸出。另一個權重矩陣 （shape[3072, 768]）存著 3072 個 768 維的"知識向量"，和第一步的模式一一對應。第 個模式命中，對應的知識向量就按匹配分數加權注入輸出。

# filtered_scores: [3072]  →  W?: [3072, 768]  →  output: [768]

三步合成一個公式：

形狀變化768 → 3072 → 768：先升維做匹配和過濾，再降維寫回。3072 只存在于 FFN 內部的瞬態，進出都是 768，和 Attention 一樣不改變 shape。

回到例子。" is"經過 Attention 后攜帶了" capital"和" France"的信號，流入 FFN，和 的 3072 個模式逐一匹配，某些模式可能對應"X 的首都是___"這類句式。命中后， 中對應的知識向量被激活并注入，這就是"用上下文檢索知識"的物理過程。

回看三步：匹配、過濾、注入，這就像一次 Key-Value 查找：

每層 3072 個模式 - 知識對；GPT-2 Small 12 層共 36,864 個；LLaMA 3.1 8B 32 層、每層 14336 個，共 458752 個。模型越大，查找表行數越多，這就是"scaling"的物理含義之一。

Layer 0 完成：Attention + FFN

至此，Layer 0 的兩個步驟（Attention 和 FFN）全部完成。兩者分工互補：

Layer 0 的完整數據流：

形狀沒變，進去[1, 5, 768]，出來還是[1, 5, 768]。但每個向量的內容已經大不一樣：帶上了上下文（Attention 搬來的）和知識增量（FFN 注入的)。圖中兩處[+]是殘差連接，子層只產出增量，原始信息不丟。Ch6 展開。

Layers: 12 層到 " Paris"

Layer 0 走完了：Attention 搬運信息，FFN 檢索知識。但 12 層 Block 結構完全相同，shape 始終[1, 5, 768]，剩下 11 層在干什么？

答案在層與層之間的連接方式里。取" is"位置的向量，Layer 0 出來的和 Layer 11 出來的做余弦相似度極低，方向幾乎無關。同樣 768 維，每一個數字都被改寫了

殘差流：不過收費站，只進服務區

殘差連接解決兩個問題：防信息遺忘、防梯度消失。先看機制，再看為什么。

對"深度網絡"的常見直覺是數據必須串行穿過每一層：像過高速公路收費站，層層攔截、層層變換。殘差流不是這樣。

殘差流（Residual Stream）是一條從 Embedding 層直通輸出層的信息主干道。數據始終沿主干道流動。Attention 和 FFN 是旁邊的服務區：拐進去加工，產出增量（delta），合并回主干道繼續前進。每一層不"替換"數據，只往主干道上追加增量。

每個[+]是一次殘差加法：Attn 和 FFN 從殘差流讀取當前狀態，計算增量，再寫回。Layer 0 寫入的信息不會被 Layer 11 覆蓋，它始終留在主干道上，被后續增量持續疊加。

用公式把 12 層全部展開：

最終輸出 = 原始 Embedding +所有層所有子層的增量之和。 和 分別是第 層 Attention 和 FFN 寫入殘差流的增量。

為什么這樣設計？如果沒有殘差連接（即去掉[+]旁路，讓每層直接串聯），會有兩個致命問題：

1. 信息遺忘。沒有殘差連接時，每一層必須在輸出中同時保留舊信息和寫入新信息——如果 Layer 5 的變換恰好丟失了 Layer 0 寫入的句法信號，后續層就再也找不回來。殘差連接讓每一層只需要輸出增量，原始信息始終留在主干道上。Layer 11 可以直接讀到 Embedding 層寫入的信號，不依賴中間層的完美傳遞。

2. 梯度消失（訓練視角的補充，趕時間可跳過）。訓練時梯度從最后一層反向傳播回第一層，每穿過一層非線性變換就乘一次導數，12 層連乘，梯度指數級衰減，淺層參數學不到東西。殘差連接提供了一條梯度高速公路：加法的導數恒為 1，梯度沿殘差路徑直接回傳，無需穿過非線性：這是 Transformer 能堆到 96 層還能訓練的原因之一。

簡言之：殘差流讓加工和傳輸解耦：主干道負責無損傳輸，服務區只負責增量加工。

每層只追加增量，那 12 層追加的東西有什么不同？研究者通過 Probing（給每層的輸出接一個簡單分類器做"單元測試"）揭示了大致的分工梯度：

實際各層功能大量重疊，但"淺層偏句法、深層偏預測"的總趨勢成立。

Layer 11 結束時，" is"位置的 768 維向量同時攜帶了句法、語義、預測三類信號，多種概念共享 768 個維度，借助近似正交避免互相干擾。

原理講完了，跑一遍代碼看看" Paris"怎么一步步浮現。

跑一遍：" Paris"怎么出現的？

" Paris"到底怎么一步步浮現的？Logit Lens提供了一種直觀的探測手段：對每一層的隱藏狀態直接應用最終的 LN + LM Head，看"如果推理到此為止，模型會預測什么"。它不反映模型的真實決策路徑（中間層不是為直接解碼設計的），但像 X 光一樣透視了殘差流中信息的逐層積累。

關于 Prompt：GPT-2 Small 只有 124M 參數，裸句 "The capital of France is" 不足以形成高置信預測。從這里開始，在 prompt 前面補一條 few-shot 示例 "The capital of China is Beijing."——和我們日常給大模型加示例是同一個思路。換成更大模型，單句即可。后續 Ch7 的代碼使用同樣的 prompt。

運行輸出（GPT-2）：

" Paris"在 50257 個候選 token 中的排名變化：

三個觀察：

1. Layer 8 是關鍵拐點。Paris 從 直接跳到 ，概率從 0.55% 飆升至 88.35%?；叵?Ch5 的 FFN-as-Memory：Layer 8 激活的那幾個 FFN 神經元恰好編碼了"法國→巴黎"的關聯，正是 Key-Value Memory 的實際運作。每層只有少數神經元被激活，這一層命中的恰好是"X 的首都"類模式。

2. 多層接力，不是重復。每層只能做一步有限變換：一次 Attention 路由 + 一次 FFN 模式匹配。從"The capital of France is"到" Paris"登頂需要多步：句法綁定 → 實體關系識別 → 知識檢索 → 預測信號組合。Layer 0–7 完成前三步，Layer 8 完成關鍵注入，Layer 9–10 鞏固和校準。更多層 = 更多加工步驟 = 更復雜的推理鏈。

3. Logit Lens 是近似，不是精確。中間層的隱藏狀態不是為直接解碼設計的——Layer 8 的 88% 不代表模型在那一刻"決定了 Paris"，只說明殘差流在那個階段已積累了大量指向 Paris 的信號。

LM Head：從向量到概率

12 層 Transformer Block 走完，5 個位置各留下一個 768 維向量。最后一步：把向量映射回詞表中的 50257 個候選詞。

翻譯哪個位置？只取最后一個。回憶 Ch4 的 Causal Mask：每個位置只能看到自己及之前的 token。位置 0（"The"）只看到自己，位置 1（" capital"）只看過前兩個 token，而位置 4（" is"）是唯一看過完整上下文的位置，信息最完整的向量，才有資格做預測。

接下來，一次矩陣乘法完成翻譯。

Unembedding：從向量回到詞表

取最后一個位置的 768 維向量 ，乘以[768, 50257]的LM Head矩陣：

得到 50257 個標量，每個對應詞表中一個 token 的logit（未歸一化的對數分數）。幾何上看：每個 logit 就是 與第 個 token 向量的點積，點積越大，說明隱藏狀態越靠近該 token 的方向，對應概率越高。

這一步是 Ch3 Embedding 的鏡像。Embedding 把 Token ID 查表變成 768 維向量（整數 → 向量）；LM Head 把 768 維向量投影到 50257 個詞表方向上（向量 → 整數）。GPT-2 中兩者共享同一個矩陣： （weight tying），一張表，兩個方向。

跑一遍：Next-Token 概率分布

Ch6 的 Logit Lens 追蹤了" Paris"從第 28383 名逐層攀升至第 1 名的過程，但那只是盯著單個 token 的排名。50257 個候選 token 的完整概率分布長什么樣？

拿 GPT-2 的真實權重跑一遍。

    print(f"  {prob.item():>8.2%}  {repr(token)}")

輸出（GPT-2，prompt 與 Ch6 相同，含 few-shot 前綴）：

兩個特征：斷崖式長尾。" Paris"獨占 74.67%，第二名不到 4%。Top-10 合計約 87%：50257 個候選中，絕大多數 token 分到的概率幾乎為零。12 層變換把隱藏狀態雕刻得非常"尖銳"：768 維向量在詞表空間中幾乎只指向一個方向。語義聚類。排名 2–4 的" Marse"（馬賽）、" Lyon"（里昂）、" Nice"（尼斯）全是法國城市。高概率候選不是隨機散落，而是形成了語義鄰域：這印證了 Ch3 Embedding 空間的結構：含義相近的 token，向量方向也相近，投影得分自然接近。

50257 個概率擺在面前。這個例子里" Paris"74.67% 一騎絕塵，但不是所有分布都這么尖銳。開放式續寫時頭部可能有多個旗鼓相當的候選，采樣策略的選擇就變得重要了。

采樣：從概率到 Token

LM Head 輸出了 50257 個 logits。從這里開始不再是神經網絡，而是經典的概率采樣，從候選中選出 1 個 token。兩個旋鈕控制"怎么選"：

Temperature：在 softmax 之前，先把每個 logit 除以溫度系數 。借用熱力學的類比：溫度越低，粒子越安分、只待在能量最低點；溫度越高，粒子越躁動、去哪都可能。 就是 greedy decoding（直接取最高分）， 是原始分布， 讓低概率 token 也有機會。

Top-K / Top-P：softmax 之后裁剪候選集。Top-K 只保留概率最高的 K 個候選；Top-P（Nucleus Sampling）保留累積概率剛達到 P 的最小集合。兩者可以疊加使用。

在我們的例子里，無論 greedy 還是 Top-K=10，" Paris"都會被選中。選中后 Token ID = 6342，解碼回" Paris"，追加到輸入序列。

自回歸：LLM 的斐波那契

上一章跑完了一次前向推理：5 個 token 穿過整條管線，" Paris"以 74.67% 被選出，Token ID = 6342 追加到輸入——序列變為[464, 3139, 286, 4881, 318, 6342]（6 個 Token ID值）。句子還沒完，能不能一口氣把剩下的詞全部生成？

為什么不一次全生成？

非不為也，實不能也。原因是一條繞不過的因果鏈：第 N 個生成的 token 必須作為第 N+1 步的輸入。

模型剛輸出" Paris"，下一步要預測它之后是什么，但" Paris"本身會改變后續每個詞的概率分布，必須先把它送回輸入才能繼續。輸出反饋為輸入，這就是自回歸（Autoregressive）：

每個

依賴前面所有詞，包括模型自己剛生成的。這是經典的 loop-carried dependency（循環攜帶依賴）：第 次迭代的輸出是第 次的輸入，就像斐波那契數列： 依賴 ， 依賴 ，不能跳步，不能并行。

因此，生成 100 個 token 就要跑 100 次前向推理，每次只產出 1 個。這是語言生成的因果約束。

兩個階段：Prefill 與 Decode

生成必須逐個進行，但輸入可以一次性并行處理，這一區別把 LLM 推理劃分為兩個階段：

• Prefill（預填充）：把用戶輸入的所有 token一次性喂給模型，算出第一個生成詞，這一步是"讀題"。輸入 token 全部已知，沒有因果依賴，可以并行。

• Decode（解碼）：之后每步只處理上一步剛生成的1 個token，產出下一個詞，這一步是"逐字作答"。每個詞依賴前一個的輸出，只能串行。

兩個階段的硬件行為區別很大：

一個 compute-bound，一個 memory-bound；Decode 每步仍要從顯存搬運整個模型的權重，但計算量驟降為一行矩陣乘法，數千 CUDA 核心等著數據送過來（Ch9 分析這個比例)。這直接決定了成本結構：輸入 token 便宜，輸出 token 貴，各家 API 的輸出定價都顯著高于輸入。

但 Decode 還有一個性能問題：每步的 Attention 需要所有前序 token 的 Key 和 Value，而這些值上一步剛算過，能不能緩存復用？

KV Cache：空間換時間

生成第 7 個 token 時，需要對所有 7 個位置計算 Attention。但前 6 個 token 的 Key 和 Value上一步已經算過了，而且由于 Causal Mask，前面位置的 K/V 不受新 token 影響，值不會變。

KV Cache就是這層 memoization：把每一層、每個 Head 算過的 K 和 V 向量緩存起來，就像給純函數的返回值做備忘錄。每一步只需要：

1. 為新 token 計算 Q、K、V

2. 把新 K、V追加到緩存尾部

3. 用新 token 的 Q 和全部緩存的 K做 Attention，得到權重后和全部緩存的 V加權求和

類似動態規劃里的備忘錄：fib(99)算完先存起來，下一步算fib(100)直接復用，不用把 99 再算一遍。

這樣就避免了對前序 token 的重復計算。時間節省巨大，但空間代價也巨大：每生成一個 token，就往 KV Cache 追加一行。在請求存活期間只malloc不free，顯存單調遞增。

以下數字以 LLaMA 3.1 8B（FP16）為例：32 層，dim=4096，32 Query Head / 8 KV Head（GQA），總參數約 8B。GPT-2 Small 太小，不足以體現 KV Cache 的顯存壓力。

每 各 一 份 層 數 數 字 節

128K 上下文時一張 A100 只能并發約 4 個對話，容量規劃的瓶頸從 QPS 變成了"并發對話數 × 上下文長度"。由此催生 PagedAttention、KV Cache 量化、GQA/MQA 等優化。

KV Cache 還帶來一個副產品：Prompt Cache。如果多次請求的 prompt 前綴相同，Prefill 階段已緩存的 KV 可以跨請求復用，無需重新計算。實踐建議：system prompt 放最前面且保持穩定，可變部分（用戶輸入、few-shot 動態選擇）放后面：前綴命中時，輸入成本會顯著下降。

GPU 執行：算力都去哪了？

Ch8 留下一個懸念：Decode 階段 GPU 利用率只有個位數。本章從芯片層分析這個現象。GPU 標稱 312 TFLOPS（每秒可執行 312 萬億次乘加操作），逐 token 生成時實際用了不到 1%。瓶頸在哪？怎么緩解？

本章沿用 Ch8 引入的 LLaMA 3.1 8B（32 層，dim=4096，FP16 權重 ~16 GB）與 A100 80GB配置。新出現的硬件參數：A100 FP16 峰值算力 312 TFLOPS，HBM 帶寬 2 TB/s

一次矩陣乘法的旅程

一個關鍵直覺：GPU 不是"一塊很快的芯片"，而是存儲系統 + 計算系統。計算單元（Tensor Core）速度極快，但只能處理片上高速緩存（SRAM）里的數據；模型權重太大，只能常駐顯存（HBM）。每次計算前，數據必須從 HBM 搬到 SRAM，這趟搬運的速度，決定了一切。

以 Decode 階段的一次 FFN 上投影為例：[1, 4096] × [4096, 14336]，一個 token 的 4096 維隱藏向量乘以 FFN 的 權重矩陣，權重約 112 MB。這次乘法必須穿過以下存儲層次：

執行過程：

1. 搬運權重（HBM → SRAM）：112 MB 權重以 2 TB/s 帶寬分塊傳入 SRAM，耗時 ≈ 56 μs

2. 計算：Tensor Core 執行乘 - 加融合，總計算量 ≈ 117 MFLOPs，312 TFLOPS 算力下耗時 ≈ 0.4 μs

3. 輸入向量僅 8 KB、輸出僅 28 KB，傳輸成本可忽略

搬運 56 μs，計算 0.4 μs——比值約 140:1。Tensor Core 在 99.3% 的時間里等數據送過來。

這不是個例，而是 Decode 階段所有算子的通病。性能分析中有一個判斷指標叫算術強度（Arithmetic Intensity）：每搬運 1 字節數據能做多少次浮點運算。A100 的分界線是 312 TFLOPS ÷ 2 TB/s ≈156 FLOPs/Byte，低于此值，GPU 被帶寬而非算力卡住。Decode 一個 token 需搬運全部 ~16 GB 權重，計算量 ~16 GFLOPs，算術強度 ≈1 FLOPs/Byte，離分界線差兩個數量級。

Batching：請求拼一刀

算術強度 = FLOPs / Bytes。分母（權重搬運量）跟模型綁定，動不了；但分子可以。同時處理 32 個請求，矩陣乘法變成[32, 4096] × [4096, 14336]，同樣搬一次 112 MB 權重，32 個輸入共享復用，算術強度從 1 升到 32。Batching（批處理）的本質不是軟件優化，是讓搬來的權重被更多 token 復用。

但最樸素的 Static Batching（把一批請求湊齊再一起跑）有個問題：所有請求必須同時開始、同時結束，短請求得陪長請求空轉。

Continuous Batching解決了這個問題：請求跑完立即退出 batch，空位立即插入新請求。

吞吐量可提升 2–4×，是 vLLM、TGI、TensorRT-LLM 等推理框架的核心調度策略。

顯存里都住了誰？

Batch 越大利用率越高，但上限不是算力——是顯存。80 GB HBM 里住著三類"居民"：

• 權重：只讀，加載后常駐，所有請求共享，上文中等待搬運的就是這 16 GB

• KV Cache：每請求獨立分配，生命周期內單調增長。128K 上下文時單對話 KV 達 16 GB

• 激活值：層間臨時數據，前一層用完即釋放給下一層。占用小但峰值隨 batch 線性增長

Batch=64 時 KV Cache 膨脹到數十 GB，直接擠壓可服務的并發數。PagedAttention 用虛擬內存的思路按頁分配 KV Cache（按需分配、減少碎片），在同樣 80 GB 里塞進更多請求。

After the Trace

一個 token 從輸入到輸出走完了。工程師會問兩件事：能 debug 嗎？該怎么用它？

能 Debug 嗎？

每一層的中間狀態都可以截獲：隱藏狀態[1, 5, 768]、Attention 權重矩陣、最終概率分布，數值一個不少。

但數值不等于理解。你看不出某個 Head 為什么給了高權重，不知道 FFN 哪些神經元編碼了什么語義。768 維向量可以打印，卻不能直接讀出里面編碼了什么，就像拿到一個巨型操作系統的二進制文件，每條指令都在，但你幾乎不可能從機器碼還原出設計意圖。

研究者在嘗試間接手段：在隱藏狀態上訓練線性分類器（Probing），探測某個位置是否編碼了詞性；替換某一層的激活、觀察輸出變化（Activation Patching），定位關鍵層；用稀疏自編碼器（SAE）把激活分解為可解釋的特征方向。這些工具在進步，但老實說——我們離真正 debug 一個 LLM 還很遠。小模型上已有零星突破，但主流規模的模型內部機制仍是高維黑箱。

變量全能讀，但沒有符號表，怎么辦？

工程師的 Takeaway

一：測試靠行為，護欄放外面1.24 億個浮點數里沒有任何一條規則說"巴黎是法國首都"，只有數值路徑，路徑的終點就是答案。你無法通過檢查參數來預測邊緣場景的行為。唯一可靠的方法與測試沒有源碼的黑盒 API 無異：構造輸入，檢查輸出。

實操原則：安全過濾、格式驗證、事實核查，都應作為模型外部的 pipeline 組件實現。模型是協處理器：喂數據、收結果、你來兜底。

二：善用 CacheCh8 展開了兩層 cache：KV Cache 避免 Decode 逐步重算；Prompt Cache 在前綴相同時跨請求復用 Prefill。實操原則：system prompt 固定、放最前，最大化前綴命中率；用結構化輸出讓模型只返回需要的字段，每少一個輸出 token，就少一次串行 Decode、少搬運一次全部權重。輸出 token 是最貴的資源，各家 API 的輸出定價都顯著高于輸入。

三：語義是幾何：Prompt 調優是路徑工程king - man + woman ≈ queen不是巧合，訓練壓力把同類關系編碼為平行的向量位移。"巴黎是法國首都"不占某個參數的某一位，而是一個幾何性質：向量經過 12 層變換后，殘差流的疊加結果恰好落在" Paris"附近。這個結構不是設計出來的，是數十億句子的統計壓力壓出來的。

同一組權重，不同的輸入走出完全不同的數值路徑。Prompt Engineering 本質上是在操控路徑的起點：few-shot examples 示范路徑走向，system prompt 約束搜索空間。理解了這條管線，prompt 調優就不是玄學，而是路徑工程：你改變的不是模型，是矩陣乘法的輸入端。

Review

Ch1 的表格是宏觀對比，走完管線后可以做更細粒度的映射：函數簽名、rodata、stack、heap，每個概念在管線里都有對應物。

偽代碼已在 Ch1 給出，對照這張表重讀一遍，會覺得很親切。

從 Pixel 到 Token

開篇借了 Chrome 團隊的比喻：追蹤一個像素走完渲染管線的旅程。現在，這枚 token 也走完了它的一生：字符串 → 整數 → 向量 → 12 層變換 → 概率分布 → 采樣 →" Paris"。

Pixel 和 Token 最終都落在同一塊芯片上：GPU。渲染管線里它把頂點變成像素，LLM 管線里它把浮點變成下一個 token。同一塊硬件，同一種矩陣乘法，產出截然不同的東西：一個是你看見的畫面，一個是你讀到的文字。

單看一次矩陣乘法，什么也看不出來。但 1.24 億個參數做上億次乘加，知識就從數值中浮現了。

沒有哪一個參數獨自“記住”了巴黎是法國首都。1.24 億個浮點數歷經 12 層變換，把"France"與"capital"的向量一步步推向" Paris"所在的方向。知識不是被存儲的，是被矩陣乘法一層一層算出來的。

每一點都平凡，但走完整條管線再回望：恰是足夠多的平凡，堆成了非凡。

當前文章內容與結構經過調整，原文見：

Life of a Token: LLM's Next-Token Pipeline（https://kcnrpnk9jqxn.feishu.cn/wiki/LDSUwt1Gfi5uOmkhRXScfIExnBb）

會議推薦

QCon 全球軟件開發大會·2026 北京站將于 4 月 16 日 -18 日正式舉辦。本屆大會以“Agentic AI 時代的軟件工程重塑”為主題，聚焦 100+ 重磅議題，匯聚來自阿里、騰訊、字節跳動、小米、百度等一線科技企業與創新團隊的技術專家，圍繞 AI 工程化、系統架構與研發模式演進展開深入探討。更多詳情可掃碼或聯系票務經理 18514549229 進行咨詢。

今日薦文

你也「在看」嗎？