<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[100 days of python - Medium]]></title>
        <description><![CDATA[implementation of algorithm regularly, until the number reaches 100. - Medium]]></description>
        <link>https://medium.com/100-days-of-python?source=rss----4abb576258f6---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>100 days of python - Medium</title>
            <link>https://medium.com/100-days-of-python?source=rss----4abb576258f6---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 00:55:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/100-days-of-python" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Day 64 — Continuous batching：只改「請求什麼時候能加入批次」，吞吐就變 2.7 倍]]></title>
            <link>https://medium.com/100-days-of-python/day-64-continuous-batching-%E5%8F%AA%E6%94%B9-%E8%AB%8B%E6%B1%82%E4%BB%80%E9%BA%BC%E6%99%82%E5%80%99%E8%83%BD%E5%8A%A0%E5%85%A5%E6%89%B9%E6%AC%A1-%E5%90%9E%E5%90%90%E5%B0%B1%E8%AE%8A-2-7-%E5%80%8D-e1adfaaf23e7?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/e1adfaaf23e7</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[inference]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 04:31:43 GMT</pubDate>
            <atom:updated>2026-11-19T04:31:43.821Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2064%20-%20continuous%20batching%20and%20the%20scheduler">day 64 on GitHub</a></p><p><em>100 Days of Python — day 64</em></p><h3>Continuous batching 是怎麼推出來的：五個步驟</h3><p>在看底下那些數字之前，先講概念本身。Continuous batching 不是誰為了吞吐硬想出來的招，它是從 attention 的形狀一路推出來的，總共五步。</p><p><strong>1. attention 是 token 唯一互相影響的地方，而誰能影響誰由 mask 決定。</strong> transformer 裡其他運算都是 token-wise 的。所以「哪些請求被批在一起」根本不是 tensor 排列的性質，<strong>而是 attention mask 的性質</strong>。</p><p><strong>2. causal mask 代表舊 token 永遠不會變，所以把它們快取起來。</strong> 新的 token 不會改變它前面那些 token 的 key 與 value，於是那些可以存下來重用 — — 這就是 KV cache，它把「生成第 n+1 個 token」從 O(n²) 的工作量變成 O(n)。</p><p><strong>3. 有了 cache，prompt 就可以分段餵。</strong> 把第一段的 key/value 存起來、接在第二段前面、mask 跟著延伸，答案完全不變。這就是 chunked prefill，也是長 prompt 能塞進固定記憶體預算的原因。</p><p><strong>4. 逼出 padding 的其實是 batch 那個維度。</strong> 把多個 prompt 疊在新的軸上，tensor 就必須是矩形，所以每個 prompt 都要補到最長的那個。換請求時最慘：新來的要做完整 prefill，其他人卻只在 decode 一個 token，於是 B 個請求在飛、新 prompt 有 n 個 token，就要付 (n−1)(B−1) 個 padding token — — B=8、n=100 時是 693 個。而 CUDA graph 要求固定形狀，只會讓情況更糟。</p><p><strong>5. 那就把那個軸拿掉。</strong> 把多條序列<strong>接成一長排 token</strong>，再用 block-diagonal 的 attention mask 讓請求彼此看不到對方。沒有 padding，而且 prefill 的 chunk 與 decode 的單一 token 可以待在同一次 forward pass 裡。這叫 ragged batching；再加上「請求一做完就在那一步退場、讓排隊中的補進來」，就是 <strong>continuous batching</strong>。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RR0yXVEQ7QOuycvX" /></figure><p>這篇文章接下來講的是故事的後半段：既然一個 batch 就是「串接 ＋ 一張 mask」，那麼<strong>該讓誰進來</strong>，以及每個選擇各要付什麼代價。</p><p>同一個模型、同一批卡、同樣 300 個每秒 12 個到達的請求：</p><pre>排程方式                 TTFT p50  吞吐        全部跑完<br>-----------------------  --------  ----------  --------<br>static batching（B=8）   25.62 s   807 tok/s   81 s<br>static batching（B=32）  9.70 s    1368 tok/s  48 s<br>continuous batching      0.06 s    2140 tok/s  30 s</pre><p>吞吐 2.7 倍、首 token 中位數快四百倍，而且<strong>沒有任何一個 kernel 被改過</strong>。差別只有一條規則：請求可以在<strong>任何兩步之間</strong>加入或離開批次，而不是只能在批次的邊界。</p><p>一個 serving engine 說穿了就是一個迴圈，每秒做幾百次同一個決定：<strong>下一個 forward pass 要帶誰</strong>。系統層講的「推論優化」幾乎都是在改這個決定，所以今天我把這個迴圈模擬出來 — — 到達、等待佇列、KV pool、prefill 與 decode — — 然後量每一種改動的效果。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WCV0Y3254xye424F" /></figure><h3>一步要花多少</h3><p>機器是 70B 等級的模型、8 路 tensor parallel、bf16，每個常數都照 Day 62.5 的方式從公開規格推出來：每張卡 17.5 GB 的權重除以 5.3 TB/s ＝ <strong>讀一次全部權重 3.30 ms</strong>；KV cache 每個 token 40 KB ⇒ 讀一個 token <strong>0.008 µs</strong>；prefill 一個 prompt token 是 2·參數/8 的 FLOPs，以一半的峰值算 ⇒ <strong>0.027 ms</strong>。</p><pre>batch  一步     每秒輸出 token  每個 token<br>-----  -------  --------------  ----------<br>1      3.32 ms  301             3317 µs<br>16     3.54 ms  4515            222 µs<br>64     4.27 ms  14996           67 µs<br>128    5.23 ms  24456           41 µs</pre><p>權重是<strong>每一步</strong>讀一次，不是每個請求讀一次，所以在正在跑的批次裡多加一個人幾乎不用錢，直到 KV 的讀取量追上權重為止。這一行就是排程器存在的全部理由：<strong>在 KV pool 允許的範圍內，把那一步塞滿</strong>。</p><h3>static batching 浪費的不是算力，是 slot</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aZjBTZMu5fMmDSwZ" /></figure><p>一個 static batch 會跑到裡面<strong>最長</strong>的那個請求結束為止。B=32 時，<strong>所有 slot-step 裡有 72% 是在算已經吐完最後一個 token 的請求</strong> — — 批次是滿的，但滿的是空氣。而且在批次開始後一步才到的請求，要等整批排乾：那個 25.6 秒的首 token 中位數就是這樣來的。不是模型慢，是排隊。</p><p>continuous batching 只改一條規則：請求一結束就立刻離開、把 KV 還回 pool，排隊中的下一個<strong>在同一步</strong>補進來。padding 浪費歸零，首 token 時間也不再取決於你運氣好不好剛好卡在批次邊界。</p><h3>負載曲線與膝點</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*442bKcgxWx1rFqQr" /></figure><pre>每秒到達  吞吐  TTFT p50  TTFT p99  ITL p99   goodput<br>--------  ----  --------  --------  --------  -------<br>4         743   0.03 s    0.66 s    20.3 ms   91%<br>8         1463  0.04 s    0.79 s    43.8 ms   82%<br>12        2140  0.06 s    1.04 s    61.2 ms   40%<br>16        2191  2.43 s    6.63 s    431.2 ms  1%<br>20        2384  2.96 s    7.88 s    431.1 ms  1%<br>24        2258  4.82 s    11.89 s   431.2 ms  1%</pre><p>膝點以下，引擎是被「請求來得不夠快」限制住的：吞吐跟著到達率走、延遲幾乎不動。膝點以上，佇列無上限地長，而<strong>唯一還好看的欄位就是吞吐</strong>。這裡的容量是被 prefill 的算力決定的，不是 batch 大小：平均一個 prompt 要 48 ms 的純算術，所以大約每秒 20 個請求就是上限，batch 開多大都一樣。</p><h3>一個長 prompt 會卡住所有人</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jvqiQPciMyQCvqbK" /></figure><p>16,000 個 token 的 prompt 是 428 ms 的算術。如果它整段當成一步跑，<strong>每一個正在 decode 的請求都會在兩個 token 之間卡 428 ms</strong> — — 使用者原本每 3.6 ms 看到一個字，突然要等將近半秒。</p><pre>chunk 預算           TTFT p50  ITL p50  ITL p99  吞吐<br>-------------------  --------  -------  -------  ----<br>不切（整段 prompt）  0.06 s    3.6 ms   61.2 ms  2140<br>1024 token           0.11 s    3.7 ms   31.7 ms  2140<br>512 token            0.24 s    3.7 ms   17.9 ms  2140<br>256 token            0.43 s    10.4 ms  10.8 ms  2139</pre><p>chunked prefill 把 prompt 切成好幾塊、混進 decode 的步驟裡，於是<strong>尾巴的大小從「prompt 多長」變成「chunk 多大」</strong>。但它不是免費的：每一塊都要再讀一次權重（所以切到 256 時 ITL 的<strong>中位數</strong>反而變差），而且一個要跑好幾步才做完的 prompt，首 token 自然更晚。這個旋鈕是拿 TTFT 換 ITL，不會生出時間。</p><h3>KV pool 滿掉的時候</h3><p>admit 一個請求，等於承諾「它每生一個 token 我都還有 KV 給它」，而沒有人知道它會生幾個。pool 一滿，就得挑一個踢掉。</p><pre>pool token  admission 上限     搶占次數  吞吐  ITL p99   goodput<br>----------  -----------------  --------  ----  --------  -------<br>150,000     無                 0         2140  61.2 ms   40%<br>150,000     16                 0         1985  62.0 ms   25%<br>60,000      無                 59        1238  428.4 ms  4%<br>60,000      16                 0         1985  59.5 ms   26%<br>60,000      無（改成換出 KV）  16        2140  75.9 ms   29%</pre><p><strong>重算（recompute）</strong> 是把受害者的 KV 整個丟掉，之後 prompt 再 prefill 一次 — — 它已經生出來的 token 也等於白生。59 次搶占讓吞吐掉了 42%、ITL 尾巴 428 ms。<strong>換出（swap）</strong> 則是把 KV 搬去主記憶體再搬回來（4,000 token 的 context 走 PCIe 來回大約 5 ms），進度全部保留，兩個數字就都回來了。</p><p>這張表裡沒有任何一列會噴錯。pool 不夠大，看起來就只是「伺服器有點慢」。</p><h3>admission control 是一個主張，不是一個旋鈕</h3><p>在小 pool 上，把同時跑的請求上限設成 16 是<strong>兩邊都賺</strong>：吞吐往<strong>上</strong> 60%（1238 → 1985）、goodput 7 倍（4% → 26%）。因為被搶占丟掉的工作本來就是純浪費 — — prompt 被 prefill 兩次、KV 寫了又丟。<strong>排隊比做到一半被丟掉便宜</strong>，這就是 admission control 的全部理由。</p><p>但在大 pool 上，同一個上限是個錯誤：本來就沒有人被搶占，設上限只是多排隊 — — 吞吐少 7%、goodput 從 40% 掉到 25%。所以上限不是「不舒服就往上調」的旋鈕，<strong>它是一個主張：KV pool 是這裡的瓶頸</strong>；如果不是，這個主張就直接讓你損失餘裕。</p><h3>誰先跑</h3><pre>策略             平均   p50  p99   最大  長 prompt（n=27）<br>---------------  -----  ---  ----  ----  -----------------<br>FCFS             5.8 s  5.5  12.5  15.7  5.6 s<br>短的先跑（SJF）  3.1 s  2.0  19.9  21.7  10.0 s</pre><p>SJF 是教科書答案，而且它真的有效：平均延遲砍半。但它同時把<strong>本來就最慢的那群</strong>的延遲變成兩倍 — — 長 prompt 在排隊時會被每一個新到的短請求超車，持續過載時甚至永遠排不到。所以實務上的排程器會做 aging：優先權隨等待時間上升，也就是「短的先跑，但有保證」。</p><h3>要看的是 goodput，不是 throughput</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5BFYcz7HBblZsAeb" /></figure><pre>設定                       吞吐  TTFT p99  ITL p99   goodput<br>-------------------------  ----  --------  --------  -------<br>continuous，不設任何限制   2140  1.04 s    61.2 ms   40%<br>＋ chunked prefill（512）  2140  1.60 s    17.9 ms   100%<br>＋ admission 上限（32）    2140  1.60 s    17.8 ms   100%<br>小 KV pool、不設上限       1238  22.65 s   428.4 ms  4%</pre><p>前三個每秒搬的 token 數<strong>完全一樣</strong>。真正把它們分開的是「有多少請求達到了服務目標」 — — 這裡定成首 token 在 2 秒內、而且 ITL 的 p99 在 50 ms 以內。<strong>調一個 serving stack 就是在移動最後那一欄</strong>，而最後那一欄在你只量第一欄的時候完全看不見。這也是為什麼一份 serving 報告要同時給 input 長度、output 長度、併發數、TTFT、TPOT 與 ITL：少掉任何一個，其他的都可以被調得很好看。</p><h3>四個看起來是贏、其實不是的結論</h3><p><strong>「batch 開大一定比較好。」</strong> 在裝不下的 pool 上把同時跑的數量拉高，結果是 59 次搶占、吞吐少 42%、ITL 尾巴 428 ms。限制你的是 KV pool，不是 kernel 的 batch 維度。</p><p><strong>「吞吐變高了，所以比較好。」</strong> 上面那張表：三個設定吞吐一模一樣，goodput 從 40% 到 100%。</p><p><strong>「短的先跑可以最小化延遲。」</strong> 它最小化的是<strong>平均</strong>，代價是長 prompt 的延遲變兩倍。</p><p><strong>「batch 是滿的，所以 GPU 很忙。」</strong> B=32 的 static batching 裡，72% 的 slot-step 是已經結束的請求。</p><h3>vLLM 怎麼開</h3><pre>--max-num-seqs 256              # 同時跑的上限（admission cap）<br>--max-num-batched-tokens 8192   # chunked prefill 的預算<br>--enable-chunked-prefill<br>--gpu-memory-utilization 0.9    # 有多少 HBM 變成 KV pool<br>--preemption-mode recompute     # 或 swap</pre><p>vLLM 把被 admit 的那一組叫 running queue，後面還有一條 waiting queue；block manager 以 page 為單位發 KV，這讓 admission 變成一個<strong>數得出來</strong>的問題而不是用猜的。最值得盯的那一行 log 是 preemption 警告 — — 那是引擎在告訴你「KV pool 那一節正在你身上發生」。</p><h3>SGLang 怎麼開</h3><pre>--max-running-requests 256      # 一樣的上限<br>--chunked-prefill-size 8192<br>--schedule-policy lpm           # 最長前綴匹配，不是 FCFS<br>--schedule-conservativeness 1.0 # 多積極 admit</pre><p>有趣的差別在預設策略：SGLang 把等待佇列照<strong>最長共同前綴</strong>排序，讓共用前綴的請求排在一起跑、直接命中 radix cache，而不是把同樣的 token 再 prefill 一次。<strong>一個為了記憶體而做的排程決定</strong> — — 跟這個系列裡其他東西是同一招。</p><h3>我自己的收穫</h3><p>五個決定，而且全部都是記憶體的問題不是算力的問題：誰可以加入批次、一步放多少 prompt、同時跑幾個、cache 滿了要怎麼辦、誰先跑。其中四個都是拿一種延遲換另一種延遲；唯一免費的那個（continuous batching 本身）之所以免費，是因為它停止浪費 slot，而不是因為它算得比較快。</p><p>而要寫進報告的數字是 goodput。只看吞吐，分不出「兩秒內回覆每一個人」和「只回覆三分之一的人、其他人等二十秒」這兩種伺服器。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1adfaaf23e7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-64-continuous-batching-%E5%8F%AA%E6%94%B9-%E8%AB%8B%E6%B1%82%E4%BB%80%E9%BA%BC%E6%99%82%E5%80%99%E8%83%BD%E5%8A%A0%E5%85%A5%E6%89%B9%E6%AC%A1-%E5%90%9E%E5%90%90%E5%B0%B1%E8%AE%8A-2-7-%E5%80%8D-e1adfaaf23e7">Day 64 — Continuous batching：只改「請求什麼時候能加入批次」，吞吐就變 2.7 倍</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 63 — 集合通訊：把模型切到很多張 GPU 上，而答案不變]]></title>
            <link>https://medium.com/100-days-of-python/day-63-%E9%9B%86%E5%90%88%E9%80%9A%E8%A8%8A-%E6%8A%8A%E6%A8%A1%E5%9E%8B%E5%88%87%E5%88%B0%E5%BE%88%E5%A4%9A%E5%BC%B5-gpu-%E4%B8%8A-%E8%80%8C%E7%AD%94%E6%A1%88%E4%B8%8D%E8%AE%8A-c0df450b9214?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/c0df450b9214</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[python-programming]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 01:46:58 GMT</pubDate>
            <atom:updated>2026-11-19T01:46:58.024Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2063%20-%20parallelism%20and%20collectives">day 63 on GitHub</a></p><p><em>100 Days of Python — day 63</em></p><p>一個 70B 模型用 Adam 訓練，每張卡放一份完整副本的話<strong>每張卡要 1,043 GB</strong> — — 比任何一張卡實際有的記憶體多一個數量級。同一個模型拿去服務，64 個請求 x 128K token 的 <strong>KV cache 是 2,560 GB</strong>。兩個都放不下，所以兩個都得切；而每一種切法，都是同一個決定在不同地方被做：<strong>哪一個集合通訊會跑、跑幾次、每次多少位元組</strong>。</p><p>TP、EP、DP、DCP、DDP、FSDP、PP — — 七個縮寫，底下只有五個原語。今天先把原語做出來，然後<strong>訓練那一組、推論那一組分開講</strong>，每一種都跟單卡對照驗證。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Xz3kAs6mYFl79kM0" /></figure><h3>五個原語</h3><pre>集合通訊        用來做什麼                         每個 rank 送出的位元組  步數<br>--------------  ---------------------------------  ----------------------  -------<br>broadcast       一個 rank 有，所有人都要           N                       log2(p)<br>all-reduce      大家各有部分和，所有人都要總和     2(p-1)/p · N            2(p-1)<br>reduce-scatter  大家各有部分和，每個人只留 1/p     (p-1)/p · N             p-1<br>all-gather      每個人有 1/p，所有人都要完整的     (p-1)/p · N             p-1<br>all-to-all      rank r 手上有要給每個 rank 的一份  (p-1)/p · N             p-1<br>point-to-point  把一個 tensor 交給下一個 rank      N                       1</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*w4O8r1HTvIi-VJQ8" /></figure><p>這張表最重要的一列是：<strong>all-reduce 根本不是原語</strong>，它是 reduce-scatter 接 all-gather。這既解釋了它為什麼要付兩倍，也是今天很多段落的全部內容 — — 同一句話套用兩次。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HkQXlYcVJl6G9bPo" /></figure><p>我在模擬的 8 個 rank 上跑了 ring 版本，向量 64 KB：14 步、每個 rank 送出 114,688 個位元組，最後每個 rank 都拿到同一個總和。天真的做法 — — 大家把整份送給 rank 0、rank 0 加完再送回去 — — 會有 917,504 個位元組全部擠在同一條線上。ring 的關鍵是<strong>任何時刻沒有任何 rank 握著超過一塊的總和</strong>，所以每個 rank 的量不會隨卡數長大，長大的只有步數。</p><p>這也就寫出了實作規則。訊息小的時候看跳數，tree 只要 2log2(p) 跳、ring 要 2(p-1) 步；訊息大的時候看位元組，ring 贏。在這個模組用的鏈路模型上交叉點大約在 <strong>2 MB</strong>。這就是 NCCL／RCCL 會依訊息大小換演算法的原因，也是為什麼 decode 裡那個很小的 all-reduce 一點都不免費 — — <strong>它付的是跳數，不是位元組</strong>。</p><h3>第一部分：訓練 — — 放不下的是權重</h3><h3>DDP 的正確性只有一行數學</h3><p>DDP（torch.nn.parallel.DistributedDataParallel）是最簡單而且真的會動的做法：<strong>每張卡都放一份完整的模型</strong>，只是各自讀 batch 的不同一段。一張卡一個 process、一步一次梯度 all-reduce，其他什麼都不共享。</p><p>四個 rank、各吃四分之一的 batch、訓練 60 步。一台機器吃完整 batch 的 loss 是 0.014105，四個 rank 的也是 0.014105，權重最大差 1.19e-07。會相等是因為 <strong>loss 是平均</strong>：各 rank 梯度的平均剛好等於全 batch 的梯度，而 all-reduce 就是在強制這個平均。DDP 的全部內容就這樣。</p><p>但要注意它<strong>沒有</strong>做什麼：模型本身一點都沒被切開，所以每張卡的記憶體完全沒變。這一句話就是下一節存在的理由。</p><p>有兩個細節讓那次 all-reduce 不會被看見。第一是 <strong>bucket</strong>：梯度是從最後一層往前算出來的，所以切成好幾塊之後可以一邊飛、backward 一邊還在跑。</p><pre>bucket 數  每個大小  每次 all-reduce  總通訊   最後曝露<br>---------  --------  ---------------  -------  --------<br>1          1024 MB   4.73 ms          4.73 ms  4.73 ms<br>4          256 MB    1.20 ms          4.81 ms  1.20 ms<br>25         41 MB     0.22 ms          5.40 ms  0.22 ms</pre><p>bucket 愈多總量稍微變大（每個都要再付一次延遲），但真正曝露在 step 時間上的少很多。第二是<strong>梯度累積</strong>：在 with model.no_sync(): 裡 DDP 會完全跳過 all-reduce、讓梯度在本地堆積，所以 N 個 micro-step 只付一次 all-reduce。這也是全文唯一一個「跳過集合通訊是安全的」場合——因為<strong>每個 rank 都跳</strong>，而那正是底下第二個無聲 bug 破壞掉的條件。</p><h3>ZeRO 與 FSDP：能切的就不要複製</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VwHL4-QA9k4qJmjE" /></figure><p>Adam 在混合精度下每個參數要 16 個位元組：bf16 權重 2、bf16 梯度 2、fp32 master 4、兩個動量各 4。<strong>是權重本身的 8 倍</strong> — — 所以讓訓練塞不下的不是模型，是 optimizer。</p><pre>階段                       每個 rank GB  線上 GB  相對 DDP  用到的集合通訊<br>-------------------------  ------------  -------  --------  -------------------------------------------<br>DDP（完全不切）            1043          228.2    1.00x     all-reduce(grad)<br>ZeRO-1（切 optimizer）     359           228.2    1.00x     reduce-scatter(grad) + all-gather(param)<br>ZeRO-2（再切梯度）         244           228.2    1.00x     reduce-scatter(grad) + all-gather(param)<br>ZeRO-3 / FSDP（再切參數）  130           342.3    1.50x     all-gather(param) x2 + reduce-scatter(grad)</pre><p>前兩階是<strong>免費的</strong>，理由就在原語那張表：all-reduce 本來就是 reduce-scatter 加 all-gather。把它拆成兩半、中間只留自己負責的那一段梯度，記憶體省掉一大半而一個位元組都沒多送。要付錢的是第三階：參數本身被切開，所以每一層都要在開跑前 all-gather 回來、算完立刻丟掉，位元組 1.5 倍換記憶體 1/8。Day 62.5 把這個取捨叫「重算 vs 存起來」，這裡是「重抓 vs 存起來」，同一條曲線。</p><h3>tensor parallel：帳單跟著 token 長</h3><p>第一個矩陣照 column 切、第二個照 row 切。column 這個方向是挑過的：<strong>它讓每個 rank 拿到完整的幾個隱藏單元</strong>，所以兩個矩陣之間那個逐元素的非線性完全不用通訊。到第二個矩陣之後，每個 rank 手上是「整個寬度、但只加了自己那一份」的<strong>部分和</strong>，一次 all-reduce 收尾。跟單卡比：4.77e-07。</p><p>8,192 個 token、8-way 時：activation 是 128 MB，每次 all-reduce 每個 rank 搬 224 MB，一次 forward 有 160 次（80 層，attention 之後一次、MLP 之後一次），合計 35 GB。<strong>它跟著 token 數長、不是跟著參數長</strong>，跟 DDP 剛好相反 — — 所以它是讓長序列訓練得起來的那條軸，也因此必須待在節點內。</p><p>sequence parallel 是把原語表再套一次：all-reduce 本來就是 reduce-scatter 加 all-gather，中間那段保持切開的狀態，於是中間的 norm 與 residual 只在 1/p 的序列上跑。位元組一模一樣（兩邊都是 224 MB），而每個 rank 的 activation 從 128 MB 降到 16 MB。</p><h3>pipeline parallel：線上最便宜，代價付在閒置</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*F-LzaOVbnelQ3VGy" /></figure><p>只有 stage 邊界的 activation 要過去，而且是點對點、根本不是集合通訊：每個邊界 128 MB、7 個邊界，整趟 forward 896 MB。比 tensor parallel 少三個數量級，所以 stage 可以放在不同節點上。</p><p>代價是 bubble — — 最後一個 stage 要等第一個 micro-batch 走完前面所有站才有事做：</p><pre>micro-batch 數  bubble  使用率<br>--------------  ------  ------<br>1               87.5%   12.5%<br>4               63.6%   36.4%<br>16              30.4%   69.6%<br>64              9.9%    90.1%</pre><p>bubble =(stages — 1) / (micro-batch 數 + stages — 1)。解法永遠是切更多 micro-batch，直到它們小到每個 matmul 填不滿 GPU 為止 — — <strong>Day 62.5 的 roofline 在底下擋著</strong>。</p><h3>真正的訓練是四條軸同時疊</h3><p>64 張卡排成 tensor 8 x pipeline 4 x data 2 的 mesh，於是每張卡只拿 80 層裡的 20 層、70 B 參數裡的 2.19 B：</p><pre>-------------------------------------  ---------------------------<br>每張卡的 optimizer state（不切）       32.6 GB<br>同樣的東西加上 ZeRO-3（切在 data 軸）  16.3 GB<br>TP 每步流量                            8.75 GB（節點內）<br>PP 每步交接                            0.12 GB（點對點）<br>梯度 all-reduce                        4.07 GB（一步一次、可重疊）</pre><p>順序本身就是重點：<strong>TP 與 PP 已經先把參數切掉了</strong>，所以 ZeRO 表裡那個 1,043 GB 在 ZeRO 還沒出手之前就剩 32.6 GB；ZeRO 只負責切「data 軸還在重複的那一份」。</p><h3>第二部分：推論 — — 放不下的是 KV cache</h3><h3>少了什麼，又換成什麼卡住</h3><p>推論沒有梯度，所以訓練那半最大的一列（228 GB 的梯度 all-reduce）<strong>根本不會被呼叫</strong>。服務端的 data parallel 就是「各自獨立、各有排程器的副本」，成本只有記憶體。而記憶體的大頭是 KV cache：</p><pre>放法                              每個 rank 的 KV GB  為什麼<br>--------------------------------  ------------------  ---------------------------<br>整份快取（64 請求 x 128K token）  2,560               —<br>TP，MHA/GQA（照 head 切）         320                 head 剛好被 p 整除<br>TP，MLA（每 token 一個 latent）   2,560               head 這個維度已經不存在<br>DP attention（照請求切）          320                 每個 rank 擁有 8 個完整請求<br>context parallel（照位置切）      320                 每個 rank 擁有一段 key</pre><p>另一半是：decode 一個請求只生一個 token，所以 TP 要搬的 activation 直接塌掉，<strong>但跳數一步都沒少</strong>：</p><pre>階段                         真正搬的量  跳數時間  位元組時間  合計      延遲佔比<br>---------------------------  ----------  --------  ----------  --------  --------<br>decode（1 token x 64 請求）  1.75 MB     28.0 us   4.6 us      32.6 us   86%<br>prefill（8,192 token）       224.00 MB   28.0 us   587.2 us    615.2 us  5%</pre><p>同一個 collective、同樣 2(p-1) 跳、資料少 128 倍。160 次加起來仍然是每個 decode step 5.21 ms，所以服務端會把 all-reduce 跟下一個 norm 融在一起、寧可少而肥不要多而瘦；也因此 <strong>tensor parallel 對 decode 的幫助會在頻寬用完之前就先停住</strong>。Day 62.5 說 decode 是被記憶體卡住，這裡是同一句話，只是把 HBM 換成了互連。</p><h3>expert parallel：權重不動，動的是 token</h3><p>Day 62 的 router 決定每個 token 要去哪幾個 expert；expert parallel 把 expert 分給各個 rank，於是 token 必須飛到擁有那個 expert 的卡上。一層兩次 all-to-all（dispatch 與 combine），跟單卡 MoE 逐位元相同。</p><p>8,192 個 token、top-8、8-way 時：每層送出 896 MB、收回 896 MB，<strong>整趟 forward 是 140 GB，是同樣 token 數下 tensor parallel 的四倍</strong>，因為每個 token 被送去 k 個 expert 而不是一個。把 dispatch 量化成 fp8 直接砍到 70 GB — — 這正是 DeepEP 會有一條量化 dispatch 路徑的原因，也是為什麼 MoE 的服務效能最後是被網路決定的。訓練 MoE 用的是同樣兩次 all-to-all，再加上 backward 的兩次。</p><h3>context parallel（DCP）：切 KV，用 log-sum-exp 合併</h3><p>每個 rank 只擁有一段 key 與 value，算出自己那段的部分輸出與 log-sum-exp，合併時用共同的最大值重新縮放再相加。跟完整 attention 比，2／4／8 個 rank 分別是 1.0e-16、8.0e-17、1.7e-16。</p><p>這就是 Day 52 為 FlashAttention 證過的那個恆等式 — — 兩個部分 softmax 只要帶著各自的最大值與總和就能合併 — — 只是當時兩半在不同的暫存器裡，現在在不同的 GPU 上。</p><p><strong>誰需要它、誰不需要</strong>，這是縮寫沒講出來的部分。切 key 這個技巧對任何 attention 都成立（那叫 Ring Attention），但它只有在「沒有別的東西好切」的時候才是最便宜的選擇。<strong>MHA 或 GQA 的 KV cache 本來就能照 head 整除</strong>，tensor parallel 早就免費幫你切好了，沒有人會想用 context parallel。<strong>MLA 把 KV 壓成每個 token 一個 latent、head 這個維度整個消失</strong>，於是每個 TP rank 都得存一整份 — — 而這正是服務端那個叫 DCP 的功能存在的原因。所以 <strong>DCP 要讀成「給 MLA 模型用的」，不是一條通用的軸</strong>；在那個情境下能選的只有照請求切（DP attention）或照位置切（這一條）。</p><h3>兩半合起來看</h3><h3>哪一軸該放在哪裡</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7jE1sJiQAJ7dmujl" /></figure><p>一個 rank、一步、8,192 個 token、每軸 8-way：</p><pre>軸                     每步 GB  節點內    跨節點     倍率<br>---------------------  -------  --------  ---------  ----<br>tensor parallel        35.00    98.4 ms   774.0 ms   7.9x<br>expert parallel        140.00   378.1 ms  3017.7 ms  8.0x<br>context parallel       17.64    48.5 ms   384.3 ms   7.9x<br>pipeline parallel      0.12     0.3 ms    2.7 ms     8.0x<br>data parallel（梯度）  228.17   612.5 ms  4900.1 ms  8.0x</pre><p>看第一欄，部署方式就自己寫好了。tensor 與 expert <strong>每一層</strong>都要付幾十 GB，只能待在節點內的短連線上；pipeline 幾乎不送東西，跨網路完全無所謂；data parallel 量最大，但<strong>一步只付一次而不是每層一次</strong>、藏得進 backward，而且在推論時它根本不存在。</p><h3>五種不會報錯的壞法</h3><p><strong>梯度用加的、忘了除以 world size。</strong> 學習率被無聲地乘上卡數。第 1／3／5 步，對的那條是 0.6129、0.3251、0.2362，加總的那條是 6.82、70,331、1.76e+10。這個 bug 在單卡上永遠測不出來 — — world size 是 1 的時候，加跟平均是同一個數。</p><p><strong>不同 rank 走到不同分支。</strong> 集合通訊是用<strong>呼叫順序</strong>配對的，不是用名字。「這個 rank 這一步沒有 token 要給任何 expert，那就跳過 all-reduce」會讓 rank 0 停在一個 collective、rank 1 停在另一個，互等到天荒地老。NCCL 不會報錯，它就是停住。所以 MoE 的實作寧可送空 buffer 也不敢跳過 — — 也所以 no_sync() 是安全的，因為<strong>每個 rank 都進去</strong>。</p><p><strong>相加的順序也是答案的一部分。</strong> 同一批資料，ring 與 tree 的 all-reduce 結果在 65,536 個值裡有 32,459 個位元不同，最大差 9.77e-04（相對 1.2e-04）。重跑同一種實作是逐位元一樣的，所以這不是亂數：<strong>浮點加法不符合結合律</strong>，兩種排程只是加的順序不同。同一個 seed、不同的 world size，就是不同的 loss 曲線。</p><p><strong>一個慢的 rank 就是整步的時間</strong>，因為集合通訊就是 barrier。假設每個 rank 每步有 1% 的機率卡一下：8 張卡時 7.7% 的步會中、整體慢 5.2%；512 張卡時 99.4% 的步都中、整體慢 49.3%。<strong>規模放大的是「出事的機會數」，不是每次出事的大小。</strong></p><p><strong>少做一次 all-reduce。</strong> 把 row-parallel 那層的 all-reduce 拿掉：形狀全對、沒有 NaN，輸出誤差 2.30，大約是輸出尺度的 77%。模型照樣生成文字，只是生得比較爛。所以任何平行化改動的第一個測試永遠是：<strong>把 world size 設成 1，答案有沒有變。</strong></p><h3>PyTorch 怎麼寫</h3><pre>mesh = init_device_mesh(&quot;cuda&quot;, (2, 4), mesh_dim_names=(&quot;dp&quot;, &quot;tp&quot;))<br><br>DistributedDataParallel(model)              # all-reduce(grad)，自動分 bucket<br>fully_shard(model, mesh=mesh[&quot;dp&quot;])         # FSDP2 = ZeRO-3<br>parallelize_module(block, mesh[&quot;tp&quot;], {<br>    &quot;w1&quot;: ColwiseParallel(), &quot;w2&quot;: RowwiseParallel()})</pre><p>ColwiseParallel 與 RowwiseParallel 就是上面 tensor parallel 那一節：前者把輸出標成 sharded、後者標成 partial，而當一個 partial 的 tensor 被要求變成 replicated 時，DTensor 就插進那次 all-reduce。<strong>你標的是 placement，collective 是框架推導出來的</strong>——所以 profile 裡冒出一次意料之外的 all-reduce，通常是某個 placement 逼出來的。</p><h3>JAX 怎麼寫</h3><pre>mesh = jax.make_mesh((2, 4), (&quot;dp&quot;, &quot;tp&quot;))<br>x = jax.device_put(x, NamedSharding(mesh, P(&quot;dp&quot;, None)))<br>w = jax.device_put(w, NamedSharding(mesh, P(None, &quot;tp&quot;)))</pre><p>你完全不呼叫集合通訊。你只說陣列放在哪裡，XLA 自己插入需要的 all-reduce、all-gather 或 all-to-all。data parallel 是把 batch 軸切開、tensor parallel 是把特徵軸切開、FSDP 是把參數軸切開再加 jax.remat。自動選得不好時，shard_map 讓你自己寫 jax.lax.psum 與 jax.lax.all_to_all；而 jax.jit(f).lower(x).compile().as_text() 會把 XLA 插進去的每一個 collective 都印出來——<strong>在 JAX 裡做平行化 review 是讀 HLO，在 PyTorch 裡是讀 profiler trace。</strong></p><h3>服務端怎麼開</h3><pre>--tensor-parallel-size 8      --expert-parallel-size 8<br>--data-parallel-size 2        --pipeline-parallel-size 2<br>--context-parallel-size 2</pre><p>同樣五個旗標、不同的算式，理由就是第二部分那幾段：沒有梯度要 all-reduce、KV cache 決定你能怎麼擺、而 collective 付的是跳數不是位元組。</p><h3>我自己的收穫</h3><p>訓練那一半的主角是權重、帳單跟著參數；推論那一半的主角是 KV cache、帳單跟著跳數。中間每一個縮寫都只是同一張表用不同方向讀：DDP 跟著參數、tensor 與 context 跟著 token、expert 跟著 token 乘 k、pipeline 不付位元組而是付閒置。底下的集合通訊從頭到尾就那幾個，變的只是數字 — — 而且這些 bug 全部都是無聲的，所以唯一真正的測試是：<strong>一個 rank 的答案，跟完全不切的時候還一不一樣。</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0df450b9214" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-63-%E9%9B%86%E5%90%88%E9%80%9A%E8%A8%8A-%E6%8A%8A%E6%A8%A1%E5%9E%8B%E5%88%87%E5%88%B0%E5%BE%88%E5%A4%9A%E5%BC%B5-gpu-%E4%B8%8A-%E8%80%8C%E7%AD%94%E6%A1%88%E4%B8%8D%E8%AE%8A-c0df450b9214">Day 63 — 集合通訊：把模型切到很多張 GPU 上，而答案不變</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 62 — MoE(Mixture of Experts)：讓模型的參數變多，但每個 token 的成本不變]]></title>
            <link>https://medium.com/100-days-of-python/day-62-moe-mixture-of-experts-%E8%AE%93%E6%A8%A1%E5%9E%8B%E7%9A%84%E5%8F%83%E6%95%B8%E8%AE%8A%E5%A4%9A-%E4%BD%86%E6%AF%8F%E5%80%8B-token-%E7%9A%84%E6%88%90%E6%9C%AC%E4%B8%8D%E8%AE%8A-dba5e7cf4178?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/dba5e7cf4178</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[moe]]></category>
            <category><![CDATA[deep-learning]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 16:00:32 GMT</pubDate>
            <atom:updated>2026-11-18T16:00:32.726Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2062%20-%20moe%20and%20routing">day 62 on GitHub</a></p><p><em>100 Days of Python — day 62</em></p><p>Day 53 量過一件事，而它其實就是整件事的起點：transformer 三分之二的參數在 feed-forward 那一塊，而<strong>每個 token 都要把它們全部跑過一遍</strong>。每個 token、每個權重，不管那個權重對這個特定的 token 有沒有話要說。</p><p>那就把那一個 FFN 換成 E 份，每個 token 只送去最好的 k 份。參數乘上 E，每個 token 的算術只乘上 k。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1vUk9hKmxnCus1H4" /></figure><pre>參數    每個 token 實際跑的<br>----------------------------------------  ------  -------------------<br>一個 dense FFN（dmodel 4096、dff 14336）  176 M   176 M<br>64 個 expert ＋ 1 個 shared               11.5 B  528 M</pre><p><strong>參數 65 倍，每個 token 的算術只有 3 倍。</strong> 把 61 層加起來就是 699 B 參數、而任何一個 token 只跑 32 B — — 這兩年所有大型開源 MoE 的形狀都是這樣。換個說法：這一層等於一個寬度 917,504 的 feed-forward，但每個 token 只會啟動其中 28,672。</p><p>而這一切當然不是免費的，本文其餘的部分就是那張帳單。</p><h3>Router，以及它造出來的那個迴圈</h3><pre>probs = softmax(x @ Wg)          # 給每個 expert 打分<br>idx   = argsort(-probs)[:, :k]   # 離散：沒有梯度穿得過去<br>w     = probs[idx]               # 這幾個權重才有梯度<br>y     = sum_j w[:, j] * expert[idx[:, j]](x)</pre><p>一層 linear 決定哪個 token 去哪個 expert。有兩件事讓 MoE 難訓練，而且兩件都來自同一行。</p><p>選 top-k 是<strong>離散的</strong>。梯度過不了 argsort，所以 router 唯一能學到東西的管道，是它「已經選上的那幾個 expert 的權重 w」。沒被選上的 expert 拿不到梯度、不會變好、於是永遠選不上。早期的贏家會愈滾愈大。</p><p>而且 loss 裡面根本沒有任何一項要求 token 要分散。對任務 loss 來說，三個 expert 把所有工作做完完全沒問題 — — 而那正是實際會發生的事。</p><h3>把「塌掉」量出來長什麼樣</h3><p>moe.py 真的訓練一個：2048 個 token、8 種 regime（正確答案取決於 token 落在空間的哪一區）、16 個 expert、top-2，router 和 expert 一起手刻訓練。</p><pre>一個 dense map（被取代掉的那個 FFN）     loss 0.0363<br>16 個 expert、top-2、沒有平衡             loss 0.0230   （好 37%）<br><br>每個 expert 拿到的 token  [579, 554, 550, 475, 461, 405, 352, 323, 293, 84, 14, 3, 1, 1, 1, 0]<br>最忙 / 平均               2.26<br>完全沒用到的 expert        16 個裡有 1 個</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vO5A5-K0ABFn6PF8" /></figure><p>MoE 的 loss 贏了 37%，然後有一個 expert 一輩子沒看過任何一個 token，另外四個看到的不到十五個。那些參數照樣佔記憶體、照樣被存進 checkpoint、照樣要參加把 token 搬來搬去的 all-to-all — — 它們不只是沒用，它們很貴。</p><h3>兩種讓 token 分散開的方法</h3><pre>router                            loss    最忙/平均  死掉  entropy  純度<br>--------------------------------  ------  ---------  ----  -------  -----<br>沒有平衡                          0.0230  2.26       1     0.812    0.641<br>輔助 loss（Switch / GShard）      0.0241  1.98       0     0.922    0.645<br>只加選擇用的 bias（DeepSeek-V3）  0.0257  1.05       0     1.000    0.568</pre><p><strong>輔助 loss</strong> 加的是 E × Σ(路由到 i 的 token 比例 × i 的平均機率)。兩個因子缺一不可、而且各司其職：比例是「實際發生了什麼」、沒有梯度；機率是可微的；相乘之後，已經很忙的 expert 的機率會被推開。在這裡它讓 loss 退了 5%。</p><p><strong>不加 loss 的那個</strong>做的事比較細緻。它給每個 expert 一個 bias，只加在<strong>挑選用的分數</strong>上 — — 絕對不加在乘上 expert 輸出的權重 w 上——然後每一步依照該 expert 負載誤差的正負號去微調它。因為 bias 碰不到 w，它不產生任何自己的梯度，也就不會跟任務 loss 打架，它只是搬動 token。結果是這一頁最平的負載、routing entropy 剛好 1.000，代價是 loss 退 12%、以及一些專一性。</p><p>誠實地看這張表：在一個玩具問題上，平衡看起來是個划不來的交易。接下來所有東西都是在說為什麼它不是。</p><h3>Capacity：buffer 是固定大小的，所以 token 會被丟掉</h3><p>kernel 要固定形狀，所以每個 expert 有一個 capacity = factor × k × tokens / experts 的 buffer，超過的 token 直接沿著 residual 跳過這一層。</p><pre>factor  buffer  不平衡時掉的  平衡後掉的  padding<br>------  ------  ------------  ----------  -------<br>1.0     256     41.2%         1.1%        +0%<br>1.25    320     27.8%         0.0%        +25%<br>1.5     384     17.6%         0.0%        +50%<br>2.0     512     3.6%          0.0%        +100%</pre><p>factor 1.0 時 buffer 剛好等於平均負載，所以<strong>高於平均的 token 全被丟掉、低於平均的 expert buffer 空一半</strong>。把 factor 調大，是把<strong>每一個</strong> expert 的 buffer 都撐大來遷就最忙的那一個，所以最後那一欄是整層都要付的無效算術。不平衡的 router 即使到 factor 2.0 還是掉 3.6%；平衡過的在 1.25 就已經是 0。</p><p>這是「划不來的交易」開始不成立的第一個地方。</p><h3>Expert parallelism：experts 放不進一張卡</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jqU6M66nK5n4VZVh" /></figure><p>一層 11.5 B 的參數不可能放在一張卡上。expert parallelism 把 E 個 expert 切給 N 張卡、每張 E/N 個 — — 於是一個 token 如果它的 expert 在別張卡上，就得<strong>被送過去</strong>、算完<strong>再送回來</strong>。每一層兩次 all-to-all，每一層、每一步都要。</p><p>而 collective 是同步的：所有人都要等最慢的那一個。所以 router 的不平衡就不再是 loss 上的一個數字，而是閒置的晶片。</p><pre>不平衡的 router、4 張卡：  1582 / 798 / 1361 / 355 個 token<br>                           最忙/平均 1.54，其他卡閒置 35%<br>平衡過的 router：          1022 / 1001 / 1032 / 1041<br>                           最忙/平均 1.02</pre><p>那為什麼是 expert parallel，而不是把每個 expert 切開給所有卡（tensor parallel）？兩者每張卡放的權重一樣多。差別在<strong>每個 token 要搬多少</strong>：TP 每層要對整個活化做一次 all-reduce（這個配置下 58.7 MB），EP 是對被路由的 token 做兩次 all-to-all（k=2 時 117.4 MB）。EP 搬的位元組是兩倍 — — 而它仍然是對的答案，因為那是稀疏、不規則、而且<strong>可以跟計算重疊</strong>的流量，而層末的 all-reduce 是一道屏障。實務上兩個一起用：attention 用 tensor parallel，experts 用 expert parallel。</p><h3>DeepEP：讓那兩次 all-to-all 付得起</h3><p>4096 個 token、top-8、d_model 7168 的一次 dispatch 要搬 470 MB，combine 再搬回來一次。節點內走 NVLink，跨節點走 RDMA、速度只有幾分之一，而且大部分目的地都在別的節點。DeepEP 就是為這個 collective 寫的函式庫，裡面有三件事值得理解，即使你永遠不會直接呼叫它。</p><p><strong>兩套 kernel，對應兩種階段。</strong> 高吞吐那套會先用 NVLink 把 token 轉送到目的節點上，然後<strong>每個目的節點只走一次 RDMA</strong>，把慢速鏈路上的位元組壓到最低 — — 這是 prefill 與訓練要的取捨。低延遲那套相反：純 RDMA、不轉送，因為在 decode 階段那一跳比它省下來的頻寬更貴。</p><p><strong>FP8 dispatch。</strong> 把前一天那套東西用在網路線上：token 用 FP8 送出去，470 MB 變 235 MB，在這個模型裡 8.59 ms 變 4.29 ms。而 combine 仍然用 bf16，因為它要把 k 個 expert 的輸出相加，FP8 在那裡掉太多。兩個方向用不同精度，這個不對稱是刻意的。</p><p><strong>重疊。</strong> 低延遲 kernel 提供一個 hook，讓「收資料」不是一道屏障：attention 可以在 MoE 的 token 還在路上時就先算，而且不會有 SM 在那裡空轉等網路。沒有這個重疊，每層兩次 all-to-all 根本撐不住。</p><h3>在 PyTorch 裡怎麼寫這一層</h3><p>整層大概五十行，而有意思的地方是：<strong>那個「對 expert 迴圈」正是你要想辦法避開的東西</strong>。</p><pre>class MoE(nn.Module):<br>    def __init__(self, d_model, d_ff, n_experts, k):<br>        self.gate = nn.Linear(d_model, n_experts, bias=False)<br>        # 所有 expert 放成「一個」參數，不是 ModuleList：<br>        self.w1 = nn.Parameter(torch.empty(n_experts, d_model, d_ff))<br>        self.w2 = nn.Parameter(torch.empty(n_experts, d_ff, d_model))<br>        self.k = k<br><br>def forward(self, x):                       # x: (tokens, d_model)<br>        probs  = self.gate(x).softmax(-1)<br>        w, idx = probs.topk(self.k, dim=-1)     # (tokens, k)<br>        w = w / w.sum(-1, keepdim=True)<br>        flat   = idx.reshape(-1)                # 每個 token 有 k 筆<br>        order  = flat.argsort()                 # 依 expert 分組<br>        counts = torch.bincount(flat, minlength=self.w1.shape[0])<br>        xs = x.repeat_interleave(self.k, 0)[order]<br>        h  = F.silu(torch._grouped_mm(xs, self.w1, counts))<br>        ys = torch._grouped_mm(h, self.w2, counts)<br>        out = torch.zeros_like(x)<br>        token_of = torch.arange(len(x)).repeat_interleave(self.k)<br>        out.index_add_(0, token_of[order], ys * w.reshape(-1, 1)[order])<br>        return out</pre><p>這裡藏了四個設計決定，而且每個真實實作裡都是同樣這四個。</p><p><strong>experts 是一個 tensor，不是一個 list。</strong> 用 nn.ModuleList([nn.Linear(...) for _ in range(E)]) 是最自然的寫法，但那代表 E 次 kernel launch、E 次權重載入，而且 expert 的編號沒辦法當索引用。寫成<strong>一個</strong> (E, d_model, d_ff) 的 Parameter 之後，「選一個 expert」就變成「選一個索引」——後面三個決定才有可能。</p><p><strong>用排序，不要用遮罩。</strong> 直覺的寫法是乘上 one-hot 遮罩、讓每個 expert 都算過每個 token；結果是對的，而且<strong>算術量變成 E 倍</strong>，MoE 的意義整個消失。實務上是：依 expert id 排序 token、對不等長的分組做一次 grouped matmul（torch._grouped_mm，或 Megatron-LM／vLLM 裡的 Triton kernel），最後再排回去。</p><p><strong>回填要用 </strong><strong>index_add_。</strong> 一個 token 出現 k 次、k 份 expert 輸出要相加，所以必須是「加」不是「寫」——而 gate 權重的梯度也正是從這個加法來的。</p><p><strong>平衡用的 aux loss 要從 </strong><strong>forward 回傳。</strong> 它需要 probs 和路由計數，而那兩個只有 layer 裡面才有。每個 MoE 程式庫最後都會有一個「各層把 aux loss 丟進去、訓練迴圈再加總」的清單。</p><p>分散式版本的 dispatch 就是一行 collective：</p><pre>torch.distributed.all_to_all_single(recv, send, out_splits, in_splits)</pre><p>而那些 splits 就是排序後每個 rank 的 token 數。不平衡的 router 會讓 splits 歪掉，所有人都要等最大的那一個 — — 這就是前面那些負載數字真正變成時間的地方。</p><h3>在 JAX 裡怎麼寫這一層</h3><p>同一個演算法，程式碼長得完全不一樣，因為 JAX 要的是<strong>固定形狀加上一條 sharding 規則</strong>，而不是 gather。</p><pre>def moe(x, wg, w1, w2, k, capacity):<br>    probs  = jax.nn.softmax(x @ wg)                   # (T, E)<br>    w, idx = jax.lax.top_k(probs, k)<br>    mask = jax.nn.one_hot(idx, n_experts).sum(1)      # (T, E)<br>    pos  = jnp.cumsum(mask, axis=0) * mask - 1        # buffer 裡的位置<br>    disp = mask[..., None] * jax.nn.one_hot(pos, capacity)   # (T, E, cap)<br><br>xe = jnp.einsum(&quot;tec,td-&gt;ecd&quot;, disp, x)           # 固定大小 (E, cap, d)<br>    he = jax.nn.silu(jnp.einsum(&quot;ecd,edf-&gt;ecf&quot;, xe, w1))<br>    ye = jnp.einsum(&quot;ecf,efd-&gt;ecd&quot;, he, w2)<br>    return jnp.einsum(&quot;ecd,tec,te-&gt;td&quot;, ye, disp, w)</pre><p>那串 einsum <strong>就是</strong> dispatch 和 combine 本身。沒有排序、沒有變動長度，而且 <strong>capacity 直接出現成陣列的一個維度</strong> — — 這正是 capacity factor 存在的理由：buffer 是固定的，滿出來的 token 沒有地方可以去。</p><p>而平行化是一個標註，不是一次呼叫：</p><pre>mesh = Mesh(devices, (&quot;data&quot;, &quot;expert&quot;))<br>w1   = jax.device_put(w1, NamedSharding(mesh, P(&quot;expert&quot;, None, None)))<br>moe  = shard_map(moe, mesh, in_specs=..., out_specs=...)</pre><p>把 w1 的 expert 軸 shard 掉，<strong>這就是 expert parallelism 的全部</strong>。einsum 需要住在別的裝置上的資料，所以 XLA 自己插入 all-to-all，沒有人手寫那個 collective。這也是兩個生態系真正的差別：PyTorch 是你呼叫 all_to_all_single 並自己管 splits；JAX 是你標註軸、編譯器產生通訊。</p><p>代價也很對稱：排序版本只對真正被路由到的 token 做算術，但要快就需要自訂 kernel；one-hot 版本是純 dense einsum、任何編譯器都能融合，但 buffer 裡每一個空位都要付錢。</p><h3>上線的時候</h3><p>兩個伺服器開出來的是同樣兩個決定。experts 住在哪幾張卡 — — <strong>SGLang </strong>的 --ep-size 8、<strong>vLLM </strong>的 --enable-expert-parallel；以及那兩次 all-to-all 由誰來搬——SGLang 的 --enable-deepep-moe 配 --deepep-mode normal|low_latency|auto，vLLM 底下接 DeepEP 或 pplx-kernels。而兩邊最後都跑成「attention 用 data parallel、experts 用 expert parallel」，因為 attention 沒有 expert 可以分，而 MoE 的權重不切放不下。</p><p>除此之外值得知道的是 SGLang 的 --enable-eplb 搭 --ep-num-redundant-experts。訓練時的平衡 loss 壓平的是<strong>平均</strong>，而真實流量不是平均：某一分鐘的請求可能全都想要同一批 expert。所以伺服器會量線上每個 expert 的負載、<strong>把 expert 在 rank 之間搬動</strong>、並<strong>把最熱的那幾個複製出去</strong>。訓練時的塌縮問題，在線上以維運問題的形式回來，然後拿到一個維運上的答案。</p><h3>這一天之後會在哪裡再出現</h3><p>「路由」是一個用梯度下降去訓練的離散選擇，而這個困難在強化學習、以及所有「學架構而不是學權重」的嘗試裡都會再出現。另外，load balancing 的那個故事 — — <strong>訓練時壓平平均，上線後再針對真實流量重新平衡</strong> — — 是一個值得認出來的模式：你能事先烤進去的東西，和你必須線上量測的東西之間的分界，在快取、在排程、在任何「工作負載不是穩態」的地方都一樣會出現。</p><p>程式碼、notebook 與互動版走查：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2062%20-%20moe%20and%20routing">day 62 on GitHub</a>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dba5e7cf4178" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-62-moe-mixture-of-experts-%E8%AE%93%E6%A8%A1%E5%9E%8B%E7%9A%84%E5%8F%83%E6%95%B8%E8%AE%8A%E5%A4%9A-%E4%BD%86%E6%AF%8F%E5%80%8B-token-%E7%9A%84%E6%88%90%E6%9C%AC%E4%B8%8D%E8%AE%8A-dba5e7cf4178">Day 62 — MoE(Mixture of Experts)：讓模型的參數變多，但每個 token 的成本不變</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 61 — 量化：把每個權重存成更少的位元，以及四捨五入的代價]]></title>
            <link>https://medium.com/100-days-of-python/day-61-%E9%87%8F%E5%8C%96-%E6%8A%8A%E6%AF%8F%E5%80%8B%E6%AC%8A%E9%87%8D%E5%AD%98%E6%88%90%E6%9B%B4%E5%B0%91%E7%9A%84%E4%BD%8D%E5%85%83-%E4%BB%A5%E5%8F%8A%E5%9B%9B%E6%8D%A8%E4%BA%94%E5%85%A5%E7%9A%84%E4%BB%A3%E5%83%B9-b9660ab796d3?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/b9660ab796d3</guid>
            <category><![CDATA[training]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[quantization]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 15:54:46 GMT</pubDate>
            <atom:updated>2026-11-18T15:54:46.768Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2061%20-%20quantization">day 61 on GitHub</a></p><p><em>100 Days of Python — day 61</em></p><p>bf16 的 70B 模型是 140 GB 的權重，而前面幾天量過結論：<strong>每個 decode step 都要把它整份讀一遍</strong>，所以每個 token 的時間是一次記憶體讀取，不是算術。把每個權重從 16 bit 改成 4 bit，兩個數字一起砍四倍 — — 140 GB 變 36 GB，28 ms 的讀取變 7 ms。</p><p>這個系列裡沒有別的東西買得到這個。剩下的問題只有「四捨五入要付多少」，而答案取決於三個決定：<strong>哪些數字共用一個 scale</strong>、<strong>離群值放哪裡</strong>、<strong>四捨五入是要讓權重誤差最小還是讓這一層的輸出誤差最小</strong>。底下每一個方法 — — int8、FP8、MXFP4、LLM.int8()、SmoothQuant、GPTQ、AWQ、QAT — — 都只是這三個決定的某一種組合。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EQof45mscMWqExZT" /></figure><p>所有數字都量在同一層 linear 上，而它的活化長得像真的一層：512 個輸入 channel 裡有 6 個，值大約是中位數的 100 倍。指標一律是這一層<strong>輸出</strong>的相對誤差，因為下一層看到的不是權重。</p><h3>一個量化過的數字是什麼</h3><pre>scale = abs(x).max() / 127          # int8：qmax = 127<br>q     = round(x / scale)            # 真正存進記憶體的是這個<br>x_hat = q * scale                   # 矩陣乘法看到的是這個</pre><pre>+0.0310 -&gt; q =  33 -&gt; +0.030661   (誤差 0.000339)<br>-0.0072 -&gt; q =  -8 -&gt; -0.007433   (誤差 0.000233)<br>+0.0009 -&gt; q =   1 -&gt; +0.000929   (誤差 0.000029)<br>+0.1180 -&gt; q = 127 -&gt; +0.118000   (誤差 0.000000)</pre><p>每個誤差最多半格。真正重要的是定義裡的第二行：<strong>步長是被 group 裡最大的那個數決定的</strong>。最大的那個剛好落在格點上、一毛都不用付；比它小的數字，小多少就付多少。所以整個主題只剩一個問題 — — 哪些數字被迫共用一個 scale。</p><h3>所有單位一次看完</h3><p>在講方法之前，先把單位講清楚。一個浮點數是三個欄位塞在同一個字裡 — — 符號位、指數、尾數（小數部分） — — 讀法是</p><pre>value = (-1)^sign * 2^(指數 - bias) * 1.尾數</pre><p>拿 0.15625 存成 fp32 來看（你可以自己用 np.float32(0.15625).view(np.uint32) 驗）：</p><pre>sign      0                        -&gt; +1<br>exponent  01111100                 -&gt; stored 124, minus bias 127 = -3<br>mantissa  01000000000000000000000  -&gt; 1.01... = 1.25<br>value     1.25 x 2^-3 = 0.15625</pre><p>這裡有兩個慣例在做很多事。指數存的是<strong>加了 bias 的無號數</strong>（讀的時候減掉 bias = 2^(e-1) - 1），這樣把兩個浮點數當成整數去比大小，順序還是對的。而小數點前面那個 1. <strong>根本不存</strong>，是隱含的，等於白賺一位精度。小到連這個都撐不住的數（小於 2^emin）會改存成 <em>subnormal</em>，前面變成 0.——這就是浮點數「逐漸退化到零」而不是「直接變零」的機制。</p><p>所以一個格式就是三個數字：指數幾位（範圍）、尾數幾位（精度），以及「全 1 的指數」拿去做什麼。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VV0V3kn8gukc3UBX" /></figure><pre>格式        位元  S / E / M   bias  最大值     最小正規值  相對步長  十進位有效位  用在哪<br>----------  ----  ----------  ----  ---------  ----------  --------  ------------  --------------------------------------------<br>fp32        32    1 / 8 / 23  127   3.403e+38  1.18e-38    1.19e-07  6.9           到處都是的預設<br>tf32        19    1 / 8 / 10  127   3.401e+38  1.18e-38    0.000977  3.0           NVIDIA tensor core：fp32 的範圍、fp16 的精度<br>bf16        16    1 / 8 / 7   127   3.39e+38   1.18e-38    0.00781   2.1           訓練：fp32 的範圍，一半的位元組<br>fp16        16    1 / 5 / 10  15    6.55e+04   6.1e-05     0.000977  3.0           較早的訓練格式，需要 loss scaling<br>fp8 e4m3fn  8     1 / 4 / 3   7     448        0.0156      0.125     0.9           FP8 前向：權重與活化<br>fp8 e5m2    8     1 / 5 / 2   15    5.734e+04  6.1e-05     0.25      0.6           FP8 梯度：範圍大、精度低<br>fp6 e3m2    6     1 / 3 / 2   3     28         0.25        0.25      0.6           MX block 元素，偏範圍<br>fp6 e2m3    6     1 / 2 / 3   1     7.5        1           0.125     0.9           MX block 元素，偏精度<br>fp4 e2m1    4     1 / 2 / 1   1     6          1           0.5       0.3           MXFP4 / NVFP4 的元素格式<br>int8        8     1 / - / 7   -     127        1           0.00787   2.1           等距格點：大小全靠外面的 scale<br>int4        4     1 / - / 3   -     7          1           0.143     0.8           等距格點：大小全靠外面的 scale</pre><p>怎麼讀這張表。<strong>指數位數買的是範圍</strong>：bf16 跟 fp32 同樣是 8 位，所以 fp32 的任何值轉成 bf16 都不會溢位。<strong>尾數位數買的是精度</strong>：相對步長是 2^-m，所以 fp32 大約 7 位十進位有效數字、bf16 大約 2 位。fp16 在同樣 16 位下做了相反的取捨——精度多、指數範圍只有十分之一——這正是 fp16 訓練需要 loss scaling 而 bf16 不用的原因。</p><p>名字也值得講兩句。e4m3 就是欄位寬度本身，所以任何格式都可以直接從名字讀出來。而 float8_e4m3fn 的 fn 是 <strong>finite</strong>：它放棄無限大，把「全 1 的指數」拿來存數字，因此多賺到一個指數級距——最大值是 448 而不是 240。</p><p>表格最下面那兩個整數格式根本沒有指數。所有「有多大」的資訊都住在旁邊存的 scale 裡，而本文其餘的部分，講的全都是怎麼挑那個 scale。</p><p>MX（micro-scaling）系列介於兩者之間：一個元素格式，加上每 32 個值共用一個指數 — — 這也是那些「小數位元數」的由來。</p><pre>MX 格式     元素    block  scale  每個值幾位元  元素最大值<br>----------  ------  -----  -----  ------------  ----------<br>MXFP8 e4m3  8 bits  32     E8M0   8.25          448<br>MXFP6 e3m2  6 bits  32     E8M0   6.25          28<br>MXFP4 e2m1  4 bits  32     E8M0   4.25          6</pre><p>block 的 scale 是 E8M0：8 位指數、沒有尾數，所以它是 2 的冪次，套用 scale 是加指數而不是乘法。NVFP4 是同一個念頭，但 block 是 16、scale 用 e4m3。</p><h3>誰跟誰共用 scale</h3><p>同一組權重、同樣的算術，只改分組：</p><pre>方案                          bits/權重  相對誤差<br>----------------------------  ---------  --------<br>int8，整個 tensor 一個 scale  8.00       0.03103<br>int8，每列一個 scale          8.00       0.01444<br>fp8 e4m3                      8.00       0.02658<br>fp8 e5m2                      8.00       0.05281<br>int4，每列一個 scale          4.00       0.26197<br>int4，每 128 個一個 scale     4.12       0.17584<br>MXFP4，每 32 個一個 block     4.25       0.12301</pre><p>每列一個 scale 的成本是每 512 個權重多一個 float（0.03 bit），誤差直接少一半。而把最後一列跟第一列對著看：<strong>4 bit、每 32 個共用一個指數，贏過 8 bit、整個 tensor 一個 scale</strong>，而且只用一半的記憶體。另外注意：4 bit 的格式從來不是 4.00 bit — — int4 group 128 實際是 4.12，MXFP4 是 4.25。scale 也是模型的一部分。</p><h3>同樣 8 bit，整數與浮點</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bT3QJdZeSCCKkV8p" /></figure><p>int8 是 254 個等距格點，最大與最小的比值是 127。間距固定，所以<strong>絕對</strong>誤差到處一樣：對接近最大值的數很好，對小一百倍的數是災難。</p><p>FP8 把位元花在指數上。e4m3 有 3 bit 尾數、動態範圍 2.3e5；e5m2 有 2 bit 尾數、範圍 3.8e9。間距隨數值大小變化，所以<strong>相對</strong>誤差到處差不多。這個差別決定了兩種格式的分工：e4m3 是前向傳遞用的 — — 範圍不必很大但要精度；e5m2 是給梯度用的 — — 梯度的數量級跨度大得多，但對精度要求低。混合 FP8 訓練兩種都用，而這就是為什麼會有兩種的真正原因。</p><p>MXFP4 再往前一步：每個元素 4 bit（1 位符號、2 位指數、1 位尾數，也就是 {0, .5, 1, 1.5, 2, 3, 4, 6} 這八種大小），每 32 個共用一個 8 bit 的 2 的冪次指數。平均 4.25 bit，而在這組權重上它比「整個 tensor 一個 scale 的 int8」還準。block floating point 不是新東西，新的是硬體開始原生支援它。</p><h3>所有方法一次看完</h3><p>上面那張表是<strong>單位</strong>，這張表是<strong>方法</strong>。而所有方法其實只被三個問題分開：<strong>量化什麼</strong>、<strong>scale 怎麼挑</strong>、以及<strong>四捨五入本身有沒有被改良</strong>。</p><pre>方法                           量化什麼          常見位元   代價                              核心想法<br>-----------------------------  ----------------  ---------  --------------------------------  --------------------------------------------------------------------<br>round to nearest (RTN)         權重              8 / 4      不用資料，直接套在 checkpoint 上  absmax scale（per tensor／row／group），所有方法的比較基準<br>MSE / percentile clipping      權重／活化        8 / 4      需要幾個校準 batch                搜一個讓平方誤差最小的裁切門檻，而不是直接用最大值<br>LLM.int8()                     權重＋活化        8 (+16)    不用資料，直接套在 checkpoint 上  把矩陣乘法拆開：含離群值的 column 留 16-bit，其餘走 int8<br>ZeroQuant / per-token dynamic  權重＋活化        8          不用資料，直接套在 checkpoint 上  活化用 per-token、執行時算的 scale；權重用 per-column<br>SmoothQuant                    權重＋活化        8          需要幾個校準 batch                把動態範圍從活化搬到權重：X W = (X/s)(W s)<br>AWQ                            權重              4          需要幾個校準 batch                先把「活化真的會用到」的 channel 乘大再量化<br>GPTQ (from OBQ / OBS)          權重              4 / 3      需要幾個校準 batch                逐 column 四捨五入，用 H = XᵀX 把誤差推給還沒處理的 column<br>SqueezeLLM                     權重              4 / 3      需要幾個校準 batch                用敏感度加權的 k-means 碼本，另外留一組稀疏離群值<br>SpQR                           權重              ~4         需要幾個校準 batch                最敏感的少數權重留高精度，其餘壓得更兇<br>HQQ                            權重              4 / 3 / 2  不用資料，直接套在 checkpoint 上  用穩健的損失去最佳化 scale 與 zero-point；不需要校準資料<br>QuIP#                          權重              2          需要幾個校準 batch                先把權重旋轉成「不相干」再用格子量化<br>AQLM                           權重              2          需要一次訓練                      對每組權重用可加的碼本，並端到端微調<br>NF4 / QLoRA                    權重              4          不用資料，直接套在 checkpoint 上  格點放在常態分佈的分位數上，再把 scale 本身也量化一次<br>GGUF k-quants                  權重              2-8        不用資料，直接套在 checkpoint 上  16～32 個一塊、再加一層 super-block scale；llama.cpp 那一家（Q4KM…）<br>FP8 (e4m3 / e5m2)              權重＋活化＋梯度  8          不用資料，直接套在 checkpoint 上  浮點格點＋per-tensor 或 per-row scale；硬體原生那條路<br>MX / NVFP4                     權重＋活化        4-8        不用資料，直接套在 checkpoint 上  block floating point：每 16～32 個值共用一個指數<br>KV cache quantization          KV cache          8 / 4      不用資料，直接套在 checkpoint 上  記憶體吃在 cache 上，所以把 K/V 以 head 或 token 為單位量化<br>QAT (STE, LSQ, PACT)           權重＋活化        4 / 3 / 2  需要一次訓練                      訓練時就帶著四捨五入；LSQ 連步長一起學、PACT 學裁切點</pre><p>「代價」那一欄可以當成一道階梯。不用資料的那些，你五分鐘前下載的 checkpoint 就能直接套。需要校準的那些，要幾百條真實序列 — — 仍然便宜、仍然離線，但結果從此取決於你餵了什麼進去。只有最後幾列需要一次訓練，這也是為什麼它們在「不是自己訓練這個模型的團隊」裡很少見。</p><p>還有記號。<strong>W4A16</strong> 是 4-bit 權重、16-bit 活化，也就是 weight-only — — 這是部署時的預設值，因為 decode 每個 token 都要把權重讀一遍，而活化很小。<strong>W8A8</strong> 與 FP8 連活化一起量化，換到的是 weight-only 拿不到的 tensor core 吞吐量，這在 prefill（被算力卡住，而不是被頻寬卡住）才有意義。另外，每 128 個權重一個 scale 的話，「W4」實際上是 4.12 bit。</p><p>本文其餘的部分會把「能在單一層上量出來」的那些實際量一遍：各種分組的 round-to-nearest、MSE 裁切、LLM.int8()、SmoothQuant、AWQ、GPTQ 與 QAT。</p><h3>難的是活化，不是權重</h3><p>一次只量化一邊，就知道傷害從哪來：</p><pre>量化哪一邊                        輸出誤差<br>--------------------------------  --------<br>只有權重，每列一個 scale          0.01462<br>只有活化，整個 tensor 一個 scale  0.06897<br>只有活化，每個 token 一個 scale   0.03394<br>兩邊都量化                        0.03703</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*reWrhrvD2wkTox7K" /></figure><p>權重接近高斯分佈，一列一個 scale 綽綽有餘。活化不是：少數幾個 channel 的值比中位數高兩個數量級，它們把整個 tensor 的 scale 撐大，其他所有數字就只剩幾個格點可用。<strong>這就是為什麼實務上的部署預設是 weight-only 量化</strong>，也是為什麼量化活化需要額外的手段。</p><p>手段有三種，而且其實是同一個念頭的三個角度。</p><p><strong>留著它們。</strong> LLM.int8() 把矩陣乘法拆開：含離群值的那 1.2% 的 column 留在 16-bit，其餘走 int8。輸出誤差 0.03703 → 0.00686。代價是兩個矩陣乘法、而且形狀不規則，所以實際速度沒有位元數看起來那麼好。</p><p><strong>搬走它們。</strong> X W^T = (X / s) (W s)^T 對任何 per-channel 的 s 都成立，所以可以把困難從活化那邊搬到權重那邊。SmoothQuant 取 s = max|X_j|^α / max|W_j|^(1-α)：</p><pre>alpha   活化動態範圍   輸出誤差<br> 0.00         43.9      0.05468<br> 0.25         17.1      0.02243<br> 0.50          6.6      0.01348<br> 0.75          2.6      0.01925<br> 1.00          1.0      0.04043</pre><p>α=0 什麼都不搬，α=1 全搬過去、換成權重壞掉，有用的值都在中間。而且 s 可以折進前一層的 layer norm，所以執行時完全免費 — — 這也是它成為「讓活化量化真的可行」的標準做法的原因。</p><p><strong>給它們自己的 scale。</strong> 這就是 per-token 與 group-wise scale 在做的事，也是硬體往 block 格式走的原因。</p><h3>「取最近的格點」不是最好的四捨五入</h3><p>4 bit、每 128 個權重一個 scale：</p><pre>方法               權重誤差  輸出誤差<br>-----------------  --------  --------<br>round to nearest   0.17584   0.17612<br>GPTQ               0.31186   0.13051<br>AWQ（alpha 0.37）  -         0.10059</pre><p>看這兩欄的方向是相反的。GPTQ 的權重<strong>錯得比 RTN 多一倍</strong>，而這一層的輸出好了 26%。這不是量錯了，這正是它的前提：<strong>沒有人在乎權重</strong>。</p><pre>H = X.T @ X / n                         # 真實輸入實際會激發哪些方向<br>Hinv = inv(H + damp)<br>for j in range(d):<br>    q = round(W[:, j] / scale) * scale  # 處理一個 column<br>    err = (W[:, j] - q) / Hinv[j, j]<br>    W[:, j+1:] -= outer(err, Hinv[j, j+1:])   # 把誤差推到還沒處理的 column</pre><p>每個 column 四捨五入之後，剛犯下的誤差會被推到還沒處理的 column 上，推的方向由 Hessian 的反矩陣決定 — — 也就是「怎麼推才會在輸出上互相抵消」。這其實是剪枝文獻裡的 Optimal Brain Surgeon 更新式，特化到單一層、單趟。</p><p>AWQ 從另一邊走到類似的地方。它完全不改四捨五入，而是把「活化真的會用到」的 column 先乘大（活化那邊同時除回來），於是同樣的四捨五入對重要的地方相對變小。那個指數是搜出來的、不是推導出來的 — — 這裡搜到 0.37。</p><p>兩者都需要校準資料：幾條真實序列，離線跑一次。這也是本文實務上的分水嶺：這一節之前的東西都是純算術，拿到 checkpoint 就能做；從這裡開始的方法都想先看看這個模型實際上被拿來做什麼。</p><h3>訓練時就帶著四捨五入</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CJ4AHl9bYSuVAdFm" /></figure><p>最後一條路是不要再把量化當成「對一個已經訓練完的模型做的事」。round() 幾乎處處梯度為零，所以反向傳遞直接假裝它是恆等函數——straight-through estimator。權重仍然以浮點存在，前向看到的是四捨五入後的值，於是最佳化器會找到「<strong>四捨五入之後</strong>才好」的權重，而這跟「最好的浮點權重再四捨五入」是不同的目標。</p><pre>wq = fake_quant(w, bits)              # 前向：四捨五入後的<br>g  = X.T @ (X @ wq - y) * 2 / n       # 反向：直接穿過去<br>w -= lr * g                           # 浮點權重繼續移動</pre><p>3 bit 下這值 2.6 倍：先訓練再量化是 2.180，訓練時帶著量化是 0.837。</p><p>然後是我沒預期會這麼乾淨的一個量測。把輸入換成幾乎正交的，再把整個實驗跑一次，好處掉到只剩 1.11 倍。因為輸入正交時每個權重各自獨立，「最好的量化權重」就真的等於「最好的權重再量化」，沒有東西可以學。<strong>好處完全來自「一個權重可以吸收另一個權重的四捨五入誤差」</strong> — — 而那正是 GPTQ 用 H = XᵀX 閉式算出來的同一個性質。訓練是用梯度下降把它找出來，GPTQ 是把它推導出來；輸入不重疊的時候，兩個都沒有用武之地。</p><p>還有一個該誠實講的註腳：QAT 的 loss 不是單調下降的。最後 300 步的標準差是 1.17，最後一步是 1.226，而最好的那一步是 0.837。前向是一個階梯函數，權重一跨過格點邊界，輸出就跳一下。所以 QAT 都是用驗證集挑 checkpoint，而不是直接拿最後一步 — — 那不是作弊，面對不平滑的目標函數那是唯一合理的做法。</p><h3>在 PyTorch 裡</h3><p>三層很容易混在一起的東西。</p><p><strong>Dtype。</strong> torch.float8_e4m3fn 與 torch.float8_e5m2 是真的 tensor dtype，而 torch._scaled_mm(a, b, scale_a, scale_b, out_dtype=torch.bfloat16) 是吃 FP8 輸入加 scale 的矩陣乘法。注意裡面<strong>沒有</strong>的東西：scale 要自己算，而「怎麼算」就是本文前半在講的事。</p><p><strong>訓練後量化。</strong> 現在的家是 torchao：</p><pre>from torchao.quantization import quantize_, Int4WeightOnlyConfig<br>quantize_(model, Int4WeightOnlyConfig(group_size=128))</pre><p>這一行就是上面那張表的其中一列 — — 4 bit、每 128 個權重一個 scale。它把每個 Linear 的權重換成一個量化過的 tensor 子類別，模型結構完全不動。GPTQ 和 AWQ 也住在這裡，兩個都要校準用的 batch。</p><p><strong>訓練。</strong> 直通估計就是一個 autograd Function：</p><pre>class RoundSTE(torch.autograd.Function):<br>    @staticmethod<br>    def forward(ctx, x): return torch.round(x)<br>    @staticmethod<br>    def backward(ctx, g): return g        # 直接穿過去</pre><p>torchao.quantization.qat 把這個包好，而 torchao.float8 做的是真的事：前向<strong>與</strong>反向都用 FP8 矩陣乘法，per-tensor 或 per-row scale，FP8 預訓練就是這樣跑的。</p><h3>在 JAX 裡</h3><p>一樣的算術，不一樣的形狀，因為 JAX 把數值放在函數裡而不是放在模組裡。</p><p><strong>Dtype。</strong> jnp.float8_e4m3fn 與 jnp.float8_e5m2 都有，而 jax.lax.dot_general(..., preferred_element_type=jnp.bfloat16) 就是在說「用 8 bit 乘、用 16 bit 累加」。累加的型別跟輸入型別一樣重要：幾千個 int8 乘積如果用 int8 累加，馬上就溢位了。</p><p><strong>直通估計</strong>在這裡完全不需要自訂類別：</p><pre>def ste_round(x):<br>    return x + jax.lax.stop_gradient(jnp.round(x) - x)</pre><p>前向算出來剛好是 round(x)；梯度因為 stop_gradient 只流過前面那個 x，等於把 round 的導數當成 1。它就是「恆等式加上一個被切斷梯度的修正項」，而看到這一行就知道那裡在做 QAT。</p><p><strong>函式庫。</strong> AQT（google/aqt）是量化訓練的函式庫：把一個 dot_general 包起來，它處理 scale、校準與反向傳遞，於是同一個函式可以用 int8 訓練、也可以用 int8 服務。Qwix 是比較新的那個，PTQ／QAT／LoRA 流程都蓋到，而且不用改寫模型。</p><p>兩邊值得帶走的差別很小但很真實：<strong>PyTorch 量化的是模組，JAX 量化的是運算</strong>。底下的東西 — — scale、分組、直通梯度 — — 完全是同一套算術。</p><h3>這一天之後會在哪裡再出現</h3><p>低精度訓練就是把同樣這些決定套到梯度與 optimizer state 上，而且多一個問題：梯度可能 underflow 成零、然後安靜地停止學習 — — loss scaling 存在的理由就是防這件事。而 GPTQ 那個「把誤差推給還沒處理的部分」的想法比量化更老：它是剪枝用的 Optimal Brain Surgeon 更新式，往後只要有人要「以最小的輸出傷害去修改一個模型」，它就會再出現。</p><p>程式碼、notebook 與互動版走查：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2061%20-%20quantization">day 61 on GitHub</a>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9660ab796d3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-61-%E9%87%8F%E5%8C%96-%E6%8A%8A%E6%AF%8F%E5%80%8B%E6%AC%8A%E9%87%8D%E5%AD%98%E6%88%90%E6%9B%B4%E5%B0%91%E7%9A%84%E4%BD%8D%E5%85%83-%E4%BB%A5%E5%8F%8A%E5%9B%9B%E6%8D%A8%E4%BA%94%E5%85%A5%E7%9A%84%E4%BB%A3%E5%83%B9-b9660ab796d3">Day 61 — 量化：把每個權重存成更少的位元，以及四捨五入的代價</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 60 — Beam search 與 speculative decoding：一個去找更好的句子，一個讓同一句話來得更快]]></title>
            <link>https://medium.com/100-days-of-python/day-60-beam-search-%E8%88%87-speculative-decoding-%E4%B8%80%E5%80%8B%E5%8E%BB%E6%89%BE%E6%9B%B4%E5%A5%BD%E7%9A%84%E5%8F%A5%E5%AD%90-%E4%B8%80%E5%80%8B%E8%AE%93%E5%90%8C%E4%B8%80%E5%8F%A5%E8%A9%B1%E4%BE%86%E5%BE%97%E6%9B%B4%E5%BF%AB-d3c3bbef5a15?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/d3c3bbef5a15</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 16:50:49 GMT</pubDate>
            <atom:updated>2026-11-17T16:50:48.953Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2060%20-%20beam%20search%20and%20speculative%20decoding">day 60 on GitHub</a></p><p><em>100 Days of Python — day 60</em></p><p>前一天結束在一個我一直想著的數字：greedy decoding — — 每一步都取機率最高的字元 — — 產生的是文法允許的 1,250 句裡的<strong>第 44 名</strong>。每一步都最佳，結果卻不是。而且 temperature、top-k、top-p 怎麼調都補不起來，因為這根本不是取樣問題。</p><p>今天是對這件事的兩個回答，而且方向完全相反。beam search 改變輸出去找一句更可能的話，代價是更貴；speculative decoding 則是輸出一個位元都不改，只是更快。兩個都拿全列舉來對答案，所以誰都不能只是「聽起來合理」。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NG42sIVi6Z6VBmDX" /></figure><h3>標準答案</h3><p>文法小到可以全部列出來：1,250 句，每一句的機率都用逐步 log 機率相加精確算出。</p><pre>整句最高    &#39;a small dog sat in the garden.&#39;    log p = -6.244<br>greedy 給   &#39;the red cat sang in the garden.&#39;   log p = -6.717，第 44 名<br>整句最低    &#39;a cat slept on the mat.&#39;           log p = -9.173</pre><p>greedy 會走進一個「之後沒有好結尾」的前綴，而且回不了頭。順帶看一下尺度：最好與最差之間差 2.9 個 log 單位（機率約 18 倍），而 greedy 只比最好的低 0.47。所以搜尋能買到的東西本來就有上限，底下都是在這個區間裡爬。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jzBafpKA7Bt80Unj" /></figure><h3>Beam search</h3><p>不要只留一個前綴，留 width 個。每一步把存活的前綴全部展開、全部計分，再整體取分數最高的 width 個。</p><pre>width          找到的名次  log p<br>-------------  ----------  ------<br>1（＝greedy）  44          -6.717<br>2              44          -6.717<br>4              10          -6.502<br>8、16、32      5           -6.407</pre><p>這張表有兩件事值得多看一眼。</p><p>第一件：width 1 就是 greedy — — 而我為了讓它真的相等繞了一段 debug。這個模型有<strong>真正的平手</strong>：兩個字元的機率一模一樣到最後一位。np.argmax 會回傳第一個，np.argsort 預設的 quicksort 不保證。排序必須是 stable 的，否則兩個演算法會給出不同的句子，而且從輸出上你永遠猜不到原因是排序法。</p><p>第二件：它停在第 5 名。再怎麼加寬都到不了第 1 名，因為最佳句的前綴早就被剪掉、而且沒有任何機制把它救回來。beam search 是<strong>啟發式</strong>不是最大化器 — — 程式裡的 assert 只保證「沒有任何 beam 會超過列舉出來的最佳解」，不保證會找到它。成本則是線性的：width 8 等於每一步都在跑 8 條序列，8 份 KV cache、8 倍 attention（前幾天那些東西）。</p><h3>它到底是在哪一步輸掉的</h3><p>因為有標準答案，失敗可以定位到「哪一個字元」。把最佳句的前綴放進 width 8 的 beam，每一步問它排第幾：</p><pre>第 9 步被丟掉，前綴是 &#39;a small d&#39;<br>當下它的分數在 64 個候選裡排第 10，而 beam 只留 8 個</pre><p>之後沒有任何機制能救回來：前綴沒了，所有以它開頭的句子就一起沒了。這才是 beam search 真正的失敗模式 — — 不是最後比錯，而是<strong>一個暫時落後、本來會追上來的前綴</strong>被剪掉。在那個字還沒寫完之前，a small d 看起來真的就是比 the old r 差。</p><p>最佳句不是找不到，是很貴：</p><pre>width  32   還是找不到<br>width  64   還是找不到<br>width 128   找到了</pre><p>為了一個名次，要用 16 倍寬的 beam。這就是這個取捨的普遍形狀：最後一點品質要吃掉大部分算力，而每多一份 width 就是多一份 KV cache、多一遍 attention。</p><h3>Beam search 的兩個毛病</h3><p><strong>更寬不保證更好。</strong> 換一個用比較小語料訓練的模型，一格一格掃 width：</p><pre>width  1   log p  -6.188<br>width  2   log p  -6.188<br>width  3   log p  -6.422   &lt;- 比更窄的 beam 還差<br>width  4   log p  -6.224</pre><p>這不是實作 bug。beam 變寬會讓更多前綴活著，而一個早期看起來普通的前綴，可能活到後面把真正該贏的那條擠掉。翻譯文獻把這個現象在品質分數上的版本叫 <strong>beam search curse</strong>：width 超過大約 5～10 之後 BLEU 開始下降，而模型機率還在上升 — — 這件事講的其實是模型本身，不只是搜尋。</p><p><strong>總機率最高＝偏好短的。</strong> 每多一個字元就多乘一個小於 1 的數，所以「找總機率最高」同時也在「找比較短的」。這裡效果很小，因為每句都是 21～38 個字元（相關係數只有 0.061），但方向看得到：總分前 10 名平均 28.8 個字元，改用每字元平均之後的前 10 名是 36.5。在翻譯那種候選長度差好幾十個 token 的場合，沒修正的 beam 會直接把句子砍短。修正法是除以 length ** alpha——一個有慣例、沒有推導的 heuristic，所以論文才會把 alpha 當超參數報出來。它就是。</p><p><strong>而且跟 beam 要 n 個答案，它給你 n 個鄰居。</strong> 它的 16 個最佳句全都是不同字串，所以數「幾句不重複」什麼也看不出來；數主詞就看得出來：那 16 句只有 8 個不同的「冠詞＋形容詞＋名詞」主詞，而從同一個模型抽 16 句有 12.8 個。這不是要修的缺陷：beam 在找最可能的輸出，而最可能的那些輸出本來就彼此相似。所以 beam search 適合<strong>只有一個正確答案</strong>的任務（翻譯、語音辨識、受限抽取），聊天模型要用前一天的取樣。</p><h3>Speculative decoding：什麼都不改，只是更快</h3><p>decode 慢的原因跟算術無關：每產生一個 token，都要把整個模型的權重從記憶體讀過一遍。所以問題不是「怎麼算得更快」，而是「一次把權重讀過去，能多吐幾個 token」。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*50PEm-Gy93AXmIdz" /></figure><p>便宜的 draft 模型一個一個抽出 gamma 個提議 — — 沒關係，它便宜。然後昂貴的 target 模型<strong>一次 forward 就驗證全部 gamma 個</strong>，因為「對 gamma 個位置計分」是一次 forward，而「產生它們」本來要 gamma 次。每個提議以 min(1, p(x)/q(x)) 的機率被接受：target 覺得它至少跟 draft 一樣可能就一定收，覺得比較不可能就以 p/q 收。第一個被拒的地方結束這一輪，而被拒的那格改從 p − q 的正部正規化後抽一個。如果全中，這一輪還白賺一個 token——因為那次驗證本來就算出了下一格的分佈。</p><h3>為什麼驗證 gamma 個 token 只要一次 forward</h3><p>整個方法站在這一步上，所以值得把「為什麼可以這樣」講清楚，而不是揮揮手帶過。</p><p>causal 模型在替位置 i 打分時，只看得到它<strong>左邊</strong>的 token。所以把 context ＋ 全部提議 接成一條序列送進去一次，就會在那一次裡產生 gamma+1 個位置各自的分佈：長度 1 的前綴早就包含在長度 gamma 的序列裡，mask 把它後面的東西全擋掉了。這跟訓練時對同一條序列做一次 forward（teacher forcing）是<strong>同一個計算</strong>——模型本來就不需要自己的輸出才能替 token 打分，只需要它左邊的 token。</p><pre>在 &#39;the old robot s&#39; 之後驗證 4 個提議：<br>  位置 0：最高是 &#39;a&#39; 0.691   提議是 &#39;a&#39;<br>  位置 1：最高是 &#39;n&#39; 0.499   提議是 &#39;n&#39;<br>  位置 2：最高是 &#39;g&#39; 0.996   提議是 &#39;g&#39;<br>  位置 3：最高是 &#39; &#39; 0.996   提議是 &#39; &#39;<br>  位置 4：最高是 &#39;i&#39; 0.296   ← 白賺的那一個</pre><p>五個分佈，一次 forward。而一次 forward 只把權重讀一遍，產生同樣這些 token 則要一個 token 讀一遍 — — 省下來的就是這個。這也說明了它是「拿算力換頻寬」，而這個交換是有極限的，就是本文最後一節。</p><h3>接受規則到底做了什麼：答案完全沒有變</h3><pre>acc   = minimum(1, p / q)<br>kept  = q * acc                      # 撐過硬幣的那部分質量<br>rest  = 1 - kept.sum()               # 拒絕的機率<br>resid = maximum(p - q, 0); resid /= resid.sum()<br>out   = kept + rest * resid          # == p</pre><p>在三個 context 上實測，out 跟 p 的最大差距是 1e-16。那是浮點數，不是近似：你部署的模型就是回答使用者的模型，逐個 token 都是，而且跟 draft 有多爛無關。</p><p>有兩個聽起來等價的捷徑，都不是。</p><p>「draft 夠好就直接收」 — — 寫出來就知道不對，實測最多把分佈搬動 0.367。</p><p>「把硬幣拿掉：只要 target 覺得不比 draft 差就收，否則拒絕」 — — 這個看起來一點問題都沒有，而它仍然把分佈搬動最多 0.043。隨機接受才讓每個 token 被接受的質量剛好是 min(p, q)，殘差抽樣才把剩下的補回正確的位置；兩半都是承重的。而且弄錯不會噴任何例外，模型只是默默變成另一個模型。</p><h3>兩個旋鈕</h3><p>第一個：draft 有多好。</p><pre>draft order  接受率  每輪 token  合文法<br>-----------  ------  ----------  ------<br>1            0.173   1.69        93%<br>2            0.605   3.42        93%<br>3            0.837   4.35        90%<br>5            0.929   4.72        88%</pre><p>先看最後一欄：它不動，而且<strong>本來就不該動</strong>。輸出分佈完全不依賴 draft，所以爛 draft 只會讓你慢，不會讓你錯。正是這個性質讓 speculative decoding 可以預設打開，而不是一個要跟品質談判的交易。</p><p>第二個：猜多遠。</p><pre>gamma  接受率  實測每輪 token  獨立假設的理論  加速<br>-----  ------  --------------  --------------  -----<br>1      0.911   1.91            1.91            1.74x<br>2      0.910   2.82            2.74            2.35x<br>4      0.842   4.37            3.65            3.12x<br>8      0.760   7.08            3.82            3.94x</pre><p>理論那欄是教科書的 (1 − a^(γ+1))/(1 − a)，假設每個提議<strong>獨立</strong>以 a 的機率被接受。gamma=8 時實測 7.08，理論只有 3.82。公式沒錯，是假設錯了：接受是高度<strong>相關</strong>的——draft 在可預測的整段（…in the gar|den.）會連續全中，只在分岔點出錯，所以長串連續接受比同樣平均的硬幣常見得多。這也正是實務上大家報「每輪平均接受長度」而不是接受率的原因。</p><h3>猜一棵樹，而不是一條鏈</h3><p>chain 把 gamma 個被驗證的位置全花在深度上：一路往前猜。tree 則拿一部分去放<strong>同一個位置的備胎</strong> — — 同一次 forward 裡驗證兩個候選。第一個被拒絕時直接試兄弟，而且中間會更新殘差分佈，所以吐出來的 token 仍然<strong>完全</strong>來自 target 分佈。</p><pre>draft    chain 每輪 token  tree 每輪 token  每個被驗證位置換到的 token<br>-------  ----------------  ---------------  --------------------------<br>order 1  1.65              1.96             chain 0.41 / tree 0.68<br>order 2  3.54              3.32             chain 0.88 / tree 0.91<br>order 3  4.41              3.72             chain 1.10 / tree 0.97</pre><p>這是一個交叉點。draft 爛的時候第一個候選常常被拒，備胎會救回整輪：tree 每輪吐更多 token，<strong>而且</strong>用掉的位置還更少。draft 準的時候第一個候選幾乎都中，每個備胎就是一個什麼都沒買到的位置，chain 反而贏。</p><p>這就是 EAGLE 那種 tree draft 在真實伺服器上的全部論點，也是它為什麼給你一個 topk 旋鈕而不是寫死一個形狀：正確的形狀取決於你實際拿到的接受率。</p><h3>什麼時候 speculation 反而變慢：batch size</h3><p>前面量的都是「每輪幾個 token」，那是必要條件，不是充分條件。speculative decoding 是拿算力換記憶體頻寬，而算力會用完。</p><p>一次 decode step 要把整個模型讀一遍。70B 級的模型大約是 140 GB 權重 ÷ 5 TB/s ＝ 28 ms 的讀取，而每個 token 的算術大約 140 GFLOP ÷ 1 PFLOP/s。speculation 把「每條序列一個位置」變成 gamma+1 個，也就是同一次讀取上疊更多算術：</p><pre>batch  一般 step  speculative step  加速<br>-----  ---------  ----------------  -----<br>1      28.0 ms    28.0 ms           4.41x<br>8      28.0 ms    28.0 ms           4.41x<br>32     28.0 ms    28.0 ms           4.41x<br>128    28.0 ms    89.6 ms           1.38x<br>512    71.7 ms    358.4 ms          0.88x</pre><p>batch 1 的時候算術單元在空轉等權重，多驗幾個位置完全免費，所以加速就是每輪吐出的 token 數。一旦算術把那次讀取填滿，每個多出來的位置都要花真的時間，而被拒絕的那些就是純浪費 — — batch 512 時這個設定<strong>比不做 speculation 還慢</strong>。</p><p>所以伺服器會依照當下跑著的 batch size 決定要不要開，而不是全域打開；也因此，在一台閒置機器上量到的接受率，幾乎沒辦法告訴你它在負載下會怎樣。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iGZZ4vAkM2MV88yk" /></figure><h3>在 SGLang 裡</h3><pre>python -m sglang.launch_server --model ... \<br>    --speculative-algorithm EAGLE3 \<br>    --speculative-draft-model-path &lt;eagle head&gt; \<br>    --speculative-num-steps 3 \        # draft 深度<br>    --speculative-eagle-topk 4 \       # 每層保留幾個分支<br>    --speculative-num-draft-tokens 8   # 每輪驗證幾個節點</pre><p>值得理解的是 --speculative-eagle-topk：它讓 draft 變成一棵<strong>樹</strong>而不是一條鏈——每層留好幾個分支，然後用一個「只看得到自己祖先」的 attention mask，一次 target forward 驗證整棵樹。同一次昂貴的 forward 裡塞進更多候選，跟上面那個取捨一樣，只是形狀更好。而 --speculative-algorithm NEXTN 是給自己帶額外預測頭的模型用的（DeepSeek-V3、GLM 的 MTP 層），draft 內建在 target 裡。</p><p>還有一件這些表格顯示不出來的事。在真實伺服器上，要看的數字是「每輪接受長度」<strong>對 batch size</strong>。speculative decoding 是拿算力換記憶體頻寬，所以在 decode 被頻寬卡住的時候會贏（小 batch、長 context），在大 batch 下可能反而輸 — — GPU 本來就滿載，每個被拒絕的提議都是花掉而什麼也沒買到的算力。</p><h3>在 vLLM 裡</h3><p>beam search 已經不是取樣參數了，它被搬出 SamplingParams，變成自己的呼叫：</p><pre>llm.beam_search(prompts, BeamSearchParams(beam_width=4, max_tokens=64))</pre><p>理由就是上面那行成本：它是對序列的搜尋，要分叉與釋放 w 份 KV cache，而不是「每個 token 一條規則」，所以不該跟 temperature 放在同一個物件裡。</p><p>speculative decoding 則是伺服器端設定：</p><pre>vllm serve meta-llama/Llama-3.1-70B-Instruct \<br>  --speculative-config &#39;{&quot;model&quot;: &quot;meta-llama/Llama-3.1-8B-Instruct&quot;,<br>                         &quot;num_speculative_tokens&quot;: 5}&#39;<br><br># 或者，根本不用 draft 模型：<br>  --speculative-config &#39;{&quot;method&quot;: &quot;ngram&quot;, &quot;num_speculative_tokens&quot;: 4,<br>                         &quot;prompt_lookup_max&quot;: 4}&#39;</pre><p>ngram 就是本文那個 draft 模型在生產環境的樣子，而且它不跑任何神經網路：直接在 prompt 裡找相同的字串，把上次接在後面的那一段當提議。摘要、改程式碼、RAG——任何「答案大量重複輸入」的場合——幾乎是免費的而且效果好得驚人。EAGLE 與 Medusa 則是另一端：用 target 模型自己的 hidden state 訓一個小頭，接受率高很多，而且不需要第二個完整模型。</p><h3>這一天之後會在哪裡再出現</h3><p>對序列做 beam search，形狀跟圖論那幾天的搜尋是同一個：展開邊界、計分、剪枝，而錯誤永遠住在剪枝那一步。而 speculative decoding 的接受／拒絕規則就是 rejection sampling，往後只要有演算法需要「從一個只能逐點求值的分佈抽樣」就會再看到它 — — 強化學習裡到處都是。</p><p>程式碼、notebook 與互動版走查：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2060%20-%20beam%20search%20and%20speculative%20decoding">day 60 on GitHub</a>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3c3bbef5a15" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-60-beam-search-%E8%88%87-speculative-decoding-%E4%B8%80%E5%80%8B%E5%8E%BB%E6%89%BE%E6%9B%B4%E5%A5%BD%E7%9A%84%E5%8F%A5%E5%AD%90-%E4%B8%80%E5%80%8B%E8%AE%93%E5%90%8C%E4%B8%80%E5%8F%A5%E8%A9%B1%E4%BE%86%E5%BE%97%E6%9B%B4%E5%BF%AB-d3c3bbef5a15">Day 60 — Beam search 與 speculative decoding：一個去找更好的句子，一個讓同一句話來得更快</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 59 — 取樣策略：怎麼讓模型不要每次都講同一句話，又不會開始胡說]]></title>
            <link>https://medium.com/100-days-of-python/day-59-%E5%8F%96%E6%A8%A3%E7%AD%96%E7%95%A5-%E6%80%8E%E9%BA%BC%E8%AE%93%E6%A8%A1%E5%9E%8B%E4%B8%8D%E8%A6%81%E6%AF%8F%E6%AC%A1%E9%83%BD%E8%AC%9B%E5%90%8C%E4%B8%80%E5%8F%A5%E8%A9%B1-%E5%8F%88%E4%B8%8D%E6%9C%83%E9%96%8B%E5%A7%8B%E8%83%A1%E8%AA%AA-b8740d7f056f?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/b8740d7f056f</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 02:00:34 GMT</pubDate>
            <atom:updated>2026-11-17T02:00:34.111Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2059%20-%20sampling%20strategies">day 59 on GitHub</a></p><p><em>100 Days of Python — day 59</em></p><p>同一個模型、同一個開頭，三種用法。每一步都取機率最大的字元：它會寫出一句話 — — 而且永遠是同一句，儘管它的文法允許 1,250 句。把 temperature 調到 2.0 照機率抽：100 個樣本裡，合文法的有 0 句。保持同樣的 2.0，只多加一條過濾規則：100 個樣本裡有 96 句不重複的話，而且每一句都合文法。</p><p>這三次模型本身完全沒變。變的是「怎麼把模型的輸出變成一個 token」這條規則，也就是今天的主題。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VlO97Iyu9y4zHPQx" /></figure><h3>這一天在系列裡的位置</h3><p>前面幾天先把會產生 logits 的東西蓋出來，然後讓它跑得便宜：KV cache、共用前綴的 radix tree、管顯存的分頁配置器。這些工作最後都停在同一個地方 — — 一個長度等於詞彙表大小的分數向量。取樣是它之後的那一步，也是這份清單裡唯一一個會改變模型<strong>說什麼</strong>、而不是說得多快的旋鈕。</p><p>為了讓「說什麼」可以被量，今天的模型是一個字元 8-gram，訓練語料是用一個小文法產生的 1,500 句：冠詞 ＋（可選的）形容詞 ＋ 五個名詞之一 ＋ 五個動詞之一 ＋ 五個地點之一。這個文法剛好允許 1,250 句，所以任何一行生成結果都可以用 parser 檢查。於是底下每個數字都是 100 個樣本的比率：幾句合文法、出現了幾句不重複的話 — — 不是靠感覺。</p><h3>一步看起來很乾淨，一句話就不是了</h3><p>context 是 &#39;the small cat &#39; 的時候，模型給 s 0.61、r 0.22、w 0.16，剩下 21 個字元加起來 0.31%。entropy 是 1.39 bits，而「機率加起來到 0.9 的最小集合」只有 3 個字元。</p><p>問題就在那 0.31%，而且它要乘開來才看得出來。一句話大約 30 步，所以「中途至少踩到一次不可能的字元」的機率是 1 − 0.996⁹³⁰ ＝ 9.0%。而且踩到一次就夠了：接下來模型得從一個它沒看過的前綴繼續寫，後面整句都是亂猜。真實模型的尾巴不是 21 個字元，是十幾萬個 token，每一個都不可能。</p><p>最直覺的解法是乾脆不要抽 — — 每一步都取最大值。這確實有效：100 個 greedy 樣本 100% 合文法。但它們是 1 句不重複的話。greedy 不是「比較差的取樣」，是完全沒有取樣。</p><h3>greedy 連「最可能的那句話」都不是</h3><p>在把 greedy 放下之前，值得看一下它在「它看起來正在做的那件事」上做得多差。文法只允許 1,250 句，少到可以全部列出來、而且每一句都精確算出機率 — — 一句話的 log 機率就是它每一步 log 機率的總和。</p><pre>整句機率最高的   &#39;a small dog sat in the garden.&#39;   log p = -6.244<br>greedy 給的      &#39;the red cat sang in the garden.&#39;  log p = -6.717，1,250 句裡排第 44</pre><p>greedy 每一步都取機率最高的字元，結果落在第 44 名，比最好的那句低 1.61 倍。原因是結構性的、不是這個模型的怪癖：某個在當下很有吸引力的字元會把你帶進一個「之後沒有好結尾」的前綴，而逐步規則回不了頭。<strong>逐步 argmax ≠ 序列 argmax。</strong> 這個落差就是「在序列上搜尋」會是另一種 decoding 策略、而不是在這裡調個參數就好的全部理由。</p><p>全部列舉還順便買到兩個免費的驗證。這 1,250 句佔掉模型「句子層級」機率的 90.9%，而 t = 1.0 實際抽樣量到的合文法率是 90%。另外，從這個分佈抽 100 句、期望會有 87.3 句不重複，實測是 88。理論跟抽樣對得上，所以本文其餘的比率可以信。</p><h3>temperature</h3><p>temperature 在 softmax 之前把 logits 除掉。小於 1 會放大分數之間的差距、讓分佈變尖；大於 1 會縮小差距、讓分佈變平；等於 0 的時候所有實作都走另一條 argmax 的路，不是真的去除以零。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-q8xCkuYOM7hTHnK" /></figure><p>兩欄要一起看。t = 0.7 時 100 個樣本給出 98 句不同的話，而且每一句都合文法 — — 這就是實務上預設值大多落在 0.6～0.9 的原因：在這個區間，多出來的隨機性幾乎都落在模型本來就覺得差不多的分岔點上。t = 1.3 剩 55%，t = 1.7 剩 5%。</p><p>有趣的是紫色那一欄也跟著掉。亂到一個程度之後就不再換到多樣性了 — — 壞掉的句子不算另一種說法 — — 所以這不是「用正確性換多樣性」，是兩個一起輸。而且崩得很快：t 從 1.0 到 1.7，entropy 只從 0.34 漲到 1.18 bits，正確率卻從 90% 掉到 5%。</p><h3>截斷：熱度留著，尾巴剪掉</h3><p>所以把 temperature 釘在最糟的 2.0，只改「哪些 token 可以被抽到」。</p><pre>規則                 合文法      不重複句數<br>不截斷                    0%          0<br>top-k 1（＝greedy）     100%          2<br>top-k 3                   0%          0<br>top-p 0.9                 2%          2<br>top-p 0.7                89%         85<br>top-p 0.5               100%         80<br>min-p 0.1               100%         96<br>typical 0.9               2%          2<br>typical 0.5              94%         84</pre><p>隨機性從來不是問題。被拿掉的是裡面「本來就不可能對」的那一部分。</p><p>這張表有兩個要誠實講的地方。top-k 1 是 greedy 換個名字，所以它那個滿分沒有意義。另外我們的詞彙表只有 24 個字元、不是 15 萬個 token，所以門檻值不能照搬——p = 0.5 對真模型來說是很兇的設定。能搬的是這張表的形狀：會自己調整的規則贏過只會數數的規則。</p><h3>為什麼是質量，不是數量</h3><p>掃過整份語料，下一個 token 的分佈分成兩種。249 步裡有一個字元機率超過 90% — — 模型很有把握，因為文法沒給它別的選擇。另外 61 步沒有任何字元超過 90% — — 模型站在分岔點上，四五個選項幾乎一樣高。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7Wy9kWDpRowWMhbq" /></figure><p>現在同一個 k 套在兩種步上。k = 1 時，有把握的那一步只丟掉 0.45% 的質量，那純粹是平滑造成的雜訊，無所謂；沒把握的那一步丟掉 54%，那是模型真正的意見被丟掉。把 k 調大到讓後者滿意，前者就開始把垃圾放進來 — — 而那些垃圾就是前面講的尾巴。</p><p>top-p 問的是另一個問題：留下「機率加起來剛好到 p」的最小集合。<strong>數量</strong>於是自己跟著分佈的形狀跑 — — 上圖有把握的那一步留 2 個、沒把握的那一步留 5 個，整份語料平均是 1.0 對 3.46。這就是 nucleus sampling 這個名字的意思：核心有多大是分佈決定的，不是你決定的。</p><p>min-p 站第三個位置：留下所有「至少值最佳 token 某個比例」的 token。它跟 top-p 一樣會自己鬆緊，而且實作上只是每個 token 比較一次 — — 不用排序、不用累積和 — — 這也是它在上面那張表裡撐過 temperature 2.0 的原因。</p><h3>第三種問法：typical sampling</h3><p>top-k 問的是數量，top-p 問的是質量。locally typical sampling 兩個都不問：它留下「意外程度 −log p 最接近這一步熵值」的 token。背後的主張是，自然語言並不是每個位置都挑最好猜的那個詞 — — 它每個詞攜帶的資訊量大致固定 — — 所以一個「比這一步的平均還要理所當然」的 token，跟一個「比平均還要意外」的一樣不典型。</p><p>在這份語料上，兩條規則其實從來沒分開過。1,875 個步驟裡，typical 0.9 每一次都跟 top-p 留下同樣數量的 token，而且一次都沒有把最可能的那個丟掉 — — 這也是上面那張表裡 typical 兩列幾乎貼著 top-p 兩列的原因。這件事要講出來而不是藏起來：24 個字元的詞彙表根本沒有空間讓兩條規則不一致，而這正是玩具模型照不出來的那種差別。</p><p>所以這裡刻意造一個會讓它們分開的分佈 — — 一個獨大的 token、一個中間群、一條很長的平尾，熵 2.28 nats：</p><pre>獨大的, p=0.60      意外程度 0.51    離熵 1.77<br>中間群, p=0.03      意外程度 3.51    離熵 1.23<br>尾巴,   p=0.0001    意外程度 9.21    離熵 6.93</pre><p>跟兩條規則都要 0.25 的質量：top-p 留 1 個，就是那個獨大的。typical sampling 留 9 個 — — 而且<strong>把最可能的那個整個丟掉</strong>，因為中間群才是攜帶典型資訊量的那一組。top-p 用機率排序，typical sampling 用「離預期意外程度多遠」排序。在 15 萬個 token 的詞彙表上這是真的會造成行為差異的；而它跟本文其他東西用的是同一個掛鉤：一個判斷式，在 softmax 之前作用在 logits 上。</p><h3>順序會改變答案</h3><p>同時設 temperature=2.5 和 top_p=0.9，有兩種跑法，而它們給的是不同的分佈：</p><ul><li>先 temperature 再 top-p：18 個候選，最高機率 0.394</li><li>先 top-p 再 temperature：2 個候選，最高機率 0.545</li></ul><p>先壓平的話，要湊滿 0.9 就得收更多 token，所以 nucleus 跟著熱度一起變寬。先截斷的話，候選集合是用「冷的」形狀決定的，加熱只是在裡面重新分配。兩者的 total variation distance 是 0.276 — — 不是小數點後的差別，是不同的 sampler。</p><p>我看過的伺服器一律是 penalties → temperature → top-k → top-p。這是慣例不是定理，而且它正好解釋了上面那張表：top-p 0.9 救不回 t = 2.0，就是因為 nucleus 是在壓平之後才量的。</p><h3>一個不會報錯的錯</h3><p>截斷會把一些 token 設成 0，而原本在它們身上的質量總得有個去處：</p><pre>cut = np.partition(p, -k)[-k]<br>q = np.where(p &gt;= cut, p, 0.0)      # 只剩 0.9969<br># q /= q.sum()                      &lt;- 忘了這一行</pre><p>把沒有重新正規化的 q 丟給累積和取樣器，0.27% 的抽樣會掉到陣列尾端之外。在 C++ 裡那是讀到界外；在 Python 裡它會無聲地變成夾到的那個索引，也就是對某一個特定 token 的偶發、而且不可重現的偏誤。每一條過濾規則最後都必須除以留下來的質量。</p><h3>在 GPU 上，top-p 根本不排序</h3><p>真實詞彙表大約 15 萬個 token，而取樣是「每個序列每一步」都要做一次，所以最直覺的作法 — — 排序、累積和、切 — — 是落在伺服器吐出的每一個 token 的關鍵路徑上。完整排序大約 2.6M 次元素比較，部分的 top-50 選擇大約 0.15M。</p><p>但 top-p 其實不需要順序。把它改寫成：<strong>找一個機率門檻，讓門檻以上的質量剛好超過 p</strong>。這在一維上是單調的，所以可以二分：</p><pre>lo, hi = 0.0, p.max()<br>for _ in range(24):<br>    mid = (lo + hi) / 2<br>    mass = p[p &gt;= mid].sum()        # 一次對整個詞彙表的 reduction<br>    lo, hi = (mid, hi) if mass &gt;= thr else (lo, mid)</pre><p>24 輪「比較 ＋ 加總」，全程沒有任何排序，而留下來的集合跟排序版完全一樣。</p><h3>在 SGLang 裡</h3><p>走 HTTP：</p><pre>curl localhost:30000/generate -d &#39;{<br>  &quot;text&quot;: &quot;...&quot;,<br>  &quot;sampling_params&quot;: {&quot;temperature&quot;: 0.8, &quot;top_k&quot;: 50, &quot;top_p&quot;: 0.95,<br>                      &quot;min_p&quot;: 0.0, &quot;repetition_penalty&quot;: 1.1,<br>                      &quot;frequency_penalty&quot;: 0.2, &quot;n&quot;: 4}}&#39;</pre><p>這一邊值得看的是 kernel。--sampling-backend pytorch 是參考實作，會真的排序；--sampling-backend flashinfer 用的是融合過的 top-k/top-p kernel，底下就是上面那個門檻搜尋。同一個分佈、不同的成本——而且因為 decode 每一步都要取樣，這個差別會直接進到 ITL（token 之間的延遲），不是出現在某張 benchmark 上而已。</p><p>SGLang 另外開了 custom logit processor 這個掛鉤，而它比聽起來有意思。本文每一條規則本質上都是同一個動作：在 softmax 之前把某些 logit 設成 −inf。把判斷式從「機率太小」換成「這個 token 會讓 JSON 不合法」，那就是 structured output；換成「這個詞被禁用」，那就是內容過濾。同一個掛鉤，不同的條件。</p><h3>在 vLLM 裡</h3><p>上面所有東西就是一個物件：</p><pre>from vllm import LLM, SamplingParams<br><br>out = LLM(&quot;Qwen/Qwen3-8B&quot;).generate(prompts, SamplingParams(<br>    temperature=0.8, top_k=50, top_p=0.95, min_p=0.0,<br>    repetition_penalty=1.1, seed=1234,<br>    n=4, logprobs=5, max_tokens=256, stop=[&quot;\n\n&quot;]))</pre><p>temperature=0 走 argmax 那條路，不是真的去除。repetition_penalty 在 temperature <strong>之前</strong>改 logits，把已經出現過的 token 的分數除掉。seed 給這個請求自己的亂數產生器——收到客訴要重現問題時，通常就只剩這個把手可以抓。logprobs=5 回傳的就是本文第一張圖的前五列。n=4 是同一個 prompt 抽四次——KV 那一半前一天已經用 refcount 和 copy-on-write 解決了，今天加的只是四顆不同的骰子。</p><p>SamplingParams 是 per-request 的，但 sampler 本身是每一步跑一次、整個 batch 一起：所有在跑的序列進同一個 kernel，各自帶著自己的 temperature 和門檻。</p><h3>這一天之後會在哪裡再出現</h3><p>「對一組價值做帶 temperature 的 softmax，用來決定要選最好的還是去試試看比較差的」 — — 這正是多臂拉霸機（multi-armed bandit）裡的 Boltzmann exploration。而 temperature 那張表裡的 entropy 欄位，就是 policy gradient 目標函數裡那個 entropy 項的同一個量，理由也一樣：避免策略塌縮到單一動作，就像 greedy decoding 塌縮到單一句話那樣。</p><p>Speculative decoding 要的東西比今天更強：draft 模型一次提好幾個 token，真模型逐個接受或拒絕，而那條接受規則必須讓今天這個分佈<strong>完全不變</strong> — — 抽得更快，但不能抽得不一樣。</p><p>程式碼、notebook 與互動版走查：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2059%20-%20sampling%20strategies">day 59 on GitHub</a>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8740d7f056f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-59-%E5%8F%96%E6%A8%A3%E7%AD%96%E7%95%A5-%E6%80%8E%E9%BA%BC%E8%AE%93%E6%A8%A1%E5%9E%8B%E4%B8%8D%E8%A6%81%E6%AF%8F%E6%AC%A1%E9%83%BD%E8%AC%9B%E5%90%8C%E4%B8%80%E5%8F%A5%E8%A9%B1-%E5%8F%88%E4%B8%8D%E6%9C%83%E9%96%8B%E5%A7%8B%E8%83%A1%E8%AA%AA-b8740d7f056f">Day 59 — 取樣策略：怎麼讓模型不要每次都講同一句話，又不會開始胡說</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 58 — PagedAttention 其實是一個記憶體配置器：block table、copy-on-write，以及 KV 池滿了之後怎麼辦]]></title>
            <link>https://medium.com/100-days-of-python/day-58-pagedattention-%E5%85%B6%E5%AF%A6%E6%98%AF%E4%B8%80%E5%80%8B%E8%A8%98%E6%86%B6%E9%AB%94%E9%85%8D%E7%BD%AE%E5%99%A8-block-table-copy-on-write-%E4%BB%A5%E5%8F%8A-kv-%E6%B1%A0%E6%BB%BF%E4%BA%86%E4%B9%8B%E5%BE%8C%E6%80%8E%E9%BA%BC%E8%BE%A6-4cbe803b2904?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/4cbe803b2904</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 16:19:20 GMT</pubDate>
            <atom:updated>2026-11-16T16:19:20.326Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2058%20-%20paged%20attention%20memory">day 58 on GitHub</a></p><p><em>100 Days of Python — day 58</em></p><p>PagedAttention 裡屬於 attention 的部分其實很小：K 和 V 改成透過一張 block table 讀，而不是從一條平坦的陣列讀。真正讓它值得做的東西全都在那一層 indirection 的外面 — — 固定大小的 block 怎麼發、池子滿了怎麼拒絕、同一個 prompt 的多個樣本怎麼共用、以及要從<strong>已經在跑</strong>的請求手上把 block 收回來時該怎麼辦。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*7reV0RKUCKFHSy-g" /></figure><p>每個請求擁有一張 block table — — 裡面是 block 的編號，不是位址 — — 而 block 全部住在一座大家共用的池子裡。一個 block manager 負責按需求發放、用 reference count 讓兩個請求可以指向同一個 block、並決定沒得發的時候要做什麼。這是一套作業系統，不是一種 attention 變體，所以今天幾乎整天都在講配置。</p><h3>為什麼要分頁：空間有，但形狀不對</h3><p>先給連續配置最好的待遇：假設它<strong>事先就知道</strong>每個請求最後會多長，所以完全不會多保留。即使如此它還是輸。</p><pre>240 個請求、16,384 個 slot 的池子  拒絕  其中「空位夠但不連續」  平均佔用率<br>---------------------------------  ----  ----------------------  ----------<br>一個請求一段連續空間               12    12                      65.7%<br>固定大小 16 個 token 的 block      5     -                       68.5%</pre><p>連續配置拒絕掉的每一個請求，都是在「池子裡的空位總量其實夠」的情況下被拒絕的。空間存在，只是被切成太小的碎塊：這就是<strong>外部碎片</strong>，作業系統課本上的那個。固定大小的 block 從結構上消滅了這個問題 — — 任何一個空 block 都一樣好用，所以配置只剩下「夠不夠」一個問題。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*_JosjefWg11_1UtK" /></figure><h3>分頁的代價</h3><p>每個請求最後一個 block 的尾巴會浪費掉，而且每個 block 都要在 block table 裡佔一筆：</p><pre>每個 block 幾個 token  浪費掉的 slot  block table 的項目數<br>---------------------  -------------  --------------------<br>1                      0.0%           201,736<br>8                      0.4%           25,318<br>16                     0.9%           12,721<br>64                     3.5%           3,266<br>256                    12.5%          901</pre><p>一個 token 一個 block 什麼都不浪費，但每個 token 都要一筆；256 個 token 一個 block 的索引少了 224 倍，卻丟掉池子的八分之一。實務上都落在小的那一端，而且理由不只是浪費：<strong>block 也是前綴共用能對齊的最小單位</strong>，block 越大、能共用的前綴就越粗。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*wQajPLcT7krFu90V" /></figure><h3>共用一個 prompt，以及 copy-on-write</h3><p>因為 block table 只是一串編號，共用幾乎不用寫什麼程式：</p><pre>def share(self, src, dst, tokens):<br>    shared = self.table[src][:self.blocks_for(tokens)]<br>    for b in shared:<br>        self.refs[b] += 1          # reference count 讓它們活著<br>    self.table[dst] = list(shared)</pre><p>一個 900 個 token 的 prompt 要四個樣本：天真做法要 228 個 block，共用之後是 <strong>60</strong> 個，少了 74%。唯一麻煩的是 prompt 的最後一個 block，它沒裝滿 — — 而每個樣本接下來都要把<strong>自己的</strong>下一個 token 寫進去，所以各自複製那一個 block。複製一個 block 而不是整個 prompt，這就是 copy-on-write，跟 fork() 用的是同一招。</p><h3>池子滿了的時候</h3><p>一定要有人把 block 吐回來，而付帳的方式恰好只有兩種。60 個請求對上 4,096 個 slot：</p><pre>政策        收回次數  代價<br>----------  --------  -----------------------------<br>重算        54        3,840 個 token 重新 prefill<br>換出到主機  51        5,696 個 token 搬出去再搬回來</pre><p>兩種都把 60 個請求全部跑完了。<strong>算力或頻寬</strong> — — 跟前一天那個分層快取是同一個取捨，只是換了一層。第三種選項「什麼都不做」的結果是池子被做到一半的請求塞滿，然後全部卡死。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FL_pvIWHDpQweYN4" /></figure><h3>兩個不會報錯的壞法</h3><p><strong>永遠沒被釋放的 block。</strong> 200 個請求、十分之一走到一條忘記釋放的失敗路徑：漏掉 617 個 block ＝ 65,536 個 slot 裡的 9,872 個，而且再也回不來。什麼都不會報錯，伺服器只是越來越收不下請求，而這個 bug 回報上來的樣子是「跑幾個小時之後吞吐量就掉了」。抓它的方法是一條不變式，在伺服器閒置時檢查：<strong>空的 block ＋ 所有 block table 裡的 block ＝ 池子大小</strong>。</p><p><strong>忘了最後一個 block 裝了多少。</strong> 70 個 token 佔 5 個 block ＝ 80 個 slot，所以最後 10 格裡是上一個用過這些 slot 的人留下來的東西。kernel 需要 block table <strong>和</strong>真正的序列長度兩樣，而 mask 必須用後者。用補滿後的長度也不會崩潰：softmax 照樣加總為 1，模型只是安靜地把一小時前某個請求的 KV 也平均了進去。</p><h3>在 vLLM 裡</h3><p>PagedAttention 就是從 vLLM 來的，它的旗標跟上面的程式碼一一對應：</p><pre>vllm serve meta-llama/Llama-3.1-8B \<br>    --block-size 16 \                # 每個 block 幾個 token<br>    --gpu-memory-utilization 0.90 \  # KV 池可以拿走多少顯存<br>    --max-num-seqs 256 \             # 同時在跑的序列上限<br>    --swap-space 4 \                 # 換出用的主機記憶體（GiB）<br>    --enable-prefix-caching          # 跨請求重用 block</pre><p>它啟動時會先 profiling：量出權重和活化值佔掉多少，剩下的乘上 --gpu-memory-utilization，再除以「每個 block 幾個 byte」得到 block 數。--block-size 就是這個檔案裡的 PagedPool.block；每個請求的 BlockTable 就是 table[rid]；ref_count 加上 copy-on-write 就是 refs[b]。</p><pre>llm = LLM(model=..., block_size=16, gpu_memory_utilization=0.9)<br>out = llm.generate(prompt, SamplingParams(n=4))   # 四個樣本共用 prompt 的 block</pre><p>SamplingParams(n=4) 不會把 prompt 的 KV 複製四份——四條序列指向同一批 block、refcount 變成 4，只有那個沒裝滿的最後一個 block 在寫入時被複製。而 --enable-prefix-caching 是把同一招用在<strong>不同請求之間</strong>：以整個 block 為單位算雜湊。</p><p>池子滿了的時候 vLLM 會直接講：Sequence group ... is preempted by PreemptionMode.RECOMPUTE。偶爾出現是正常的；一直刷就代表池子配不上你要的併發度，而解法是把 --gpu-memory-utilization 調大、--max-num-seqs 調小，或是用 --swap-space 改成付頻寬。</p><h3>在 SGLang 裡</h3><p>同樣的零件，不同的名字和預設值：</p><pre>python -m sglang.launch_server --model-path meta-llama/Llama-3.1-8B \<br>    --mem-fraction-static 0.9 \      # KV 池拿多少顯存<br>    --page-size 1 \                  # 每頁幾個 token（預設 1）<br>    --max-running-requests 256 \     # decode batch 上限<br>    --chunked-prefill-size 8192 \    # 把長 prefill 切塊<br>    --max-total-tokens 200000        # 或直接指定池子大小</pre><p>有兩個差別值得知道。SGLang 的 page 預設是<strong>一個 token</strong> — — 也就是上面那張浪費表最左邊那一欄：零內部碎片，代價是索引很長。它付得起，是因為索引是 GPU 上的一張 req_to_token_pool tensor，而不是每個請求一個 Python list；slot 本身則放在 token_to_kv_pool。這兩個結構正好就是這個檔案裡的 PagedPool.table 和 PagedPool.free。</p><p>而池子滿了的時候，SGLang 選擇 <strong>retract</strong>（收回）而不是換出：請求回到等待佇列、slot 釋放、之後重跑。理由正好是前一天那棵樹 — — 被收回的請求的前綴多半還在 radix cache 裡，所以「重算」其實只重算沒命中的那一小段。--chunked-prefill-size 則是另一道防線：把長 prefill 切成小塊，讓它不會一次吃掉整個池子，也不會讓 decode 停太久。</p><p>兩個系統在預設值上意見不同，在結構上完全一致：一座固定的 slot 池、每個請求一張表、共用靠 reference count、滿了有一套政策。</p><h3>這些東西之後會用在哪</h3><p>服務系統給你的每一個旋鈕，都是上面四件事之一：block 多大、池子多大、誰可以跟誰共用、滿了要怎麼辦。把設定檔當成「block size、pool size、共用政策、preemption 政策」來讀，那些旗標就不再是口耳相傳的魔法 — — 而且當症狀是「在排隊」而不是「token 很慢」時，你會知道該動哪一個數字。</p><p>程式碼和互動式走查都在 repo：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2058%20-%20paged%20attention%20memory">day 58 on GitHub</a>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cbe803b2904" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-58-pagedattention-%E5%85%B6%E5%AF%A6%E6%98%AF%E4%B8%80%E5%80%8B%E8%A8%98%E6%86%B6%E9%AB%94%E9%85%8D%E7%BD%AE%E5%99%A8-block-table-copy-on-write-%E4%BB%A5%E5%8F%8A-kv-%E6%B1%A0%E6%BB%BF%E4%BA%86%E4%B9%8B%E5%BE%8C%E6%80%8E%E9%BA%BC%E8%BE%A6-4cbe803b2904">Day 58 — PagedAttention 其實是一個記憶體配置器：block table、copy-on-write，以及 KV 池滿了之後怎麼辦</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 57 — RadixAttention：讓開頭相同的請求共用同一份 KV cache]]></title>
            <link>https://medium.com/100-days-of-python/day-57-radixattention-%E8%AE%93%E9%96%8B%E9%A0%AD%E7%9B%B8%E5%90%8C%E7%9A%84%E8%AB%8B%E6%B1%82%E5%85%B1%E7%94%A8%E5%90%8C%E4%B8%80%E4%BB%BD-kv-cache-25ac927837e5?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/25ac927837e5</guid>
            <category><![CDATA[inference]]></category>
            <category><![CDATA[causal-inference]]></category>
            <category><![CDATA[sglang]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 14:24:55 GMT</pubDate>
            <atom:updated>2026-11-16T14:24:55.348Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2057%20-%20radix%20attention">day 57 on GitHub</a></p><p><em>100 Days of Python — day 57</em></p><p>昨天那份 cache 是一條序列自己的。但在真的伺服器上，多數請求的開頭是一模一樣的：同一段 system prompt、同樣那幾個範例、同一段對話的前幾輪。把這些 key 和 value 為每個請求再算一次，是 LLM 服務裡最大的一塊白工 — — 而 prefill 正是算力受限的那一半，所以「不用做」在這裡是能拿到的最大一筆節省。</p><p>在進入細節之前，先用一張圖把整個機制講完：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*E1EtRTytFTgSPXHY" /></figure><p>請求進來，tokenizer 把每個請求變成一串 token id，然後拿這串 id 去一棵「已經快取過什麼」的 <strong>radix tree</strong> 裡查：從 root 往下走，只要 token 還對得上就繼續，走到的那一段就不必再 prefill。樹上每個節點擁有 KV pool 裡的一段 slot，所以不管底下掛了幾段對話，<strong>共用的樹幹只存在一份</strong>；而走到一半分岔的請求會讓那條邊被切開，而不是複製一份。</p><p>下半部就是 <strong>HiCache</strong>：同一棵樹，但多了「掉下去的地方」 — — 一個節點可以住在 GPU 池、主機 DRAM，或遠端儲存，而淘汰是把它<strong>往下降級</strong>而不是刪掉。這改變了「cache miss」的意思：從「重新 prefill」變成「從慢一點的地方搬回來」。這篇文章接下來就是把這棵樹做出來、量它省了多少，再量那些額外的層值多少。</p><p>在這個檔案模擬的聊天工作量裡（20 段對話、每段 4 輪、共 80 個請求，所有人共用一段 200 個 token 的 system prompt 加兩個範例），<strong>所有 prompt token 裡有 84.6% 是在重算已經快取過的東西</strong>：總共 47,466 個 prompt token，真正沒見過的只有 7,320 個。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*kdRe4xMzRxVkIc3y" /></figure><h3>資料結構</h3><p>把快取過的 token 序列放進一棵 radix tree（Day 24），查詢就自然掉出來了：從 root 往下走，只要 token 還對得上就繼續，走到的長度就是不用重算的前綴。</p><pre>def match(self, tokens):<br>    node, i = self.root, 0<br>    while i &lt; len(tokens):<br>        child = node.children.get(tokens[i])<br>        if child is None:<br>            break<br>        j = common_prefix_len(child.key, tokens[i:])<br>        if j &lt; len(child.key):          # 在一條邊的中間分岔<br>            return i + j, child, j<br>        i += len(child.key)<br>        node = child<br>    return i, node, len(node.key)</pre><p>當一個請求走到某條邊的中間就分岔時，那條邊被切成兩段：前半變成共用的父節點，兩邊各自掛自己的尾巴。這就是 radix tree 跟一般 trie 的差別 — — <strong>邊上放的是一整串 token，不是一個</strong> — — 而且這個差別不是裝飾。同樣這些序列：</p><pre>節點數  佔用的 token slot<br>--------------------------------  ------  -----------------<br>一般 trie（一個 token 一個節點）  7,216   -<br>radix tree                        83      7,320<br>完全不共用                        -       47,466</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*WEEvbZiNDsiL9aE4" /></figure><p>分享到多少要看是哪種請求。一段對話的第一輪只分享得到 system prompt 和範例 — — 440 個 token 裡的 380 個，86%。第二輪之後連自己前面講過的也在樹上 — — 644 裡的 542，84%，而且請求本身還長了一半。同一個結構同時處理這兩種情況，而它完全不知道什麼是 system prompt、什麼是對話，它只知道前綴。</p><h3>淘汰：LRU，但只能動葉子</h3><p>池子是有限的，所以要淘汰，政策就是 Day 30 的 LRU 加上一條額外規則。把池子大小掃一遍會看到兩件事：</p><pre>池子（token slot）  佔整棵樹  命中率<br>------------------  --------  ------<br>200                 3%        0.0%<br>400                 5%        0.0%<br>600                 8%        81.0%<br>800                 11%       84.7%<br>2,000               27%       84.7%<br>7,320               100%      84.6%</pre><p>從 800 個 slot 開始命中率就不動了：用整棵樹 11% 的空間拿到 84.7%，全部給它也只是 84.6%。賺到命中的那一段是共用前綴，而<strong>只淘汰葉子的 LRU 永遠碰不到它</strong> — — 它是內部節點，底下掛著所有東西。</p><p>而再小下去不是退化，是崩掉。池子至少要裝得下共用前綴（這裡 400 個 token）再加上一個請求活得下來的量；低於那條線，每一次插入都把上一次剛寫進去的擠掉。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*6cwyOhKQjkIUH0si" /></figure><p>那條額外規則就是這東西跟普通 LRU 快取的全部差別。普通 LRU 會挑時間戳最舊的節點，而那通常正是共用前綴：所有人都是從它<strong>經過</strong>而不是停在它上面，所以沒有人去更新它的時間戳。在這份工作量上實測，一般 LRU 會挑中的那個節點自己只有 124 個 token，但跟著它一起變成不可達的有 379 個，包括掛在下面的每一段對話。正在 decode 的請求所停的節點也要用 refcount 釘住，理由一樣。</p><h3>陷阱：文字的前綴不等於 token 的前綴</h3><pre>&quot;abc&quot;  -&gt;  (5,)<br>&quot;abd&quot;  -&gt;  (4, 7)<br><br>共同的字元 2 個，共同的 token 0 個</pre><p>在一個「ab」和「abc」都是單一 token 的 tokenizer 下，兩個共用三分之二字元的字串可以一個 token 都不共用，因為合併跨過了那個邊界。用文字當 key 的快取會把一個「第二個請求裡根本不存在的 token」的 key/value 交出去 — — 形狀對、數值有限、不報錯，而模型讀到的是別人的東西。</p><p>比對一定要在 tokenizer 之後、用 token id 做。Day 51 那個 tokenizer 正是這種合併發生的地方。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SoJUtOhqDJ77Heo8" /></figure><h3>一層不夠：HiCache 與 Mooncake</h3><p>上面都假設「一張卡、一座池子」。但比較忙的伺服器會有好幾個租戶，這時樹就塞不下了：144 個請求、6 種不同的 system prompt，整棵樹要 15,175 個 slot，而 GPU 池只有 800 — — 命中率從 82.3% 掉到 <strong>68.7%</strong>，而且有 26,205 個 token 被真的丟掉、之後要重算。</p><p>解法是改變「淘汰」的意思。與其把冷掉的分支丟掉，不如<strong>降級</strong>：讓它留在樹上，只是把它的 slot 搬到慢一點的地方。</p><pre>if self.l2_capacity:<br>    victim.tier = 2              # 降級：留在樹上，離開 GPU<br>    self.size  -= len(victim.key)<br>    self.size2 += len(victim.key)<br>else:<br>    drop(victim)                 # 直接丟掉：下一個請求要重新 prefill</pre><pre>第 2 層（主機記憶體）  命中率  從第 2 層取回  真的被丟掉<br>---------------------  ------  -------------  ----------<br>沒有                   68.7%   0              26,205<br>1,600 slot（2 倍）     82.3%   10,672         7,405<br>6,400 slot（8 倍）     82.3%   10,672         0</pre><p>用一個比 GPU 池大八倍的主機記憶體層，命中率回到 82.3% — — 正好等於「整棵樹都放在 GPU 上」的水準 — — 而且一個 token 都沒被丟掉。代價是其中 10,672 個 token 是從主記憶體<strong>複製</strong>回來而不是重算的：<strong>用頻寬換算力</strong>，而這筆交易划算的條件很明確 — — prefill 越貴（也就是共用前綴越長）越划算。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*5ZLz3Tcww-OQu6jg" /></figure><p>這就是 SGLang 的 <strong>HiCache</strong>：同一棵 radix tree，但一個節點可以住在 GPU 池、主機 DRAM，或是可選的遠端儲存（SSD 或其他機器），並在背景把分支往上搬或往下趕。對使用者來說介面沒變，變的是「cache miss」不再等於「重算」，而可能只是「從慢一點的地方搬回來」。</p><p><strong>Mooncake</strong>（Kimi 背後的架構）把同一個觀察放大到整個叢集。prefill 是算力受限、decode 是記憶體受限 — — 就是前一天那兩台不同的機器 — — 那就讓它們跑在<strong>不同的機器池</strong>上；而 KV cache 變成一座叢集共用的儲存，由全部機器的 CPU 記憶體和 SSD 組成，透過 RDMA 搬運。於是排程可以反過來做：把請求送去「它的前綴已經在那裡」的機器，而不是把前綴送去機器。他們自己把這個設計叫做 KVCache-centric，而那個詞正好就是今天的總結 — — 一旦你量過有多少工作只是重複的前綴，cache 就不再是副產品，而是整個系統圍著轉的東西。</p><h3>在 PyTorch 和 JAX 裡：省得掉計算，省不掉空間</h3><p>transformers 沒有跨請求的前綴共享。你能自己做的是把 system prompt 先算一次，然後每個請求複製一份：</p><pre>sys_ids = tok(SYSTEM_PROMPT, return_tensors=&quot;pt&quot;).to(&quot;cuda&quot;)<br>base    = model(**sys_ids, use_cache=True).past_key_values    # 只算一次<br><br>for user_turn in requests:<br>    past = copy.deepcopy(base)                 # 每個請求一份完整副本<br>    out  = model(input_ids=encode(user_turn), past_key_values=past,<br>                 use_cache=True)</pre><p>JAX 是同一個故事、不同的機制：它的 cache 是一個補滿的固定形狀陣列，所以「前綴」就是「前面那幾個 slot」，每個請求從 base_len 開始用 jax.lax.dynamic_update_slice 往後寫。</p><p>兩邊都省掉了 prefill，而兩邊都沒有共用記憶體：每個在跑的請求都帶著自己的副本。今天那兩個數字裡，省計算那一半這樣就拿得到，省空間那一半（47,466 → 7,320 個 slot）拿不到。這不是哪個函式庫的缺陷，而是只要 cache 還是你程式碼手上的一個物件，共用就需要一個「擁有全部記憶體」的東西。</p><h3>接下來看 SGLang — — 今天這個東西就是從它來的</h3><p>SGLang 不是上面那兩個的同類。它是<strong>推論伺服器</strong>：一個行程，把權重載入一次、用 HTTP 接很多使用者的請求、決定每一步誰跟誰同一個 decode batch，並且掌管整張卡的顯存。正因為顯存歸它管，多個同時在跑的請求才能指向同一份快取前綴 — — 而那就是 RadixAttention，預設就開著。</p><pre>python -m sglang.launch_server --model-path meta-llama/Llama-3.1-8B \<br>    --mem-fraction-static 0.9        # token 池有多大<br>    # --disable-radix-cache          # 把共用關掉，用來對照<br><br>curl localhost:30000/flush_cache       # benchmark 之間把樹丟掉<br>curl localhost:30000/get_server_info   # cache hit rate 在這裡</pre><p>名字幾乎跟這個檔案一對一：那個類別在 SGLang 裡真的就叫 RadixCache；我們放在 node.key 上的 token，在它那裡是昨天那座 token_to_kv_pool 的 slot 編號；我們的 refs 是它的 protected 節點，請求還在 decode 時鎖住、淘汰不准碰。/flush_cache 是做 benchmark 前第一件要呼叫的事，不然第二輪的數字是第一輪的樹在幫忙。</p><p>vLLM 用另一種結構達到同樣的目標：--enable-prefix-caching 把 KV 切成固定大小的 block、對每個 block 的內容算雜湊，雜湊一樣就重用。差別正好就是今天這段程式碼裡的取捨——radix tree 可以在任意 token 位置分岔但要維護一棵樹，block 雜湊只能以 block 對齊、但實作簡單得多。兩邊都必須在 <strong>token id</strong> 上比對，理由就是上一節那個例子。</p><h3>這些東西之後會用在哪</h3><p>這是整個系列第一次，前半段的資料結構直接在後半段的 LLM 裡付現：Day 24 的 radix tree、Day 30 的 LRU，再加上一個 refcount（因為項目可能正在被用）。最值得記住的是那條容量曲線的形狀 — — 在池子還裝得下共用前綴之前是平的，裝不下就直接掉到谷底 — — 因為它說的是：要保護的是那段樹幹，不是總量。</p><p>程式碼和互動式走查都在 repo：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2057%20-%20radix%20attention">day 57 on GitHub</a>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25ac927837e5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-57-radixattention-%E8%AE%93%E9%96%8B%E9%A0%AD%E7%9B%B8%E5%90%8C%E7%9A%84%E8%AB%8B%E6%B1%82%E5%85%B1%E7%94%A8%E5%90%8C%E4%B8%80%E4%BB%BD-kv-cache-25ac927837e5">Day 57 — RadixAttention：讓開頭相同的請求共用同一份 KV cache</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 56 — KV cache：它存什麼、要多少記憶體，以及 prefill 和 decode 為什麼是兩台不同的機器]]></title>
            <link>https://medium.com/100-days-of-python/day-56-kv-cache-%E5%AE%83%E5%AD%98%E4%BB%80%E9%BA%BC-%E8%A6%81%E5%A4%9A%E5%B0%91%E8%A8%98%E6%86%B6%E9%AB%94-%E4%BB%A5%E5%8F%8A-prefill-%E5%92%8C-decode-%E7%82%BA%E4%BB%80%E9%BA%BC%E6%98%AF%E5%85%A9%E5%8F%B0%E4%B8%8D%E5%90%8C%E7%9A%84%E6%A9%9F%E5%99%A8-b969953f1e89?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/b969953f1e89</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[causal-inference]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 14:21:24 GMT</pubDate>
            <atom:updated>2026-11-16T14:21:24.596Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2056%20-%20kv%20cache">day 56 on GitHub</a></p><p><em>100 Days of Python — day 56</em></p><p>昨天那個 mini-GPT 生成文字的方式是：每生一個字元，就把整個模型在整段序列上重跑一次。那是最直覺的寫法，而它是二次方的 — — prompt 長 T、要生 n 個 token，工作量正比於 n(T + n)。</p><p>把已經算過的 key 和 value 留著，它就變成 nT。在這個檔案的玩具模型上，64 個 prompt 再生 64 個 token，重算版要 0.31 秒、有 cache 是 0.04 秒；而這個倍率會隨序列長度繼續變大，所以重點不是 8.6 倍，是「形狀」從二次方變線性。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*hfMTNWbEEuXy7WgJ" /></figure><p>而這一個改動也把推論切成兩個瓶頸完全不同的階段 — — 那才是今天真正要理解的部分。</p><h3>cache 裡放的是什麼</h3><p>每層兩個陣列：到目前為止每個 token 的 key 和 value。一次配置到最大長度，因為每個 token 重新配置一次 numpy 陣列會整個複製一遍 — — 那就是 cache 自己的那個二次方問題。</p><pre>class KVCache:<br>    def __init__(self, cfg, max_len=None):<br>        H, dh = cfg[&#39;n_head&#39;], cfg[&#39;d_model&#39;] // cfg[&#39;n_head&#39;]<br>        self.k = [np.zeros((H, max_len, dh)) for _ in range(cfg[&#39;n_layer&#39;])]<br>        self.v = [np.zeros((H, max_len, dh)) for _ in range(cfg[&#39;n_layer&#39;])]<br>        self.length = 0</pre><p>注意<strong>沒有</strong>放進去的是 query。query 只被製造它的那個 token 用一次，之後再也沒人讀；key 和 value 則是後面每一個 token 都要讀，所以值得留的是它們。</p><p>大小是 2 × 層數 × kv head 數 × head_dim × 每個數的位元組，而且是每個 token、每條序列各一份：</p><pre>模型                     bytes/token  128k context 下<br>-----------------------  -----------  ---------------<br>這裡的玩具模型           512          0.1 GB<br>32 層、32 個 kv head     524,288      64.0 GB<br>32 層、GQA 8 個 kv head  131,072      16.0 GB<br>80 層、GQA 8 個 kv head  327,680      40.0 GB</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-OP38m81aE7YMRmi" /></figure><h3>它是最佳化，所以必須完全不改變答案</h3><p>驗收標準是對拍：先 prefill 整段 prompt，再一個一個 decode，每一步都必須等於完整 forward 會說的話。</p><pre>cached 的一步與完整 forward 的最大差：3.75e-16<br>用同一個 seed 取樣 24 個 token，兩邊字字相同：True</pre><p>幾乎所有 cache bug 都會在這裡現形，而且形式都一樣：一個有限、看起來合理、但不相等的數字 — — 寫入位置差一格、留著舊資料、RoPE 用錯位置。它們都不會丟例外。</p><h3>prefill 和 decode</h3><p>Arithmetic intensity 是「每搬一個 byte 做幾次乘加」。它決定一個階段是被計算單元卡住還是被記憶體卡住，而 GPU 想要的是幾百這個等級。</p><pre>context  prefill MACs/byte  decode MACs/byte<br>-------  -----------------  ----------------<br>128      64.3               0.50<br>512      261.2              0.50<br>2,048    1,107.9            0.50<br>8,192    5,433.0            0.50</pre><p>那個 0.50 不是巧合，而且它把整件事濃縮成一個數字：decode 時，每一個被讀進來的權重、每一個 cache 裡的數字，都只被用在<strong>一次</strong>乘加上；而 fp16 一個數字是兩個 byte。一次乘加配兩個 byte 就是 0.5。prefill 則是把讀進來的那份權重給 T 個 token 一起用，它的強度就是從這裡來的。</p><p>這也讓 GQA 的效果變得很精確：多個 head 共用同一份 K/V，decode 要讀的 byte 少了幾倍，但要做的乘加也少了同樣幾倍，所以強度還是 0.50。它讓 decode 變便宜，但沒有讓它變得不是記憶體受限。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*O39nB546-nas3RmP" /></figure><h3>所以 decode 要 batch</h3><p>不管同時有幾條序列在 decode，權重每一步都只被讀一次，所以在計算量追上來之前，多塞幾條序列幾乎是免費的。實測（numpy 跑在 CPU 上，所以看形狀不要看毫秒數）：</p><pre>batch  每步幾毫秒  每條序列幾微秒<br>-----  ----------  --------------<br>1      0.21        211<br>8      0.96        120<br>32     4.29        134<br>128    17.3        135</pre><p>從 1 條到 8 條，每條序列的成本幾乎砍半；再往上就壓平了，因為 cache 裡有 512 個 token 時，numpy 的時間已經花在 attention 的 einsum 上而不是權重上。在 GPU 上這段平坦區會長很多 — — 這就是服務系統拼命把 decode batch 塞滿的理由。</p><p>而擋住 batch 繼續變大的，正是 cache 本身：batch 裡每一條序列都帶著自己的一份，而那就是記憶體被吃掉的地方。batch 越大吞吐越好、cache 越多空間越緊 — — 這條張力就是之後所有 KV cache 管理技巧的起點。</p><h3>不會報錯的壞法：忘了清 cache</h3><p>第一條序列還在 cache 裡的時候，直接開始第二條 — — 沒有 reset，就繼續往後接。</p><pre>logits 的最大差：0.2731（平均 0.1303）<br>最可能的下一個 token 在 12 步裡有 4 步不一樣<br>新 token 能看到的東西裡，最多有 67% 屬於上一條序列</pre><p>什麼都不會報錯。形狀全對、logits 有限、softmax 照樣加總為 1。模型只是在讀別人的對話，而唯一的症狀是輸出「有點怪」 — — 在一個同時服務好幾個使用者的聊天伺服器上，這種 bug 回報上來的樣子就是「模型有時候怪怪的」。前面那個對拍測試立刻就抓得到它；用眼睛看生成結果抓不到。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*eQi6dHk_SUWJwtCm" /></figure><h3>同一個 cache 在 PyTorch 和 JAX 裡長什麼樣</h3><p>上面都是一個玩具類別。PyTorch 和 JAX 是同一個層級的東西 — — 你用它們「寫模型」的陣列函式庫 — — 而在這兩者裡，cache 都是你自己的程式碼握著的東西，變的只有名字和規則。</p><p><strong>PyTorch / transformers</strong> 直接把 cache 當成 past_key_values 交還給你：</p><pre>from transformers import AutoModelForCausalLM, AutoTokenizer<br>model = AutoModelForCausalLM.from_pretrained(name, dtype=torch.float16).cuda()<br><br># prefill：整段 prompt 一次進去，cache 跟著回來<br>out  = model(**tok(&quot;the cat sat&quot;, return_tensors=&quot;pt&quot;).to(&quot;cuda&quot;), use_cache=True)<br>past = out.past_key_values           # 每層一對 (k, v)<br>nxt  = out.logits[:, -1].argmax(-1, keepdim=True)<br># decode：一次送一個 token 進去，cache 每步多一列<br>for _ in range(50):<br>    out  = model(input_ids=nxt, past_key_values=past, use_cache=True)<br>    past = out.past_key_values<br>    nxt  = out.logits[:, -1].argmax(-1, keepdim=True)</pre><p>past[0][0].shape 是 (batch, kv_heads, 目前長度, head_dim)，就是我們的 cache.k[l] 多一個 batch 維。model.generate() 會幫你跑完這個迴圈，自己寫出來只是為了看清楚。<strong>忘了傳 </strong><strong>past 不會報錯</strong>：模型會把那一個 token 當成全新的序列；而重複用別的請求留下來的 past，就是前一節那個沒清 cache 的 bug。</p><p><strong>JAX</strong> 不能讓 cache 長大，因為 jit 是對形狀編譯的——每步多一列就等於每步重新編譯一次。所以它一開始就配滿，再用位置寫進去：</p><pre>cache_k = jnp.zeros((heads, MAX_LEN, head_dim))      # 一次配到最大長度<br><br>def decode_step(params, cache_k, cache_v, q, token, pos):<br>    k, v = project(params, token)<br>    cache_k = cache_k.at[:, pos].set(k)              # functional 寫入，形狀不變<br>    cache_v = cache_v.at[:, pos].set(v)<br>    live = jnp.arange(MAX_LEN) &lt;= pos                # 把還沒寫到的尾巴遮掉<br>    att  = jnp.where(live, q @ cache_k.T / jnp.sqrt(d), -jnp.inf)<br>    return jax.nn.softmax(att) @ cache_v, cache_k, cache_v<br>step = jax.jit(decode_step)                          # 編譯一次，之後重用</pre><p>在 jit 裡面，.at[].set() 會被編譯成就地更新而不是複製。pos 之後的格子是垃圾，所以那個 mask 不是可選的——忘了它，模型就會對一堆零做 softmax，形狀完全正確、也不會報錯。</p><h3>接下來我們來看看 SGLang — — 它是另一種框架</h3><p>PyTorch 和 JAX 是同一個層級：你拿來「寫模型」的函式庫。SGLang 不是它們的同類，它是蓋在那些函式庫上面的<strong>推論伺服器（inference server）</strong>。你不會用它寫 decode 迴圈；你是啟動一個行程，它把權重載入一次、用 HTTP 接很多使用者的請求、決定每一步要把哪些請求放進同一個 batch，並且掌管整張卡的顯存。vLLM、TensorRT-LLM 也是同一類東西。</p><p>一旦有個伺服器在做這件事，cache 就不可能再是你迴圈裡的一個變數。幾百個請求在毫無關聯的時間點進來和結束，每個請求配一塊新陣列的話，幾分鐘之內記憶體就碎掉了。所以 SGLang 開機時就把「權重以外」的顯存整塊切成固定大小的 token slot，再一格一格發出去：</p><pre>python -m sglang.launch_server --model-path meta-llama/Llama-3.1-8B \<br>    --mem-fraction-static 0.9 \     # KV 池可以拿走多少顯存<br>    --max-running-requests 256 \    # decode batch 的上限<br>    --chunked-prefill-size 8192     # 把長 prefill 切成塊</pre><p>那座池子（token_to_kv_pool）<strong>就是</strong> cache，而每個請求用一張索引表（req_to_token）指到自己佔的那些 slot——我們的 cache.length 在這裡變成表上的一列，而不是物件上的一個欄位。真正重要的容量是用 token 數算的：(顯存 − 權重) / 每 token 的 bytes，而後面那個數字就是前面那張表裡的值。這一個除法決定了這台機器能同時容納多少使用者，也是為什麼 --mem-fraction-static 幾乎是所有人第一個動的旋鈕。</p><p>另外兩個旗標則是今天那兩個量測變成的政策。--max-running-requests 限制 decode batch 的大小，因為 decode 是記憶體受限、想要大 batch，而 batch 裡每條序列都在吃 slot。--chunked-prefill-size 的存在理由是：一段長 prefill 是算力受限的，會把 GPU 佔住幾十毫秒，期間所有正在 decode 的請求都停著——所以要把 prefill 切成小塊，夾在 decode 步之間跑。</p><h3>這些東西之後會用在哪</h3><p>LLM 服務裡幾乎每一件事都是上面那兩個事實的後果。cache 是每條序列一份而且很大，所以記憶體管理就變成了排程問題；decode 固定在 0.50 MACs/byte 的記憶體受限區，所以吞吐量要靠 batch 而不是靠更快的乘法器，而任何能減少「要搬多少 byte」的東西 — — GQA、量化過的 cache、讓多個請求共用同一段前綴 — — 換到的都是實打實的時間。</p><p>程式碼和互動式走查都在 repo：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2056%20-%20kv%20cache">day 56 on GitHub</a>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b969953f1e89" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-56-kv-cache-%E5%AE%83%E5%AD%98%E4%BB%80%E9%BA%BC-%E8%A6%81%E5%A4%9A%E5%B0%91%E8%A8%98%E6%86%B6%E9%AB%94-%E4%BB%A5%E5%8F%8A-prefill-%E5%92%8C-decode-%E7%82%BA%E4%BB%80%E9%BA%BC%E6%98%AF%E5%85%A9%E5%8F%B0%E4%B8%8D%E5%90%8C%E7%9A%84%E6%A9%9F%E5%99%A8-b969953f1e89">Day 56 — KV cache：它存什麼、要多少記憶體，以及 prefill 和 decode 為什麼是兩台不同的機器</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 55 — 用 numpy 從零訓一個 char-level mini-GPT：十萬個參數、手寫反向傳播，以及一個可以跟真相比對的 loss]]></title>
            <link>https://medium.com/100-days-of-python/day-55-%E7%94%A8-numpy-%E5%BE%9E%E9%9B%B6%E8%A8%93%E4%B8%80%E5%80%8B-char-level-mini-gpt-%E5%8D%81%E8%90%AC%E5%80%8B%E5%8F%83%E6%95%B8-%E6%89%8B%E5%AF%AB%E5%8F%8D%E5%90%91%E5%82%B3%E6%92%AD-%E4%BB%A5%E5%8F%8A%E4%B8%80%E5%80%8B%E5%8F%AF%E4%BB%A5%E8%B7%9F%E7%9C%9F%E7%9B%B8%E6%AF%94%E5%B0%8D%E7%9A%84-loss-f0e131c41d17?source=rss----4abb576258f6---4</link>
            <guid isPermaLink="false">https://medium.com/p/f0e131c41d17</guid>
            <category><![CDATA[gpt]]></category>
            <dc:creator><![CDATA[Ray King / 金睿]]></dc:creator>
            <pubDate>Sun, 15 Nov 2026 17:29:14 GMT</pubDate>
            <atom:updated>2026-11-15T17:29:14.681Z</atom:updated>
            <content:encoded><![CDATA[<p>程式碼：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2055%20-%20char%20level%20mini%20gpt">day 55 on GitHub</a></p><p><em>100 Days of Python — day 55</em></p><p>前四天把零件做好了：tokenizer、attention、transformer block、位置編碼。今天把它們放進同一個檔案，然後真的訓練起來。沒有框架也沒有 autograd — — 反向傳播是手寫的，而且跟中央差分對過，最差相對誤差 3.06e-06。</p><p>模型是 104,728 個參數：d_model 64、2 個 block、4 個 head、context 32 個字元。在筆電 CPU 上跑 500 步 Adam 之後，它會寫出像 the old bird sat in the garden. 這樣的句子——更有用的是，它寫出來的句子有 67% 到 100%（看你怎麼取樣）是來源真的產得出來的。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*IknQcndoDMTe5Bk5" /></figure><h3>語料是自己生出來的，而這正是重點</h3><p>大部分的玩具語言模型是拿一份抓來的文字訓練，所以訓練完唯一能講的話就是「loss 降了」。降到哪裡？跟什麼比？</p><p>所以這裡的語料是模組裡一套五個空格的文法產生的：冠詞、可有可無的形容詞、名詞、動詞、地點，一共 38,005 個字元、24 種不同字元。因為產生器是已知的，這份文字的熵也是已知的：每個句子是五個獨立的選擇、合計 10.288 bits，平均攤在 31.56 個字元上，就是 <strong>0.3260 bits 每字元</strong>。沒有模型能低於這條線，而低很多的模型是在背答案不是在學。</p><p>它同時也給了生成結果一個不靠主觀判斷的測試：把產生的每一行丟回文法，問它產不產得出來。</p><h3>訓練</h3><p>輸入 32 個字元，目標是同一串往右移一格。Adam、learning rate 3e-3、batch 16、500 步，沒有排程也沒有 gradient clipping。</p><pre>step     1   loss 3.1724   bits/char 4.5769<br>step   100   loss 0.7284   bits/char 1.0508<br>step   300   loss 0.3515   bits/char 0.5070<br>step   500   loss 0.3367   bits/char 0.4858<br><br>final training loss  0.3375 = 0.4869 bits/char<br>held-out loss        0.3301 = 0.4762 bits/char<br>source entropy       0.3260 bits/char</pre><p>第一個要檢查的數字是第一步：什麼都不知道的代價是 ln(24) = 3.1781，而第 1 步量到 3.1724。held-out 的那份文字是同一套文法換個 seed 產生的，模型沒看過，而它的分數跟訓練集幾乎一樣——所以模型學到的是文法，不是它看過的那 38,005 個字元。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*ABL9ICpedX83TNbU" /></figure><h3>生成：把 temperature 的取捨量出來</h3><p>生成是一次一個字元：拿最後一個位置的 logits、除以 temperature、（可選）只留分數最高的 k 個、抽一個、接回去、再跑一次。</p><pre>設定                      合文法的句子  第一句<br>------------------------  ------------  -----------------------------------------------------<br>temperature 1.0           6 句中 67%    the old bird sat in the garden.<br>temperature 0.8, top-k 5  6 句中 50%    the quiet child ran near the doog ran under the tree.<br>temperature 0.2           7 句中 100%   the old robot sang under the tree.</pre><p>這張表有兩件事要老實講。0.2 那一列幾乎等於 greedy，而它的句子開始重複 — — 同一個 robot 一直出現 — — 這就是取樣取捨的全貌：低溫買到安全，付出的是多樣性。而 0.8 那列低於 1.0 並不是真的反轉：樣本只有六句，而一句裡一個字元歪掉整句就不合格，這種百分比本來就會跳。要認真比較取樣設定，得生成幾百句而不是六句。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*GQnWjopzdxzoU_tA" /></figure><h3>兩個讓 loss 變低的 bug</h3><p><strong>忘了 causal mask。</strong> 沒有它的 250 步 loss 是 0.0491，有它是 0.3824。沒有 mask 的那個看起來好非常多，而它在作弊：每個位置都看得到自己要預測的那個字元。形狀、梯度、loss 曲線通通沒有意見。只有在生成的時候才會露餡，因為那時沒有未來可以偷看：</p><pre>the e e eeeeeeeeeeeeeeeeeee e ee.e.<br> de dedededededededededededededededede</pre><p>合文法比例 0%，而這是 loss 比較低的那個模型。</p><p><strong>忘了把目標往右移一格。</strong> 讓模型去預測它剛拿到的那個字元，150 步的 loss 是 0.0012，而正確版是 0.4863。loss 直奔 0 很容易被讀成成功；實際上它學的是恆等函數，而生成時它要抄的那個字元正好就是還不存在的那一個。它只會吐空白。</p><p>兩個 bug 的形狀一樣：<strong>loss 變低是因為題目被改簡單了，不是因為模型變好了</strong>。唯一抓得到它們的，是去評估模型真正要做的那件事 — — 這裡就是生成，然後把生成結果丟回文法檢查。</p><h3>訓練完之後它在看哪裡</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/0*y0R9Iah-cujgnBKk" /></figure><p>這是訓練後第二個 block、第一個 head 的注意力矩陣，直接從前向傳播的 cache 裡拿出來，讀的是 the small cat sat on the mat.。右上角整片空白就是 causal mask。權重大多落在最近幾個字元上，偶爾往回抓一個比較遠的——對一個「把詞拼完、然後接一段合法的下一塊」的任務來說，本來就該長這樣。不過要忍住不要對單一個 head 編故事：這裡只有兩層、每層四個 head，它們是一起工作的。</p><h3>這些東西之後會用在哪</h3><p>上面每一件事放大之後都不變：同一個迴圈、同一個 loss、同樣那兩個 bug。隨規模改變的只有「你還檢查得起什麼」。在這裡，來源的熵是已知的、整份語料塞得進一個字串、而錯的梯度六次有限差分就抓得到。到了另一端這些都沒有了 — — 所以這些習慣值得在這麼小的東西上先養成：一個可以拿來比的數字，以及一個「照模型真正被使用的方式去跑」的評估。</p><p>程式碼和互動式走查都在 repo：<a href="https://github.com/KingRei/100DaysPython/tree/master/day%2055%20-%20char%20level%20mini%20gpt">day 55 on GitHub</a>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0e131c41d17" width="1" height="1" alt=""><hr><p><a href="https://medium.com/100-days-of-python/day-55-%E7%94%A8-numpy-%E5%BE%9E%E9%9B%B6%E8%A8%93%E4%B8%80%E5%80%8B-char-level-mini-gpt-%E5%8D%81%E8%90%AC%E5%80%8B%E5%8F%83%E6%95%B8-%E6%89%8B%E5%AF%AB%E5%8F%8D%E5%90%91%E5%82%B3%E6%92%AD-%E4%BB%A5%E5%8F%8A%E4%B8%80%E5%80%8B%E5%8F%AF%E4%BB%A5%E8%B7%9F%E7%9C%9F%E7%9B%B8%E6%AF%94%E5%B0%8D%E7%9A%84-loss-f0e131c41d17">Day 55 — 用 numpy 從零訓一個 char-level mini-GPT：十萬個參數、手寫反向傳播，以及一個可以跟真相比對的 loss</a> was originally published in <a href="https://medium.com/100-days-of-python">100 days of python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>