Nemotron 3.5 Bolt 完全拆解：从 120B 到 74B，Star Elastic 结构压缩与 2.0625-bit 量化如何把大模型塞进 24GB

Star Elastic 是什么

Star Elastic 是 NVIDIA 提出的一种训练后（post-training）弹性化方法，论文题为 Star Elastic: Many-in-One Reasoning LLMs with Efficient Budget Control（arXiv:2605.07182，2026 年 5 月首次提交，2026 年 10 月更新），作者来自 NVIDIA 的 ADLR 团队，包括 Ali Taghibakhshi、Ruisi Cai、Pavlo Molchanov 等人。

它的核心承诺是：给定一个已经训练好的父模型，用一次训练的成本，产出一族互相嵌套的子模型。

论文原文的表述是：Star Elastic”添加 N 个嵌套子模型到给定的父推理模型上，只需一次 post-training 任务的算力（带来 N 倍节省）“。这里的”N 倍节省”是关键卖点——传统做法是每个尺寸单独训练一次（或用 Minitron 这类方法先剪枝再蒸馏，每个候选都要跑一遍），成本随模型数量线性增长；Star Elastic 用一次训练就把所有尺寸都拿到手。

“嵌套”（nested）是一个需要特别强调的性质，它有两层含义：

1. 权重共享：小模型不是独立的一份权重，而是大模型权重的一个子集。12B 变体的每一层、每一个通道，都直接来自 30B 变体里对应的位置。部署一族模型，只需要存最大的那一份。
2. 零样本切片：训练完成后，从同一个 checkpoint 里直接切出各个尺寸，不需要再训练。论文称之为 zero-shot slicing。

论文给出的定量结论是：从 Nemotron Nano v3（30B/3.6A）出发生成 23B（2.8A）和 12B（2.0A）两个变体，总共只用了 160B 训练 token，相比从头预训练省了 360 倍，相比当时最先进的顺序压缩方法省了 7 倍。

图 2：Star Elastic 的训练与部署流水线。训练时每个样本同时流向教师和冻结的父模型，预算被送入 router 生成可微掩码；部署时全部变体从单一 elastic checkpoint 零样本切出。来源：Star Elastic 论文（arXiv:2605.07182）Figure 2。

嵌套是怎么建立起来的：重要性排序

嵌套不是随便切的。要保证”小模型是大模型的子集”，就必须先决定每个组件的重要性顺序——重要的留在里面，不重要的先被剪掉。这样任何预算档位都取的是”重要性最高的那批组件”，天然构成嵌套。

论文的第一阶段就是重要性估计（importance estimation），给各个维度的组件打分，得到排序排列。需要打分的维度有：嵌入通道、注意力头、Mamba 头与头通道、FFN 通道、MoE 专家、以及层（深度）。

宽度维度的打分。 论文对各类组件用的是基于激活的显著性分数（activation-based importance），这是 Minitron 一路下来的思路——一个组件对模型越”有影响”，它的激活幅度或它对输出的贡献就越大。几个具体形式：

嵌入通道的分数是把归一化后的输入激活在 batch 和序列两个维度上求和：

其中 $X$ 是输入激活，$\text{LN}$ 是 LayerNorm，$B$ 和 $L$ 分别是 batch 与序列长度，下标 $i$ 取第 $i$ 个通道。直观理解：这个通道在大量样本、大量位置上激活得越大，就越重要。

FFN 通道的分数取自 up-projection 层的激活：

$W_{up}$ 是 FFN 的上投影权重矩阵，$X(W_{up})^{T}$ 就是该层实际的中间激活。

MoE 专家的打分用 REAP。 MoE 层的特点是专家条件激活——每个 token 只走 Top-K 个专家，所以不能简单按通道激活来算。论文采用了 Router-Weighted Expert Activation Pruning（REAP） 的打分，对专家 $f_j$ 的显著性分数为：

其中 $\mathcal{X}_j$ 是被路由到专家 $j$（即 $g_j(x)\in\text{TopK}(g(x))$）的那些输入集合，$g_j(x)$ 是 router 给专家 $j$ 的门控值，$f_j(x)$ 是专家 $j$ 对该输入的输出。

这个打分式的设计意图很明确：它在”该专家被激活的那些 token 上”，把路由权重和专家输出幅度相乘再平均。它同时考虑了两个方面：

• 路由频率——被激活得越多的专家越重要；
• 功能贡献——输出幅度越大的专家越重要。

论文特意对比了”朴素的基于频率的剪枝”：只看频率会漏掉那些激活不多但一激活就贡献巨大的专家；REAP 把两者结合起来，才能为异构 MoE 弹性化提供有原则的专家选择依据。

深度维度的打分用逐层移除的 MSE。 层的重要性是迭代估计的：每一轮，对每个还留着的层 $j$，把这一层去掉，看 logits 变了多少：

$\mathcal{M}_{\text{full}}$ 是完整模型的 logits，$\mathcal{M}_{-j}$ 是去掉层 $j$（以及之前已经剪掉的层）后的 logits。

“迭代”这个词很重要：层的相对重要性会随着其他层被剪掉而变化（层之间有补偿效应），所以要一轮一轮地重新估计，而不是一次算完。归一化则保证分数在不同校准数据集之间可比。

弹性公式：宽度与深度的嵌套层次

有了重要性排序，就可以定义”哪些子网络是合法的”。论文定义了沿各个轴的弹性选择，对子网络 $\mathcal{S}$：

• 嵌入维度 $d_e^{\mathcal{S}}$
• 注意力头数 $n_h^{\mathcal{S}}$
• Mamba 头数 $m_h^{\mathcal{S}}$ 与头通道数 $m_d^{\mathcal{S}}$
• MoE 专家数 $e^{\mathcal{S}}(\ell)$
• FFN 中间维度 $f^{\mathcal{S}}(\delta)$

注意 $e^{\mathcal{S}}(\ell)$ 和 $f^{\mathcal{S}}(\delta)$ 带着层下标——专家数和 FFN 宽度允许逐层独立选择，这正是”异构配置”（heterogeneous）的含义，也是后面 Bolt 能把 top-K 固定为 9、同时让各层专家数不同的基础。

关键是嵌套约束：对每个轴，子网络选的都是按重要性排序后最显著的那批连续组件，保证小预算变体永远是大预算变体的子集。

深度轴则由一个二值选择向量控制：

其中 $\gamma_i^{\mathcal{S}}\in\{0,1\}$ 表示第 $i$ 层在子网络 $\mathcal{S}$ 中是否激活，去掉的总是重要性最低的层。

训练：可学习的 router 与两阶段课程

结构和排序准备好了，接下来是怎么在一次训练里同时优化所有预算档位。

论文为每个弹性轴训练一个专用 router，学习”用户给定的预算 → 该轴应该取哪个配置”这个映射。每个 router 就是两层全连接、中间夹一个 LeakyReLU：

输入 $u^{(\texttt{axis})}=\zeta_l$ 是一个 one-hot 向量，表示目标压缩档位。比如三个预算（100%、70%、50%），输入就分别是 $[1,0,0]$、$[0,1,0]$、$[0,0,1]$。对异构配置，router 输出的是逐层的目标尺寸，例如 MoE 专家轴输出 $|\mathcal{E}|\times N_{\text{MoE}}$ 个值。

router 的输出要变成”可微的离散选择”，才能让梯度流回 router 参数。论文用 Gumbel-Softmax，温度 $\tau$ 控制近似平滑度：

其中 $g_i\sim\text{Gumbel}(0,1)$ 是 Gumbel 噪声，$\kappa$ 是平衡 logits 幅度的缩放因子。当 $\tau\to 0$ 时该分布趋近 one-hot。每个训练迭代从这些分布采样，得到松弛的离散选择。

router 自己的损失把”选出来的配置”映射到资源约束上：

$\mathcal{C}$ 是 router 所选配置的资源代价（参数数目、显存、延迟或吞吐），$\hat{\mathcal{C}}$ 是目标资源代价。这个设计意味着显存预算不是一个硬性截断，而是被写进损失里的一个优化目标。

模型精度一侧，用的是知识蒸馏，教师是未弹性化的父模型：

$p_\varphi$ 是教师的 softmax 输出，$p_\theta$ 是学生弹性模型的输出，$\tau$ 是蒸馏温度。总目标把两者合起来：

$\psi$ 是 router 参数，$\lambda>0$ 平衡精度与资源约束。

论文强调了一个与先前方法的本质区别：router 是从实际训练信号中直接做架构选择的，而不是依赖事后评估的零样本代理指标。它优先挑的是”在知识蒸馏下继续学习能力强”的子网络，而不是”初始化时 loss 最小”的子网络——这两者并不等价。

两阶段课程采样。 多预算联合训练会出现一个实际麻烦：论文观察到，如果在长上下文阶段用朴素的均匀采样，全预算模型会退化而小预算模型会提升，说明存在梯度竞争。为此论文设计了随上下文长度切换的两阶段采样：

• 阶段 1（短上下文）：序列长度约 8192，对 $n_b$ 个目标预算均匀采样，每个 batch 以 $1/n_b$ 的概率分配。均匀采样保证 router 从所有子网络获得均衡的训练信号，让架构探索不带预算偏向。
• 阶段 2（扩展上下文）：序列长度 49152，转为非均匀采样，权重偏向大预算模型：

为什么需要扩展上下文阶段？论文的解释是：推理任务需要长的 token 预算做多步推理，短上下文训练不足以培养真正的推理能力。用 49K 上下文训练，才能让各个弹性变体接触到长推理链。这个”先短后长”的安排同时也吸取了 Nemotron Elastic 的经验——先保证小模型恢复精度，再注入长上下文推理能力。

部署时的”弹性预算控制”

嵌套模型还有一个额外的用法，论文称为 elastic budget control（弹性预算控制）。

背景是这样的：带推理能力的模型通常有一个”思考阶段”和一个”作答阶段”——先生成一段思维链，再基于思维链输出最终答案。已有的预算控制方法（如 Nemotron Nano 系列用的）流程是：思考阶段通过 <think> token 触发，监控生成的思考 token 数，到了预设预算（比如 2k token）就终止；然后作答阶段在（可能不完整的）推理文本条件下强制生成最终答案。

问题是：这些方法的模型架构是静态的——prefill、思考、作答三个阶段用的是完全同一个模型。可思考阶段和作答阶段的计算需求并不相同：思考阶段要生成大量 token 来探索推理路径，作答阶段则需要更强的指令遵循和内部一致性来把推理链变成正确答案。用同一份容量去覆盖复杂度不同的两个阶段，就是浪费。

论文比较了四种配置：

实验结论是 $\mathcal{M}_S\to\mathcal{M}_L$（小模型思考、大模型作答）是最优配置。理由不对称：思考阶段是”高产量推理”，用 $\mathcal{M}_S$ 可以用极低的计算开销生成很长的推理轨迹；作答阶段是”高保真合成”，需要 $\mathcal{M}_L$ 的容量来保证答案正确。论文报告，弹性预算控制在精度–延迟 Pareto 前沿上带来最高 16% 的精度提升和最高 1.9 倍的延迟降低。

一个工程细节值得一提：在小模型和大模型之间切换时，KV cache 状态通常是不兼容的，需要重算。而 Star Elastic 因为在弹性化过程中保留了 Mamba 和注意力层的结构，嵌套模型之间的缓存状态高度一致，论文实测表明缓存状态可以在嵌套模型间安全移植。当前报告的墙钟时间仍包含缓存重算开销，论文因此认为这个数字是保守下界——一旦推理框架支持缓存复用，收益还会更大。

图 3：跨计算预算的弹性预算控制配置。$\mathcal{M}_S\to\mathcal{M}_L$（如 23B→30B）在很宽的预算范围内给出最好的精度–延迟权衡。来源：Star Elastic 论文（arXiv:2605.07182）Figure 3。

图 4：逐基准 Pareto 前沿对比：混合弹性预算控制（彩色曲线）对普通 Nano v3 预算控制（灰色）。在所有基准上，弹性配置都主导了 Pareto 前沿。来源：Star Elastic 论文（arXiv:2605.07182）Figure 5。

嵌套带来的实际收益

嵌套结构不只是训练上的省事，它在部署时也有直接的量化收益。论文给出了几组数字。

吞吐与 batch。 在 H100 上以 bfloat16 测量（ISL/OSL = 8192/16384）：

注意这个表的结构：小变体不只是”跑得快”，它还能在同一张卡上把 batch 开到 3 倍以上。论文的说法是”显著加速（本例中最高 2.4 倍）的同时，还能在同一 GPU 上以高得多的 batch size 推理”。对服务端来说，batch 空间就是吞吐空间。

部署显存。 因为变体是嵌套的，存一族模型只需要存最大的那一份。论文的对比是：

具体数字：弹性 Nano v3（12B + 23B + 30B）在 BF16 下占 58.9 GB，而三个独立 checkpoint 要 126.1 GB——不到一半。Nano v2 上的同类对比是 24 GB vs 54 GB。

量化后的进一步压缩。 每个变体在不同精度下的加载显存（论文 Table 5）：

这张表解释了”嵌套 + 量化”的组合威力：BF16 下所有档位都放不进 RTX 5080，而 12B 的 NVFP4 版本只要 8.0 GB。论文报告：12B NVFP4 在 RTX 5080 上可以跑（该卡上所有 BF16 档位都 OOM），在 RTX 5090 上 30B/23B 只有 NVFP4 才可部署；在 RTX Pro 6000 上 12B NVFP4 达到 7426 tokens/s，是 30B BF16 基线（2178 tokens/s）的 3.4 倍。

这正是 Bolt 走这条路线的底层逻辑：先把一族模型做成嵌套的一份权重，再对这份权重做低比特量化，最后按设备显存切出合适的那一档。

父模型与目标

父模型是 Nemotron 3.5 Super VL 120B-A12B：总参数 120B、激活参数 12B，架构是 Mamba-2 与 Transformer 的混合（hybrid）MoE，带一个 C-RADIO v4-H 视觉编码器，上下文支持到 256K token。

目标是压成 74B-A9B：总参数降到 61.7%，激活参数从 12B 降到 9B。注意这两个数字下降幅度不一样——总参数降得比激活参数多，这不是巧合。

异构专家数与固定 top-K

模型卡里最值得逐字读的一句是：

一个预算条件化的 router（budget-conditioned router）逐层非均匀地选择路由专家数目和 MoE 中间宽度，而 expert top-K 固定为 9，从父模型的 22 降下来。

这里有三个关键设计：

第一，top-K 固定为 9。 父模型的每个 token 激活 22 个专家，Bolt 只激活 9 个。top-K 直接决定激活参数和每 token 的计算量；从 22 降到 9 是激活参数从 12B 降到 9B 的主要来源之一。

第二，专家数目逐层可不同。 这就是前面讲的”异构”（heterogeneous）能力——e^S(ℓ) 带层下标。不是所有层都保留同样比例的专家：router 可以决定某个层的专家留多一点、某个层留少一点。这比”全局统一剪枝比例”灵活得多，因为不同层对容量的敏感度本来就不同。

第三，MoE 中间宽度也逐层可选。 除了”保留几个专家”（数量），还可以调”每个专家内部多宽”（FFN 中间维度 $f^S(\delta)$）。这两个自由度一起构成 MoE 层的压缩空间。

预算里已经算进了量化

一个容易被忽略但很重要的细节：router 的架构搜索不是只盯着 BF16 的权重大小，它的预算里已经预估了后续量化后的体积和运行状态的精度。

模型卡原文写得很明确：router 的架构搜索目标是”在 batch size 1、128K 上下文下部署体积低于 24GB”，而这个预算”已经把后续量化纳入考虑，包括权重和运行时状态的精度（比如 2-bit 的路由专家权重和 16-bit 的 SSM 状态）”。

这解释了为什么这一步必须放在量化之前，而且搜索目标必须知道量化要做什么：如果按 BF16 体积搜索，搜出来的结构量化后可能只剩 15GB，白白浪费预算；如果按 4-bit 预估，搜出来的结构量化到 2-bit 后又可能超预算。Bolt 的做法是让结构搜索的”价格标签”就是最终的 2-bit 尺寸——结构优化和精度优化被放在同一个预算口径下。

优化目标与收敛

搜索的优化目标是：在满足显存预算的前提下，找到知识蒸馏损失最低的架构。架构和模型权重通过知识蒸馏 + 一个”模型大小惩罚项”联合优化。

收敛节奏（模型卡给出的数字）：

• 架构搜索在 8K 上下文下进行，router 在前 8B token 内收敛；
• 架构固定后，继续在 8K 下恢复到总共 72B token；
• 然后再在 128K 上下文下训练 48B token；
• 总共 120B token。

这个安排正是前面讲的”两阶段课程”的具体数值版本：先在便宜的 8K 上下文下把知识恢复上来（恢复更快），再扩展到长上下文。模型卡对此的解释是”利用 8K 下更快的知识恢复，而不是直接从 128K 开始”。

视觉塔是从父模型搬回来的

这里有个工程上很实用的细节。Star Elastic 的压缩只作用在文本塔上，知识蒸馏恢复的也只是文本能力。视觉能力怎么办？

Bolt 的做法是：把父模型 Super 3.5 VL 训练好的视觉塔直接接回来到压缩后的 LLM 上，然后只对视觉到语言的投影层（vision adapter）做轻量微调。训练用的是一份纯图像的混合数据，每 epoch 约 660 万样本，包括通用英文的 captioning、VQA、计数与文档数据集（约 200 万）、用 Qwen3-30B 重新打标的 CC3M 图像（约 170 万）、中文文档 OCR 数据（约 250 万），以及 PDF / 表格文档数据和 NVCLIP OCR 用的数据集。

模型卡还特别说明：视觉适配器训练和 SFT 阶段对恢复视觉 benchmark 是关键的，因为压缩本身只作用于文本塔。这是一个很实际的提醒——多模态模型的压缩不是”整体压一下”那么简单，各个模态的塔需要分别处理。

后续还有监督微调（SFT）和多阶段强化学习（RLHF + 端到端 GRPO，包括模拟 MCP server 的多轮工具交互环境与 SWE 环境），最终通过 checkpoint merging 得到 BF16 检查点。这些属于训练侧流程，这里只需知道：量化发生在这整条流程的最后一步。

IQ2_XXS：几乎”真正的” 2-bit

Bolt 的专家权重用的是 IQ2_XXS 格式，文档里的定义简洁到可以直接引用 ggml 源码注释：

（几乎）“真正的” 2-bit 量化。由于 ggml 设计要求必须使用块结构，它最终使用 2.0625 bpw，因为每个 256 元素的块要带一个 16-bit 的 scale。

也就是说，2.0625 这个数字不是一个设计选择，而是一个块量化格式的算术结果：数据本身是 2 bit/元素，但每 256 个元素要额外附加 2 字节的块缩放因子，摊到每个元素上是 $16/256=0.0625$ bit。于是：

在 ggml 的结构体定义里，这个格式长这样：

1
typedef struct {
2
    ggml_half d;        // 16 位块级缩放因子
3
    uint16_t  qs[QK_K/8]; // 2-bit 索引打包，代码本查找
4
} block_iq2_xxs;        // QK_K = 256，即每块 256 个元素

QK_K 是块大小（256）。每个块存一个 16 位 half 精度的缩放因子 d，以及 $\text{QK\_K}/8 = 32$ 个 uint16_t——每个 uint16_t 打包 8 个 2-bit 索引，32 个正好覆盖 256 个元素。

IQ2_XXS 里的”IQ”是 importance-aware quantization（重要性感知量化）的意思，这一点很关键：它不是简单地把权重四舍五入到 2 bit，而是在离线阶段用一个小型码本（codebook）来近似权重，并让码本的设计考虑到量化误差对模型输出的影响。权重被表示为”从码本里选一个向量”的索引，而不是直接的整数。

这样做的收益是：同样是 2 bit 的索引，它能表示的权重组合远多于均匀 2-bit 网格。它的代价是解码时要查表——这正是 kernel 层面要做的工作。

从工程角度再补一句：2.0625 bpw ≈ 0.258 字节/参数。74B 参数中占大头的专家权重按这个比例算，体积也就有了着落——这也印证了前面那句”不到 3 个比特”的预算分析。

混合精度：不同部件，不同预算

Bolt 并不是把所有权重一刀切到 2 bit。官方给出的精度分配如下：

这是按部件分配精度预算的思路。为什么这样分？

• 专家 FC 层拿最紧的预算：这类权重在参数量上占绝对主导，把它们的比特数压到最低，对体积的杠杆最大；而且 MoE 专家在推理时是稀疏激活的——同一时刻只有 9 个专家被用到，个别专家上的量化误差对输出的影响会被路由结构部分吸收。
• Mamba 线性层保留 NVFP4：Mamba 是状态空间模型（SSM）结构，它的线性层参与循环状态更新，误差会在时间步之间累积放大。给它多一些精度，是控制状态漂移的必要代价。
• attention、embedding、lm_head 这类层保留 Q8_0：这些层要么直接决定输入/输出的表示（embedding、lm_head、attention），要么对数值敏感度高，而且它们在总参数量中占比很小——保护它们几乎不花体积预算，却能换来明显的精度收益。这正是”把有限的精度预算花在刀刃上”的做法。

Bolt 模型卡同时提到，KV cache 在部署时用 FP8（vLLM 启动参数里的 --kv-cache-dtype fp8），这属于运行时缓存而非权重，但与权重精度是同一套”分层精度”哲学的延伸。

为什么只量化权重

官方给的理由只有一句话，但值得展开：

我们只量化权重，因为网络在 RTX / DGX Spark 上的执行主要是权重带宽受限的。

理解这句话需要区分推理的两种阶段：

• Prefill（预填充）：一次处理整段 prompt，所有 token 并行，是计算受限（compute-bound）的，矩阵乘法的算力利用率高，此时瓶颈在 FLOPs；
• Decode（解码）：一次只生成一个 token，batch 很小，每个权重只被用一次就要去读写下一个，是带宽受限（memory-bound）的，瓶颈在每 token 要搬运多少字节。

本地部署、单用户、低并发场景下，绝大多数时间花在 decode 上。于是”把权重体积压小”直接等于”每 token 少搬字节”，加速是接近线性的。官方把这一点写得更直白：在低 batch 推理场景下，kernel 的延迟会随权重的压缩率线性改善，因此低比特量化带来显著的推理速度收益。

不量化激活则是为了省去激活量化的全部复杂度：激活量化需要校准数据、需要处理离群值、需要额外的 scale 计算与反量化开销，而在权重带宽受限的场景里，激活只占搬运量的一小部分——把工程复杂度花在这里的回报很低。这是一个很务实的取舍。

蒸馏而不是微调

2 bit 量化对模型能力的破坏是真实存在的。Star Elastic 论文里给出了一个参照数字：在 Nano v3 的 30B 变体上，NVFP4 直接做 PTQ 会造成 4.12% 的平均精度下降——注意这只是 4 bit。Bolt 的专家权重是 2 bit，破坏只会更大。

NVIDIA 用的补救手段是 量化感知蒸馏（Quantization-Aware Distillation, QAD），来自一篇专门的方法论文 Quantization-Aware Distillation for NVFP4 Inference Accuracy Recovery（arXiv:2601.20088）。它与常见 QAT（量化感知训练）的区别在于：训练信号不是标签/交叉熵，而是教师模型的输出分布。

Star Elastic 论文把嵌套场景下的 QAD 定义得很清楚。给定一个已训练好的弹性 BF16 教师 $\mathcal{T}$（参数 $\Theta^{\text{bf16}}_{\max}$）和同一套 router 决定的嵌套掩码层次，初始化一个量化学生 $\mathcal{S}_q$——架构和掩码与教师相同，但权重是量化过的 $\Theta^q$（NVFP4）。每一步训练：

1. 按与 BF16 弹性化时相同的阶段 2 分布 $p_2$ 采样一个预算 $b\in\{30\text{B},23\text{B},12\text{B}\}$；
2. 只对学生施加该预算对应的掩码；
3. 最小化师生 logits 之间的 KL 散度：

这个式子里最需要盯住的是那个期望号。它不是对单一大小的学生做量化蒸馏，而是在所有嵌套预算上做期望：

学生始终带着嵌套掩码层次、从未弹性化的教师那里蒸馏。于是小预算的梯度会正则化最显著的那些共享权重，而全预算的梯度塑造尾部权重。

这句话有两层含义值得说透。

第一层是”共享权重被多重保护”。 嵌套结构里，最重要的那批权重是所有变体都要用的。当训练在小预算变体上进行时，能被更新的参数只有那批最关键的共享权重，梯度全部压在这些参数上，等于优先把关键权重训好。而当训练在大预算变体上进行时，梯度才能触达尾部（较小预算用不到）的权重。这实际上是一种由结构天然形成的课程学习：先把骨干练扎实，再修边角。

第二层是”量化结构不能被破坏”。 论文明确反对”先切片、再各自量化”的做法，理由有三条：

1. 每个变体都要单独跑一次量化流程；
2. 破坏嵌套权重共享的性质——量化之后再切，各变体的权重就不再是同一份参数空间的子集；
3. 无法从单一量化 checkpoint 零样本切出小变体。

所以 QAD 的做法是在整个量化流程中始终保持单一嵌套 checkpoint。这是一个很典型的”结构约束优先”的工程决策：宁可让训练复杂一点，也要保住”一个文件族、一份权重”的部署便利。

QAD 的实际配方与效果

Star Elastic 论文给出的 nested QAD 配方相当短：

• 数据：复用阶段 2 的扩展上下文知识蒸馏数据集；
• 上下文长度：48K；
• batch size：512；
• 学习率：恒定的小值 $1\times 10^{-5}$；
• 训练步数：200 步，约 5B token；
• 模型选择：取在各弹性变体的下游 benchmark 上综合精度最好的 checkpoint。

只有 5B token、200 步——相比 BF16 弹性化那 160B token，这只是一个很短的收尾阶段。这个成本对比本身说明了 QAD 的定位：它不是为了重新学习能力，而是为了让量化后的权重”回到”教师已经知道的那个解附近。

量化恢复率的实测结果（论文 Table 4，恢复率 = 量化变体平均精度 / 对应 BF16 弹性变体平均精度）：

几个读法：

• FP8 直接 PTQ 就够了：论文原文说 FP8 用 post-training quantization 即可，量化后套用嵌套掩码就能得到所有变体，精度损失可忽略——所以上表里 FP8 那一列没有经过 QAD，只是常规 PTQ；
• NVFP4 必须做 QAD：PTQ 会导致 4.12% 的下降，QAD 之后恢复到 97.79%（30B）；
• 12B 的 FP8 恢复率是 100.26%，超过 100%——这通常说明量化起到了正则化作用，或者评估本身的波动落在这一量级。这类数字不必过度解读，但至少说明这个档位上没有可测的精度损失。

顺带一提：Star Elastic 论文里的 NVFP4 配置还包含”保持 6 层自注意力和其前面的 Mamba-2 层为 BF16、KV cache 量化到 FP8”这样的混合精度安排——混合精度不是 Bolt 独有的，而是这套方法论里反复出现的手法：把所有层一视同仁地量化，几乎总是次优的。

图 5：Nemotron 3.5 Bolt 从压缩到量化的各个阶段精度。压缩并量化后的模型比同尺寸模型更准确。来源：NVIDIA Nemotron 官方技术博客（2026-10-15）。

“24GB”不等于”任意 24GB 显卡都能开满 256K”

模型卡把上下文长度写成”最高 256K token”，同时加了一句限定：

prompt、视觉输入、对话历史、工具结果和生成的回答共享这个上下文窗口。各个部署配方可能使用更小的上下文窗口，来适配可用的 GPU 显存和并发数。

这是长上下文模型部署中最容易被误读的一点。权重只占显存的一部分，KV cache 会随上下文长度线性增长。即便权重恰好塞满 24GB，也没有空间留给 KV cache。所以”24GB 版本”的真实含义是：权重文件本身约 24GB，能在一张 24GB 以上的卡上加载，而不是”任意 24GB 显存都能开满 256K 上下文”。

官方给出的 vLLM 部署配方里，除了权重参数还有一长串与显存相关的选项值得注意：

1
vllm serve nvidia/NVIDIA-Nemotron-3.5-Bolt-74B-A9B-24GB \
2
  --tensor-parallel-size 1 \
3
  --max-model-len 262144 \
4
  --max-num-seqs 1 \
5
  --enable-chunked-prefill \
6
  --kv-cache-dtype fp8 \
7
  --linear-backend b12x \
8
  --moe-backend b12x \
9
  --attention-backend FLASHINFER \
10
  --mamba-backend flashinfer \
11
  --video-pruning-rate 0.5

几个参数直接反映前面的技术选择：

• --max-num-seqs 1：并发数是 1。这是本地单用户场景的配置，也解释了为什么整个优化都围绕”权重带宽”而不是”算力利用率”；
• --kv-cache-dtype fp8：KV cache 用 FP8。权重压到 2 bit 之后，KV cache 反而成了显存的主要变量，所以也要压；
• --linear-backend b12x 和 --moe-backend b12x：低比特线性层与 MoE 的专用 kernel 后端。2.0625-bit 权重需要专门的解码 kernel，这是 IQ2_XXS 落地不可或缺的一环；
• --mamba-backend flashinfer、--mamba-cache-dtype bfloat16：Mamba 状态用 BF16 保存，与前面”SSM 状态 16-bit”的说法一致；
• --video-pruning-rate 0.5：视频输入做 50% 剪枝，因为视觉 token 会挤占上下文预算。

加速还有一块来自投机解码

博客里还有一个独立的加速组件：LiLiCorr 草稿模型。

LiLiCorr 是一个 1.13B 参数的并行草稿模型（不含共享的目标 embedding 和 LM head）。它的机制值得单说一句，因为博客把它和两个已有方法做了明确对比：

LiLiCorr 通过在一次轻量网络前向中联合给整个草稿的候选 token 打分来加速投机解码。这改进了 DFlash 的独立 token 选择，同时避免了 DSpark 的逐 token 神经修正，从而用很小的开销产出更连贯的草稿。

也就是说，它的位置在”完全独立地选候选”和”逐 token 串行修正”之间：一次前向、联合打分。官方公布的接受长度是：在 vLLM 下并发 64、草稿 7 个 token 时，NVFP4 草稿在贪心解码下平均接受长度 4.68，概率采样下 4.25。

投机解码属于推理侧的加速技术，本站已有若干篇拆解其机制（例如 EAGLE 完全拆解 讲特征级草稿模型，DFlash 块扩散解码 讲扩散式草稿），这里不展开，只需要知道：在权重已经压到 2 bit、单步延迟被压得很低之后，投机解码是继续提升吞吐的下一个杠杆。

数字的读取方式

官方给出的推理性能测量有一个需要明确的前提：

所有测量都是用 llama.cpp 在 Windows 11 ARM x64 上、同一台 RTX Spark 硬件（Surface Laptop Ultra，128GB）完成的。

选定的结果（模型卡与博客口径）：

这张表需要如实读。 上表两项测量里，Bolt 都不是最快的：吞吐 83.99 TPS 低于 Qwen3.6 的 96.63 和 Gemma 4 的 100.56；端到端 replay 时长 600.80 秒长于对照的 453.97 与 480.68 秒。这与会话开头引用的官方目标”解码速度不低于 80 TPS”是一致的——83.99 刚刚越过这条线，而它不是靠速度取胜的。

Bolt 主打的数字在精度侧：GDPVal-AA-V2 28.47、Terminal-Bench 2.1 50.98、BrowseComp 66.75、WebArena 50.86、GPQA Diamond 86.43，全部高于同表的两个对照模型。官方博客的原话是”在相似内存占用、相似速度的模型中精度最高”，并写明在相似内存占用的模型里，Bolt 在 PinchBench 排第 1、WebArena 排第 2、BrowseComp 排第 2。

换句话说，24GB 这个预算下的取舍是”用速度和体积换智能”：把 74B 的参数塞进 24GB，就必须接受 2 bit 带来的解码 kernel 开销与略低的吞吐，换来的是这一档里更高的能力上限。理解这一点，才能明白为什么这篇的技术重点全部压在”如何在 2 bit 下保住精度”而不是”如何更快”。

另外两点也值得提醒：

• 速度数字来自指定设备与框架（llama.cpp / Windows 11 ARM / RTX Spark），不能直接套到另一台机器。换成 vLLM、换成别的 GPU、换成不同并发，数字都会变；
• 官方托管服务的价格未在技术博客中给出，需要以实际发布为准。

模型本身的形态

最后交代模型的基本规格，便于和前面各节的数字对上：

开放的内容包括：24GB 主模型、LiLiCorr 草稿模型、量化前的 BF16 checkpoints（供进一步定制），以及配套的 GGUF 版本。

图 6：Nemotron 3.5 Bolt 74B-A9B 24GB 与开放 MoE 模型的基准精度对比。对照模型的选取标准是”用 4-bit 量化后能塞进 24GB”。来源：NVIDIA Nemotron 官方技术博客（2026-10-15）。

与”块量化格式”的关系

IQ2_XXS 属于 ggml 的 k-quants / i-quants 家族，是一整套为端侧 CPU/GPU 混合推理设计的块量化格式。它的表亲 Q4_K_M、Q6_K 等就是常见 GGUF 文件里那些”Q4_K_M 量化”的名字。本站已有一篇专门拆解这个格式族的文章——GGUF 完全拆解：一个文件里的张量布局、k-quants 块量化与元数据字典，讲透了块结构、位布局与元数据字典。

Bolt 与那篇的关系值得一提：Bolt 是 IQ2_XXS 这种 2-bit 格式第一次被用在一个 74B 级别的前沿模型上，并且从训练阶段就为它做适配（QAD）。以往低比特块量化多是”训练好的模型 → 直接转 GGUF 量化”的后处理流程；Bolt 则把量化提前写进了结构搜索的预算里。这说明低比特格式正在从”部署时的权宜之计”变成”模型设计时的先决条件”。

与”权重量化方法”的关系

本站已拆解过一整条权重量化演进线：从 GPTQ 完全拆解 的二阶信息驱动，到 AWQ 完全拆解 的保护显著权重，到 SmoothQuant 完全拆解 的 W8A8 激活平滑，再到 LLM.int8() 完全拆解 的混合精度分解。

Bolt 与它们的区别在目标位宽和恢复手段两点：

• 位宽：GPTQ / AWQ 主攻 4 bit，SmoothQuant 是 W8A8。Bolt 的专家层是 2.0625 bit，比它们都狠一档；
• 恢复手段：GPTQ / AWQ 是训练后量化（PTQ），靠校准数据算误差补偿；Bolt 用的是 QAD——需要额外的蒸馏训练（虽然只有 5B token）。所以严格说 Bolt 的量化不是纯 PTQ，而是”PTQ + 轻量蒸馏”的组合。

Bolt 的特殊之处还在于量化的对象是一个”嵌套弹性权重空间”。GPTQ / AWQ 处理的是单一模型；Bolt 的 QAD 要在保持嵌套结构不变的前提下完成量化——这是前面讲的 $\mathcal{L}_{\text{QAD}}$ 里那个期望号存在的全部理由。

与”KV cache 量化”和”低比特 kernel”的关系

权重压到 2 bit 之后，权重不再是显存的主要变量。本站已有多篇 KV cache 量化文章可作延伸：KIVI 完全拆解 讲非对称 2-bit KV 量化（Key 按通道、Value 按 token），KVQuant 完全拆解 讲预旋转逐通道量化与非均匀码本。Bolt 的 vLLM 配方里 --kv-cache-dtype fp8 就是把 KV 压到 FP8——权重 2 bit、KV 8 bit 的组合是端侧部署的常见配比。

另一侧是 kernel：2.0625 bit 的权重不能直接喂给 Tensor Core，需要专门的解码 kernel。本站的 Marlin 完全拆解 讲的是 W4A16 如何喂满 Tensor Core，BitBLAS 完全拆解 讲低比特权重边解码边计算——IQ2_XXS 在 vLLM 里对应的 b12x backend 属于同一类问题：如何在推理时高效地把紧凑的位打包解回可计算的数值。

与 MoE 模型压缩的关系

Bolt 的结构压缩落在 MoE 的三个自由度上：专家数、专家宽度、激活专家数（top-K）。本站的 DeepSeekMoE 完全拆解 讲细粒度专家切分与共享专家隔离，MoHGE 完全拆解 讲异构分组专家——都属于”MoE 结构怎么设计”这条线。Bolt 的 Star Elastic 则回答了一个反向问题：给定一个已经设计好的 MoE，怎么在不重训的前提下把它缩到各种尺寸。