# 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是序列长度（较小）
├─ 矩阵维度从4096×4096降到256×256
├─ 内存占用从16MB → 256KB（减少99%）
└─ 计算量相应减少64倍
   ↓
解压层（投影回原始维度）：
├─ 使用学习的映射矩阵将结果恢复
├─ 从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）
- 计算量减少 (4096/256)² = 256倍
- 内存占用减少 (4096/256)² = 256倍

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

效果总结：
- 计算复杂度：从O(seq_len × d_model²)降到O(seq_len × d_latent²)
- KV缓存大小：从16MB → 1MB（减少93%）
- 推理速度：因为矩阵更小，访问内存更快，速度提升 2-3倍
- 质量：通过训练优化投影矩阵，质量接近原始注意力

为什么这样做有效？
- 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.4）
│
└─ 推理时：每层只激活 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 等基准上达到前沿水平
└─ 关键：知识容量×8，激活计算量÷5

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

## 8.6.4 DeepSeek 如何结合 MLA 和 MoE

### 两大创新的协同

```
DeepSeek V3的架构：

1. 在注意力层使用MLA
   ├─ 减少内存占用
   ├─ 加快注意力计算
   └─ 没有牺牲性能

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 实际的性能影响

### 推理成本

```
推理成本对比示例（基于 2026-05-24 官方公开价格核验，仅为量级示意）：

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 V3（示例）：
├─ deepseek-chat 输入（cache hit）：$0.07/1M token
├─ deepseek-chat 输入（cache miss）：$0.27/1M token
├─ deepseek-chat 输出：$1.10/1M token
└─ deepseek-reasoner 价格更高：输入 $0.14/$0.55/1M（hit/miss），输出 $2.19/1M

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

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

## 8.6.7 本节小结

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

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

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

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

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

## 8.6.8 思考题

1. 如果 MoE 这么高效，为什么其他公司（OpenAI、Anthropic）不大规模使用？
2. MoE 有什么缺点？是否所有问题都适合用 MoE？
3. MLA 和 MoE 的组合还有改进空间吗？下一个创新可能是什么？


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET 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?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.