拆开 Qwen3.8：一台大模型的机器手册

第0章 开工之前：你需要的全部数学

这一章回答一个问题：要看懂一台叫 Qwen3.8 的机器，最少需要会哪几样数学？答案是六样，全部在这一章讲完，之后十九章不再补课。

0.1 向量：一串数字为什么能表示「意思」

先从一个不涉及语言的例子开始。要描述一个人，你可以用三个数：身高 175、体重 68、年龄 17。这三个数排成一行写作 (175, 68, 17)，就是一个三维向量(vector)，它有三个维度(dimension)，每一维记录一件事。向量有意义的地方在于：两个人像不像，现在可以算了。(175, 68, 17) 和 (176, 70, 17) 三个数都接近，(160, 45, 42) 就明显是另一个人。相似这件从前只能靠感觉的事，变成了一道算术题。

把维度从 3 加到 5120，把「身高体重年龄」换成 5120 件说不清是什么的事，就是 Qwen3.8-27B 表示一个词的方式——它的 hidden_size 就是 5120。每个词在机器里都是一串 5120 个小数，打印出来每行放 10 个要占 512 行。

那怎么算「像不像」？最常用的两把尺子是点积和余弦相似度。点积(dot product) 的算法是：两个向量对位相乘，再全部加起来。

手算一遍。假设有三个玩具向量（真实模型是 5120 维，这里缩到 3 维只为了能手算）：

猫 ⋅ 狗 = 0.9×0.8 + 0.1×0.2 + 0.2×0.1 = 0.72 + 0.02 + 0.02 = 0.76。
猫 ⋅ 汽车 = 0.9×0.1 + 0.1×0.9 + 0.2×0.7 = 0.09 + 0.09 + 0.14 = 0.32。
点积大的那一对更像。

但点积有个毛病：把猫的每一维都乘以 10，它和任何向量的点积都会跟着变成 10 倍，可它还是那个猫。余弦相似度(cosine similarity) 就是来修这个毛病的——先把两个向量各自的长度除掉，只留方向。

接着上面的数：∥猫∥ = √0.86 ≈ 0.927，∥狗∥ = √0.69 ≈ 0.831，∥汽车∥ = √1.31 ≈ 1.145。于是 cos(猫, 狗) ≈ 0.76 ÷ 0.770 ≈ 0.99，cos(猫, 汽车) ≈ 0.32 ÷ 1.062 ≈ 0.30。0.99 对 0.30 比 0.76 对 0.32 更好读，因为它有固定的上下界。

0.2 矩阵乘法：这台机器唯一的动作

矩阵(matrix) 就是把数排成长方形的表格。一个 n×k 的矩阵有 n 行 k 列。矩阵乘法(matrix multiplication) 记作 @，规则只有一句：

为什么中间那个 k 必须相等？因为结果里的每一个数，都是「左边取一整行、右边取一整列，两者做点积」。左边一行有 k 个数，右边一列也有 k 个数，两串数必须一一配对才能相乘相加——一边 3 个一边 5 个，配不上，这个乘法就不存在。写成公式：

手算一个 2×3 @ 3×2。设 A = [[1, 2, 3], [4, 5, 6]]（2 行 3 列），B = [[7, 8], [9, 10], [11, 12]]（3 行 2 列）。中间的 3 对上了，所以结果是 2×2，一共四个数，一个一个算：

C₁₁ = A 第 1 行 ⋅ B 第 1 列 = 1×7 + 2×9 + 3×11 = 7 + 18 + 33 = 58
C₁₂ = A 第 1 行 ⋅ B 第 2 列 = 1×8 + 2×10 + 3×12 = 8 + 20 + 36 = 64
C₂₁ = A 第 2 行 ⋅ B 第 1 列 = 4×7 + 5×9 + 6×11 = 28 + 45 + 66 = 139
C₂₂ = A 第 2 行 ⋅ B 第 2 列 = 4×8 + 5×10 + 6×12 = 32 + 50 + 72 = 154

结果是 [[58, 64], [139, 154]]。注意 B @ A 也算得出来（3×2 @ 2×3 → 3×3），但结果完全不是这个——矩阵乘法不满足交换律，左右顺序是有意义的。

现在到了这一章最重要的一句话，后面十九章的参数点钞全部建立在它上面：

拿真数据验证一下。Qwen3.8-27B 的 hidden_size 是 5120，稠密 FFN 的中间维是 17408。FFN 里的 gate_proj 就是一个把 5120 维变成 17408 维的矩阵，所以它是 5120×17408：

5120 × 17408 = 89,128,960 个参数，约 8913 万。

这个数不是估的。本站的参数点钞脚本对同一张矩阵算出来的就是 89,128,960（见 paramcount.out.txt 里 gate_proj 那一行）。一张矩阵、一次乘法，你已经能自己复算模型的一部分了。

再来一个更大的：嵌入表要把 248,320 个词各自映射成一串 5120 个数，所以它是 248320×5120 = 1,271,398,400，也就是 1.27B。光是一张查询表，就吃掉了 12.7 亿个参数。

0.3 「参数」到底是什么

参数（parameter，也叫权重 weight）：模型里那些训练时会被改动、推理时只读不改的数字。它们全部住在权重矩阵里。模型文件里存的就是它们，别无他物。

训练是这么回事：一开始所有矩阵里的数都是随机的，模型说什么都是胡话；喂给它一段文本让它猜下一个字，猜错了就算出「每一个参数应该往哪个方向挪一点点」，然后全体挪一小步。这一步叫梯度下降(gradient descent)。重复到天量次数之后，那些数就变成了能说人话的一组取值。

273.6 亿有多大？如果你一秒念一个数，不吃不喝不睡，念完 27,355,639,808 个参数需要约 867 年。而这还只是两个模型里小的那个：Qwen3.8-2.4T-A95B 的总参数是 2.420 T，也就是 24,200 亿，念完要七万多年。

还有一个必须现在就分清的区别，否则第 1 章那张四轴表看不懂：

这张表就是全站核心论点的第一块砖：27B 和 2.4T 的差别写在超参数里（层数 64 对 92、hidden 5120 对 8192、稠密 FFN 对 512 个专家），不在参数的存储格式里。第 1 章会把这句话摊开讲。

0.4 浮点数：一个数字在电脑里占几个字节

先说整数。计算机里一切都是 0 和 1，一个 0 或 1 叫一位(bit)，8 位叫一字节(byte)。n 位能表示 2ⁿ 种取值：8 位 256 种，4 位只有 16 种。INT8 就是用 8 位存一个整数（−128 到 127），INT4 用 4 位（−8 到 7，只有十六个台阶）。

但模型里的参数是小数，而且大小差得很远——有的是 0.0001，有的是 300。要用固定位数同时表示这两种数，办法是把科学计数法搬进二进制。浮点数(floating point number) 把可用的位切成三段：

把这一句话记牢，后面全部推得动：指数位管范围，尾数位管精度，两者在固定的总位数里抢地盘。

为什么训练偏爱 BF16 而不是 FP16？两者都是 2 字节，区别只在地盘怎么分。FP16 把 10 位给尾数、只留 5 位给指数，能表示的最大数只有 65504 上下；训练时梯度偶尔会窜到很大，一旦越界就变成无穷大，那一步的更新全废，整个训练可能就崩了。BF16 反过来，指数位保持 8 位不变（和 FP32 一模一样），砍的全砍在尾数上（23 位砍到 7 位）。于是它的动态范围与 FP32 完全相同、不会溢出，代价是有效数字变少、单次读写有零点几个百分点的误差；而训练本来就是天量次小步累加，对这点误差不敏感，对「这一步直接变成无穷大」却极其敏感。

一句话：BF16 是宁可丢精度也不丢范围。这也解释了 FP32 转 BF16 在硬件上为什么特别便宜——把 FP32 的后 16 位截掉就是 BF16，指数段原封不动。

现在把这一节和 0.2 节接起来，得到本章最实用的一条换算：

27.36B 个参数 × 每个 2 字节（BF16）= 54.7 GB。这就是为什么 Qwen3.8-27B 的 BF16 权重文件是 54.66 GB——不是别人随口标的一个数，是参数个数乘位宽算出来的。换成 4 位量化，同样这 273.6 亿个参数只需要约四分之一的空间，实测的 Q4_K_M 文件是 17.11 GB。

0.5 对数与数量级：为什么讲模型总在说 B 和 T

英文的计量前缀是三位一跳：K 是 10³（千），M 是 10⁶（百万），B 是 10⁹（十亿），T 是 10¹²（万亿）。中文是四位一跳：万、亿、万亿。两套系统错开一位，是中文读者读这类文章最常出错的地方。

拿两个锁定值直接相除，就能看清差距：2.420 T ÷ 27.36 B ≈ 88 倍；而它每个 token 真正用上的激活参数 95.29 B ÷ 27.36 B ≈ 3.5 倍。同一对模型，看显存差 88 倍，看单 token 计算量只差三倍半——这个反差就是第 10 章的全部内容。

对数(logarithm) 是这样一个问题的答案：10 的几次方等于这个数？log₁₀(1000) = 3，log₁₀(27.36×10⁹) ≈ 10.44，log₁₀(2.420×10¹²) ≈ 12.38。两者相差 1.94，也就是差了将近两个数量级，正好对应 10^1.94 ≈ 88 倍。在对数尺度上，「相差多少倍」变成了「相差多少」——这就是它的全部用处。

这也解释了为什么讲缩放规律的论文全都画对数坐标图。经验规律大多长成 y = a·x^k 这种幂律(power law)形式；两边取对数就变成 log y = log a + k log x，是一条直线，斜率就是 k。于是跨五个数量级的实验点能画在一张图里，而且能顺着直线往外推。第 13 章讲 Scaling Law 时，你看到的每一张图都是这么来的。

0.6 softmax：把任意一堆数变成一组概率

最朴素的办法是每个数除以总和。行不通：有负数时会出现负的「概率」；如果正负正好抵消，分母还会是 0。softmax 的办法是先给每个数取一次指数 e^z，再除以总和：

取指数这一步干了三件事，缺一不可：一是把负数变正（e 的任何次方都大于 0，负概率的问题消失）；二是保序（原来大的仍然大，排名不会被打乱）；三是放大差距（原始分差 1，指数之后就差 e ≈ 2.72 倍，模型的选择因此变得果断）。

手算一个三项的例子。取 z = (2, 1, 0)：

e² ≈ 7.389，e¹ ≈ 2.718，e⁰ = 1，三者之和 ≈ 11.107。
p₁ = 7.389 ÷ 11.107 ≈ 0.665；p₂ = 2.718 ÷ 11.107 ≈ 0.245；p₃ = 1 ÷ 11.107 ≈ 0.090。
三者相加 = 1.000。原始分只差 1 和 2，概率却拉开到 0.665 对 0.090，七倍多。

还有一条工程上极其重要的性质：softmax 对整体平移不变——每一个 z 都减去同一个常数，结果一模一样。验证：取 z = (0, −1, −2)（每项减 2），e⁰ = 1、e⁻¹ ≈ 0.368、e⁻² ≈ 0.135，和 ≈ 1.503，得到 0.665、0.245、0.090，与刚才一字不差。真实实现都靠这条性质先减去最大值再取指数：不减的话，z 稍大一点（比如 800），e⁸⁰⁰ 直接溢出成无穷大，整个分布报废。

第1章 全景：把 Qwen3.8 当成一台机器

这一章回答三件事：这次到底开源了什么、不同尺寸是不是量化出来的、以及在往下走之前，你该用什么标准去信这份材料里的每一个数字。

1.1 这次到底开源了什么

四个仓库，其实是两个模型各带一份官方 FP8 版本。权重上线的时间是 2.4T-A95B 在 8 月 12 日、27B 在 8 月 14 日——注意它和上表的建仓日不是一回事，仓库可以先建好占位、过几天再推权重。这个细微差别本身就值得记住：同一件事有多个时间戳时，先问清你看的是哪一个。

三条必须主动说出来的事实，因为它们全都是网上高频的误传：

• 没有官方小尺寸。4B、8B、32B 这些名字在官方仓库里一个都不存在。社区里流传的小尺寸版本是第三方做的蒸馏或再训练，不是官方发布。
• 没有 Instruct / Thinking / Base 三件套。Qwen3.8 是单一统一权重，思考模式默认开启，深度靠 reasoning_effort 这个开关调（可选 xhigh / medium / low）。这是相对上一代把 Instruct 和 Thinking 分开发布的明确路线变化。
• 没有官方 GitHub 仓库，也没有 arXiv 技术报告。模型卡就是唯一的权威文档。这一点对本站影响巨大——它意味着这个站不能只靠「读论文」，而必须靠「模型卡的 config.json（一手事实）+ 上游论文（原理）+ 推理框架文档（工程数字）」三条腿站着。第 18 章会正面谈这件事。

1.2 全站的核心问题：不同尺寸是量化出来的吗

把差异拆开看，一共有四条互相独立的轴。这张表是全站最重要的一张：

请特别留意第 ③ 行：两个模型的层布局是同一个模板，都是「3 层线性注意力配 1 层全注意力」，区别只在这个模板重复了 16 次还是 23 次。这不是巧合，而是这一代架构的设计方式——同一张图纸按需要重复不同的次数。第 7 章会把这个 3:1 布局拆开讲。

再看第 ④ 行：它和上面三行的差别，不在于「改得多还是少」，而在于发生在哪个时刻。用第 0 章那条公式说最清楚：字节数 = 行 × 列 × 位宽 ÷ 8。前三轴动的是「行」和「列」，动完必须重新训练；第四轴只动「位宽」，参数个数一个不变，形状一个不变。

「训练之后」这一格里其实挤着三件完全不同的事，绝不能混：

• 剪枝(pruning)：真的把已训练模型的一部分权重砍掉，参数量真的变少，之后通常还要再训一小段来补。这是一条真实存在的技术路线（代表工作是 Minitron，arXiv:2407.14679），但它不是 Qwen3.8 这两个模型之间的关系。
• 蒸馏(distillation)：让一个大模型当老师，把它的输出分布教给一个学生模型。学生是另一套独立的参数，不是从老师身上切下来的。上一代 Qwen3 的强到弱蒸馏（arXiv:2505.09388）发生在后训练阶段，教的是教师的输出与 logits，不是把大模型的权重砍成小模型。
• 量化(quantization)：只改每个参数用几位来记，参数一个没少、形状一个没变。所以它是唯一一件「改完还能一一对应回原来那张矩阵」的事。

加上训练之前的独立预训练，一共四件事。全站要澄清的核心误解，本质上就是把这四件事压成了一件。

1.3 一台机器的爆炸图

现在把这台机器立起来看。下面这个拆机台里是 Qwen3.8-27B 的全部 64 层，按它们在 config 里的真实顺序排列：每 4 层一组，前 3 层是门控增量网络(Gated DeltaNet)，第 4 层是门控注意力(Gated Attention)，这一组重复 16 次。

怎么玩：把鼠标悬停在任意一层上，会显示这一层是哪一类零件、有多少参数；按住拖动可以转动整台机器，看清内部的层与层之间怎么串；点拆解会把 64 层沿轴向拉开，这时候 3:1 的节奏一眼就能看出来——每三层浅色之后必有一层深色。你不需要现在就懂每个零件在算什么，只要先记住这台机器的形状：它非常高（64 层），每一层的进出口一样宽（都是 5120），而且四层一个循环。

那么一个 token 从进到出，具体走过哪些零件？

三个值得现在就记住的点。第一，中间那条主干里，四层一组、其中只有一层是全注意力；只有这一类层会产生随上下文长度不断增长的 KV cache，另外三层的记忆是固定大小的。全网的显存计算器几乎都在这里算错，第 5 章会算给你看。第二，最右边那条虚线是自回归(autoregressive)回路——模型一次只吐一个词，吐完把它接到输入末尾，整条链重走一遍。第三，图像分支和文本分支最后汇进的是同一条序列，不是两个模型拼在一起，这就是「原生多模态」这个词的实际含义，第 11 章会展开。

1.4 知识依赖图：这二十章该按什么顺序读

这个站是一条主线：每一章往手上那个最小实现里加一层，最后你手上是一台能跑的机器。所以章与章之间是有依赖的——有些章不先学，后面那章会字面意义上看不懂。下面这张图把依赖关系画出来了。

五个核心章值得单独点名：第 5 章 KV cache（推理为什么越来越慢、显存到底被谁吃掉）、第 6 章 Gated DeltaNet（把记忆压成固定大小的那一类层）、第 9 章 MoE（把 FFN 切成 512 份）、第 12 章 亲手点钞（逐张矩阵数出 27B 和 2.4T，全站的高潮）、第 14 章 小模型不是大模型切出来的（本章 1.2 节那个论点的正式了结）。如果你时间有限，这五章一章都不要跳。

1.5 证据分级：这份材料里哪些能信到什么程度

还有一类特别容易被误读的东西：旧闻。一条 2025 年的消息被排在 2026 年 8 月的发布通稿里，读起来就像是因为新模型才发生的新采用。判断方法很简单：看到任何一条「某某公司改用了它」，先找日期，找不到日期就当它没有日期。

第2章 分词与嵌入：文字怎么变成数字

这一章回答一个最朴素的问题：你在输入框里敲下的一行汉字，是怎么变成一堆浮点数的。答案里藏着一个反直觉的事实——负责这件事的两个部件加起来吃掉了 27B 里的 2.54B，比全部 16 层注意力还贵，而它们几乎不做任何计算。

2.1 分词器：为什么不是一个字一个数

计算机里没有「字」，只有数。所以任何语言模型的第一步都是把文字换成整数编号。最容易想到的办法是一个字一个编号：常用汉字三千多个，编到 8000 号也够了。

字节对编码（Byte Pair Encoding, BPE）：一种自下而上的合并算法。先把所有文本拆成最小单位（字节），然后统计整个语料里哪两个相邻片段最常挨在一起，把这一对合并成一个新片段，记进词表；重复这个动作几万次，就得到一张词表。

BPE 的好处是它自己会分层。常见的词在几万次合并里被完整合成一个 词元（token），罕见的词自动退化成若干个常见片段的拼接，最坏的情况一路退回单个字节。因为最底层是字节，所以只要是能存进电脑的东西，分词器就一定能表示——这叫 字节回退（byte fallback）。模型永远不会遇到「这个字不认识」。

Qwen3.8 的词表大小是 248,320。这个数直接写在两份 config 里：cfg27b.json 的 text_config.vocab_size 和 cfg24t.json 的 vocab_size，两个模型一字不差，完全相同。这本身就是本站主线的一个小证据：27B 和 2.4T 共用同一套分词器，它们的差异不在「文字怎么进来」这一层。

词表越大，同一段文字切出来的 token 越少，模型跑得越省；但词表大小会直接乘进下一节那张表里。记住 248,320 这个数，它马上要乘一个 5120。

2.2 嵌入表：一张 248320 × 5120 的大表

分词之后，「猫」这个 token 变成了一个整数，比如 27331。现在的问题是：能不能直接把 27331 这个数喂给神经网络？

嵌入表（Embedding Table）：一张 V 行 d 列的矩阵，V 是词表大小，d 是模型主干的宽度。第 i 行就是第 i 个 token 的向量表示。把 token 换成向量这一步，就是按行号取出对应的那一行。

于是参数量就是一个乘法。cfg27b.json 里 hidden_size 是 5120，vocab_size 是 248320：

这个数值得停下来感受一下。1.27B 个参数，用 BF16 存每个占 2 字节，光这一张表就是 2.54 GB。而整个 27B 模型量化成 Q4_K_M 之后的完整权重文件也才 17.11 GB。换个角度：每个 token 的向量是 5120 个 BF16 数，也就是 10,240 字节——每个词元都有一张 10 KiB 的身份证，24.8 万张身份证摞在一起，就是这 2.54 GB。

2.3 输出头：为什么它是独立的另一份 1.27B

模型跑完全部 64 层之后，手上是一个 5120 维的向量。它得变成「词表里 248320 个 token 各自的可能性」。做这件事的部件叫 输出头（LM head / output head），本质是一个 5120 × 248320 的矩阵乘法，输出 248320 个原始分数，再过一次 softmax 变成概率。

权重绑定（weight tying）：让输出头直接复用嵌入表的权重（用它的转置），而不是另存一份。因为两者的形状本来就互为转置，这在技术上完全可行，而且能省掉整整一份 V×d。很多模型，尤其是参数预算紧张的小模型，都这么做。

Qwen3.8 没有这么做。证据就在 config 里，一行，不用猜：

所以出口那张表是独立训练、独立存储的另一份 1,271,398,400 个参数。进门一份、出门一份，加起来：

拿它和别的部件比一下就更刺眼了：全部 16 层 Gated Attention 加起来是 16 × 104.86 M = 1.68 B，占 6.1%。也就是说，这台机器里「查字典」花的参数，比「全部的注意力」还多出一半还不止。

另外要说清一处不对称，免得「进门查表、出门查表」这个顺口的说法把你带偏：两端的参数量一样，计算量完全不一样。进门是取一行，几乎不花时间；出门是一次真正的 5120×248320 矩阵乘法，而且每生成一个 token 都要重新做一遍。第3章之后你会越来越熟悉这个区分。

2.4 位置信息从哪来

到这里，一句话已经变成了一串 5120 维的向量。但有个东西还没进来：顺序。

补位置信息大致有三条路。第一条是 绝对位置嵌入（absolute positional embedding）：再建一张表，第 i 个位置有一个向量，加到该位置的 token 向量上。简单直接，但有两个麻烦：这张表要占参数；而且表有多少行，模型就只认识多少个位置，训练时没见过第 300000 个位置，推理时就抓瞎。

第二条是给注意力分数加一个只依赖距离的偏置。第三条，也是 Qwen3.8 用的，叫 旋转位置编码（Rotary Position Embedding, RoPE）：不往向量上加东西，而是转它——把位置编码成一个旋转角度，作用在注意力的 Q 和 K 上。它的妙处是两个转过的向量做点积时角度相减，结果只依赖两者的相对位置。

这一章只需要你记住三件事：位置信息是单独补进去的；Qwen3.8 用 RoPE；RoPE 一个参数都不带——它是一个纯函数，所以本章的参数账里没有「位置」这一项。至于 Qwen3.8 那个相当特别的用法（只给 256 维里的 64 维加旋转，底数用 10,000,000 而不是常见的 10,000，27B 还多一套多模态版本），全部留给第4章。

第3章 注意力：为什么要「看别的词」

这一章回答：一个词要理解自己的意思，为什么必须回头看别的词；以及模型是怎么把「看谁、看多重」变成一串可以求导的乘法的。学完你会亲手算出一个注意力矩阵，并且知道那个除以根号 d 的操作一旦拿掉，会发生什么。

3.1 不用注意力会怎样

先看一句话：

小明把书放在桌子上，然后他把它拿走了。

「它」指的是书还是桌子？你几乎不用想就知道是书——因为桌子拿不走。但注意你刚才做了什么：你回头扫了一遍前面出现过哪些名词，然后逐个判断哪个更可能跟「拿走」搭配。这两个动作，第2章那台机器一个都做不了。到目前为止我们造出来的东西只会把每个 token 单独查成一个向量，「它」查出来的向量和这句话里有没有出现过「书」毫无关系。

注意力的想法很直接：既不压缩，也不设窗口。让每个位置自己去看前面所有位置，并且自己决定看谁、看多重。不设窗口，所以远近都够得着；不压缩，所以早期的内容原样留在那里，需要的时候再去取。代价是每个位置都要和所有位置比一遍，计算量随序列长度平方增长——这笔账会在第5章变成一个非常具体的显存数字，第6、7章讲 Qwen3.8 为什么最终只让四分之一的层付这笔钱。

3.2 Q、K、V：三个投影，一段输入

要让「它」去看前面的词，得先把这件事拆成可计算的步骤。注意力用了三个角色。

写成公式就是三次矩阵乘法。设输入 X 是一个 T×d 的矩阵（T 个位置，每个位置一个 d 维向量，第2章刚做出来的那个）：

为什么非得分成三个，不能直接拿 X 自己跟自己比？有两个理由。一是自恋问题：任何向量和自己的点积都是最大的，不做变换的话每个位置永远最关注自己，学不到别的。二是职责冲突：「我要找什么」和「我是什么」被迫用同一组数字表示，「我能提供什么」也挤在同一组里——三件不同的事共用一套坐标，模型没有余地把它们分开。拆成三个投影，等于给模型三个自由度，让它自己去学怎么分工。

3.3 注意力公式：逐个符号拆开

三个投影准备好之后，剩下的就是一行式子：

读这行式子的正确顺序是从里往外：先 QK^⊤ 得到一张 T×T 的记分板，再除以 √d_k 调量级，再逐行 softmax 变成权重，最后用这些权重去加权平均 V 的各行。整个过程里只有三个矩阵是参数，其余全是算出来的。

那个 √d 到底在干什么

这是全式最容易被跳过、也最值得停下来的一步。假设 q 和 k 的每个分量都是独立的、均值 0、方差 1 的随机数，那么它们的点积是 d_k 项乘积之和：

±16 这个量级听起来无害，但 softmax 吃的是指数。两个位置的分数差 16，意味着它们的权重比是 e¹⁶ ≈ 890 万倍——第一名会拿走几乎全部的权重，剩下所有位置加起来分不到百万分之一。softmax 就从一个「柔和的排序」塌成了一个「硬性的选择」。

这不只是不好看，后果是梯度消失。softmax 塌成接近 one-hot 时，它对输入的导数几乎处处为 0（softmax 的雅可比矩阵是 diag(p) − pp^⊤，当 p 接近某个坐标轴上的单位向量时整个矩阵趋近于零矩阵）。反向传播到这里，梯度就断了，这一层学不动。除以 √d_k 把方差拉回 1，分数的典型大小回到 ±1，权重分布就重新变得「有区分但不极端」。

3.4 亲手算一遍

公式看懂和公式算过是两回事。下面这个实验台把式 3-2 拆成可以逐步观察的几块，建议至少玩三件事。

一，把缩放因子从 1/√d 改成 1，盯着权重分布看它怎么塌。你会看到一条明显的分界：缩放正常时，权重像一座缓坡；去掉缩放，它变成一根针。二，看 QK^⊤ 的热力图，哪一行亮在哪一列，就是哪个位置在看哪个位置。三，打开和关掉因果掩码，看矩阵的右上角是怎么被抹黑的。

因果掩码（causal mask）：语言模型干的是「预测下一个词」。训练时整句话是一次性铺开算的，如果第 i 个位置能看到第 i+1 个位置，它就是在抄答案——训练时分数漂亮，真正生成时后面还不存在，立刻崩。所以要把记分板上 j > i 的格子在 softmax 之前设成 −∞，取指数后变成 0，归一化时自动不参与。热力图上就是一个上三角被抹掉、只剩下三角的矩阵。

3.5 多头：为什么要分成好几组

到这里，一层注意力给每个位置产生了一组权重。问题是，一句话里同时存在好几种需要追踪的关系。

多头注意力（Multi-Head Attention, MHA）：把注意力做 h 遍。每一遍叫一个头（head），有自己独立的 W_Q、W_K、W_V，各自算出自己的一组权重和自己的输出；最后把 h 个输出拼接起来，再过一个输出投影 W_O 混合回主干宽度。

有一个关键的会计事实：在传统做法里，多头几乎不额外花参数。因为通常取 d_head = d/h，h 个头的投影矩阵拼起来正好还是一个 d×d 的方阵，和单头时一样大。换句话说，多头买到的不是「更多算力」，而是把同样的参数切成几份，让它们能各自形成独立的关注模式。这是一笔非常划算的买卖，也是 Transformer 里最优雅的设计之一。

说「传统做法」是因为 Qwen3.8 恰恰在这里做了两处不常规的偏离：d_head 不等于 d/h，而且 K/V 的头数比 Q 少得多。这两件事，连同一个额外的输出门，就是下一章的全部内容。

第4章 Qwen3.8 的全注意力层长什么样

这一章是全站「读一手材料」的示范章。上一章讲的是教科书上的注意力，这一章我们把 cfg27b.json 摊开，一个字段一个字段读下去，看看真机上那一层到底长什么样——它和教科书至少差了四处，每一处都有明确的工程理由，也有一处官方从未解释。

4.1 GQA：24 个 Q 头配 4 个 KV 头

先把两行 config 摆出来。mat/cfg27b.json 的 text_config 里：

上一章说多头是「把注意力做 h 遍，每遍有自己的 W_Q、W_K、W_V」。那是 多头注意力（Multi-Head Attention, MHA）：Q、K、V 头数一样多。Qwen3.8 不是。它的 Q 有 24 个头，K 和 V 只有 4 个——每 6 个 Q 头共用同一组 K 和 V。

多查询注意力（Multi-Query Attention, MQA）：走到极端，让全部 Q 头共用一组 K 和 V。缓存直接除以头数。代价是所有头被迫看同一份索引、搬同一份内容，只有提问方式不同，表达能力明显受损。

分组查询注意力（Grouped-Query Attention, GQA）：折中方案。把 Q 头分成若干组，组内共用一套 K、V，组间各自独立。Qwen3.8-27B 是 24 个 Q 头分 4 组，每组 6 个。

注意图里最后那一行：缓存里不存 Q。Q 是当前这个 token 现算的，用完就扔；K、V 才要留给后面的 token 用。所以把 Q 头数做大不花缓存，把 KV 头数做大才花——GQA 正是抓住了这个不对称。

这个 4 直接决定了全站最重要的那个数。27B 有 16 层全注意力（4.6 节会说为什么是 16），每 token 要缓存的元素数是 2 × 16 × 4 × 256 = 32,768 个，fp16 下正好 64 KiB。要是 KV 头也做成 24，这个数会变成 2 × 16 × 24 × 256 = 196,608，也就是 384 KiB——在 262,144 的满上下文下，KV cache 从 16 GiB 涨到 96 GiB。这一个字段的差别，就是「24GB 卡上跑得动」和「跑不动」的差别。

4.2 head_dim 256：一个反常识的选择

上一章说过一个几乎是默认的约定：d_head = d / h。这样 h 个头拼起来正好等于主干宽度，Q/K/V/O 四个投影都是方阵，多头一分钱不多花。

Qwen3.8 打破了这个约定。hidden_size 是 5120，Q 头数是 24，5120 ÷ 24 = 213.33…——根本除不尽。而 config 里 head_dim 是一个独立写死的字段：

后果是：24 × 256 = 6144，比 hidden 的 5120 大。Q 投影把 5120 维升维到 6144 维（这还没算下一节的门），做完注意力之后 o_proj 再从 6144 降回 5120。也就是说，注意力内部工作在一个比主干更宽的空间里。

这在 Transformer 里不常见：通常要么等宽，要么为省参数而更窄。宽 20% 是实打实的额外开销，Q、K、V、O 四张矩阵都跟着变大。

4.3 输出门：Gated Attention 的「Gated」在哪

config 里还有一行，这一行是「Gated Attention」这个名字的来历：

输出门（output gate）：一路和 Q 同样宽的信号 g，经过激活函数后逐元素乘到注意力输出上。output_gate_type: "swish" 说明用的激活是 swish。它的参数不是另开一张矩阵来的，而是把 q_proj 的输出宽度直接翻倍——前一半当 Q，后一半当门。

所以 q_proj 的形状是 5120 × (24 × 256 × 2) = 5120 × 12288。整层的账现在可以完整算出来了：

4.4 部分 RoPE：只给四分之一的维度加旋转

第2章留了个尾巴：注意力天生看不见顺序，位置信息必须单独注入。Qwen3.8 用的是 RoPE，而且用法很特别。先把原理讲清楚。

旋转位置编码（Rotary Position Embedding, RoPE）：不往向量上加东西，而是转它。把 q 向量相邻的两个维度看成平面上的一个点 (x, y)，位置 m 就把这个点绕原点旋转 mθ 弧度；k 也照做。整个 d_rot 维就是 d_rot/2 对这样的平面点，每对用不同的转速。

它的核心性质是一句几何常识：两个转过的向量做点积，转的角度会相减。

这一句「角度相减」就是 RoPE 全部的价值：注意力分数自动只依赖相对位置，而不需要模型去记住绝对位置。而且 R 是一个纯函数——RoPE 一个参数都不带，这就是为什么表 4-1 里没有它的份。

多个转速：为什么不能只用一个角度

如果所有维度都用同一个 θ，位置每增加 2π/θ 向量就转回原处，模型分不清位置 5 和位置 5+2π/θ。所以 RoPE 用一整套从快到慢的转速：快的那几对对近距离敏感，慢的那几对要几万个位置才转小半圈。rope_theta 就是控制这个速度谱有多宽的底数。

Qwen3.8 的 rope_theta 是 10,000,000（1e7），比常见的 10,000（1e4）大三个数量级。按式 4-2，在 d_rot=64 时，最慢那一对的转速是 base^−62/64：base=1e4 时约 1.33×10⁻⁴ 弧度每位置，转一整圈要约 4.7 万个位置；base=1e7 时约 1.66×10⁻⁷，转一圈要约 3800 万个位置（本站按式 4-2 计算）。原生上下文 262,144、外推目标 1,010,000，都远在一圈之内——大 base 就是为长上下文准备的。

只转四分之一

现在是这一节真正特别的地方。config 里：

head_dim 是 256，但只有 64 维（32 对）参与旋转，剩下 192 维原封不动地穿过去，不带任何位置信息。

4.5 mRoPE：27B 独有的那一段

把两份 config 并排放，会看到一处只在 27B 出现的东西：

多模态旋转位置编码（multimodal RoPE, mRoPE）：把参与旋转的那些维度对分成几段，每一段吃一个坐标轴。27B 的 mrope_section 是 [11, 11, 10]——三段，长度分别是 11、11、10 对。

这三个数加起来是 32。这不是巧合：head_dim 256 × partial_rotary_factor 0.25 = 64 维参与旋转，而 RoPE 是成对使用的（每两维凑成一个平面点），64 ÷ 2 = 32 对。mrope_section 把这 32 对切成三份，正好分完。你可以把这条当成一个自检：如果哪天看到一份 config 里三段和不等于 head_dim × partial_rotary_factor ÷ 2，那多半是抄错了。

不管细节如何，有一件事是确定的：这是「稠密 vs MoE」之外，两个模型的又一处真实架构差异，而且它的来源不是「谁大谁小」，是「谁要处理图像」。全站的主线到这里又多了一个证据——27B 和 2.4T 不是同一个模型的两个尺寸档，它们连位置编码都不一样。

4.6 这一层在 27B 里只出现 16 次

最后一个字段，也是把这一章接到后面几章的那一个：

64 ÷ 4 = 16。这一整章讲的东西，在 Qwen3.8-27B 里只出现 16 次。另外 48 层走的是完全不同的路——Gated DeltaNet，一种维持固定大小状态的线性注意力（第6章）。整机的布局是 16 次重复的「3 层 DeltaNet + 1 层全注意力」，每层后面各跟一个 FFN。

把账摆出来看比例：

注意力占 6.1%，比查表的 9.3% 还少。这不是说它不重要——16 层全注意力承担了整台机器唯一的「精确回看任意位置」的能力，第7章会讲为什么把它砍到 0 层不行。但从参数账上看，它确实是个小部件。而它真正昂贵的地方不在参数，在推理时的显存：那 16 这个数会原样出现在 KV cache 的公式里，也就是下一章的主题。

第5章 KV cache：推理为什么越来越慢

这一章回答三件事：为什么每生成一个词都要把前面所有词重算一遍（以及怎么不重算）、这份「不重算」的代价具体是多少字节、以及为什么全网几乎所有 Qwen3.8 显存计算器在这一项上都高估了整整 4 倍。

5.1 不缓存会怎样

把这笔账摊开算。第 3 章讲过，注意力要用三样东西：查询 Q、钥匙 K、内容 V。它们都是把每个 token 的向量乘上一张权重矩阵得来的。生成第 t 个 token 的时候，你需要的是这一个新 token 的 Q，和前面全部 t 个 token 的 K、V。

不缓存的话，第 1 步算 1 个 token 的 K、V，第 2 步算 2 个，第 3 步算 3 个……第 n 步算 n 个。总计算量是 1+2+3+…+n，也就是高中数学里那个等差数列求和：n(n+1)/2。

代具体数字：生成 1000 个 token，不缓存要做 1000×1001÷2 = 500,500 次 token 级的 K、V 投影；缓存的话只要 1000 次。差 500 倍。而且这个倍数会随长度继续拉大——如果一口气生成到 262,144 个 token（Qwen3.8-27B 的原生上下文长度），不缓存是缓存的 131,072 倍。一个本来跑 1 分钟的任务，会变成跑三个月。

5.2 缓存的代价是显存

时间省下来了，代价换到了空间上。缓存要存在显卡里，存多少字节是可以精确算出来的——而且这个公式只有四个因子，每个因子都能直接从 config.json 里读到。

拿到数字个数，换成字节就是再乘一个「每个数占几个字节」：

式 5-2 里最值得盯住的是 T 那一项：KV 显存和上下文长度严格成正比。不是「差不多成正比」，是一条从原点出发的直线。这就是为什么长上下文永远是显存问题，而不是算法问题。

5.3 代入 Qwen3.8-27B：一个反直觉的结果

现在把 Qwen3.8-27B 的数字填进式 5-1。mat/cfg27b.json 里能直接读到：num_hidden_layers: 64、num_key_value_heads: 4、head_dim: 256。

看到这三个数，绝大多数人会写下这一行：

错了。问题出在 L_full 上——式 5-1 里那个因子写的是全注意力层的层数，不是总层数。Qwen3.8-27B 的 64 层里，只有 16 层是全注意力。

所以正确的算式是：

32,768 个数字。fp16 每个数 2 字节 → 65,536 字节 = 64 KiB/token；fp8 每个数 1 字节 → 32 KiB/token。而按 64 层算出来的是 131,072 个数 → fp16 256 KiB/token，正好是真实值的 4 倍。

这张表里最刺眼的是最后一行的对比：真实值 61.65 GiB 已经很吓人了，错算值 246.58 GiB 会让人直接得出「这个模型根本没法在单机上开 1M 上下文」的结论——而真相是，在一张 141GB 的卡上，fp8 KV 的 1M 上下文（30.82 GiB）是有余地的。一个算错了的公式，会让人放弃一个本来做得到的方案。

上面这个计算器把两条算法并排放着：左边按 L_full=16 算，右边按 64 算。拖上下文长度的滑块，看两条柱子怎么分叉；再切量化位宽，看权重那一块怎么变。能不能塞进一张卡，从来不是权重一个人的事——这一点在下一节会被算成具体数字。

5.4 24GB 显卡到底能开多长上下文

「24GB 显卡能跑 Qwen3.8-27B」这句话，网上到处都是。它不算错，但它省略了一个决定使用体验的变量。把 5.2 的公式和量化后的权重体积放在同一张纸上，就能把这句话补完整。

这一节是全站这条推导的正本。第 1、4、6、7、8 章引用的那个上下文区间都从这里出来，第 17 章会把同一笔账再算一遍，并把它铺到 8GB / 16GB / 服务器几档硬件上。

接下来把 24 GiB 这块预算逐项摊完。一张卡上同时住着五样东西，权重只是最大的那一样；漏掉任何一项，上下文估计都会偏高，而偏高的后果是跑到一半突然显存不足。

五项逐个的来源与可靠性：

写成一句话就是：

• fp16 KV（64 KiB/token）→ 上下文约 8–10 万 token
• fp8 KV（32 KiB/token）→ 上下文约 17–20 万 token

注意这里为什么给的是区间而不是一个数：五项输入里有一项本身就是区间（框架开销 1.0–2.0 GiB）。一个输入不确定，输出就不该假装确定——把它写成「约 9 万」这样的单点值，会让读者以为这个数是测出来的。区间的宽度也是有信息的：1.0 到 2.0 GiB 这一整格的不确定性，只让结论在 8.3 万和 9.9 万之间摆动（19%），而 262K 需要 16 GiB 的 KV，是上沿的 2.6 倍——结论对那个最软的输入并不敏感。

5.5 KV cache 也能量化

式 5-2 里有四个因子，其中三个在模型出厂时就定死了，你改不了。但 b_dtype——每个数占几个字节——是推理时你自己能选的。

KV cache 量化（KV cache quantization）：把缓存里的 K、V 从 fp16（每个数 2 字节）改成 fp8（1 字节）来存，读的时候再还原成计算需要的精度。权重不动，只动缓存。在 vLLM 里就是启动时加一个参数 --kv-cache-dtype fp8；llama.cpp 那边对应的是 --cache-type-k 和 --cache-type-v。

效果是直给的：每 token 从 64 KiB 降到 32 KiB，同样的显存预算能开一倍长的上下文。表 5-1 的第三列就是这么来的，5.4 节那个「约 8–10 万 → 约 17–20 万」也是——注意翻倍的是区间的两端，结论仍然是区间。

5.6 2.4T 的账

同一个公式，换一组数。Qwen3.8-2.4T-A95B 是 92 层，其中 23 层全注意力 + 69 层线性（同样是 3+1 循环，重复 23 次），KV 头数 4，head_dim 256——注意后两个数和 27B一模一样，这也是「同一张图纸，不同的重复次数」这个说法的一处硬证据。

fp16 → 92 KiB/token，fp8 → 46 KiB/token。误按 92 层全算是 368 KiB/token，同样是整整 4 倍的高估——因为 3:1 这个比例在两个模型上是一样的，错算的倍数也就一样。

把 27B 和 2.4T 放在一起看会发现一个值得记住的对比：2.4T 的总参数是 27B 的将近 90 倍，但它每 token 的 KV cache 只是 27B 的 1.44 倍（92 ÷ 64 = 1.4375）。为什么？因为 KV cache 只跟全注意力层数、KV 头数、head_dim 有关，跟 FFN 有多宽、专家有多少个一点关系都没有——而 2.4T 那多出来的两万多亿参数，几乎全在 MoE 的专家里（第 9、10 章）。

第6章 Gated DeltaNet：把记忆压成固定大小

这一章回答：Qwen3.8-27B 的 64 层里，那 48 层「没有 KV cache」的层，到底把历史存到哪里去了？答案是一块永远不变大的记事本——以及为了让这块记事本不糊掉，需要做哪两件事。

6.1 问题：KV cache 随长度线性增长，这条路走不通

第 5 章算出来的数字，摆在一起看是这样的：

最后一行是这一章存在的理由：1M 上下文的 KV cache（61.65 GiB）比这个模型的全精度权重（约 50.9 GiB）还大。而这已经是只算 16 层之后的数字——如果 64 层全是全注意力，同样的 1M 上下文要 246.58 GiB，一台八卡机器装完权重之后也塞不下。

问题的性质要看清楚：权重是常数项，KV cache 是随长度线性增长的项。两者之间没有任何一种量化能改变的力量对比——fp8 KV 把每 token 从 64 KiB 砍到 32 KiB，是把那条直线的斜率减半，撞墙的位置往后挪一倍，仅此而已。要把 100 万上下文变成日常可用，需要的不是更小的斜率，是把这条线掰平。

6.2 换个思路：只存一个固定大小的记事本

线性注意力（Linear Attention）：把注意力里的 softmax 拿掉（或者换成别的、可以拆开的函数）之后得到的一族机制。拿掉 softmax 会损失一些表达能力，但换来一个决定性的好处——历史可以被累加进一个固定大小的矩阵，不必逐条保留。

看看拿掉 softmax 之后会发生什么。第 t 步的输出本来是「对所有历史 v_i 按权重求和」。去掉 exp 和归一化，权重就是裸的点积 q_t·k_i：

也就是 o_t = Σ_i≤t (q_t·k_i) v_i：把每个历史位置的内容 v_i，按它的键和当前查询的点积大小加权，全部加起来。

这一步是全章的转折点：点积是可以结合律重排的。(q·k_i)v_i 可以写成 (k_iv_i^⊤)^⊤q，于是求和号可以整个挪到 q 的另一侧，先把所有 k_iv_i^⊤ 加起来，再让 q 去乘这个和。而那个和，就是我们要的记事本：

把式 6-1 和第 5 章的 KV cache 并排放，差别一目了然：KV cache 要存 T 份 k 和 T 份 v；式 6-1 只存一张 d_k×d_v 的表，T 完全不出现在它的尺寸里。

6.3 delta rule：怎么往记事本上写才不糊

式 6-1 有一个致命毛病，一句话就能说清：它只会往上叠，从来不擦。

设想同一个地址被写了两次：第 5 个 token 写下 k, v₁，第 900 个 token 又用几乎同一个 k 写下 v₂。式 6-1 的结果是 S 里那个方向上同时躺着 v₁ 和 v₂，用 q≈k 去查，取回来的是 v₁+v₂——两条信息糊成了一条，而且没有任何办法把它们分开。序列越长，糊得越厉害，几万个 token 之后记事本变成一团噪声。

门控增量网络（Gated DeltaNet）：Yang、Kautz、Hatamizadeh 等人在 arXiv:2412.06464（Gated Delta Networks: Improving Mamba2 with Delta Rule，NVIDIA，ICLR 2025）提出的线性注意力层，也是 Qwen3.8 那 48 层（2.4T 是 69 层）线性注意力的原型。它同时装了两个遗忘机制：一个整体的门控，一个定点的 delta rule。

论文自己的总结是一句很短的话：「gating enables rapid memory erasure while the delta rule facilitates targeted updates」（arXiv:2412.06464）。翻成大白话就是分工明确的两个旋钮——门控 α 管「快速整体遗忘」（话题变了，整页调淡），delta rule 管「定点精确更新」（这一条记录改了，只改这一条）。少了门控，换话题时旧内容会一直拖着；少了 delta rule，同一个地址被反复写就会糊。两者互补，缺一个都不行——这也是 6.4 节那个实验室里两个「故意弄坏」开关分别在演示的事。

6.4 亲手跑一遍：递推形式 vs 分块并行形式

式 6-2 有一个工程上的麻烦：它是递推的。S_t 要等 S_t−1 算完才能开始，一个 token 接一个 token，没法并行。推理时这不成问题（本来就是一个字一个字往外蹦），但训练时是灾难——训练时整段几万 token 的序列是一次性喂进去的，如果被迫串行走几万步，GPU 上几万个计算单元会一直闲着等。

分块并行形式（chunkwise parallel form）：把序列切成固定长度的块（比如每 64 或 128 个 token 一块），块内用矩阵乘法一次算完，块与块之间只传递一个状态矩阵。于是串行的步数从「token 数」降到「块数」，而块内是 GPU 最喜欢的稠密矩阵乘。

这里有一条铁律：两种形式必须在数学上严格等价。训练用分块并行、推理用递推，如果两条路径算出来的东西不一样，那就是「训练的模型」和「部署的模型」不是同一个模型——症状是训练指标好看、一上线就胡说，而且极难定位。所以任何一份 DeltaNet 实现，第一件事都是拿这两条路径互相对拍。

上面这个实验台就在做这件事：同一组随机的 q, k, v, α, β，一路按式 6-2 逐 token 递推，另一路按分块并行算，然后逐元素比最大绝对差。如果实现是对的，这个差应该只剩浮点舍入的量级——双精度下大约 1e-16，单精度下大约 1e-6。它不会是 0（加法的顺序不同，舍入就不同），但也绝不该是 1e-2。

实验台上还有两个「故意弄坏」的开关，建议都拨一遍：

• 关掉门控（强制 α=1）：把序列拉长，看状态矩阵的数值范围怎么一路涨上去，以及读出来的结果怎么逐渐变成一团分不开的平均。这是 6.3 节说的「糊」，眼见为实。
• 关掉 delta rule 的擦除项（只留 Diag(α)S + βkv^⊤）：这时两条路径仍然各自自洽，但它们算的已经不是同一个递推了；把这个残缺版的递推结果和完整版比，误差会从 1e-16 直接跳到 1e-1 量级——差好几个数量级。这个跳变正好说明擦除项不是可有可无的修饰。

6.5 Qwen3.8 的 DeltaNet 层长什么样

把 mat/cfg27b.json 里跟线性注意力有关的几行挑出来，逐条读：

最后一行值得多说一句。mamba_ssm_dtype 这个字段名里的 Mamba 直接说明了血缘：Gated DeltaNet 属于 Mamba 这一系的状态空间 / 线性循环模型，它的论文副标题就是「Improving Mamba2 with Delta Rule」。而把状态钉死在 fp32 是有原因的：状态是一路乘下去的（门控 α 逐步连乘），几万步之后 bf16 的舍入误差会累积到不可忽略。这一行配置本身就是「这个部件对数值精度敏感」的官方声明。

参数账

用 mat/paramcount.out.txt 里逐张矩阵数出来的结果：

in_proj_ba 那一行是本节最有信息量的一处：96 = 48 + 48，说明 β 和 α 各是「每个值头一个标量」，而不是每个维度一个数。式 6-2 里写成 Diag(α) 的一般形式，在 Qwen3.8 这里退化成了「整块乘同一个数」。这不是从文档上抄来的，是从矩阵形状上数出来的——config 里没有任何一行字直接说这件事。

记事本到底有多大

状态矩阵是 d_k×d_v = 128×128 = 16,384 个数，每个头一份。一层有多少份，取决于状态是按 K 头分还是按 V 头分。按 Gated DeltaNet 原论文的定义，每个值头各持有一个 d_k×d_v 的状态矩阵，键／查询头通过重复对齐到值头——所以份数看的是 linear_num_value_heads：

• 按 48 个 V 头各存一份（本站口径）：48 × 128 × 128 = 786,432 个数／层 → fp32 3 MiB/层，48 层共 144 MiB
• （如果误按 16 个 QK 头算：16 × 128 × 128 = 262,144 个数／层 → 1 MiB/层，48 层共 48 MiB——这是本站早先的算法，已作废）

6.6 那个 4 长的因果卷积在干嘛

linear_conv_kernel_dim: 4。这个部件小到几乎会被忽略：40,960 个参数，是 27B 里最小的部件之一。对比一下——FFN 里随便一张矩阵是 89,128,960 个参数，是它的 2176 倍；全部 48 层的卷积加起来 1,966,080 个参数，占 27.36 B 的 0.007%。

因果卷积（causal convolution）：沿着序列方向、只往回看不往前看的滑动窗口。核长 4 意味着每个位置的输出由「它自己 + 前 3 个 token」这四个位置线性组合而来。「因果」就是「不许看未来」的意思，和注意力里的因果掩码是同一个约束。

它在补什么？纯线性注意力的短程能力偏弱。回想式 6-1 的读取方式：o = S^⊤q——这是一次「按内容查询」，它对「谁挨着谁」是天然不敏感的。「上一个 token 是什么」这种最基本的局部信息，理论上可以由状态里的某个方向携带，但要靠训练把它挤出来，代价不低。而一个核长 4 的卷积用四万个参数就把这件事办了：每个位置直接拿到最近 4 个 token 的线性组合。用最便宜的部件解决最局部的问题，把状态矩阵腾出来干远距离的活。

顺带算一笔常被忽略的账：卷积也需要一个小缓存——要算下一个位置，得记住最近 3 个 token 在那 10240 个通道上的值。fp32 下约 120 KiB/层。它同样与序列长度无关，同样是每条请求各一份。

6.7 代价：它记不住细节

前面六节讲的都是好处。现在讲代价，而且这个代价不是工程上没做好，是数学上必然的。

一个数数就能说清的论证：状态矩阵的键那一侧只有 d_k = 128 维。任何 128 维空间里，最多只能有 128 个线性无关的向量。序列走到第 129 个 token 时，它的 k₁₂₉ 必然可以写成之前某些 k 的线性组合——也就是说，往这个「新地址」上写东西，不可能不动到旧地址上的内容。到了 262,144 个 token，平均每一个键方向上挤着两千多个 token。

相比之下，全注意力在 262K 上下文下老老实实存了 262,144 份 K 和 V，每一份都在原地，一个字节都没混。这就是那 16 GiB 买到的东西：精确回忆。

具体会在什么任务上翻车？典型的是「大海捞针」（needle in a haystack）这一类：在十几万字里藏一句无关紧要的话，然后问模型那句话说了什么。这种任务要的正是逐字精确回忆一个没有任何语义重要性的细节——恰好是固定大小状态最不擅长的：它在压缩的时候必须有所取舍，而一句「不重要」的话在写入的那一刻看不出后面会被问到。

那么，一个自然的问题：既然线性注意力有这个硬伤，为什么不干脆全用全注意力？答案在第 5 章已经算过——262K 要 16 GiB，1M 要 61.65 GiB，而且这还是打了四折之后的数字。两条路各有一个致命缺点：全注意力记得住但装不下，线性注意力装得下但记不住。Qwen3.8 的选择是两个都用，按 3:1 混着排。下一章专门讲这个比例：为什么是 3:1，为什么那 16 层全注意力必须留着，以及它们各自在这个模型里承担了什么。

第7章 3:1 混合布局：两种记忆的分工

这一章回答一个工程问题：既然全注意力太贵、线性注意力又记不准，那到底该放多少层全注意力？Qwen3.8 的答案写在 config.json 的一个数字里——full_attention_interval: 4。

7.1 两个极端都不行

捷径一：64 层全是注意力

第 5 章的公式还记得吧——每个 token 要在每一个全注意力层里留下一份 K 和一份 V。把 64 层全做成注意力层，这笔账是这样的：

把 L_full 填成 64（假装 64 层全是注意力），fp16：2 × 64 × 4 × 256 × 2 = 262,144 字节 = 256 KiB，每个 token 都要这么多。Qwen3.8 的原生上下文是 262,144 个 token，乘起来是 64 GiB。

64 GiB 是什么概念？一张 RTX 4090 是 24 GB 显存，你需要三张 4090 只用来放 KV cache——模型权重还一个字节都没放呢。这条路直接死掉。

捷径二：64 层全是 Gated DeltaNet

那反过来，全用第 6 章那种固定大小的记事本？KV cache 直接归零，显存问题一夜消失。代价出现在另一个地方：精确回忆。

大海捞针（Needle in a Haystack）：一类专门用来测长上下文的任务。做法是把一句无关的话（针）藏进一篇几十万字的长文（草堆）里，然后问模型那句话是什么。它考的不是理解，是逐字复述某个具体位置的内容。

全注意力层为什么能做对这种题？因为它把每个 token 的 K、V 原封不动地存着，要找第 137,492 个 token 时，直接去那一格取就行——它是一本翻得到任意一页的书。

Gated DeltaNet 不是书，是一块固定大小的白板。第 6 章讲过，它的状态矩阵形状是固定的，新信息进来就要往上写，写多了就得擦掉一些旧的（那个门控就是在决定擦多少）。读了 20 万字之后，白板上留下的是一份被反复覆写过的摘要。摘要能答「这篇文章讲什么」，答不了「第 137,492 个字是什么」。

这里要格外小心一件事：并不是说线性注意力「不行」。它在语言建模的整体困惑度上可以做得很接近，甚至在长文本吞吐上远远胜出。它塌下去的是一小类但极其常用的能力：精确定位、逐字复述、多跳查表。而这类能力恰好是你把一份 20 万 token 的代码库丢给模型时最需要的那种。

7.2 Qwen3.8 的答案：每 4 层放 1 层全注意力

两个极端都走不通，那中间路线在哪儿？Qwen3.8 的答案朴素得有点让人失望：每 4 层里放 1 层全注意力，其余 3 层用 Gated DeltaNet。这就是本章标题里的 3:1。

这不是我推断的，是 config.json 里明写的一个数：

「interval 4」的意思是：每隔 4 层出现一次全注意力层。从第 1 层开始数，第 1、2、3 层是线性层，第 4 层是全注意力；第 5、6、7 层是线性，第 8 层是全注意力……一直到第 64 层。所以全注意力层的层号就是 4 的倍数：4、8、12、16、20、24、28、32、36、40、44、48、52、56、60、64——正好 16 个。

三代同构：同一张图纸，只是重复次数不同

现在把这个模板拿去套另外两个模型，会看到全站最值得记住的一张表：

盯着中间那一列看：(3×DeltaNet + 1×Attention) 这个括号里的东西，三个模型一模一样。48 = 12 × 4，64 = 16 × 4，92 = 23 × 4。三个模型的差别，在这一列上只剩下括号前面那个数字：12、16、23。

这正是第 1 章那张四轴表里的第 ③ 轴（注意力布局）。第 ③ 轴上，27B 和 2.4T 的差别是 16 组 vs 23 组；第 ② 轴上，差别是稠密 FFN vs MoE。这两件事都在训练之前就定死了——图纸画出来就是那样，不可能训练完再改。而第 ④ 轴的量化发生在训练之后，它一层都不动，只是把每个数字记得粗一点。这一章看到的东西，就是「尺寸差异发生在训练之前」这句话最直观的证据。

7.3 谱系：这个设计从哪来

问「这个设计从哪来」的时候，很容易得到一个含糊的答案。这里要把它拆成两层，因为这两层确实指向两个不同的东西。

设计源头：Qwen3-Next（2025-09）

3:1 混合布局第一次在 Qwen 系列里出现，是 2025 年 9 月的 Qwen3-Next-80B-A3B。表 7-1 的第一行就是它：48 层 = 12 组。Qwen3.8 用的是同一个比例，只是把组数从 12 加到了 16（27B）和 23（2.4T）。

Alibaba Cloud 的官方博客在介绍 Qwen3-Next 时把这个比例写得很直白：3:1 ratio (75% layers use Gated DeltaNet, 25% keep standard attention)，并给出 32K 以上上下文吞吐提升约 10 倍的说法。这是目前能找到的、关于「为什么这么设计」最接近一手的公开表述。

代码谱系：Qwen3.5

另一条线索藏在 config.json 的最上面两行。Qwen3.8-27B 的 model_type 写的不是 qwen3_8，而是 qwen3_5；architectures 写的是 Qwen3_5ForConditionalGeneration。模型卡的原文也说它是 Built on the architectural foundation of Qwen3.5。

这说明：3:1 的设计思路来自 Qwen3-Next，但落到代码上、固化成主线架构的是 Qwen3.5，Qwen3.8 直接复用了那一套实现。所以你在 Hugging Face 上加载 Qwen3.8 时，transformers 里跑的其实是名字叫 Qwen3_5 的那份类定义——这不是故障，是架构没变。

为什么必须保留少量全注意力层：论文级的论证

Qwen3.8 没有技术报告，所以「为什么不能全用线性层」这个问题，官方没有正面回答过。但这个问题在公开文献里被反复论证过，两篇最直接的是：

Jamba（arXiv:2403.19887）把状态空间层和注意力层混在一起，专门讨论了为什么少量注意力层不可省。Samba（arXiv:2406.07522）做了一组更简洁的混合架构消融，把「加多少注意力」这件事的取舍摆出来看。这两篇给出的是同一个方向的结论：把注意力层砍到零，一类依赖精确检索的能力会明显退化；而只要保留一小部分，退化就能被很大程度地补回来。

换句话说，3:1 这个具体的比例是 Qwen 团队的工程选择，但「必须留一点全注意力」这件事本身，是有公开论文支撑的。

7.4 这个比例换成别的会怎样

光看结论没意思。既然 full_attention_interval 就是一个数，那就把它当成旋钮拧一拧：从 1（每层都是全注意力，退化成传统 Transformer）拧到 8（更稀疏，全注意力层只剩 8 层）。左边是显存，右边是能力，中间是你要做的取舍。

拖动 interval，两条曲线会朝相反方向走：全注意力层数越多，KV cache 越大，但那个「精确回忆」小任务的成功率越高；层数越少，显存越省，成功率越往下掉。你要找的不是某个「最优点」——这条曲线上没有最优点，只有取舍点。你在意什么，最优点就在哪儿。

另一件值得亲眼看一遍的事：随着对话越来越长，那 16 层的 KV 是怎么一根一根长上去的，而另外 48 层始终是同一个高度。

7.5 省下来的到底是什么

现在把账彻底算清楚。同样是 Qwen3.8-27B 那些参数（4 个 KV 头、head_dim 256、fp16），只改层布局这一件事：

48 GiB。这就是「每 4 层放 1 层全注意力」这个决定，在 262K 上下文下换来的东西。48 GiB 相当于两张 4090 的全部显存，或者说：它把「必须用多卡才能碰的长上下文」变成了「单卡有机会摸到的东西」。第 17 章会看到，24GB 卡上到底能跑多长，答案完全建立在这 48 GiB 上。

但这不是免费午餐

省下 48 GiB 的代价，前面已经说过一遍，这里必须再说一遍，因为它太容易被「省了 48 GiB」的兴奋盖过去：那 48 层的记忆是有损的。

更准确地说：全注意力层的记忆是「无损但线性增长」，Gated DeltaNet 的记忆是「有损但恒定」。3:1 混合的意思是——你手上有一条 16 层宽的无损通道，和一条 48 层宽的有损通道，模型必须学会把「以后可能要逐字调用的东西」尽量塞进前者。这件事它做得好不好，官方没给数据。这也是为什么 7.4 那个实验室必须写清楚「本站模拟」。

7.6 vLLM 是怎么伺候这种模型的

到这里为止，混合架构看起来只有好处：省显存、保能力。但工程上从来没有白拿的东西——它把复杂度转嫁给了推理框架。

问题出在显存管理上。传统 Transformer 的推理框架（比如 vLLM 的 PagedAttention）把 KV cache 切成一个个大小相同的块（block），像操作系统管内存页那样分配和回收。这套机制的前提是：所有层长得一样，每层每 token 占的空间相同，一块就是一块。

混合架构把这个前提打破了。现在框架要同时管两种东西：

vLLM 在支持 Qwen3-Next 时给出的做法是：自动调整全注意力层的「逻辑块大小」，让两类层占用相同的物理显存。翻译成人话——既然 DeltaNet 层每个序列固定要吃掉一块（比如 3 MiB），那就把注意力层的块也凑成同样大小，这样显存池里全是等大的格子，分配器又可以按老办法工作了。这是个很朴素但很聪明的对齐技巧：不去改分配器，而是把两种不同形状的东西都塞进同一种盒子。

顺带一个数字，来自 vLLM 给 Qwen3.8-27B 的部署 recipe：单卡跑 1M 上下文的配置下，可容纳约 6.6M 个 KV token。能报出这么大的数，前提正是这一章讲的——真正吃 KV 的只有 16 层。

第8章 FFN：62.6% 的参数都在这里

这一章回答一个会让人愣一下的问题：你花了五章学注意力，可注意力只占 Qwen3.8-27B 参数的 6.1%。那 62.6% 的参数在哪儿？在一个到现在为止只被顺带提过一句的东西里——每一层后面挂着的三张矩阵。

8.1 注意力负责「看谁」，FFN 负责「想什么」

所以一个 Transformer 层其实是两个动作交替：

注意力（或 DeltaNet）负责「看谁」——当前这个位置该从上下文的哪些位置取信息，取多少。它是个搬运工兼调度员，本身不加工内容。第 3 到第 7 章讲的全是这件事。

FFN 负责「想什么」——拿到搬过来的那一堆信息之后，在这个位置上单独做一次加工。注意「单独」这两个字：FFN 是逐位置（position-wise）作用的，第 5 个 token 的 FFN 计算和第 500 个 token 的 FFN 计算互不干扰，用的还是同一套权重。它完全不看别的位置。

前馈网络（Feed-Forward Network, FFN）：Transformer 每一层里那个「只看自己、不看别人」的加工模块。输入一个向量，输出一个同样长度的向量，中间先把维度撑宽、做一次非线性、再压回来。

还有一个常被提到的说法：FFN 那个被撑宽的中间层，很像一个键值查找表——宽出来的每一维可以看成一条「如果输入长这样，就往输出里加这个东西」的规则。17408 维就是 17408 条规则。这个视角能解释为什么 FFN 要占掉这么多参数：模型学到的大部分具体知识，是存在这些规则里的，不是存在注意力里的。

8.2 SwiGLU：三张矩阵而不是两张

最早的 Transformer 里，FFN 是两张矩阵：先用一张把 5120 维撑到宽的中间维，做一次非线性，再用另一张压回 5120。Qwen3.8 用的是三张。config.json 里的线索有两条：

门控前馈网络（Gated Linear Unit, GLU 系列，Qwen3.8 用的这一种叫 SwiGLU）：把撑宽这一步拆成两条并行的路——一条叫 gate_proj（门），一条叫 up_proj（内容）。门这条路先过一次非线性，再和内容那条路逐元素相乘，相乘的结果才送去第三张矩阵 down_proj 压回原维度。

那个 silu 长这样：

为什么是三张不是两张

两张矩阵的老式 FFN 里，中间那 17408 维的每一维都是「算出来多少就往下传多少」，非线性只负责把负数压掉。三张矩阵的版本多了一个能力：每一维放行多少，是由输入自己另算出来的一个数说了算的。

具体看第 i 维：up_proj 算出一个值（内容），gate_proj 算出另一个值再过 silu（开度），两个一乘。如果开度接近 0，这一维的内容就被掐灭了，不管它本身多大；如果开度接近 1，内容原样放行。也就是说，网络可以学会「只在满足某种条件时才启用某条规则」。

回到 8.1 那个查找表的视角：两张矩阵的版本，17408 条规则总是全体参与，只是权重不同；三张矩阵的版本，网络可以为每条规则单独学一个「什么时候该醒过来」的条件。门控买到的是选择性。

8.3 算账：一层 FFN 是 267.39M

三张矩阵，每张的形状都是 5120 × 17408（down_proj 是 17408 × 5120，参数个数一样）。矩阵的参数个数就是它的行数乘列数——这是第 0 章的内容。

先感受一下 267.39 M 这个数：一层 FFN 的参数，就比整个 Qwen3-0.6B 那个量级的小模型还多出一大截。而 Qwen3.8-27B 有 64 层。

关键的一步：64 层全都有 FFN

这里是最容易算错的地方。第 7 章刚说过 64 层里只有 16 层是全注意力，很容易顺手以为 FFN 也只有 16 层。不是。每一层——不管它的前半截是 Gated Attention 还是 Gated DeltaNet——后半截都挂着一个 FFN。第 7 章建造台阶里那句 layers.append(FFN(cfg)) 写在 if/else 外面，就是这个意思。

所以：64 × 267,386,880 = 17,112,760,320 ≈ 17.11 B。

17.11 B ÷ 27.36 B = 62.6%。这个模型三分之二的参数，在这三张平平无奇的矩阵里。

再对照第 7 章看一眼，会发现一个有意思的错位：参数占比和显存增长是两件完全不同的事。FFN 占了 62.6% 的参数，但它一个字节的 KV cache 都不占——因为它逐位置计算，算完就扔，什么都不用缓存。反过来，Gated Attention 只占 6.1% 的参数，却贡献了 262K 上下文下那全部 16 GiB 的 KV。权重是一次性买断的固定成本，KV 是按使用量计费的变动成本。

8.4 17408 这个数从哪来

17408 看起来像个随便挑的数。把它和 5120 一除，规律就出来了：

17408 ÷ 5120 = 3.4，正好是个一位小数。

扩张比（expansion ratio）：FFN 中间维和模型隐藏维的比值。它决定 FFN 把向量「撑多宽」再压回来。这个比值几乎是每个 Transformer 都要选的一个超参数。

为什么正好是 3.4 这么干净？因为这两个数都是 1024 的整数倍：5120 = 5 × 1024，17408 = 17 × 1024。所以扩张比其实是 17 ÷ 5，一个整数比。1024 的倍数对硬件友好——GPU 做矩阵乘法时按固定大小的块切分，维度能被 128、256 这类数整除时，最后一块不会只填一半，算力不浪费。

常见的扩张比有两个传统档位：

4 倍——最早的 Transformer 和 GPT 系列用的就是这个，那时候 FFN 是两张矩阵，参数量 = 2 × 4 d² = 8 d²。

8/3 ≈ 2.67 倍——LLaMA（arXiv:2302.13971）那一路的做法。逻辑很清楚：换成三张矩阵的 SwiGLU 后，为了让参数量和老式 4 倍两矩阵版本持平，就得把中间维乘上 2/3，于是 3 × (8/3) d² = 8 d²，正好对上。

Qwen3.8 的 3.4 落在这两档之间偏上：3 × 3.4 = 10.2 d²，比老式 4 倍 MLP 的 8 d² 多出 27.5%。翻译过来就是：它没有为了省参数而缩窄 FFN，反而在 FFN 上比传统配置多花了钱。这和 8.3 那个 62.6% 是同一件事的两种说法。

8.5 铺垫：如果把这一张大矩阵切成很多小的

把这一章的账再看一眼：一层 FFN 267.39 M，64 层 17.11 B，占全模型的 62.6%。现在换个角度提问——

Qwen3.8-2.4T-A95B 是怎么做到 2.4 万亿参数的？

先用这一章的方法试着推一下。它的隐藏维是 8192。如果它也是稠密 FFN，用同样的 3.4 扩张比，中间维大约 27,853，一层 FFN 就是 3 × 8192 × 27853 ≈ 684 M。它有 92 层，FFN 总量约 63 B。离 2.4 万亿差着三十多倍。

那把中间维再撑大三十几倍呢？中间维就得做到一百多万（27,853 × 38 ≈ 106 万）。这条路会死在两个地方：一是显存装不下——权重体积是按总参数算的，2.4 万亿参数光 BF16 权重就是 4.40 TiB；二是速度垮掉——稠密 FFN 的每一个参数，每来一个 token 都要参与一次乘加，参数涨三十倍，每个 token 的计算量就涨三十倍。

矛盾就摆在这儿：我们想要更多的参数（装更多知识），但不想要更多的计算（每个 token 还是要快）。稠密 FFN 把这两件事焊死了——参数量和计算量严格成正比。

第9章 MoE：把 FFN 切成 512 份

上一章留下一个矛盾：知识存在 FFN 里，想多存就得加参数；可稠密 FFN 的每一个参数，每个 token 都要用一遍——加参数就是加计算。这一章讲那个把这两件事拆开的办法：把一张 17408 维的大矩阵，换成 512 张 2048 维的小矩阵，每次只用其中 11 张。Qwen3.8-2.4T 的两万四千亿参数，就是这么堆出来的。

9.1 上一章留下的那个死结

先把第 8 章的账重抄一遍，因为整章都是从这三个数出发的。Qwen3.8-27B 的一层稠密 FFN 是 267,386,880 个参数（3 × 5120 × 17408），64 层加起来 17.11 B，占全模型的 62.6%。知识主要存在这里。

那么问题来了：如果想让这个模型多知道一百倍的东西，该怎么办？

最直接的想法是把 FFN 加宽——中间维从 17408 拉到 1,740,800。参数量确实涨了 100 倍。代价呢？这里需要第 0 章那条最朴素的事实：矩阵乘法里，每一个参数在每一次前向传播中都要被用上一次，做一次乘法、一次加法。所以对稠密模型来说：

这就是死结。你想要的是知识多，被迫付出的是每个字都变慢一百倍。而且这两件事在稠密结构里是绑死的，你没有任何旋钮可以只拧其中一个。

9.2 条件计算：参数量和计算量第一次分家

混合专家（Mixture of Experts, MoE）：把一层里那一张大 FFN 换成很多张小 FFN（每一张叫一个专家，expert），再配一个小小的路由器（router，也叫 gate）来决定当前这个 token 该交给哪几个专家处理。没被选中的专家，这一次前向传播里一个乘法都不做。

这个结构最著名的一句广告词来自 Switch Transformer（arXiv:2101.03961）的摘要，原文是：一个稀疏激活的模型，拥有「outrageous numbers of parameters」（大得离谱的参数量），「but a constant computational cost」（但计算成本恒定）。这句话里最重要的是那个 but：它宣告了参数量和计算量从此可以分别定价。

再补一句类比失效处：图书馆里是人在挑书，挑的依据是书名和目录；MoE 里是一个小神经网络在挑，它挑的依据既不是书名也不是内容，而是当前那个 5120 维（在 2.4T 里是 8192 维）向量指向哪个方向。这个「小神经网络」朴素得会让你吃惊——下一节专门讲它。

9.3 路由：谁来决定去哪几个专家

你可能会想象路由器是个复杂的东西——毕竟它要在 512 个专家里做选择，还要选得有道理。实际上它是这样的：

然后取分数最高的 10 个（num_experts_per_tok: 10），把这 10 个分数重新归一化成权重，让对应的 10 个专家各处理一遍 x，按权重加起来。再加上一个永远参与的共享专家（9.5 节讲它）：

现在把这张路由矩阵放回它的尺寸感里：它有 4,194,304 个参数，而它所在的这一层一共有 25,824,329,728 个参数。0.016%。也就是说，决定这一层 258 亿参数里哪 5.58 亿会被唤醒的，是一张只占这一层万分之一点六的小矩阵。

9.4 Qwen3.8-2.4T 的具体配置：逐条读那五个字段

现在打开 mat/cfg24t.json，和 MoE 相关的一共五个字段，一条条读：

细粒度专家：2048 这个数有多窄

先感受一下 2048 有多窄。第 8 章讲过，27B 的稠密 FFN 是 hidden 5120 撑到 17408，扩张比 3.4——中间层比进出口宽三倍多。而 2.4T 的一个专家是 hidden 8192 撑到 2048，扩张比 0.25：中间层比进出口窄了四倍。这不是「一个小一点的 FFN」，这是一个瘦到几乎不像 FFN 的东西。

为什么要切这么细？DeepSeekMoE（arXiv:2401.06066）的论文里把这个策略叫细粒度专家切分（fine-grained expert segmentation），原文的说法是把专家「finely segmenting the experts into mN ones and activating mK from them」——把 N 个专家各切成 m 份变成 mN 个，同时把激活个数从 K 提到 mK。切完之后总参数量和总计算量都不变，变的只有一件事：组合数。

这个「组合数」是整个细粒度策略的全部理由，值得把数字摆出来。假如是 64 个专家选 1 个，一共只有 64 种搭配方式；而 512 个选 10 个，搭配方式有

同样的参数量、同样的计算量，切得更细就能表达出多得多的组合。这是细粒度专家唯一的、也是全部的论证。

算账：一层 MoE 到底多少参数

一个专家就是第 8 章那个 SwiGLU，三张矩阵一张不少，只是中间维换成 2048：

两者的比值是 25,824,329,728 ÷ 557,842,432 = 46.29。也就是说，这一层里每 46 个参数只有 1 个会为当前这个 token 干活。

这个对比值得多停留一秒。你花了八章造出来的那个 27B 模型，从嵌入表到输出头、64 层全部零件加起来 27.36 B——还装不满 2.4T 的一层。而 2.4T 有 92 层。

但如果只看每 token 的计算量，画风完全变了：2.4T 一层 MoE 激活 557.84 M，27B 一层 FFN 是 267.39 M，只差 2.09 倍。这 2.09 倍还能拆开验算：2.4T 每 token 实际过的中间维总和是 11 × 2048 = 22,528，27B 是 17,408，比值 1.29；hidden 是 8192 对 5120，比值 1.6；1.29 × 1.6 = 2.07，和 2.09 对得上（零头来自路由门）。

9.5 共享专家：那个永远被激活的第 11 个

回到式 9-2 里那个 E_共享。它和另外 512 个专家形状完全一样（3 × 8192 × 2048 = 50,331,648），唯一的区别是：它不参与选择，每个 token 都要过它一遍。

解决办法朴素得可爱：把这份通用知识单独抽出来，放进一个永远激活的专家里。DeepSeekMoE（arXiv:2401.06066）把这个策略叫共享专家隔离（shared expert isolation），原文写的是「isolating K_s experts as shared ones, aiming at capturing common knowledge and mitigating redundancy in routed experts」——隔离出若干个共享专家，目标是承接通用知识、减轻路由专家里的冗余。

这两条策略——细粒度切分和共享专家隔离——正是 DeepSeekMoE 论文的全部两大主张，而 Qwen3.8-2.4T 的配置把它们同时用上了：512 个又细又窄的路由专家（细粒度），外加 1 个永远在岗的共享专家（隔离）。

再看一眼共享专家的性价比：它占这一层总参数的 50,331,648 ÷ 25,824,329,728 = 0.195%（五百分之一），却占这一层激活参数的 50,331,648 ÷ 557,842,432 = 9.0%（十一分之一）。用总量千分之二的参数，接住了每个 token 都要用的那部分知识。

9.6 负载均衡：不管它，路由会塌

现在讲那个最小的字段：router_aux_loss_coef: 0.001。这个小到不起眼的系数，防的是 MoE 最经典的一场灾难。

对策是在训练的损失函数里加一项辅助损失（auxiliary loss），专门惩罚不均衡。Switch Transformer（arXiv:2101.03961）给出的形式是这样的：