927 字
3 分钟
DeepSeek R1 与推理架构创新：MoE、RL 与开源力量
2025 年 1 月，DeepSeek 发布了 R1 模型。
这不是又一个「跟随者」。R1 在多个基准测试上对标 OpenAI o1，却以开源的形式发布，参数、权重、训练细节全部公开。
更令人惊讶的是，DeepSeek 还发布了 R1-Zero——一个完全通过强化学习训练、没有任何监督微调的推理模型。
这改变了推理模型的竞争格局。
本文要点
- DeepSeek R1 架构概览
- MoE（混合专家）架构深度解析
- GRPO：高效强化学习训练方法
- R1-Zero：纯 RL 训练的突破
- 蒸馏模型：小模型也有大能力
- 开源推理模型的行业意义
一、DeepSeek R1 概览
1.1 核心数据
┌─────────────────────────────────────────────────────────────┐│ DeepSeek R1 规格参数 │├─────────────────────────────────────────────────────────────┤│ ││ 总参数量：671B（6710 亿） ││ 激活参数：37B（每 token 实际参与计算） ││ 层数：61 层 ││ 隐藏维度：7168 ││ 专家数量：256 个 ││ 每层激活专家：8 个 ││ 上下文长度：128K tokens ││ ││ 训练数据： ││ • 预训练：14.8T tokens ││ • SFT：150 万条 ││ • RL：大规模强化学习 ││ ││ 开源许可：MIT License ││ │└─────────────────────────────────────────────────────────────┘1.2 性能对比
xychart-beta
title "推理模型性能对比（AIME 数学竞赛）"
x-axis ["GPT-4o", "Claude 3.5", "o1-preview", "DeepSeek R1", "o1"]
y-axis "准确率 %" 0 --> 100
bar [13, 20, 56, 79, 83]
xychart-beta
title "代码能力对比（Codeforces 评分）"
x-axis ["GPT-4o", "Claude 3.5", "DeepSeek R1", "o1"]
y-axis "评分" 0 --> 2000
bar [1280, 1450, 1800, 1890]
1.3 开源意义
┌─────────────────────────────────────────────────────────────┐│ DeepSeek R1 开源价值 │├─────────────────────────────────────────────────────────────┤│ ││ 对研究者： ││ 可以研究完整的模型架构 ││ 可以分析训练方法和数据 ││ 可以进行改进和创新 ││ 可以复现实验结果 ││ ││ 对开发者： ││ 可以本地部署和微调 ││ 可以保护数据隐私 ││ 可以定制化应用 ││ 无 API 成本限制 ││ ││ 对行业： ││ 打破闭源模型垄断 ││ 推动技术民主化 ││ 促进生态繁荣 ││ 加速应用落地 ││ │└─────────────────────────────────────────────────────────────┘二、MoE 架构深度解析
2.1 什么是 MoE？
MoE（Mixture of Experts，混合专家）是一种模型架构，通过「条件计算」实现更大的模型容量，同时保持较低的计算成本。
flowchart TB
A[输入 Token] --> B[Router 路由器]
B --> C{选择专家}
C --> D[专家 1]
C --> E[专家 2]
C --> F[专家 3]
C --> G[专家 4]
C --> H[...]
D --> I[加权组合]
E --> I
F --> I
G --> I
H --> I
I --> J[输出]
style B fill:#2196f3,color:#fff
style D fill:#4caf50,color:#fff
style E fill:#4caf50,color:#fff
style F fill:#ff9800,color:#fff
style G fill:#ff9800,color:#fff
2.2 DeepSeek MoE 架构特点
┌─────────────────────────────────────────────────────────────┐│ DeepSeek MoE 特点 │├─────────────────────────────────────────────────────────────┤│ ││ 1. 大规模稀疏激活 ││ • 256 个专家，每层只激活 8 个 ││ • 激活率：8/256 = 3.1% ││ • 大幅降低计算成本 ││ ││ 2. 共享专家设计 ││ • 部分专家被所有 token 共享 ││ • 用于捕获通用知识 ││ • 提高参数利用效率 ││ ││ 3. 专家负载均衡 ││ • 动态调整专家选择 ││ • 防止某些专家过载 ││ • 提高整体效率 ││ ││ 4. 通信优化 ││ • 跨节点专家并行 ││ • 高效的通信策略 ││ • 支持大规模训练 ││ │└─────────────────────────────────────────────────────────────┘2.3 MoE vs Dense 架构
# Dense 架构：所有参数都参与计算def dense_forward(x, weight): # 每次前向传播使用全部参数 return x @ weight # 计算量 O(d²)
# MoE 架构：只有部分参数参与计算def moe_forward(x, experts, router, top_k=8): # 1. 路由决策：选择 top-k 专家 router_probs = router(x) # [batch, num_experts] top_k_indices = torch.topk(router_probs, top_k).indices
# 2. 只计算选中的专家 output = 0 for idx in top_k_indices: expert = experts[idx] weight = router_probs[idx] output += weight * expert(x)
return output # 计算量 O(d² * top_k / num_experts)对比示例（671B 参数）：
Dense 架构：• 每次前向：671B 参数全部参与• 计算量：巨大• 内存：巨大
MoE 架构（DeepSeek R1）：• 每次前向：37B 参数参与（激活率 5.5%）• 计算量：相当于 37B Dense 模型• 内存：需要存储 671B，但计算效率高 18 倍三、GRPO：高效强化学习训练
3.1 什么是 GRPO？
GRPO（Group Relative Policy Optimization）是 DeepSeek 提出的强化学习训练方法，专门针对推理模型优化。
flowchart TB
subgraph GRPO 训练流程
A[采样多条推理链] --> B[执行并验证]
B --> C[计算相对奖励]
C --> D[更新策略]
D --> A
end
subgraph 传统 PPO
E[采样] --> F[计算优势]
F --> G[需要价值网络]
G --> H[更新]
end
3.2 GRPO vs 传统 RL 方法
┌─────────────────────────────────────────────────────────────┐│ GRPO vs PPO 对比 │├───────────────┬─────────────────┬───────────────────────────┤│ 维度 │ PPO │ GRPO │├───────────────┼─────────────────┼───────────────────────────┤│ 价值网络 │ 需要 │ 不需要 ││ 样本效率 │ 较低 │ 较高 ││ 计算成本 │ 高 │ 较低 ││ 奖励计算 │ 绝对奖励 │ 相对奖励 ││ 方差控制 │ 需要 GAE │ 组内对比自然降低 ││ 适用场景 │ 通用 RL │ 推理任务 │└───────────────┴─────────────────┴───────────────────────────┘3.3 GRPO 核心算法
class GRPOTrainer: """GRPO 训练器"""
def __init__(self, model, verifier, group_size=4): self.model = model self.verifier = verifier self.group_size = group_size # 每组采样数
def train_step(self, problem): """单步训练"""
# 1. 为同一问题采样多条推理链 reasoning_chains = [] for _ in range(self.group_size): chain = self.model.generate_reasoning(problem) reasoning_chains.append(chain)
# 2. 执行并验证每条推理链 rewards = [] for chain in reasoning_chains: result = self.execute_chain(chain) is_correct = self.verifier.verify(problem, result) rewards.append(1.0 if is_correct else 0.0)
# 3. 计算相对奖励（组内对比） mean_reward = np.mean(rewards) std_reward = np.std(rewards) + 1e-8
advantages = [] for reward in rewards: # 相对奖励 = (奖励 - 组均值) / 组标准差 advantage = (reward - mean_reward) / std_reward advantages.append(advantage)
# 4. 更新策略：奖励高于平均的增强，低于平均的抑制 for chain, advantage in zip(reasoning_chains, advantages): self.model.update_policy(chain, advantage)
return { "mean_reward": mean_reward, "best_chain": reasoning_chains[np.argmax(rewards)] }
def execute_chain(self, chain): """执行推理链""" result = None for step in chain: result = self.execute_step(step, result) return result3.4 GRPO 的优势
为什么 GRPO 更适合推理模型训练？
1. 无需价值网络 • 传统 PPO 需要训练一个价值网络估计状态价值 • GRPO 通过组内对比直接计算优势 • 减少了一半的模型参数
2. 更低的方差 • 同一问题的多条推理链具有可比性 • 组内对比自然消除了任务难度差异 • 训练更稳定
3. 更高的样本效率 • 每组样本都有贡献 • 失败的推理链也提供学习信号 • 减少无效探索
4. 天然适合推理任务 • 推理任务有明确的正确/错误标准 • 容易设计验证器 • 奖励信号清晰四、R1-Zero：纯 RL 训练的突破
4.1 什么是 R1-Zero？
R1-Zero 是 DeepSeek 的一个实验性模型，完全通过强化学习训练，没有任何监督微调（SFT）阶段。
flowchart LR
subgraph 传统训练流程
A1[预训练] --> B1[SFT]
B1 --> C1[RLHF]
end
subgraph R1-Zero 训练流程
A2[预训练] --> B2[纯 RL 训练]
end
style B2 fill:#f44336,color:#fff
4.2 R1-Zero 的惊人发现
┌─────────────────────────────────────────────────────────────┐│ R1-Zero 关键发现 │├─────────────────────────────────────────────────────────────┤│ ││ 1. 推理能力自发涌现 ││ • 没有任何推理示例训练 ││ • 模型自己学会了「一步步思考」 ││ • 自然发展出验证、回溯等策略 ││ ││ 2. 自发行为模式 ││ • 反思：检查自己的推理 ││ • 验证：确认中间结果 ││ • 回溯：发现错误后重新开始 ││ • 规划：分解复杂问题 ││ ││ 3. 性能表现 ││ • AIME：约 70% 准确率 ││ • 接近经过 SFT 训练的模型 ││ • 证明 RL 的巨大潜力 ││ ││ 4. 技术意义 ││ • 挑战了「SFT 必需」的传统认知 ││ • 展示了纯 RL 训练推理模型的可能性 ││ • 为未来研究开辟新方向 ││ │└─────────────────────────────────────────────────────────────┘4.3 R1-Zero 训练过程
class R1ZeroTrainer: """R1-Zero 纯 RL 训练"""
def __init__(self, base_model, verifier): self.model = base_model self.verifier = verifier
def train(self, problems, num_epochs=1000): """纯 RL 训练"""
for epoch in range(num_epochs): for problem in problems: # 直接从预训练模型开始 RL # 没有 SFT 阶段！
# 生成推理链 chain = self.model.generate( problem, temperature=1.0, # 较高温度鼓励探索 max_tokens=4096 )
# 验证结果 is_correct, feedback = self.verifier.verify( problem, chain )
# 直接用验证结果作为奖励 reward = 1.0 if is_correct else 0.0
# 更新模型 self.model.update(chain, reward)
# 记录涌现行为 if self.detect_emergent_behavior(chain): self.log_emergent_behavior(chain)
def detect_emergent_behavior(self, chain): """检测涌现行为""" patterns = [ "让我验证一下", "等等，这里可能有问题", "让我重新思考", "分步解决" ]
for pattern in patterns: if pattern in chain: return True return False4.4 R1-Zero vs R1
┌─────────────────────────────────────────────────────────────┐│ R1-Zero vs R1 对比 │├───────────────┬─────────────────┬───────────────────────────┤│ 维度 │ R1-Zero │ R1 │├───────────────┼─────────────────┼───────────────────────────┤│ SFT 阶段 │ 无 │ 有（150 万条） ││ 训练数据 │ 仅 RL │ 预训练 + SFT + RL ││ 推理能力 │ 自发涌现 │ 引导学习 ││ AIME 分数 │ ~70% │ ~79% ││ 可读性 │ 较差 │ 较好 ││ 研究价值 │ 极高 │ 实用价值高 │└───────────────┴─────────────────┴───────────────────────────┘
结论：• R1-Zero 证明了纯 RL 的可行性• SFT 仍是提升性能和可读性的有效手段• 两种方法的结合（R1）效果最佳五、蒸馏模型：小模型也有大能力
5.1 什么是模型蒸馏？
模型蒸馏是将大模型的知识迁移到小模型的技术，让小模型获得接近大模型的能力。
flowchart LR
A[DeepSeek R1<br/>671B] --> B[蒸馏训练]
B --> C[DeepSeek R1-Distill<br/>1.5B/7B/14B/32B]
style A fill:#4caf50,color:#fff
style C fill:#2196f3,color:#fff
5.2 蒸馏模型规格
┌─────────────────────────────────────────────────────────────┐│ DeepSeek 蒸馏模型规格 │├───────────────┬───────────────┬───────────────┬─────────────┤│ 模型 │ 参数量 │ 基座 │ AIME 分数 │├───────────────┼───────────────┼───────────────┼─────────────┤│ R1-Distill-Qwen-1.5B │ 1.5B │ Qwen-2.5 │ 28% ││ R1-Distill-Qwen-7B │ 7B │ Qwen-2.5 │ 56% ││ R1-Distill-Qwen-14B │ 14B │ Qwen-2.5 │ 66% ││ R1-Distill-Qwen-32B │ 32B │ Qwen-2.5 │ 72% ││ R1-Distill-Llama-70B │ 70B │ Llama-3 │ 78% │└───────────────┴───────────────┴───────────────┴─────────────┘5.3 蒸馏过程
class DistillationTrainer: """模型蒸馏训练器"""
def __init__(self, teacher_model, student_model): self.teacher = teacher_model self.student = student_model
def distill(self, problems, epochs=3): """执行蒸馏"""
for epoch in range(epochs): for problem in problems: # 1. 教师模型生成推理链 teacher_chain = self.teacher.generate_reasoning( problem, temperature=0.7 )
# 2. 学生模型学习 student_output = self.student.generate( problem, teacher_chain # 提供教师的推理链作为参考 )
# 3. 计算蒸馏损失 loss = self.compute_distillation_loss( teacher_chain, student_output )
# 4. 更新学生模型 self.student.update(loss)
def compute_distillation_loss(self, teacher_output, student_output): """计算蒸馏损失""" # KL 散度：让学生输出分布接近教师 kl_loss = kl_divergence( student_output.logits, teacher_output.logits )
# 交叉熵：保持正确的预测能力 ce_loss = cross_entropy( student_output.logits, teacher_output.answer )
return kl_loss + 0.5 * ce_loss5.4 蒸馏模型的价值
┌─────────────────────────────────────────────────────────────┐│ 蒸馏模型的价值 │├─────────────────────────────────────────────────────────────┤│ ││ 1. 降低部署成本 ││ • 小模型可以在消费级 GPU 运行 ││ • 7B 模型单卡即可推理 ││ • 降低硬件门槛 ││ ││ 2. 提高推理速度 ││ • 小模型延迟更低 ││ • 支持更多并发 ││ • 改善用户体验 ││ ││ 3. 保护隐私 ││ • 本地部署 ││ • 数据不出本地 ││ • 满足合规要求 ││ ││ 4. 定制化微调 ││ • 小模型更容易微调 ││ • 针对特定领域优化 ││ • 快速迭代 ││ ││ 5. 推理能力继承 ││ • 继承大模型的推理能力 ││ • 保持较高的准确率 ││ • 性价比极高 ││ │└─────────────────────────────────────────────────────────────┘六、开源推理模型的行业意义
6.1 打破垄断
闭源推理模型的问题：
• OpenAI o1：闭源，API 定价高昂• Claude：部分推理能力，但非专门推理模型• Google Gemini：推理能力有限
DeepSeek R1 改变了什么：
• 完整开源，MIT 协议• 可商用、可修改、可分发• 打破「推理模型 = 昂贵服务」的认知• 让中小企业也能使用推理模型6.2 推动生态发展
┌─────────────────────────────────────────────────────────────┐│ 开源带来的生态变化 │├─────────────────────────────────────────────────────────────┤│ ││ 研究层面 ││ ├── 可以研究模型架构细节 ││ ├── 可以分析训练方法 ││ ├── 可以改进和创新 ││ └── 论文数量快速增加 ││ ││ 应用层面 ││ ├── 本地部署方案涌现 ││ ├── 微调工具链成熟 ││ ├── 行业应用落地加速 ││ └── Agent 应用爆发 ││ ││ 商业层面 ││ ├── 云服务商提供 R1 托管 ││ ├── 企业私有化部署 ││ ├── 行业定制化服务 ││ └── 成本大幅降低 ││ │└─────────────────────────────────────────────────────────────┘6.3 对中国 AI 产业的影响
技术层面：• 证明了中国团队有能力做出世界领先的推理模型• MoE + RL 的技术路线得到验证• 为后续研究奠定基础
产业层面：• 降低了中国企业使用推理模型的门槛• 减少了对国外闭源模型的依赖• 推动了本土 AI 应用发展
人才层面：• 吸引更多人才进入推理模型领域• 开源模型成为学习教材• 加速人才培养七、实践指南
7.1 本地部署
# 使用 vLLM 部署 DeepSeek R1from vllm import LLM, SamplingParams
# 加载模型llm = LLM( model="deepseek-ai/DeepSeek-R1", tensor_parallel_size=8, # 8 卡并行 max_model_len=32768, trust_remote_code=True)
# 推理sampling_params = SamplingParams( temperature=0.7, max_tokens=8192, # 推理模型特有参数 stop=["<|end_of_reasoning|>"])
outputs = llm.generate( ["请证明根号 2 是无理数。"], sampling_params)
for output in outputs: print(output.outputs[0].text)7.2 使用蒸馏模型
# 使用 7B 蒸馏模型（单卡可运行）from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained( "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", torch_dtype=torch.bfloat16, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained( "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B")
# 推理prompt = "解释量子纠缠现象"inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate( **inputs, max_new_tokens=2048, temperature=0.7)
print(tokenizer.decode(outputs[0]))常见问题 FAQ
Q1：DeepSeek R1 和 OpenAI o1 哪个更好？
A：各有优势。o1 在某些基准上略高，但 R1 完全开源，可本地部署、可微调，性价比更高。实际选择取决于需求。
Q2：普通显卡能运行 DeepSeek R1 吗？
A：完整 671B 模型需要多卡集群。但蒸馏模型（7B/14B/32B）可以在消费级显卡上运行，推荐使用蒸馏版本。
Q3：R1-Zero 的发现有什么实际意义？
A：证明了纯 RL 可以训练推理能力，未来可能大幅降低训练成本，减少对标注数据的依赖。
Q4：MoE 架构有什么缺点？
A：主要缺点是：1）需要更大显存存储所有参数；2）训练更复杂，需要负载均衡；3）推理时专家选择可能不均衡。
Q5：蒸馏模型和原模型差距有多大？
A：7B 蒸馏模型约为原模型性能的 70%，32B 蒸馏模型约为 90%。蒸馏模型在小参数量下已经非常实用。
小结
DeepSeek R1 不仅是技术突破，更是开源力量的胜利。
核心要点回顾：
┌─────────────────────────────────────────────────────────────┐│ DeepSeek R1 核心总结 │├─────────────────────────────────────────────────────────────┤│ ││ 架构创新：671B MoE，37B 激活参数 ││ ││ 训练方法：GRPO 高效强化学习 ││ ││ R1-Zero：纯 RL 训练，推理能力自发涌现 ││ ││ 蒸馏模型：1.5B-70B，降低部署门槛 ││ ││ 开源意义：打破垄断，推动生态，降低成本 ││ │└─────────────────────────────────────────────────────────────┘开源让 AI 更平等。
参考资料
支持与分享
如果这篇文章对你有帮助，欢迎支持作者或分享给更多人
DeepSeek R1 与推理架构创新：MoE、RL 与开源力量
https://blog.souloss.com/posts/machine-learning/agent-guide/deepseek-r1-and-reasoning-architecture/ 部分信息可能已经过时
相关文章 智能推荐
1
注意力残差与 Kimi 架构创新：重新定义深度学习残差连接
AI 深度解读 Kimi Attention Residuals 论文——动态注意力替代固定残差连接，在 48B 参数模型上验证效果，获得马斯克点赞的架构创新。
2
推理模型与 OpenAI o 系列：从 o1 到 o4 的演进之路
AI 全面解析 OpenAI o 系列推理模型——从 o1 到 o4 的技术演进、Chain of Thought 机制、RLVR 训练方法，以及在 ARC-AGI 基准上的突破性表现。
3
Agent 架构模式：Handoffs、Fan-out 与 Supervisor
AI 深度解读 Agent 架构模式——Handoffs 交接模式、Fan-out/Fan-in 并行模式、Supervisor 监督模式
4
从Chatbot到Agent：打造能自主干活的AI
AI 从Chatbot到Agent——打造能自主干活的AI
5
Agent 规划架构：ReAct、Plan-and-Execute 与 Reflexion
AI 深入解析 Agent 三大规划架构——ReAct（推理+行动协同）、Plan-and-Execute（计划与执行分离）、Reflexion（自我反思），附代码实现与对比分析。