> For the complete documentation index, see [llms.txt](https://yeasy.gitbook.io/ai_beginner_guide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://yeasy.gitbook.io/ai_beginner_guide/di-er-bu-fen-he-xin-ji-shu-jie-xi/08_new_architectures/8.6_mla_moe_innovation.md).

# 8.6 DeepSeek 的技术创新：MLA 和 MoE

> 用更聪明的方式而不是更大的规模来实现更好的性能

## 8.6.1 传统注意力的浪费

为了理解 DeepSeek 为什么需要 MLA，先看看传统 Transformer 注意力机制的问题：

```mermaid
graph TD
    A["标准Transformer的多头注意力<br/>32个注意力头，每个处理一个方面"]

    B["头1: 专注于语法"]
    C["头2: 专注于语义"]
    D["头3: 专注于实体关系"]
    E["..."]
    F["头32: 可能也在做语法 重复!"]

    A --> B & C & D & E & F

    G["问题:<br/>1. 有很多重复和冗余<br/>2. 每个头都需维护完整注意力矩阵<br/>3. 内存和计算都被浪费<br/>4. 实际可能只需10个视角, 不需32个"]

    B & C & D & E & F --> G

    style G fill:#FFB6C6
```

## 8.6.2 MLA：多头潜在注意力

DeepSeek 引入的 MLA（Multi-head Latent Attention）解决了这个问题。

### 核心思想

```mermaid
graph LR
    A["维护32个独立的<br/>完整注意力矩阵<br/>← 传统方式"]

    B["用一个低维的<br/>潜在表示<br/>编码所有头的信息<br/>← MLA方式"]

    C["在推理时<br/>从潜在表示<br/>解码需要的信息"]

    A -->|vs| B --> C

    D["简单类比<br/>传统: 32张完整照片<br/>MLA: 1张压缩照片"]

    E["更形象的比喻<br/>传统: 32份完整公司百科<br/>MLA: 1份精简版摘要<br/>节省空间同时保留关键信息"]

    style A fill:#FFB6C6
    style B fill:#90EE90
    style C fill:#FFD700
```

### 如何工作？

```
MLA的工作流程：

输入：序列 [token1, token2, ..., tokenN]
   ↓
投影到潜在空间：
├─ 将高维的Q,K,V投影到低维潜在空间
├─ 假设原始维度是4096（embed_dim）
├─ 投影到256维的潜在空间
├─ 这一步压缩比 = 4096/256 = 16倍
└─ 节省93%+的KV缓存！（关键：只存储256维的缓存）
   ↓
注意力计算：
├─ 缓存的是压缩后的低秩隐向量；真正算注意力时，低秩投影会被“吸收”进权重、恢复到各头维度
├─ 复杂度仍是O(N²)（N 为序列长度，不因 MLA 变小），注意力算力与标准多头注意力大致相当
├─ 变小的是**每个 token 需要缓存的向量维度**：4096 → 256
├─ KV 缓存占用从 16MB → 1MB（减少约93%，对应 16 倍压缩）
└─ 长序列推理的显存与带宽瓶颈大幅缓解
   ↓
解压层（投影回原始维度）：
├─ 使用学习的映射矩阵将结果恢复
├─ 从256维映射回4096维
├─ 这个映射是在训练中优化的，丢失的信息很少
├─ 关键：解压层很轻量（只是矩阵乘法）
└─ 恢复的质量接近原始注意力
   ↓
输出：与传统注意力相同的质量

推理优化的关键（KV缓存）：
传统Transformer：
├─ 处理1000个token，需要存储1000×4096维的K和V
├─ 总占用内存 = 1000 × 4096 × 4bytes = 16MB（仅KV）
└─ 序列越长，内存爆炸

MLA方式：
├─ 处理1000个token，只需存储1000×256维的压缩K和V
├─ 总占用内存 = 1000 × 256 × 4bytes = 1MB（仅压缩KV）
└─ 节省93%的KV缓存！这正是长序列推理的瓶颈
```

### 数学直觉（简化版）

```
传统注意力：
Attention(Q,K,V) = softmax(QK^T/√d_k)V

其中：
Q, K, V 都是大矩阵（d_model × sequence_length）
- d_model通常是4096（对于大模型）
- 计算QK^T需要4096×4096的矩阵乘法
- 存储完整的KV缓存很昂贵

MLA的方式（三个关键步骤）：

第1步：投影到潜在空间
Q_low = Q @ W_q_down   # 维度：d_model → d_latent
K_low = K @ W_k_down   # (4096维 → 256维)
V_low = V @ W_v_down

第2步：在潜在空间进行注意力计算
Attention_low(Q_low, K_low, V_low) = softmax(Q_low·K_low^T/√d_latent)V_low

这里的直观感受：
- Q_low·K_low^T 是 256×256 的矩阵乘法（而不是 4096×4096），中间矩阵明显更小
- 但 MLA 真正省下的不是注意力算力，而是需要缓存的 K/V：压缩后 KV 缓存大幅减小，这才是它的核心收益（见下方"效果总结"）

第3步：投影回原始维度
Output = Attention_low @ W_output  # 256维 → 4096维

效果总结：
- KV缓存大小：从16MB → 1MB（减少约93%，对应约16倍压缩）—— 这是 MLA 最主要的收益
- 推理速度：长序列推理的瓶颈通常在显存带宽（反复读取巨大的 KV 缓存），缓存变小后访问更快，推理吞吐随之提升
- 注意力计算量：与标准多头注意力大致相当（实现中会把低秩投影"吸收"进权重、恢复到各头维度），所以 MLA 省的是显存而非算力
- 质量：通过训练优化投影矩阵，质量接近原始注意力

为什么这样做有效？
- 32个注意力头中有大量冗余（很多头学到类似的模式）
- 潜在空间能够有效编码这些冗余
- 类比：就像JPEG压缩图像，去掉看不见的细节，保留重要信息
```

### KV 缓存压缩的实际影响

```
对长序列推理的革命性改进：

场景：处理128K token的长文本

传统Transformer：
├─ 每层的KV缓存占用：128K × 4096 × 2 × 2bytes = 2GB
├─ 假设96层：96 × 2GB = 192GB（仅KV缓存！）
└─ 需要H100级别的GPU才能运行

MLA方式：
├─ 每层的KV缓存占用：128K × 256 × 2 × 2bytes = 128MB
├─ 假设96层：96 × 128MB = 12.3GB（仅KV缓存）
└─ 可以在A100 40GB上轻松运行

成本对比：
- H100 GPU：$40,000/个
- A100 GPU：$10,000/个
- MLA节省的硬件成本：4倍

这就是DeepSeek能用更便宜GPU的原因之一！
```

## 8.6.3 MoE：混合专家

### 第二个创新：不是所有 token 都需要所有参数

```mermaid
graph TD
    A["传统神经网络<br/>每个token通过所有参数<br/>许多参数被浪费<br/>效率低下"]

    B["MoE的想法<br/>有多个专家网络"]

    B1["专家1: 数学和逻辑"]
    B2["专家2: 语言和语法"]
    B3["专家3: 代码和技术"]
    B4["专家4: 常识性推理"]

    C["路由器 Gating Network<br/>根据token内容决定<br/>使用哪些专家"]

    D["每个token只激活Top-K个专家<br/>比如激活2-4个<br/>只使用必要的参数<br/>不用全部参数"]

    E["结果<br/>总参数16倍增加<br/>但实际激活参数不变!"]

    A --> B
    B --> B1 & B2 & B3 & B4
    B1 & B2 & B3 & B4 --> C
    C --> D --> E

    style A fill:#FFB6C6
    style E fill:#90EE90
```

### 具体工作方式：路由器如何工作

公司部门分工的比喻：

```mermaid
graph TD
    A["传统方式<br/>所有人处理所有任务<br/>客户请求: 修复电脑<br/>财务、HR、技术、市场部都参与<br/>浪费资源 效率低"]

    B["MoE方式<br/>由路由器分配任务"]

    B1["路由器 总经理<br/>接收请求: 修复电脑<br/><br/>评分:<br/>技术部 0.9<br/>销售部 0.05<br/>HR部 0.03<br/>财务部 0.02"]

    B2["路由决策<br/>选择Top-K=2的部门"]
    B3["最终分配<br/>技术部 100%<br/>或软分配:<br/>技术部 90% + 销售部 10%"]

    B4["仅调用选中的部门<br/>其他部门员工不需参与<br/>节省资源 提高效率"]

    A -->|vs| B
    B --> B1 --> B2 --> B3 --> B4

    style A fill:#FFB6C6
    style B4 fill:#90EE90
```

MoE 的路由机制详解：

1. 路由网络（Gating Network）的结构： ├─ 输入：token 的嵌入表示（比如 4096 维） ├─ 简单的线性层：4096 维 → 8 个专家分数 ├─ 输出：8 个 softmax 分数 \[0.3, 0.4, 0.2, 0.05, ...] └─ 速度：非常快（只是一次矩阵乘法）
2. Top-K 选择： ├─ 经典 MoE（如 Mixtral-8x7B）使用 K=2（每个 token 激活 2 个专家） ├─ 路由权重：假设分数是\[0.4, 0.35, 0.15, 0.1, ...] ├─ 硬选择：选择最高的 2 个（0.4 和 0.35） │ └─ 专家 A: 40%, 专家 B: 35%, 其他: 0% │ └─ 软选择（也叫平衡选择）： └─ 按照概率分配（基于分数） └─ 专家 A: 40%, 专家 B: 35%, 专家 C: 15%, ...
3. 负载均衡：防止所有 token 都选择同一个专家 ├─ 问题：如果路由器总是倾向于选择专家 A │ 那么其他专家就会被浪费 │ ├─ 解决方案：添加辅助损失函数 │ ├─ 在训练时添加额外的损失： │ │ “确保每个专家被使用的次数相近” │ │ │ ├─ 如果有 8 个专家和 1000 个 token │ │ └─ 理想情况：每个专家处理 1000/8 = 125 个 token │ │ └─ 如果某个专家只被选了 10 次，就增加损失 │ │ │ └─ 训练到收敛：负载均衡自动实现 │ └─ 效果：即使 MoE 参数很多，也能高效使用

### MoE 在 DeepSeek-V3 中的实现

```
DeepSeek-V3的MoE架构：

参数配置（基于 DeepSeek-V3 技术报告）：
├─ 总专家数：256 个
├─ 共享专家：1 个（所有 token 都必须通过）
├─ 每次激活：Top-K=8 个路由专家 + 1 个共享专家
├─ 总参数：约 671B（MoE 层含 256 个专家的全部参数）
├─ 每个 token 激活参数：约 37B（8 个路由专家 + 共享专家）
└─ 稀疏性：每个 token 只激活全参数的一小部分

推理流程：
输入：一个token的嵌入向量
   ↓
路由器（Gating Network）：
├─ 计算分数：[分数1, 分数2, ..., 分数256]
├─ 应用softmax
└─ 选择Top-K=8 的路由专家（基于分数）+ 1 个共享专家
   ↓
执行计算：
├─ 8 个被选中的路由专家分别处理这个 token
├─ 共享专家也处理这个 token（所有 token 都通过）
├─ 单 token 激活参数共约 37B（含路由专家 + 共享专家）
└─ 按照路由权重混合结果
   ↓
输出：融合后的特征表示
```

### 稀疏激活的力量

```
稀疏激活 = 只激活部分参数，而不是全部参数

DeepSeek-V3的参数配置解释：

总参数数 vs 激活参数数 的区别：

┌────────────────────────────────────────┐
│ 总参数：671B（约 6,710 亿参数）        │
│ 这包括：                               │
│ ├─ 256 个路由专家（占大头）            │
│ ├─ 1 个共享专家                        │
│ └─ 注意力层等共享组件                  │
│                                        │
│ 每次推理激活：约 37B（约 370 亿参数）  │
│ 这来自：                               │
│ ├─ Top-K=8 个被路由器选中的专家        │
│ ├─ 加上 1 个共享专家                   │
│ └─ 加上注意力层等共享部分              │
│                                        │
│ 稀疏性：37B / 671B ≈ 5.5%             │
│ 含义：每次推理只激活约 5.5% 的参数     │
└────────────────────────────────────────┘

重点理解：为什么"总参数 671B，激活 37B"？

DeepSeek-V3 共 61 层 Transformer：
├─ 每层的前向网络（FFN）是 MoE 结构
│  ├─ 256 个路由专家 + 1 个共享专家
│  ├─ 每个 token 只激活其中 Top-K=8 个路由专家
│  └─ 加上共享专家 → 每层 MoE 激活 9 个专家
│
├─ 注意力层是所有 token 共享的
│  └─ 使用 MLA（多头潜在注意力，详见 8.6.2）
│
└─ 推理时：每层只激活 9 个专家 + 注意力层
   全部 61 层加总，激活参数约 37B（每个 token）

对比不同模型的参数配置：

传统密集模型（比如 200B 量级的 dense 模型）：
├─ 总参数：200B
├─ 激活参数（推理）：200B（全部）
└─ 推理成本：必须运行 200B 的计算

MoE 稀疏模型（DeepSeek-V3）：
├─ 总参数：671B（容量更大）
├─ 激活参数（推理）：37B（仅 5.5%）
├─ 推理成本：只运行 37B 的计算
├─ 对比 200B 密集模型：37B / 200B ≈ 0.19 倍
│ 即推理成本"反而显著低于"同代 dense 模型
└─ 好处：用更低的推理成本，访问 671B 规模的知识容量！

为什么这样设计有效？

知识分布假设：
不同的知识分散在不同的"专家"中
- 256 个细粒度专家分别擅长不同领域
- 数学、代码、语言、常识、长尾知识等
- 路由器根据 token 内容选出最匹配的 8 个

对于一个数学 token：
不需要激活与之无关的专家（浪费）
只需要激活路由器选中的 8 个专家（高效）
路由器在训练中学会了这种选择

结果效果对比：

方案 1：使用 200B 密集模型
├─ 参数数：200B
├─ 推理速度：1.0x（基准）
├─ 性能：取决于训练，通常 GPT-3.5 量级

方案 2：使用 671B 稀疏模型（DeepSeek-V3）
├─ 参数数：671B（总）/ 37B（激活）
├─ 推理速度：约 0.19x 的 FLOPs（远少于 200B dense）
├─ 性能：在 MMLU/HumanEval/Math 等基准上达到前沿水平
└─ 关键：知识容量×3.4，激活计算量÷5

这就是为什么 DeepSeek 能用更低推理成本达到更好效果！
```

## 8.6.4 DeepSeek 如何结合 MLA 和 MoE

### 两大创新的协同

```
DeepSeek V3的架构：

1. 在注意力层使用MLA
   ├─ 减少内存占用
   ├─ 大幅压缩 KV 缓存（省显存，不是省算力）
   └─ 没有牺牲性能

2. 在前向网络层使用MoE
   ├─ 增加模型的知识广度
   ├─ 但只激活必要的参数
   └─ 推理速度不受影响

整体效果对标（基于各自官方报告）：
┌──────────────────────────────────┐
│ DeepSeek V3 与GPT-4 Turbo对比  │
├──────────────────────────────────┤
│ 参数规模：在同一量级             │
│ 激活参数：DeepSeek的稀疏性优势  │
│ 推理性能：多数任务相当             │
│ 训练成本：DeepSeek报告低成本案例│
└──────────────────────────────────┘

注：跨厂商比对易受多种因素影响，
宜参考各自官方技术报告。
```

## 8.6.5 这为什么节省了这么多成本？

### 训练成本的分解

```
训练一个大模型的成本：

总成本 = 数据成本 + 计算成本 + 人员成本

计算成本 = FLOPs × 硬件成本

FLOPs = Forward-Backward Operations
      = 模型大小 × 数据大小 × 迭代次数

DeepSeek相比GPT-4的改进：

1. 模型更高效
   └─ MLA + MoE = 同性能下更少激活计算

2. 数据选择更聪明
   └─ 高质量数据 > 大量数据
   └─ 不需要训练在垃圾数据上

3. 利用更少GPU资源
   └─ 不需要最新最贵的GPU
   └─ 可以用A100而不必须用H100

4. 中国成本更低
   └─ 电费更便宜
   └─ 工程师成本更低

所有这些因素的组合：

根据 DeepSeek 官方报告，一次代表性训练运行的成本约 $5.6M
业界对 GPT-4 的训练成本估计范围较广（未见官方披露）
成本优势显著，但不宜简化为"固定倍数"（详见本节8.6.7）
```

## 8.6.6 实际的性能影响

### 推理成本

```
推理成本对比示例（仅为量级示意，价格以各厂商官方当期价目页为准）：

OpenAI GPT-4 Turbo（历史示例）：
├─ 输入：$0.01/1K token
├─ 输出：$0.03/1K token
└─ 一个典型问题：成本随输入/输出比例变化，不宜固化为单值

Claude 3.5 Sonnet（示例）：
├─ 输入：$0.003/1K token
├─ 输出：$0.015/1K token
└─ 一个典型问题：~$0.005

DeepSeek Flash（示例，官方价目表按非高峰 / 高峰两档计价，非高峰为高峰的一半）：
├─ deepseek-flash 输入（cache hit）：$0.003 / $0.006 每 1M token
├─ deepseek-flash 输入（cache miss）：$0.15 / $0.3 每 1M token
├─ deepseek-flash 输出：$0.6 / $1.2 每 1M token
└─ 型号名换过好几轮：deepseek-chat / deepseek-reasoner 已于 2026-07-24 退役；deepseek-v4-flash 如今只是兼容别名，请求由 DeepSeek-V4.1-Flash 承接；当前价目表列出的是 deepseek-flash 与 deepseek-v4-pro

成本相对关系：
GPT-4 Turbo : Claude : DeepSeek 只能作为同一日期、同一 token 结构下的量级比较；生产选型应重新计算。

说明：
- 实际成本受缓存命中率、模型版本、问题难度、输出长度等影响
- 自部署 vs 托管 API 的成本结构完全不同
- 价格政策会随时更新，应以官方当期价格为准（DeepSeek 见 api-docs.deepseek.com 的 Models & Pricing 页）
```

## 8.6.7 本节小结

DeepSeek 的成本优势来自于两个关键创新：

1. **MLA（多头潜在注意力）**
   * 压缩注意力的表示
   * 减少显存（KV 缓存）占用，注意力算力基本不变
   * 保持性能
2. **MoE（混合专家）**
   * 稀疏激活参数
   * 更多知识，更少计算
   * 高效的权衡

加上工程和数据策略，DeepSeek 展示了一个重要方向：

* 在部分公开基准和应用场景中取得有竞争力的模型性能
* 通过 MLA、MoE、数据选择和系统优化降低训练与推理成本
* 具体“便宜多少倍”取决于对比对象、价格口径、缓存命中率和部署方式，不宜写成固定倍数

这改变了 AI 产业的格局：不再需要巨额融资才能做出顶级模型。

## 8.6.8 思考题

1. MoE 如今几乎是大模型标配（Llama 4、Mixtral、DeepSeek 都在用）。那它的代价是什么？为什么不是所有模型都用？
2. MoE 有什么缺点？是否所有问题都适合用 MoE？
3. MLA 和 MoE 的组合还有改进空间吗？下一个创新可能是什么？