Skills MCP Model 博客 提交 Skills
登录 注册

DeepSeek 模型架构深度解析

深入理解 DeepSeek 的核心技术创新:MoE 混合专家、MLA 多头潜在注意力、MTP 多 Token 预测、FP8 混合精度训练。从原理到代码,从架构到性能,彻底掌握 DeepSeek 技术栈。

开始探索

DeepSeek 模型架构全景图

DeepSeek V3 和 R1 的技术架构全景。671B 总参数,37B 激活参数,多项世界级创新。

DeepSeek V3 架构概览

DeepSeek V3 采用 MoE(Mixture of Experts)混合专家架构作为核心设计。总参数量 671B,但每次推理仅激活 37B 参数 per token。这得益于其稀疏激活机制:每个 token 只路由到少量专家子网络,而非激活全部参数。

V3 架构的核心组成包括:

架构组件 技术描述 关键参数
Transformer Backbone 基于 Transformer 的 Decoder-only 架构 61 层 Transformer
DeepSeekMoE 细粒度专家分割 + 共享专家隔离 256 个路由专家 + 8 个共享专家
MLA 多头潜在注意力,低秩 KV 压缩 KV Cache 压缩至原来的 1/5~1/10
MTP 多 Token 预测,同时预测未来 N 个 token 深度 M = 1(预测 1 个额外 token)
FP8 Training 首次在超大规模模型上验证 FP8 训练 训练成本 557 万美元

V3 与 R1 架构对比

V3 和 R1 共享相同的底层架构(MoE + MLA),但训练策略和目标不同:

对比维度 DeepSeek V3 DeepSeek R1
基础架构 671B MoE + MLA 基于 V3 架构(671B)
训练方式 监督预训练 + SFT 强化学习(RL)+ 冷启动 SFT
核心能力 通用对话、写作、翻译、知识问答 推理、数学、编程、逻辑思考
推理模式 直接生成答案 Chain-of-Thought 思维链推理
上下文窗口 160K 160K(671B)/ 128K(蒸馏版)

671B 参数全景

DeepSeek V3 的 671B 参数分布如下:

参数构成

Embedding 层

词表大小 128K,嵌入维度 7168。多头潜在注意力机制将 KV 压缩到低维潜在空间,大幅减少参数量。

  • 词表嵌入: 128K x 7168
  • 位置编码: RoPE(旋转位置编码)
参数构成

Transformer 层

61 层 Transformer,每层包含 MLA 注意力模块和 DeepSeekMoE FFN 模块。前 3 层使用密集 FFN(非 MoE)。

  • 61 层 Decoder-only
  • 58 层 MoE + 3 层 Dense FFN
参数构成

MoE 专家层

256 个路由专家 + 8 个共享专家。每个 token 激活 8 个路由专家 + 1 个共享专家。每个专家为一个小型 FFN 网络。

  • 256 路由专家 + 8 共享专家
  • Top-8 门控路由
参数构成

激活参数

37B 激活参数 per token。通过稀疏激活,仅 5.5% 的参数参与每次推理计算,大幅降低计算开销。

  • 37B / 671B = 5.5% 激活率
  • 推理成本降低 90%+

MoE 混合专家架构详解

MoE(Mixture of Experts)是 DeepSeek 的核心架构创新。671B 参数中仅激活 37B,大幅降低推理成本。

专家路由机制

在传统 Transformer 中,每个 token 都经过相同的 FFN 层处理。MoE 架构将 FFN 层替换为多个「专家」子网络,每个 token 通过门控网络(Gate)选择最相关的专家进行计算。

DeepSeek V3 的 MoE 设计如下:

  • 总专家数:256 个路由专家(Routed Expert)+ 8 个共享专家(Shared Expert)
  • 每 Token 激活:8 个路由专家 + 1 个共享专家 = 9 个专家参与计算
  • 门控策略:Top-K Gating,K = 8(从 256 个专家中选择得分最高的 8 个)
  • 共享专家:8 个专家对所有 token 始终激活,捕获通用知识

Top-K 门控机制

门控网络是一个线性层,将 token 的隐藏状态映射到 256 维的专家得分向量。然后选择得分最高的 K 个专家,通过 softmax 归一化计算各专家的权重:

# Top-K 门控路由(伪代码)
gate_logits = Linear(hidden_states) # [batch, seq, 256]
topk_weights, topk_indices = topk_softmax(gate_logits, k=8) # 选择 Top-8 专家
expert_output = sum(weight * expert[expert_idx](hidden_states) for each selected expert)
shared_output = shared_expert(hidden_states) # 共享专家始终激活
final_output = expert_output + shared_output

其中 topk_softmax 先选择 Top-K 专家,再在选中专家间做 softmax,未被选中的专家不参与计算。

Auxiliary-Loss-Free 负载均衡

传统 MoE 模型通常使用辅助损失(auxiliary loss)来鼓励专家负载均衡,防止「专家坍塌」——即大部分 token 被路由到少数几个专家,其余专家闲置。但辅助损失会增加训练复杂度,且可能影响模型性能。

DeepSeek 提出了一种创新的 auxiliary-loss-free 负载均衡策略

  • Expert Bias 动态调整:每个专家维护一个偏置项(bias),训练过程中根据专家负载动态调整。负载过高的专家降低其偏置,负载过低的专家提高偏置。
  • Sequence-level 辅助损失:在序列级别而非 token 级别施加轻微平衡约束,确保每个序列内的专家使用分布均匀。
  • 互补调度:当某个专家负载过高时,系统自动将部分 token 路由到次优但可用的专家。

为什么 MoE 高效?

MoE 架构的核心优势在于 稀疏激活。671B 的总参数提供了海量知识容量,但每次推理仅激活 37B(5.5%),使得计算量远低于同规模的密集模型。

效率优势

计算量降低

密集 671B 模型每次推理需要计算全部 671B 参数。MoE 仅计算 37B 激活参数,计算量约为密集模型的 1/18。

  • FLOPs 降低约 94%
  • 推理延迟降低约 90%
效率优势

知识容量保持

尽管每次只激活少量参数,671B 的总参数规模让模型能存储远多于密集模型的知识,不同专家专注于不同领域。

  • 671B 总知识容量
  • 专家专业化分工
效率优势

训练成本优化

稀疏激活 + FP8 混合精度训练让 DeepSeek V3 的训练成本降至 557 万美元,仅为同级别密集模型的 1/10 到 1/20。

  • 557 万美元总成本
  • H800 GPU 集群

MLA 多头潜在注意力机制

Multi-head Latent Attention(MLA)是 DeepSeek 的注意力创新,通过低秩 KV 压缩大幅降低推理显存。

传统 MHA 的问题

在标准多头注意力(Multi-Head Attention, MHA)中,每个 token 需要缓存其 Key 和 Value 向量以支持后续 token 的自回归生成。对于长序列,KV Cache 的显存占用迅速增长:

# 传统 MHA 的 KV Cache 大小
KV_Cache = 2 * num_layers * num_heads * d_head * seq_len * batch_size
# 对于 DeepSeek V3(128 头,128 维,61 层,128K 上下文):
# 每个 token 的 KV Cache 约为 61 * 2 * 128 * 128 = 1,998,848 个 float = 7.6 MB
# 128K 上下文的 KV Cache 约为 7.6 MB * 128K ≈ 973 GB(不可接受)

MLA 的核心思想:低秩 KV 压缩

MLA 的核心创新在于将 Key 和 Value 投影到低维潜在空间,再进行注意力计算。具体来说:

  1. KV 压缩投影:将原始的高维 Key/Value 通过一个下投影矩阵压缩到低维潜在向量 c_KV(维度远小于原始维度)。
  2. 缓存潜在向量:推理时仅缓存低维潜在向量 c_KV,而非缓存完整的 Key 和 Value 矩阵。
  3. 上投影还原:注意力计算时,通过上投影矩阵将潜在向量还原为完整的 Key 和 Value。
# MLA 注意力计算流程
# 1. 压缩投影(训练时/推理时均执行)
c_KV = W_down_KV @ hidden_states # [batch, seq, d_latent] d_latent << d_model

# 2. 缓存潜在向量(仅推理时)
KV_Cache = c_KV # 仅缓存低维潜在向量

# 3. 上投影还原(注意力计算时)
k = W_up_K @ c_KV # 还原为完整 Key
v = W_up_V @ c_KV # 还原为完整 Value

# 4. 标准注意力计算
q = W_q @ hidden_states
attention = softmax(q @ k^T / sqrt(d_head)) @ v
output = W_o @ attention

RoPE 解耦设计

RoPE(Rotary Position Embedding)是现代 Transformer 中广泛使用的位置编码方式。但 RoPE 与低秩压缩存在冲突:RoPE 作用于 Key 向量,而 MLA 压缩的是 Key 和 Value 的联合表示。

DeepSeek 的解决方案是 RoPE 解耦:将 Query 和 Key 各自拆分为两部分 —— 一部分经过 RoPE 处理(捕获位置信息),另一部分不经过 RoPE(保留内容信息)。RoPE 部分单独处理,不参与 KV 压缩。

# RoPE 解耦设计
# Query 拆分
q_content = W_qc @ hidden_states # 内容部分,不经过 RoPE
q_rope = W_qr @ hidden_states # 位置部分,经过 RoPE
q_rope = RoPE(q_rope)

# Key 拆分
k_content = W_kc @ c_KV # 内容部分,从潜在向量还原
k_rope = W_kr @ hidden_states # 位置部分,单独计算
k_rope = RoPE(k_rope)

# 拼接后计算注意力
q = concat(q_content, q_rope)
k = concat(k_content, k_rope)
attention = softmax(q @ k^T / sqrt(d_head)) @ v

显存节省计算

MLA 的 KV Cache 压缩效果显著。假设潜在维度为 d_latent,原始 KV 维度为 d_model:

压缩比

MLA 压缩效果

DeepSeek V3 中,d_latent = 512,而传统 MHA 的 KV 维度为 128 * 128 = 16384。压缩比约为 32:1。

  • 潜在维度: 512
  • 原始 KV 维度: 16384
  • 压缩比: ~32x
显存节省

实际效果

在 128K 上下文窗口下,MLA 将 KV Cache 从约 973 GB 降低到约 40 GB,使得长上下文推理在单卡上成为可能。

  • 传统 MHA: ~973 GB
  • MLA: ~40 GB
  • 节省: ~96%
推理加速

吞吐量提升

更小的 KV Cache 意味着更少的内存读写和更高的吞吐量。MLA 使长序列推理的吞吐量提升 3-5 倍。

  • 内存带宽节省: ~90%
  • 吞吐量提升: 3-5x

MTP 多 Token 预测机制

Multi-Token Prediction(MTP)让模型同时预测多个未来 token,提升训练效率和推理质量。

MTP 工作原理

传统自回归模型一次只预测下一个 token。MTP 让模型在每一步同时预测接下来的 N 个 token(DeepSeek V3 中 M = 1,即预测 1 个额外 token,共 2 个 token)。

MTP 的核心思想是:模型的主干网络输出隐藏状态后,通过多个独立的「预测头」(Prediction Head)分别预测 t+1, t+2, ..., t+M 位置的 token。

# MTP 前向传播(DeepSeek V3,M=1)
# 主模型前向
hidden = transformer(input_tokens) # 主模型输出

# 第一个预测头(预测 t+1,标准 next-token prediction)
logits_1 = lm_head(hidden) # 预测下一个 token
loss_1 = cross_entropy(logits_1, tokens[:, 1:])

# 第二个预测头(预测 t+2)
hidden_2 = MTP_Module(hidden, embedding(tokens[:, :-1])) # MTP 模块
logits_2 = mtp_head(hidden_2) # 预测再下一个 token
loss_2 = cross_entropy(logits_2, tokens[:, 2:])

total_loss = loss_1 + lambda * loss_2 # 加权组合

MTP 模块设计

MTP 模块是一个轻量级 Transformer 层,接收主模型隐藏状态和当前 token 的 embedding 作为输入,输出对未来 token 的预测:

  • 输入融合:将主模型隐藏状态与当前 token 的 embedding 拼接,通过线性层融合。
  • Transformer 块:一个标准的 Transformer 层(含注意力和 FFN),对融合后的表示进行进一步处理。
  • 输出头:一个共享的 LM Head 将处理后的表示映射到词表分布。

训练效率提升

MTP 在训练阶段提供了更强的学习信号。模型不仅需要预测下一个 token,还需要预测后续 token,这迫使模型学习更长远的依赖关系。

训练收益

更强的训练信号

多个预测目标提供了更丰富的梯度信号,帮助模型更快收敛。每个训练步骤获得的信息量是传统方法的 2 倍。

  • 收敛速度加快约 30%
  • 等量数据下效果更好
训练收益

长期规划能力

MTP 迫使模型进行「超前思考」,提升了对长程依赖的建模能力。这也是 R1 推理能力增强的重要原因之一。

  • 长程依赖建模提升
  • 推理连贯性增强

推理阶段:MTP 模块可丢弃

MTP 的一个重要设计是:MTP 模块在推理时可以完全丢弃。推理时仅使用主模型的标准 next-token prediction,MTP 模块不参与推理计算,因此不会影响推理速度。

MTP 带来的推理加速主要体现在:由于训练阶段学习到了更好的表示,主模型(不含 MTP 模块)的推理质量更高,在相同任务上需要更少的推理步骤。

推理时的投机解码(Speculative Decoding):虽然 MTP 模块在标准推理中不使用,但可以作为投机解码的「草稿模型」,同时生成多个候选 token,由主模型验证,从而加速推理。这种模式下,推理速度可提升 1.5-2 倍。

FP8 混合精度训练技术

DeepSeek 首次在超大规模模型上验证了 FP8 训练的可行性,训练成本降至 557 万美元。

FP8 vs BF16 vs FP32

深度学习训练中常用的数据精度比较:

精度格式 总位数 指数位 尾数位 动态范围 显存占用
FP32 32 8 23 3.4 x 10^38 4 bytes / 参数
BF16 16 8 7 3.4 x 10^38 2 bytes / 参数
FP8 E4M3 8 4 3 448 1 byte / 参数

FP8 的显存占用仅为 BF16 的一半、FP32 的四分之一,但动态范围较小(E4M3 格式),对训练稳定性要求极高。

分块量化(Block-wise Quantization)

DeepSeek 采用分块量化策略解决 FP8 动态范围不足的问题:

  • 分块策略:将激活值和权重按 128x128 的块进行分组,每个块独立计算缩放因子(scale factor)。
  • 在线缩放:缩放因子根据当前块的最大绝对值动态计算,确保量化精度。
  • 高精度累加:矩阵乘法的累加在 FP32 精度下进行,避免量化误差累积。
# 分块量化伪代码
# 前向传播:FP8 矩阵乘法
for each block (128x128) in activation_matrix:
scale = max(abs(block)) / 448 # E4M3 最大值为 448
block_fp8 = round(block / scale) # 量化到 FP8
output_block = block_fp8 @ weight_fp8 # FP8 矩阵乘法
output_block = output_block * scale # 反量化

# 反向传播:梯度在 BF16 精度下计算
gradient = backward(output, loss) # BF16 梯度

训练稳定性保障

在 671B 规模上使用 FP8 训练极具挑战。DeepSeek 采用了多项稳定性保障措施:

稳定性措施

混合精度策略

前向传播使用 FP8 计算(GEMM 操作),梯度计算和优化器状态使用 BF16/FP32。关键路径(如 softmax、layernorm)保持高精度。

  • 前向 GEMM: FP8
  • 梯度/优化器: BF16/FP32
  • 关键操作: 高精度
稳定性措施

动态梯度缩放

训练过程中动态调整梯度缩放因子,防止 FP8 下溢(underflow)和上溢(overflow)。

  • 自适应缩放因子
  • 溢出检测与回退
成本收益

557 万美元总成本

FP8 训练将显存需求减半,训练速度提升约 40%。DeepSeek V3 在 2048 块 H800 GPU 上训练约 2 个月,总成本仅 557 万美元。

  • 显存: 减少 50%
  • 训练速度: 提升 40%
  • 总成本: 557 万美元

DeepSeekMoE 架构优化细节

细粒度专家分割、共享专家隔离、动态路由——DeepSeekMoE 的三大核心优化。

细粒度专家分割

传统 MoE 模型通常使用少量大专家(如 8 个专家,每个专家是完整的 FFN)。DeepSeekMoE 将每个大专家进一步分割为多个更小的专家,实现更精细的专业化:

  • 分割策略:将 1 个标准 FFN 专家(如 8x 中间维度)分割为 2 个细粒度专家(每个 4x 中间维度),每个专家专注于更细粒度的知识模式。
  • 路由灵活性:更多专家意味着更灵活的组合。不同 token 可以选择不同的专家子集,实现更精准的知识激活。
  • 负载均衡优势:细粒度分割使专家负载更加均匀,每个专家的参数量减少,降低了单个专家过载的风险。

共享专家隔离

DeepSeekMoE 引入了「共享专家」概念,与路由专家分离:

共享专家

始终激活的通用知识

8 个共享专家对所有 token 始终激活,捕获跨领域的通用知识(如语法、常识、基础推理)。不参与路由竞争,确保基线能力。

  • 8 个共享专家
  • 始终激活,不参与路由
  • 捕获通用知识
路由专家

按需激活的专业知识

256 个路由专家通过 Top-8 门控选择性激活,每个专家专注于特定领域(如数学、编程、医学、法律等)。

  • 256 个路由专家
  • Top-8 选择性激活
  • 领域专业化知识

动态路由与专家负载统计

DeepSeekMoE 的路由系统在训练过程中动态调整,确保专家负载均衡:

# 动态偏置调整
# 每个训练步骤后更新专家偏置
for expert in range(num_experts):
load = expert_token_count[expert] / total_tokens
if load > target_load * 1.2:
expert_bias[expert] -= learning_rate # 降低热门专家偏置
elif load < target_load * 0.8:
expert_bias[expert] += learning_rate # 提高冷门专家偏置

# 路由时加上偏置
gate_logits = Linear(hidden_states) + expert_bias
topk_weights, topk_indices = topk_softmax(gate_logits, k=8)

这种动态偏置机制使专家负载在训练过程中自动趋于均衡,无需额外的辅助损失函数,避免了辅助损失对模型性能的潜在负面影响。

DeepSeek R1 推理架构详解

基于强化学习的推理增强模型。GRPO 算法、思维链涌现、知识蒸馏——R1 的核心技术全景。

RL 训练流水线

DeepSeek R1 的训练分为多个阶段,最终形成强大的推理能力:

阶段 方法 目的
阶段 1:冷启动 SFT 使用少量高质量思维链数据微调 让模型获得基本的推理格式和思维链模式
阶段 2:推理 RL 在推理任务上使用 GRPO 强化学习 提升数学、编程、逻辑推理能力
阶段 3:拒绝采样 从 RL 模型采样,筛选高质量输出 构建高质量 SFT 数据集
阶段 4:全领域 SFT 混合推理数据 + 通用数据微调 恢复通用能力,同时保持推理能力
阶段 5:全领域 RL 在所有任务上使用 RLHF 对齐 提升有用性、安全性、无害性

GRPO(Group Relative Policy Optimization)

GRPO 是 DeepSeek 提出的强化学习算法,是 PPO(Proximal Policy Optimization)的改进版本。核心思想是:

  • 组内相对优势:对每个问题生成多个候选回答(一组),以组内平均奖励为基线计算相对优势,而不是使用绝对奖励值。
  • 无需 Critic 模型:传统 PPO 需要一个与策略模型同规模的 Critic(价值)模型,GRPO 通过组内比较消除了 Critic 模型的需求,节省约 50% 的训练资源。
  • KL 散度约束:直接在损失函数中估计 KL 散度,限制策略更新的幅度,防止模型偏离参考策略过远。
# GRPO 核心逻辑
# 对每个问题,生成 G 个候选回答
group_responses = [model.generate(question) for _ in range(G)]
group_rewards = [reward_model(question, r) for r in group_responses]

# 组内相对优势(减均值除标准差)
mean_reward = mean(group_rewards)
std_reward = std(group_rewards)
advantages = [(r - mean_reward) / std_reward for r in group_rewards]

# 策略梯度更新
loss = -mean(advantages * log_prob_ratio - beta * kl_divergence)
model.update(loss)

奖励建模

R1 的奖励模型包含两个核心维度:

奖励维度

准确性奖励

对数学题检查最终答案是否正确,对编程题检查代码是否通过测试用例,对推理题检查结论是否逻辑一致。

  • 答案正确性验证
  • 代码测试通过率
  • 逻辑一致性检查
奖励维度

格式奖励

鼓励模型将推理过程放在专用的标签中,确保输出格式规范、可读。这有助于模型形成结构化的思维链。

  • 推理过程格式规范
  • 结构化的思维链输出

思维链的涌现

R1 最令人惊叹的特性是「思维链的涌现」。在纯 RL 训练(R1-Zero)中,模型在没有人类标注推理步骤的情况下,自主学会了:

  • 自我验证:在推理过程中检查自己的中间步骤是否正确。
  • 反思与回溯:当发现推理错误时,自动回溯到之前的步骤重新推理。
  • 多路径探索:尝试多种推理路径,选择最合理的结果。
  • 「Aha Moment」:模型在推理中会出现类似于人类「灵光一现」的时刻,重新评估并修正之前的推理路径。

知识蒸馏到小模型

DeepSeek 将 R1 671B 的推理能力蒸馏到小模型(1.5B 到 70B),使用 800k 精心筛选的推理样本:

蒸馏策略

数据筛选

从 R1 671B 的输出中筛选 800k 高质量推理样本,覆盖数学、编程、科学推理等多个领域。

  • 800k 精选样本
  • 多领域覆盖
  • 高质量过滤
蒸馏策略

蒸馏目标模型

基于 Qwen-2.5(1.5B/7B/14B/32B)和 Llama-3.1/3.3(8B/70B)进行蒸馏,使小模型获得强大的推理能力。

  • Qwen-2.5 系列
  • Llama-3.1/3.3 系列
  • 1.5B 到 70B 全覆盖

核心模块代码实现

基于 DeepSeek-V3 开源代码的核心模块实现,使用真实变量名和结构。

MoE 前向传播

# DeepSeekMoE 前向传播(基于 DeepSeek-V3 开源代码) class DeepSeekMoE(nn.Module): def __init__(self): self.num_experts = 256 # 路由专家数量 self.num_shared_experts = 8 # 共享专家数量 self.top_k = 8 # Top-K 路由 self.n_routed_experts = 256 self.routed_scaling_factor = 1.0 # 门控网络 self.gate = nn.Linear(hidden_size, self.n_routed_experts, bias=False) # 路由专家(每个专家是一个 FFN) self.experts = nn.ModuleList([ ExpertFFN() for _ in range(self.num_experts) ]) # 共享专家 self.shared_experts = SharedExpertFFN() def forward(self, hidden_states): identity = hidden_states orig_shape = hidden_states.shape # 1. 门控路由 gate_logits = self.gate(hidden_states) # 选择 Top-K 专家 weights, indices = torch.topk(gate_logits, self.top_k, dim=-1) weights = F.softmax(weights, dim=-1, dtype=torch.float32) # 2. 路由专家计算 routed_output = self.moe_forward(hidden_states, weights, indices) # 3. 共享专家计算(始终激活) shared_output = self.shared_experts(identity) # 4. 合并输出 final_output = routed_output + shared_output return final_output def moe_forward(self, hidden_states, topk_weights, topk_ids): # 将 token 按分配到的专家分组 outputs = torch.zeros_like(hidden_states) for expert_idx in range(self.num_experts): # 找到分配到该专家的 token expert_mask = (topk_ids == expert_idx).any(dim=-1) if not expert_mask.any(): continue expert_input = hidden_states[expert_mask] expert_output = self.experts[expert_idx](expert_input) # 加权累加 weight = topk_weights[expert_mask][topk_ids[expert_mask] == expert_idx] outputs[expert_mask] += expert_output * weight.unsqueeze(-1) return outputs

MLA 注意力实现

# MLA 多头潜在注意力(基于 DeepSeek-V3 开源代码) class MultiHeadLatentAttention(nn.Module): def __init__(self): self.q_lora_rank = 1536 # Query 低秩分解维度 self.kv_lora_rank = 512 # KV 联合压缩维度 self.qk_rope_head_dim = 64 # RoPE 部分维度 self.qk_nope_head_dim = 128 # 非 RoPE 部分维度 self.v_head_dim = 128 self.num_heads = 128 # Query 低秩分解 self.q_a_proj = nn.Linear(hidden_size, self.q_lora_rank, bias=False) self.q_a_layernorm = nn.RMSNorm(self.q_lora_rank) self.q_b_proj = nn.Linear(self.q_lora_rank, self.num_heads * (self.qk_nope_head_dim + self.qk_rope_head_dim)) # KV 联合压缩 self.kv_a_proj_with_mqa = nn.Linear( hidden_size, self.kv_lora_rank + self.qk_rope_head_dim, bias=False) self.kv_a_layernorm = nn.RMSNorm(self.kv_lora_rank) self.kv_b_proj = nn.Linear( self.kv_lora_rank, self.num_heads * (self.qk_nope_head_dim + self.v_head_dim)) def forward(self, hidden_states, freqs_cis, kv_cache=None): # 1. Query 低秩分解 q = self.q_a_proj(hidden_states) q = self.q_a_layernorm(q) q = self.q_b_proj(q) q = q.view(-1, self.num_heads, self.qk_nope_head_dim + self.qk_rope_head_dim) q_nope, q_rope = q.split([self.qk_nope_head_dim, self.qk_rope_head_dim], dim=-1) q_rope = apply_rotary_emb(q_rope, freqs_cis) # RoPE 编码 # 2. KV 联合压缩 kv_a = self.kv_a_proj_with_mqa(hidden_states) c_kv, k_rope = kv_a.split([self.kv_lora_rank, self.qk_rope_head_dim], dim=-1) k_rope = apply_rotary_emb(k_rope.unsqueeze(1), freqs_cis) # RoPE 编码 # 3. 缓存低维潜在向量 c_KV(推理时) if kv_cache is not None: kv_cache.append(c_kv) # 4. 上投影还原 Key 和 Value c_kv = self.kv_a_layernorm(c_kv) kv = self.kv_b_proj(c_kv) kv = kv.view(-1, self.num_heads, self.qk_nope_head_dim + self.v_head_dim) k_nope, v = kv.split([self.qk_nope_head_dim, self.v_head_dim], dim=-1) # 5. 拼接 Query 和 Key 的两部分 q = torch.cat([q_nope, q_rope], dim=-1) k = torch.cat([k_nope, k_rope.expand(-1, self.num_heads, -1)], dim=-1) # 6. 标准注意力计算 attn_weights = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt( self.qk_nope_head_dim + self.qk_rope_head_dim) attn_weights = F.softmax(attn_weights, dim=-1) output = torch.matmul(attn_weights, v) return output

MTP 模块实现

# MTP 多 Token 预测模块(基于 DeepSeek-V3 开源代码) class MultiTokenPredictionModule(nn.Module): def __init__(self): self.hidden_size = 7168 # 输入融合层 self.embedding_norm = nn.RMSNorm(hidden_size) self.hidden_norm = nn.RMSNorm(hidden_size) self.input_proj = nn.Linear(hidden_size * 2, hidden_size, bias=False) # MTP Transformer 块 self.mtp_block = TransformerBlock() # 输出投影(共享 LM Head) self.output_norm = nn.RMSNorm(hidden_size) self.shared_head = nn.Linear(hidden_size, vocab_size, bias=False) def forward(self, hidden_states, input_ids): # 1. 获取当前 token 的 embedding token_emb = self.embedding_norm(embedding(input_ids)) # 2. 融合主模型隐藏状态和 token embedding hidden_norm = self.hidden_norm(hidden_states) combined = torch.cat([hidden_norm, token_emb], dim=-1) combined = self.input_proj(combined) # 3. 通过 MTP Transformer 块 mtp_output = self.mtp_block(combined) # 4. 输出预测 mtp_output = self.output_norm(mtp_output) logits = self.shared_head(mtp_output) return logits # 训练时使用 hidden = transformer(input_ids) # 主模型前向 logits_main = lm_head(hidden) # 标准 next-token 预测 logits_mtp = mtp_module(hidden, input_ids) # MTP 额外预测 loss_main = cross_entropy(logits_main[:, :-1], targets[:, 1:]) loss_mtp = cross_entropy(logits_mtp[:, :-2], targets[:, 2:]) total_loss = loss_main + 0.3 * loss_mtp # 加权组合

DeepSeek 模型性能分析

FLOPs 利用率、显存带宽、通信开销、扩展效率——DeepSeek 的性能全貌。

FLOPs 利用率

指标 DeepSeek V3 说明
理论峰值 FLOPs ~990 TFLOPS(H800 FP8) 单卡 H800 的 FP8 理论峰值
实际达到 FLOPs ~580 TFLOPS 训练时的实际计算吞吐
FLOPs 利用率 ~58.6% 远超行业平均水平(通常 30-45%)

DeepSeek 通过精心设计的计算 kernel 和通信重叠策略,实现了极高的 FLOPs 利用率。58.6% 的利用率在 MoE 模型中属于顶尖水平(MoE 模型由于稀疏激活和 all-to-all 通信,利用率通常低于密集模型)。

显存带宽分析

显存分析

模型权重

671B 参数,FP8 格式存储。总权重显存约 671 GB(FP8),BF16 格式约 1342 GB。

  • FP8: ~671 GB
  • BF16: ~1342 GB
  • 使用 FP8 节省 50%
显存分析

KV Cache(MLA)

MLA 将 KV Cache 压缩至传统方法的 1/32。128K 上下文下的 KV Cache 约 40 GB。

  • 传统 MHA: ~973 GB
  • MLA: ~40 GB
  • 节省: ~96%
显存分析

优化器状态

AdamW 优化器需要存储动量和方差(FP32),每个参数约 8 bytes。优化器状态约 5.4 TB(FP32)。

  • 动量: 671B * 4 bytes
  • 方差: 671B * 4 bytes
  • 总计: ~5.4 TB

通信开销

MoE 模型的分布式训练涉及两种通信模式:

  • All-Reduce(数据并行):在所有 GPU 之间同步梯度,通信量与 GPU 数量成正比。DeepSeek 使用 2048 块 H800 GPU,采用了高效的 Ring All-Reduce 算法。
  • All-to-All(专家并行):将 token 从当前 GPU 发送到对应专家所在的 GPU。这是 MoE 模型特有的通信开销,DeepSeek 通过专家均匀分布和通信重叠策略最小化开销。
通信优化策略:DeepSeek 采用「计算-通信重叠」技术,在 GPU 计算的同时进行通信,将通信开销隐藏在计算中。通过精细的流水线设计,通信开销占总训练时间的比例控制在 15% 以内。

扩展效率

GPU 数量 每步耗时 扩展效率 说明
256 H800 ~8.0 秒 100%(基线) 强扩展基线
512 H800 ~4.5 秒 ~89% 通信开销增加
1024 H800 ~2.6 秒 ~77% All-to-All 通信开销显著
2048 H800 ~1.5 秒 ~67% 训练配置,扩展效率仍可接受

DeepSeek V3 在 2048 块 H800 GPU 上实现了约 67% 的扩展效率。对于 671B 参数的 MoE 模型,这是一个相当优秀的成绩。相比密集模型,MoE 的 All-to-All 通信是扩展效率的主要瓶颈,DeepSeek 通过通信重叠和专家分布优化将这一影响降至最低。

DeepSeek 相关资源

深入了解 DeepSeek 模型的更多内容,从使用到部署到开发者生态。

DeepSeek 模型架构常见问题

DeepSeek V3 的 671B 参数和 37B 激活参数是什么意思? +
671B 是模型的总参数量(所有专家参数的总和),37B 是每个 token 推理时实际激活的参数数量。MoE 架构通过稀疏激活机制,每个 token 仅路由到 8 个路由专家和 1 个共享专家(共 9 个专家),因此实际参与计算的参数仅约 37B(占总参数的 5.5%)。这大幅降低了推理成本,同时保持了 671B 参数的知识容量。
MLA 多头潜在注意力比传统注意力好在哪里? +
MLA 的核心优势在于 KV Cache 压缩。传统 MHA 需要缓存完整的 Key 和 Value 矩阵,对于 128K 上下文可能占用近 1TB 显存。MLA 通过低秩 KV 联合压缩,将 Key 和 Value 投影到低维潜在空间(如 512 维),缓存量降至传统方法的 1/32 左右。同时通过 RoPE 解耦设计,保留了旋转位置编码的优势。这使得长上下文推理在单卡上成为可能,推理吞吐量提升 3-5 倍。
MTP 多 Token 预测会影响推理速度吗? +
不会。MTP 模块在设计上可在推理时完全丢弃,推理时仅使用标准的主模型 next-token prediction。MTP 仅在训练阶段发挥作用,提供更强的学习信号,帮助模型学习更好的表示和长程依赖。此外,MTP 模块可作为投机解码的草稿模型,同时生成多个候选 token,由主模型验证,这种模式下推理速度可提升 1.5-2 倍。
DeepSeek 如何解决 MoE 模型的专家负载不均衡问题? +
DeepSeek 提出了创新的 auxiliary-loss-free 负载均衡策略。传统 MoE 使用辅助损失函数强制专家负载均衡,但可能影响模型性能。DeepSeek 的方案是:为每个专家维护一个动态偏置项,训练过程中根据专家负载自动调整——负载过高则降低偏置,负载过低则提高偏置。同时结合细粒度专家分割(256 个路由专家)和共享专家分离(8 个共享专家始终激活),在序列级别施加轻微平衡约束,实现无需辅助损失的负载均衡。
DeepSeek R1 的强化学习训练和传统 RLHF 有什么不同? +
DeepSeek R1 采用 GRPO(Group Relative Policy Optimization)算法,是 PPO 的改进版本。核心区别在于:1)GRPO 不需要 Critic 模型(价值网络),通过组内相对比较(对同一问题生成多个回答,以组内平均奖励为基线)来估计优势,节省约 50% 训练资源;2)R1 的 RL 训练专注于推理能力,使用准确性奖励(答案正确性)和格式奖励,而非传统 RLHF 的人类偏好奖励;3)R1 的训练流程包含冷启动 SFT、推理 RL、拒绝采样、全领域 SFT 和全领域 RL 五个阶段,是系统性的推理能力增强方案。
FP8 训练如何在 671B 规模上保持稳定? +
DeepSeek 在 671B 规模上验证 FP8 训练的可行性,依赖多项关键技术:1)分块量化(Block-wise Quantization),将激活值和权重按 128x128 块分组,每块独立计算缩放因子,确保量化精度;2)混合精度策略,前向 GEMM 使用 FP8,梯度和优化器状态使用 BF16/FP32,关键操作(softmax、layernorm)保持高精度;3)动态梯度缩放,训练过程中自适应调整缩放因子,防止 FP8 下溢和上溢。这些措施使 FP8 训练在超大规模上稳定收敛,显存占用减半,训练速度提升约 40%,总成本降至 557 万美元。

参考来源与延伸阅读

本页技术内容基于 DeepSeek 官方论文和技术报告,可自行查阅验证。

每日精选 Skill 推荐,免费送到你邮箱

输入邮箱,每天接收一个精选 AI Agent 技能推荐。完全免费,持续更新。

完全免费,取消任意时间。我们不会发送垃圾邮件。