DSpark 是 DeepSeek 提出的一套大模型推理加速方案,在 DeepSeek-V4 线上把单用户生成速度提升 60%–85%,且输出分布严格无损(一个字都不改)。核心两招——让草稿写得更准,让验证花得更省。

这篇论文言简意赅,直接奔着两个硬核点去:半自回归生成的局部 softmax 设计,以及硬件感知调度器里那个绕不开的无损性证明。读完之后不得不感叹Deepseek团队的牛！

---

0. 为什么这篇论文值得逐字读

大多数投机解码的论文,要么只优化「草稿写得准不准」,要么只优化「该验多长」,而且基本都停在离线 benchmark 上刷接受长度。

DSpark 的不同在于三点:

1. 它把算法和系统打通了——半自回归解决草稿质量,置信度调度解决高并发吞吐,两者是耦合设计的;
2. 它有严格的无损性论证,并且诚实地指出了自己调度算法里一个会破坏无损性的坑,再用异步工程把坑填上;
3. 它真上了生产(DeepSeek-V4-Flash / Pro),而且对线上数据的解读相当克制,那个 +661% 的数字作者自己说别当真。

下面从最底层讲起。

---

1. 先把问题说清楚:自回归的原罪

LLM 生成文字是自回归的:每吐一个 token,都要把前面所有 token 重新过一遍整个模型做一次完整前向传播。

形式化地说,推理延迟和输出长度成正比。后果是 GPU 利用率低、用户等待时间长。在实时对话、多轮 Agent 这类延迟敏感场景里,这是生产部署的头号瓶颈。

---

2. 投机解码:白嫖加速的把戏

2023 年的投机解码 (Speculative Decoding) 给了一个优雅解法:用一个又小又快的草稿模型 $M_d$ 一口气猜出 $\gamma$ 个候选 token,再用真正的目标模型 $M_t$ 一次前向传播把整块批改掉,接受与目标分布一致的最长前缀,并补一个 bonus token。

2.1 接受规则与无损性

在第 $k$ 个草稿位置,目标模型算出自己的分布 $p_k^t$,与草稿分布 $p_k^d$ 比较,token $x_k$ 被接受的概率是:

$$\text{accept}(x_k)=\min \left(1,\frac{p_k^t(x_k)}{p_k^d(x_k)}\right)$$

直觉:目标模型觉得这个字比草稿模型更该写,就直接收;觉得草稿写过头了(草稿太自信),就按比例折扣概率收。 验证严格从左往右,第一个被拒的位置 $k$ 一出现,后面 $x_{k+1},\dots ,x_{\gamma }$ 全部作废,无论它们质量多高。

这个规则在数学上保证最终输出分布精确等于目标模型自己自回归生成的分布。这是投机解码的灵魂:不是用质量换速度,是白赚的加速。

2.2 加速的核心公式与三个杠杆

设 $\tau$ 为每轮真正被接受的 token 数,$T_{\text{draft}}$、$T_{\text{verify}}$ 分别为草稿与验证的墙钟时间,则平均每 token 延迟:

$$L=\frac{T_{\text{draft}}+T_{\text{verify}}}{\tau }\text{\hspace{1em}(1)}$$

想加速,只有三条路:

• 降 $T_{\text{draft}}$:草稿写得更快
• 升 $\tau$:草稿写得更准
• 降有效 $T_{\text{verify}}$:验证花得更聪明

DSpark 三条都动了。记住这个公式,后面所有设计都在围着它转。

---

3. 两类草稿模型,各有各的死穴

草稿模型的设计,决定了 $T_{\text{draft}}$ 和 $\tau$ 怎么权衡。

① 自回归草稿(如 Eagle3):也是一个字一个字猜,每个位置都条件于前面已采样的字。建模能力强、连贯,但 $T_{\text{draft}}\propto \gamma$——猜的字越多越慢。所以它被迫用很小的 $\gamma$、很浅的网络。

② 并行草稿(如 DFlash):一次前向传播把 $\gamma$ 个字同时全猜出来,$T_{\text{draft}}$ 几乎与块大小无关。这就允许它用更深的网络、更长的块(如 $\gamma =16$)。

DFlash 是 SOTA 并行草稿,它把草稿模型条件于从目标模型多层抽取的上下文特征(KV injection):

$$H_{\text{ctx}}=\text{RMSNorm}\left(W_c\right[H^{(l_1)};\dots ;H^{(l_m)}\left]\right)\text{\hspace{1em}(2)}$$

再把这些上下文特征沿序列维拼进每个草稿层的 K/V:

$$K_i=[W_i^K{H}_{\text{ctx}};W_i^K{H}_d],V_i=[W_i^V{H}_{\text{ctx}};W_i^V{H}_d]\text{\hspace{1em}(3)}$$

块内所有位置双向互相注意,并注意到目标上下文。

但并行草稿有个致命病——多模态碰撞 (multi-modal collision)。 因为每个位置是独立预测的,互相看不见。论文的例子很经典:上下文后面合理的接法有「of course」和「no problem」两种,并行草稿第 1 位可能采「of」、第 2 位可能采「problem」,拼出「of problem」这种鬼话。原因是第 2 位对所有可能的前驱求边缘,而非条件于第 1 位实际采样的那个字。

结果是后缀衰减 (suffix decay):越往后接受率掉得越快,草稿和验证算力双双浪费。

---

4. 第一刀:半自回归生成

核心思想:计算量大头继续用并行(保速度),只在输出端加一个极轻的串行头,让每个位置偷看一眼前面刚定下来的字(补依赖)。

4.1 因子分解 + 局部 softmax(这是关键)

并行阶段:并行骨干(本文用 DFlash)一次前向产出隐状态 $h_1,\dots ,h_{\gamma }$ 和基础 logits $U_1,\dots ,U_{\gamma }$。(一个小改动:把 anchor 本身当成第 1 个预测位置,即 anchor + $\gamma -1$ 个 mask 产出 $\gamma$ 个 logits,省一点算力。)

串行阶段:给基础 logits 叠加一个前缀依赖的转移偏置 $B_k(x_0,x_{<k},x_k)$,通过自回归因子分解诱导出一个块内因果分布:

$$P(X\mid x_0)=\prod _{k=1}^{\gamma }{p}_k(x_k\mid x_0,x_{<k}),p_k(v\mid x_0,x_{<k})=\frac{\exp (U_k(v)+B_k(x_0,x_{<k},v))}{{\sum }_{u\in V}\exp (U_k(u)+B_k(x_0,x_{<k},u))}\text{\hspace{1em}(4)}$$

注意这个 softmax 是逐位置局部归一化的,不是全局归一化的能量模型。 这一点是整个设计的命门,原因在第 6 节相关工作里——投机解码的拒绝采样规则要求草稿模型给出精确的逐 token 概率 $p_k^d(x_k)$。

历史上很多「在并行隐状态上叠加序列模块」的方案都栽在这:

• CRF-NAT 用全局归一化的配分函数,算不出精确逐 token 概率;
• CTC-drafter 因为对齐路径的隐变量边缘化,只能退化成贪心验证。

DSpark 靠把序列修正保持在局部,让每个 token 的概率仍是一次精确的 softmax 求值,干净地绕开了这个坑。这是它能做无损投机解码的根本前提。

4.2 两种串行头

Markov 头(默认):最省,$B_k$ 只依赖前一个 token,退化为一阶转移 $B(x_{k-1},x_k)$。理论上它是个 $V\times V$ 矩阵,太大,用低秩分解 $B=W_1{W}_2$,其中 $W_1\in {\mathbb{R}}^{V\times r}$、$W_2\in {\mathbb{R}}^{r\times V}$:

$$B(x_{k-1},\cdot )=W_1[x_{k-1}]W_2\in {\mathbb{R}}^V\text{\hspace{1em}(5)}$$

$W_1$ 是查表(embedding lookup),$W_2$ 是 logit 投影。默认 $r=256$,存储和每步计算都很小,大词表也扛得住。回到例子:第 1 位采出「of」后,Markov 头在第 2 位给「course」加分、给「problem」减分,碰撞被压住。

RNN 头:Markov 头只记得前一步。RNN 头维护一个递归状态 $s_k$,累积块内整段前缀历史。每步把状态、前一 token embedding、骨干隐状态拼成 $z_k=[s_{k-1};W_1[x_{k-1}];h_k]$,做一次门控更新(类 GRU):

$$\begin{array}{rl}{s}_k& =\sigma (W_g{z}_k)\odot s_{k-1}+(1-\sigma (W_g{z}_k))\odot \tanh (W_c{z}_k),\\ B_k(x_{<k},\cdot )& =W_2^{\top }\tanh (W_o{z}_k)\end{array}\text{\hspace{1em}(6)}$$

实验结论:RNN 头只在很长的块上比 Markov 头好一点点,实现更复杂、部署性更差,所以默认用 Markov 头。 这印证了标题那句——「一点点自回归就够用了」。

---

5. 第二刀:置信度调度验证(系统侧精华)

第一招让块可以做长。但**「猜得多」≠「端到端就快」**。高并发下无脑验整块,反而拖垮系统吞吐。

理想验证长度沿两个轴变化:

• 数据轴:代码这类结构化任务接受率天然高,开放聊天接受率低;
• 系统轴:系统闲时多验几个字几乎免费,系统忙时每多验一个大概率被拒的字,就占了一个本该服务别人的 batch 名额。

DSpark 用「置信度头 + 硬件感知调度器」解决。

5.1 置信度头

让草稿每写一个字额外输出一个标量 $c_k\in (0,1)$,含义是「在前面 token 全部过审的前提下,第 $k$ 个 token 能过审的条件概率」。结构极轻:

$$c_k=\sigma (w^{\top }[h_k;W_1[x_{k-1}]])\text{\hspace{1em}(7)}$$

监督信号用一个有解析解的目标——逐步接受率 $c_k^{\ast }$,由草稿分布与目标分布的全变差距离 (TV distance) 决定:

$$c_k^{\ast }=1-\frac{1}{2}\Vert p_k^d-p_k^t{\Vert }_1\text{\hspace{1em}(8)}$$

这恰好就是投机解码逐步接受概率的精确公式。两分布越接近,接受率越高。

5.2 序列温度缩放 STS:为什么不能直接用原始置信度

这里有个微妙但致命的点:下游调度器需要接受概率的绝对数值(要拿去算期望接受长度 $\tau$),而不只是排序。可神经网络的置信度天生过度自信 (overconfident)。直接用原始分数,吞吐估计会全错,调度就崩。

阈值类方法不在乎这个(它们只需要排序对),但 DSpark 的调度需要精确的累积接受概率,所以必须校准。

STS 的做法:因为一个前缀整体被接受的联合概率,按链式法则因子分解为各位置置信度的累积乘积 ${\prod }_{i\le k}{c}_i$,所以在验证集上从左到右逐位做一维网格搜索,找最优温度系数,最小化累积乘积的期望校准误差 ECE,同时保持前面已校准位置不变。温度缩放是保序变换,只改概率数值、不破坏置信度头学到的排序。

效果:校准后平均 ECE 从 3%–8% 降到约 1%,ROC-AUC 在 0.81–0.90,既有判别力又准。

5.3 硬件感知调度器:全局吞吐最大化

这是全篇最漂亮的部分。把「该验多长」formalize 成一个全局吞吐最大化问题。

设 batch 内有 $R$ 个请求,给请求 $r$ 分配验证长度 ℓr∈{0,…,γ}\ell_r\in\{0,\dots,\gamma\}ℓr​∈{0,…,γ}。因为投机解码只接受连续前缀,位置 $j$ 的存活概率是累积乘积:

$$a_{r,j}=\prod _{i\le j}{c}_{r,i}$$

一步验证里:

• 丢给目标模型的总 token 数:$B={\sum }_{r=1}^R(1+{\ell }_r)$
• 期望被接受的 token 数:$\tau ={\sum }_{r=1}^R(1+{\sum }_{j=1}^{{\ell }_r}{a}_{r,j})$
• $\text{SPS}(B)$ = 引擎在前向 batch 为 $B$ 时每秒能跑多少步,开机时 profile 一次,存成轻量 cost table,查表 $O(1)$

目标:最大化系统级 token 吞吐:

$$\Theta =\tau \cdot \text{SPS}(B)$$

为什么这个看似组合爆炸的问题能贪心解? 关键是单调性。存活概率关于 $j$ 单调不增:

$$a_{r,j}=a_{r,j-1}\cdot c_{r,j}\le a_{r,j-1}$$

而把请求 $r$ 的验证长度从 $j-1$ 延到 $j$,期望多接受的 token 数恰好等于 $a_{r,j}$(边际增益 = 存活概率)。这个单调性保证:把全局所有候选 token 按 $a_{r,j}$ 从高到低排序、贪心往里收,天然尊重块内前缀依赖(不可能在收第 $j$ 位前先收第 $j+1$ 位)。

于是算法 1 就是:全局降序排序所有合法前缀扩展 → 沿这条贪心录取路径逐个 admit → 每 admit 一个就用 $O(1)$ 查表更新 $\Theta$ → 一旦 $\Theta$ 不再上升立刻 break。

5.4 无损性的坑 + 附录 A 反例完整推导(重头戏)

投机解码无损有个铁律——非预期性 (non-anticipating):「要不要录取第 $k$ 个 token」的决定,绝不能依赖第 $k$ 个 token 实际采样成了什么。

麻烦来了:置信度头要看前一个 token($W_1[x_{k-1}]$),所以算下一个存活概率 $a_{r,k+1}$ 必须先知道当前 token $x_{r,k}$ 的实例。如果做一次事后回顾式 (retrospective) 的全局搜索,就会把 $x_{r,k}$ 偷偷泄漏进对第 $k$ 步的录取决定,引入选择偏差。

下面把附录 A 的反例逐个数字走完。

设单请求 $R=1$,最大长度 $\gamma =2$,第一位接受概率 $a_1=0.8$,profile 的硬件曲线:

$$\text{SPS}(1)=1.0,\text{SPS}(2)=0.5,\text{SPS}(3)=0.45$$

先算验 0 个、1 个草稿 token 的吞吐:

$${\Theta }_0=1\cdot \text{SPS}(1)=1.0$$
$${\Theta }_1=(1+0.8)\cdot \text{SPS}(2)=1.8\times 0.5=0.9$$

如果不早停,调度器会继续评估 ${\Theta }_2$。但 $c_2$ 依赖 $x_1$,于是 $a_2=a_1{c}_2$ 也依赖 $x_1$。看 $x_1$ 的两种实现:

情况 1($x_1$ 恰好导致高续接置信,$c_2=0.9$):$a_2=0.8\times 0.9=0.72$

$${\Theta }_2=(1+0.8+0.72)\times 0.45=2.52\times 0.45=1.134$$

$1.134$ 是 {1.0, 0.9, 1.134}\{1.0,\,0.9,\,1.134\}{1.0,0.9,1.134} 中最大 → 返回 $\ell =2$ → 第一个 token 被录取进验证前缀。

情况 2($x_1$ 导致低续接置信,$c_2=0$):$a_2=0$

$${\Theta }_2=(1+0.8+0)\times 0.45=0.81$$

最大值仍是 ${\Theta }_0=1.0$ → 返回 $\ell =0$ → 第一个 token 不被录取。

矛盾点暴露:第一个 token 到底录不录,竟取决于第一个 token 自己是什么。 这就是选择偏差——调度器偷偷偏爱「后续看起来顺」的那些 token。

论文进一步把输出分布算出来,证明它真的改变了结果。设词表 {A,B}\{A,B\}{A,B},第一位的分布:

$$p^t(A)=0.7,p^t(B)=0.3;p^d(A)=0.5,p^d(B)=0.5$$

第一位标准接受概率(应等于 $a_1$):

∑x∈{A,B}min⁡(pt(x),pd(x))=min⁡(0.7,0.5)+min⁡(0.3,0.5)=0.5+0.3=0.8 ✓ \sum_{x\in\{A,B\}}\min\big(p^t(x), p^d(x)\big) = \min(0.7,0.5)+\min(0.3,0.5) = 0.5+0.3 = 0.8\ \checkmark x∈{A,B}∑​min(pt(x),pd(x))=min(0.7,0.5)+min(0.3,0.5)=0.5+0.3=0.8 ✓

假设回顾式调度器如上行为:$x_1=A$ 触发高置信(故 $\ell =2$)、$x_1=B$ 触发低置信(故 $\ell =0$)。则首位输出 token 的分布:

• 若 $x_1=A$:被录取,接受概率 $\min (1,0.7/0.5)=1$,输出即 $A$;
• 若 $x_1=B$:不被录取,目标模型从 $p^t$ 重新采一个新 token。

于是:

$$\mathrm{Pr}(Y=A)=\underset{0.5\times 1}{\underbrace{\mathrm{Pr}(x_1=A)\cdot 1}}+\underset{0.5\times 0.7}{\underbrace{\mathrm{Pr}(x_1=B)\cdot p^t(A)}}=0.5+0.35=0.85$$
$$\mathrm{Pr}(Y=B)=0.15$$

得到输出分布 $(0.85,0.15)$,与目标分布 $(0.7,0.3)$ 不符——无损性被打破。证毕。

早停为什么能救? 用同样数字:初始 ${\Theta }_{\text{best}}={\Theta }_0=1.0$,试录第一个 token 得 ${\Theta }_1=0.9$,判断 $0.9>1.0$?不成立 → 立刻 break,返回 $\ell =0$。整个过程只用到了采样前就已知的 $a_1=0.8$,根本没去计算需要 $x_1$ 的 $c_2$。录取决定因此只依赖前缀信息,非预期性保住。

注:早停取到全局最优,前提是 $\Theta$ 单峰,即隐含假设硬件容量曲线平滑下降。真实硬件不满足这点——见第 8 节。

---

6. 训练目标(公式 9–12)

三个损失,全部用位置权重 $w_k=\exp (-(k-1)/\gamma )$ 加权,越靠前权重越大(前面的字一旦被拒整块作废,杠杆最高):

交叉熵(教草稿预测正确下一字):

$${\mathcal{L}}_{\text{ce}}=-\sum _{k=1}^{\gamma }{w}_k\log p_k^d(x_k^{\ast })\text{\hspace{1em}(9)}$$

分布匹配(惩罚 TV 距离):

$${\mathcal{L}}_{\text{tv}}=\sum _{k=1}^{\gamma }{w}_k\Vert p_k^d-p_k^t{\Vert }_1\text{\hspace{1em}(10)}$$

因为逐步接受概率 $=1-\frac{1}{2}\Vert p^d-p^t{\Vert }_1$,压低 ${\mathcal{L}}_{\text{tv}}$ 直接等价于拉高期望接受率。

置信度损失(BCE,教置信度头预测软标签 $c_k^{\ast }$):

$${\mathcal{L}}_{\text{conf}}=-\sum _{k=1}^{\gamma }{w}_k(c_k^{\ast }\log c_k+(1-c_k^{\ast })\log (1-c_k))\text{\hspace{1em}(11)}$$

合成:

$$\mathcal{L}={\alpha }_{\text{ce}}{\mathcal{L}}_{\text{ce}}+{\alpha }_{\text{tv}}{\mathcal{L}}_{\text{tv}}+{\alpha }_{\text{conf}}{\mathcal{L}}_{\text{conf}},({\alpha }_{\text{ce}},{\alpha }_{\text{tv}},{\alpha }_{\text{conf}})=(0.1,0.9,1.0)\text{\hspace{1em}(12)}$$

注意 ${\alpha }_{\text{tv}}\gg {\alpha }_{\text{ce}}$——目标是「骗过目标模型」而非「写对答案」,这两件事并不完全等价。训练时目标模型全程冻结,草稿模型共享其 embedding 与 LM head(也冻结),只更新骨干、串行块、置信度头。

---

7. 实验:为什么并行打赢了自回归

主结果:在 Qwen3-4B/8B/14B 上,DSpark 的宏平均接受长度比自回归 Eagle3 高 30.9% / 26.7% / 30.0%,比并行 DFlash 高 16.3% / 18.4% / 18.3%,在 Gemma4-12B 上同样成立。

最反直觉的现象:并行/半自回归普遍打赢了「理应更连贯」的纯自回归 Eagle3。 论文用「逐位条件接受率」拆开,给了漂亮解释。

这个指标的定义很关键:统计第 $k$ 位时,分母只数那些前 $k-1$ 位全部被接受的实例,从而剥离「被前缀拖累」的惩罚,暴露每一步的纯预测质量。

三个发现:

① 第 1 个字是胜负手。 第一位大家都只看上下文,拼的纯是网络容量。自回归被 $O(\gamma )$ 延迟逼成浅网络,并行能用深网络,所以 DFlash 在第一位就明显更高(Math 0.88 vs 0.81,Chat 0.72 vs 0.53)。而投机解码是严格前缀存活过程,第一位一旦被拒整块全废,杠杆最大,这点优势被指数级放大——这就是并行全局打赢自回归的根因。

② 后面靠依赖建模。 第 2 位之后,自回归利用「前文已定、后文更好猜」维持甚至上升条件接受率(Chat 从 0.53 升到 0.74);DFlash 因独立预测后缀快速衰减(Code 0.87→0.78,Chat 0.72→0.63),这正是多模态碰撞。

③ DSpark 两头通吃。 既继承并行的高起点(Math 起步 0.93),又用串行头压住衰减,全程高而稳。

其他值得记的:

• 一点点自回归就够:2 层 DSpark 打赢 5 层 DFlash;块越长优势越大,从 $\gamma =7$ 的 +16%/+15%/+18%(math/code/chat),拉大到 $\gamma =15$ 的 +30%/+26%/+22%。
• 串行头几乎不要钱:batch=128 下草稿长度 4→16,整轮延迟仅增 0.2%–1.3%,却换来最高 30% 的接受长度。
• 置信度头确实能剪枝:阈值调高后,Chat 接受率从 45.7% 飙到 95.7%(剪掉注定被拒的尾巴),Math/Code 从 76.9%/67.6% 升到 92.5%/92.0%。

---

8. 落地工程:异步调度如何把第 5.4 节的坑天然填上

线上比离线多两个现实冲突:

1. 真实硬件的 $\text{SPS}(B)$ 曲线是锯齿状跳变的,不是平滑单峰(早停的全局最优前提失效);
2. 动态变化的验证长度会和 CUDA Graph 重放、零开销调度 (ZOS) 打架——ZOS 要求「下一步 batch size 在本步结束前就得确定」,同步调度会卡死 GPU 流水线。

DSpark 的解法是异步调度。 用两步之前的置信度输出来估算即将到来的验证容量上限 $K$,把录取过程 cast 成动态 top-$K$ 选择;而当前这一步的候选 token 仍按最新的累积置信度严格排序。近似容量带来轻微时间偏移,但选择机制本质保序——最有把握的 token 永远被优先验证。这样既隐藏了调度延迟,又无缝兼容 ZOS。

最妙的一步:正因为容量 $K$ 只依赖两步之前的信息,这个异步设计本身就形成一道因果屏障。于是 DSpark 可以大胆去掉早停、做无约束全局搜索(去翻越锯齿悬崖找全局最优),却不会泄漏当前 token、不会破坏无损性——第 5.4 节那个会破坏无损性的坑,被异步天然填上了。这是算法洞察和系统工程咬合得极漂亮的一处。

变长 kernel 问题:不同请求验证长度不一,标准 decode kernel 只擅长定长 query,硬塞会因 padding 和负载不均严重浪费 GPU。解法是解耦物理执行与逻辑序列追踪——把所有请求的 token 拍平、当独立元素一视同仁处理,复杂的序列内依赖用一个 marker tensor 集成进稀疏注意力实现。在 DeepSeek-V4 架构上只需改 index-attention 和 compress 两个 kernel。

---

9. 线上数据 + 那个诚实的 661%

DSpark-5($\gamma =5$)对比老基线 MTP-1(单 token 草稿):

• V4-Flash:中等 SLA(80 tok/s/用户)下吞吐 +51%;匹配吞吐下单用户生成速度快 60%–85%;
• V4-Pro:中等 SLA(35 tok/s/用户)下 +52%;匹配吞吐下快 57%–78%。

机制(图 8):并发不高时调度器把验证预算从 MTP-1 固定的 2 个 token 放大到 4–6 个,吃满空闲算力;并发一高就平滑收紧,把低置信 token 在占用 batch 名额前剪掉。这就是它能稳住高并发的根本。

这里要给作者点个诚实分。 论文里那个 +661%(V4-Flash 在 120 tok/s 严苛 SLA 下)的数字,他们自己明确说别当成真实加速倍数——那是因为在极严 SLA 下,单 token 的 MTP-1 已濒临崩溃、只能撑极小并发,分母太小才显得比值巨大。作者把它解读为「DSpark 把以前根本做不到的交互档位变得可行」,即把服务的帕累托前沿往外推,而非吹一个 6 倍速。这种克制在如今的论文里不算常见,值得尊重。

---

10. 局限与总结

局限:即便调度器把验证浪费压到最低,DSpark 仍需先花固定草稿成本用并行骨干生成那 $\gamma$ 个 token。遇到本身接受率极低的复杂请求,这笔前期算力不可回收。作者提出未来可在草稿模型里做难度感知的提前退出,让这类请求绕过整块生成。

总结:DSpark 的价值不在颠覆,而在缝合与落地。

• 算法上,它用一个极轻的局部归一化串行头,把「并行写得快」和「自回归写得准」缝在一起,既保住了无损投机解码必需的精确逐 token 概率,又压住了后缀衰减;
• 系统上,它把验证长度选择 formalize 成全局吞吐最大化,用单调性证明了贪心可解,诚实地指出了无损性的坑,再用异步因果屏障优雅填坑;
• 工程上,它真上了 DeepSeek-V4 生产,数据扎实、解读克制。

一句话总结：这是一篇「能落地」的论文,不是「刷榜」的论文。 半自回归骨架、置信度调度、异步无损保证这三件套,大概率会成为后续高并发投机解码方案的标配组件。