DeepInfer 项目推荐:DeepSeek 把自家生产推理框架开源了,C++ 调度器 + 置信度投机解码 + EPLB 全在仓库里

DeepInfer(deepseek-ai/DeepInfer)是 DeepSeek 官方开源的大模型推理框架。它不是 demo,也不是"把 vLLM 改个名字",而是支撑 DeepSeek V4.1 Flash 大规模在线服务的那套引擎本体——官方在配套的部署问答里给了一个数字:单个集群每天服务 155 万亿 tokens,综合营收 38 美元/GPU·小时。

对做推理基础设施的人来说,这份开源的看点不在"又一个推理框架",而在于它把超大规模在线服务里那些"论文里说不清、只能靠打出来"的工程取舍,连同代码一起交出来了:C++ 实现的零开销异步调度器、按边际收益裁剪草稿 token 的变长投机验证、MoE 冗余专家放置的贪心算法、把重算成本变成常数的 SWA 有界重放、以及为"可复现"专门关掉的 kernel 优化。这篇推荐就挑这几处能讲透的地方拆一拆。

关键数据概览

  • 仓库:deepseek-ai/DeepInfer,Apache-2.0 许可
  • 热度:17.8k stars / 1.8k forks(2026 年 10 月 16 日创建,一周内到量)
  • 语言构成:Python 为主 + C++/CUDA 内核与调度器(csrc/)+ TileLang kernel 双后端(cuda/ 与 asc/)
  • 最新版本:尚无 Release/Tag,以 main 滚动发布;首次提交 2026-10-20,最近一次提交 2026-10-21
  • 活跃度:pushed_at 2026-10-21,提交以"Bump DeepEP 子模块 + 文档 Q&A 更新"为主,仓库结构已稳定
  • 支持模型:DeepSeek-V4.1-Flash(默认 checkpoint deepseek-ai/DeepSeek-V4.1-Flash-1017)
  • 支持硬件:NVIDIA SM100 | 华为昇腾 950 NPU
  • 构建门槛:Linux · GCC ≥ 13 · Python 3.12 · CUDA 13(N 卡)/ CANN 9.2(昇腾)
  • 规模:约 400 个文件,csrc/engine/scheduler.hpp 单文件 66KB,核心算子以 TileLang 编写

起源:把"怎么服务 155 万亿 tokens/天"的答案写进仓库

DeepSeek 在开源 DeepInfer 之前,已经陆续放出了 FlashMLA、DeepGEMM、DeepEP、TileLang 等一整套算子与通信库。DeepInfer 是把这些零件串成整机的那一层,官方给它的定位很明确:这是一个 offline inference(离线推理)的开源版本,包含"大规模服务所需的核心能力"。

有意思的是它的"留白"。README 坦白列了三样没有随这次开源一起给出来的东西:KV cache 系统、完整的 VE/Prefill/Decode 分离部署、以及 DP 副本间的负载均衡。理由也直说:这三块的代码"与我们内部基础设施强耦合"。但配套的 doc/inference_deployment_qa.md(近 3 万字)把这三块的设计思路、参数、甚至实测的 moe_lb 数值都写了出来——代码不给,思路给全。这种"开源引擎 + 开源设计文档"的组合,对读代码的人来说反而更好用:先看懂取舍,再去读能读的那部分实现。

它和 vLLM 的关系也不遮掩:Acknowledgments 里第一句就是"originally built primarily on vLLM",另有 SGLang、TensorRT-LLM 的启发。所以更准确的理解是:DeepInfer 是 vLLM 血统 + DeepSeek 自家算子 + 为自家模型做的深度特化。它不是通用框架,而是"把一个特定模型跑到极致"的样本。

技术亮点一:调度器用 C++ 重写,为了把 CPU 时间从关键路径上偷走

先看一个细节:deepinfer/engine/ 里的 Python 只是壳,真正的调度逻辑在 csrc/engine/scheduler.hpp——一个 66KB 的 C++ 头文件。为什么要把调度器写进 C++?

因为 decode 阶段的每步循环里,GPU 和 CPU 是串行卡着的:

step N:  schedule(N) → forward(N) → sample(N) → post-process(N)

schedule 和 post-process 是纯 CPU 逻辑,post-process(N) 又必须等 sample(N) 的结果从 GPU 同步回来。于是 GPU 在 post-process(N) 和 schedule(N+1) 这两段里纯空转。DeepInfer 的做法是标准的异步流水:GPU 跑 forward(N) → sample(N) 的同时,CPU 并行跑 schedule(N+1) → launch_forward(N+1) → post-process(N−1) → launch_sample(N+1)。

思路不新(SGLang、NanoFlow 都这么干),真正难的是边界条件:CPU 在不知道 N 步结果的情况下就要预排 N+1 步的计划。所以 SchedulerOutputs 里专门留了一个字段:

struct SchedulerOutputs {
    std::vector<SequencePtr> scheduled_seqs;
    bool prompt_run;
    int num_batched_tokens;
    // optimistic estimation in async-scheduling varlen case
    std::vector<int> seqlens_q;      // 乐观估计:N 步的接受长度还没回来
    ...
    double total_tflops;             // Includes attention; immutable scheduling-time MFU estimate.
};

注释写得很直白:seqlens_q 是"乐观估计"。变长投机解码下,第 N 步到底接受几个 token 要等 GPU 回来才知道,但 CPU 已经得按一个假定的长度把 N+1 步排好。这个"猜"的准确度直接决定流水线的成色——猜多了要回滚,猜少了浪费算力。

更讲究的是动态估时。CUDA Graph 是按固定 batch size 预捕获的(cuda_graph_runner.py 里用 bisect_left 挑"不小于请求量的最小已捕获尺寸"),但同一个 graph size 的实际耗时还会随上下文长度变化。于是调度器里做了两个"只信最近样本"的估计器(csrc/engine/mtp_varlen.hpp):

// 9 格滑窗取中位数,至少 5 个样本才敢用;用于估计 sampler 耗时
class SamplerRuntimeEstimator {
    void update(double value_ms) {
        _samples[_next] = value_ms;
        _next = (_next + 1) % _window_size;
        _size = std::min(_size + 1, _window_size);
        auto sorted = _samples;
        std::sort(sorted.begin(), sorted.begin() + _size);
        ...
    }
    std::optional<double> get() const;   // 样本不够就返回 nullopt,不瞎猜
};

// 拟合 forward 耗时里与上下文相关的斜率:输入 (forward_ms - baseline_ms) / graph_size
class ForwardRuntimeEstimator { ... };   // 先按 graph size 聚合取中位数,再对中位数取中位数

工程味道全在这些小地方:用中位数不用均值(抗毛刺)、样本不足就返回 nullopt(不拿脏数据做决策)、先按 graph 分组再取中位数(避免大 batch 样本淹没小 batch)。这类"估计器"看起来不起眼,但它决定了异步流水线在负载抖动时是稳还是崩。

技术亮点二:投机解码不是"验证越多越好"——DSpark 按边际收益裁剪草稿

DeepInfer 的投机解码叫 DSpark,草稿模型一次吐 5 个 token。朴素做法是"固定验证 5 个",但 DeepSeek 在部署问答里点出了一个关键事实:

草稿 token 的接受概率在不同请求、不同位置上差别很大,固定长度验证会把验证算力浪费在低概率 token 上。

于是他们在模型里加了一个 Confidence Head:预测每个草稿 token 的接受概率。代码在 deepinfer/model_executor/models/mtp/dflash.py:

class ConfidenceHead(nn.Module):
    """Predict the acceptance probability of each draft token."""

    def forward(self, hidden, markov_emb, out=None, step_i=0):
        return confidence_head_fused(hidden, weight=self.proj.weight, markov_emb=markov_emb,
                                     temperature=self.temperature[step_i], out=out)

注意两个细节:head 的输入不只是 hidden state,还拼了 markov embedding(草稿模型的马尔可夫头权重)——也就是说它预测的是"在当前上下文 + 这个草稿头的情况下,这一位会被接受的概率",而不是一个全局常数;每个草稿位置 step_i 有各自的温度(DEEPINFER_DFLASH_CONFIDENCE_HEAD_TEMPERATURE 支持传 tuple),因为第 1 位和第 5 位的接受概率分布完全不同。

拿到逐位置信度之后,调度阶段的逻辑是:

# 示意:按"预期收益/成本"排序,选出最优前缀子集
drafts = sample_drafts(...)                    # [req, 5],带 confidence_rates
for req in batch:
    order = argsort(confidences[req], descending=True)   # 高接受率优先
    for k in candidate_prefix_lengths:                   # 结合实测吞吐曲线
        gain = expected_accepted_tokens(req, order[:k]) / verify_cost(k)
    verify_len[req] = argmax(gain)             # 每请求、每步都不同

效果是实打实的:每步验证的草稿 token 数从 5.00 降到 3.2~4.4(约 −30%),而平均接受长度基本不变(3.20 → 3.29)。省下来的验证算力直接变成吞吐:

并发(seqs/rank)固定 5 验证长度变长验证长度固定 5 接受长度变长接受长度变长 vs 固定 5 吞吐增益
1654.443.323.24−1.5%
3253.653.253.17+1.6%
4853.943.303.26+3.6%
60(生产工作点)53.583.303.21+5.4%
7253.243.293.12+6.7%
9653.243.303.15+11.0%

低并发时它是负收益,高并发时才转为正收益——这条曲线本身就是极好的工程教训:投机解码的"剪枝"不是免费的,你得有足够的并发把省下的验证算力重新填满,它才回本。DeepSeek 把它做成可配置的(DEEPINFER_ENABLE_MTP_VARLEN、DEEPINFER_USE_NEXTN_DECODE),而不是硬编码,理由很充分。

还有一个很妙的实现取舍:异步调度下,schedule(N+1) 跑的时候第 N 步的置信度还没从 GPU 回来。所以 CPU 只定总预算,逐请求的验证长度改在 GPU 上用 TileLang kernel 现算——累乘置信度、全局排序取 top-k、再 fuse 一个 remap scatter,结果写回 pinned buffer。CPU 和 GPU 各自干自己擅长的那半件事。

技术亮点三:EPLB——给热点专家配副本,用贪心把负载"削峰"

MoE 的专家并行有个绕不过去的现实:不同专家的热度天然不均。DeepInfer 的 EPLB(Expert Parallel Load Balancer)机制是给每个 GPU 分配几个冗余专家位,用来放热点专家的副本;周期性根据统计重排,再用 NVLink 的 symm_mem 原地 shuffle 权重。

问题在于"怎么排"才是最优的。代码里把这个目标写得很清楚(deepinfer/model_executor/eplb/policy.py):

# 对固定的 layer 而言,目标是将这层的 physical expert 分到各个 rank 上,
# 并且使得 sum_{step i} max_{rank j} (sum_{e 被分到 rank j} e 在 step i 的负载) 尽量小

翻译成人话:优化的是"历史每一步里最慢那个 rank"的时间之和,而不是总负载的方差。因为一步 decode 的耗时由最慢的 rank 决定——这是个 minimax 问题,不是均衡问题。这个目标函数一旦写对,算法就顺势出来了:

for job_index in range(num_physical):          # 逐个放置专家(大批量优先)
    vector = vectors[layers, expert_order[:, job_index]]
    torch.add(loads, vector.unsqueeze(1), out=candidates)      # 放到各 rank 后的新负载
    torch.maximum(candidates, peaks.unsqueeze(1), out=candidates)  # ⭐ 和该 rank 的历史峰值取 max
    torch.sum(candidates, dim=-1, out=scores)                 # 对历史 step 求和 = minimax 目标
    scores.masked_fill_(occupancy == capacity, float("inf"))   # 已满的 rank 排除
    rank = scores.argmin(dim=-1)                               # 贪心选目标最小的 rank
    ...

那个 torch.maximum(candidates, peaks) 是整个算法的灵魂:放一个新专家不是简单地把负载加上去,而是可能抬高这个 rank 的历史峰值。只有把峰值抬高的代价算进去,贪心才真的在优化 minimax。整个放置过程全部用 tensor 运算批量完成([num_layers, num_ranks, num_steps] 一次算完所有层),不是 Python 循环——因为这段代码在生产里会被反复调用。

配套的几个数字也很说明问题:

  • Prefill:每 GPU 从 4 个冗余专家起步,100 步统计窗,每 1000 步重排,实测 moe_lb(最慢 rank/均值)= 1.074(EP4DP4)/ 1.045(EP2DP2)
  • Decode:每 GPU 从 1 个冗余专家起步(EP64 下四舍五入后是 7 个/GPU),1000 步统计窗,每 10000 步重排,moe_lb = 1.090

Prefill 排得勤、Decode 排得懒——因为 decode 阶段每个 rank 都在忙、shuffle 权重的停顿代价更高,而 prefill 的 batch 组成变化快得多。这种"同一套机制、两套参数"的调法,就是把实验数据变成本能。

另外三处值得独读的设计

1. SWA bounded replay:把重算成本变成常数

V4.1 Flash 用了滑动窗口注意力(SWA)。前缀缓存命中时,麻烦在于 SWA 的 KV 也要还原——如果老实重算,可能要把一长串上下文重跑一遍。

DeepInfer 的解法是"只重算最后 128 个 token,并把注意力窗口截断在这次重放段内":从位置 s 开始重放,位置 i 的 query 只和 max(s, i−127) 到 i 的 key 计算,得到一个近似的 SWA KV。代价因此变成常数,与上下文长度、层数都无关。

更狠的是解码器侧的应用:在 CED 架构里,解码器层的 block KV 是从最后一层编码器 hidden 投影出来的,但解码器的 SWA KV 得逐层算——精确重建要跑 2560 个 token × 20 层。他们改成每次 prefill 只重算最后 128 个 token,结果只给 decode 用、永不进前缀缓存,直接"把总 prefill 计算量几乎减半"。

配套的命中策略也写死了:命中长度由 block KV 决定,最后一块要不要重算由 SWA KV 是否存在决定,缺了就退一块重算;在 YOCO 截断要求下,长度 L 的输入最大命中 L − 134(128 窗口 + 6 token 投机回溯余量)。这类"近似 + 明确误差边界"的设计,比吹"零重算"实在得多。

2. Batch-invariant + 确定性采样:为"可复现"主动放弃优化

推理框架一般不会碰这两个词,因为它们是反性能的。DeepInfer 却把它们做成了开关:

  • DEEPINFER_BATCH_INVARIANT=1:同一 prompt 无论和谁拼 batch,结果完全一致。原理是所有归约(reduction)都走与 batch 组成无关的固定顺序,而不能用"batch 越大、切分越优"的动态策略。
  • 确定性采样:在此基础上再设 DEEPINFER_ENABLE_MTP_VARLEN=0 并给 SamplingParams 传固定的 seq_seed,相同输入 token + 相同采样参数 → 逐位相同输出(注意:关掉变长投机是必须的,因为变长验证本身依赖运行时反馈)。

为什么生产框架要提供这个?因为评测、回归测试、线上问题复现都要求"同输入同输出"。没有它,改一个 kernel 后跑分差异到底来自优化还是随机性,根本说不清。仓库里那套 tests/models/offline_decode_ppl.json 的逐样本 PPL 基线比对,就是靠这个开关才立得住。

3. 双硬件后端:NVIDIA 与昇腾共享一套调度,算子各写一份

deepinfer/model_executor/layers/tilelang_ops/ 下面有个很能说明问题的目录结构:

tilelang_ops/
├── sampler.py            # 抽象/共享
├── fused_sample.py
├── cuda/                 # NVIDIA 专用
│   ├── sampler.py
│   └── fused_sample.py
└── asc/                  # 昇腾(Ascend)专用
    ├── sampler.py
    └── fused_sample.py

调度器、模型结构、缓存管理、异步流水是全平台共享的;只有算子层按平台分叉。 这个分界线划得很干净——它意味着"支持国产芯片"不是重写一个框架,而是重写一层 kernel。README 里也能看到对应的环境变量分叉(DEEPINFER_ACCELERATOR=nvidia|ascend)与依赖分文件(requirements-nvidia.txt / requirements-ascend.txt)。对一个要跨两家加速器的团队来说,这是最省钱的组织方式。

顺便提一个值得学的细节:结构化输出用的是 xgrammar,但 deepinfer/structure_output/compiler.py 里对缓存的默认态度很谨慎:

# xgrammar <= 0.1.x had production incidents with cache enabled; keep this env as the kill switch.
self.disable_cache = envs.DEEPINFER_XGRAMMAR_DISABLE_CACHE
if self.cache_limit_bytes <= 0:
    logger.warning("xgrammar cache is enabled WITHOUT a size limit ... "
                   "may cause OOM (DoS vector, see CVE-2025-32381).")

把上游库踩过的坑写成带 CVE 编号的告警,而不是默默相信默认值——这才是生产级代码该有的样子。

优点:为什么值得读

1. 它是一份"真实工作点"的样本,不是玩具 README 给的 benchmark 是 4 卡 SM100 跑 prefill、64 卡跑 decode(各在一个 scale-up 域内);文档给的参数、moe_lb、接受长度、TTFT 预算模型,全是线上调出来的数字。想学"大规模推理到底怎么调",这比任何综述都有料。

2. 取舍讲得极其坦白 哪里用了近似(SWA bounded replay)、近似误差怎么界定(L − 134 的命中上限)、哪个优化在低并发下是负收益(变长验证 −1.5%)、哪些代码因为耦合内部基础设施没开源——全部都写出来了。这种坦白本身就是文档价值。

3. 双硬件栈,对国产算力生态有直接参考价值 NVIDIA 与昇腾共享调度、分叉算子的分层方式,是一份现成的"如何让推理框架同时支持两家加速器"的架构答案。

4. 可复现性做成了产品特性 batch-invariant + 确定性采样 + 逐样本 PPL 基线,这套组合让"性能回归测试"在 LLM 推理里第一次变得可执行。

5. Apache-2.0,商用无碍 和 DeepSeek 自家一堆算子库(FlashMLA、DeepGEMM、DeepEP)许可一致,可以整体拼装进自有服务。

注意事项:上手前得想清楚的事

1. 门槛是"真正的大规模",不是"一块卡" 官方口径:最小可部署单元是 1P + 1D,而推荐的 decode 配置是 EP64 及以上,所以"最小高效部署单元"是 64 卡 prefill + 64 卡 decode。它支持的硬件是 SM100(Blackwell 级) 和 昇腾 950,不是消费级卡。个人开发者想拿它跑本地模型,方向就错了。

2. 只支持一个模型 当前仅支持 DeepSeek-V4.1-Flash。它不是通用推理框架,别指望拿它跑 Llama 或 Qwen。

3. 不是开箱即用的服务 README 明确列出"完整推理服务还需要但没有随本次开源给出"的三样:KV cache 系统、VE/Prefill/Decode 完整分离部署、DP 副本间负载均衡。想做端到端在线服务,这部分得自己补(或者读文档照着实现)。

4. 需要自己编译,且入口是离线推理 没有 pip 包、没有 wheel、没有 Release。得 export DEEPINFER_ACCELERATOR=nvidia && ./build.sh,在空 Python 3.12 环境里从源码构建。当前开放的入口是 examples/offline_inference.py 这类离线推理脚本。

5. 迭代中的 main 分支 仓库一周前才建立,无 tag 无 release,API 与环境变量名仍可能变。建议锁 commit 使用,别跟 main 漂。

适合谁

  • 做推理基础设施的工程师:想认真搞懂"异步调度怎么算预算、投机解码怎么剪枝、EPLB 目标函数怎么立",这里的代码与文档可以直接当教材;
  • MoE 大模型的服务团队:EPLB 的 minimax 贪心放置 + 冗余专家 + symm_mem 原地 shuffle,是现成可移植的实现,尤其适合专家热度不均的场景;
  • 要跨 NVIDIA / 昇腾双栈的团队:共享调度 + 分叉算子的分层,以及 cuda/ 与 asc/ 双写的目录约定,是一份省事的架构模板;
  • 关心"可复现推理"的人:batch-invariant、确定性采样、PPL 基线比对的组合,是做模型评测与回归的人绕不开的参考;
  • DeepSeek 模型的自部署方:既然官方把 V4.1 Flash 的引擎开源了,自建服务的最优起点就是它本身,而不是拿通用框架硬调。

项目地址:deepseek-ai/DeepInfer | 部署问答:doc/inference_deployment_qa.md | 默认模型:DeepSeek-V4.1-Flash-1017

DeepInfer 最值得读的,不是它有多快(快是结果),而是那些被写进代码和注释里的判断:为什么调度器要用 C++、为什么估时要取中位数、为什么变长验证在低并发下干脆关掉、为什么近似重算要配一个明确的误差上限。这些判断平时只存在于大厂内部的口头传承里,现在它们躺在 csrc/engine/scheduler.hpp 和 policy.py 里,任何人都能逐行对照。对做后端与推理工程的人来说,这就是那种"光读代码就能涨功力"的仓库,值得现在就 clone 下来。