ylhan/note_sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

将 note 笔记库同步到 note_sync，AI_compiler 作为 submodule

Browse Source
This commit is contained in:
ylhan
2026-08-20 17:42:14 +08:00
commit 8a4210f380
44 changed files with 5080 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
大模型/DeepSeek V4 系列.md
+125
View File
@@ -0,0 +1,125 @@
# DeepSeek V4 系列
> 发布日期：2026年4月24日 | 开源协议：MIT
## 概述
DeepSeek V4 是深度求索（DeepSeek）在 2026 年 4 月发布的新一代大语言模型系列，包含两个版本：
| | V4 Pro（旗舰版） | V4 Flash（轻量版） |
|---|---|---|
| **总参数量** | 1.6T（1.6万亿） | 284B（2840亿） |
| **激活参数** | ~36B/token | 13B/token |
| **上下文窗口** | 1M tokens | 1M tokens |
| **架构** | MoE（混合专家） | MoE（混合专家） |
| **定位** | 旗舰性能，对标 GPT-5 | 低成本、低延迟，接近 Pro 推理能力 |
---
## 核心技术架构
### 1. 混合专家架构（Mixture-of-Experts, MoE）
- V4 Pro：384 个专家/层，每次推理激活 6 个
- V4 Flash：精简专家数量，每次推理激活 13B 参数
- 优势：总参数大但计算量可控，推理效率高
### 2. 混合注意力机制（Hybrid Attention）
- **DSA2 稀疏注意力**：降低长上下文的计算开销
- **CSA（压缩稀疏注意力）+ HCA（重度压缩注意力）**（Flash）：
- KV 缓存内存开销降低高达 90%
- 在 1M 上下文下，单 token 推理 FLOPs 仅为 V3.2 的 27%
- KV 缓存仅为 V3.2 的 10%
### 3. 其他关键技术
- **流形约束超连接（mHC）**：增强残差连接，改善跨层信号传播
- **Muon 优化器**：加速收敛，提升训练稳定性
- **多 Token 预测（MTP）**：一次预测多个 token，加速生成
- **DSpark 推测解码**（Flash）：集成草稿模块加速推理
---
## 三种推理模式
| 模式 | 说明 | 适用场景 |
|---|---|---|
| **Non-think（低）** | 快速、直观的响应 | 简单对话、翻译、摘要 |
| **Think High（高）** | 显式思维链推理 | 逻辑推理、规划任务 |
| **Think Max（最大）** | 最大推理深度 | 复杂数学、竞赛编程 |
---
## 关键基准测试
### V4 Pro 亮点
| 基准测试 | 得分 | 对比 |
|---|---|---|
| Codeforces Rating | 3206 | 超越 Gemini 3.1-Pro |
| LiveCodeBench | 93.5 | 与 GPT-5.4 竞争 |
| MMLU-Pro | — | 接近 GPT-5 水平 |
### V4 Flash 亮点
| 基准测试 | 得分 |
|---|---|
| MMLU-Pro (EM) | 87.5 |
| GPQA Diamond | 90.1 |
| LiveCodeBench | 93.5 |
| SWE Verified (Resolved) | 80.6 |
| Terminal Bench 2.1 | 82.7 |
| BrowseComp | 83.4 |
---
## 定价对比
### V4 Pro（通过 DeepInfra）
| Token 类型 | 每百万 Token 价格 |
|---|---|
| 输入 | $1.74 |
| 输出 | $3.48 |
| 缓存输入 | $0.145 |
### V4 Flash
| Token 类型 | 每百万 Token 价格 |
|---|---|
| 输入 | ~$0.14 |
| 输出 | ~$0.28 |
> V4 Pro 输出成本比 Claude Opus 4.7（$25/1M）便宜约 7 倍
---
## 独立评测（NIST/CAISI，2026年5月）
- V4 Pro 性能约为 **GPT-5 水平**（2025年8月发布）
- 距美国最前沿模型约 **8 个月**差距
- CAISI 测试过的**最强中国 AI 模型**
- 在某些非公开基准（ARC-AGI-2、CTF-Archive-Diamond）上明显落后于 GPT-5.5 和 Opus 4.6
---
## 战略意义
1. **芯片自主**：与华为昇腾（Ascend）、寒武纪合作优化，不依赖 NVIDIA/AMD
2. **开源生态**：MIT 协议开源，模型权重在 Hugging Face 上公开
3. **与 GPT-5.5 同日发布**：中美 AI 竞争白热化的标志性事件
4. **自我定位坦诚**：官方公开承认距前沿 3-6 个月差距
---
## 相关链接
- [[Transformer 架构详解]]
- [[MoE 混合专家架构]]
- [[多模态大模型]]
- [[大模型架构基础]]
---
*最后更新：2026-08-05*
大模型/FFN 前馈网络详解.md
+410
View File
@@ -0,0 +1,410 @@
# FFN 前馈网络详解
> Feed-Forward Network — Transformer 中参数量最大（~2/3）、负责知识存储和特征变换的核心组件
---
## 一、FFN 在 Transformer 中的角色
```
Transformer Block：
注意力层（信息混合） FFN 层（特征变换）
┌─────────────────┐ ┌─────────────────────┐
│ Token 之间交互 │ │ 每个 Token 独立处理 │
│ "谁跟谁有关？" │ → │ "这个 Token 是什么意思？"│
│ 参数量 ~1/3 │ │ 参数量 ~2/3 │
└─────────────────┘ └─────────────────────┘
```
| 组件 | 参数量占比 | 功能 |
|---|---|---|
| **注意力层** | ~1/3 | Token 间的信息路由与混合（"连接信息"） |
| **FFN 层** | ~2/3 | Token 内部的特征变换与知识存储（"存储知识"） |
> **直觉**：注意力层决定"从哪读信息"，FFN 层存储"读到的信息怎么理解"。研究表明 FFN 的权重矩阵充当了**联想记忆（Associative Memory）**——W₁ 的每一行是一个"模式检测器"，W₂ 的对应列是"该模式的输出"。
---
## 二、基础公式
### 标准 FFN（原始 Transformer）
```
FFN(x) = W₂ · ReLU(W₁ · x + b₁) + b₂
```
```
输入 x（d_model 维度）
│
▼
W₁: d_model → d_ff ← 升维（通常 d_ff = 4 × d_model）
│
▼
激活函数（ReLU/GELU/...） ← 引入非线性
│
▼
W₂: d_ff → d_model ← 降维回原维度
│
▼
输出（d_model 维度）
```
### 参数量计算
```
标准 FFN（无偏置）：
params = d_model × d_ff + d_ff × d_model
= 2 × d_model × d_ff
= 2 × d_model × 4d_model （通常 d_ff = 4d）
= 8 × d_model²
```
| d_model | d_ff (4×) | FFN 参数量 | 一层总参数（含注意力） |
|---|---|---|---|
| 512 | 2048 | 2.1M | ~3M |
| 4096 (LLaMA 7B) | 11008 (约2.7×) | ~90M | ~135M |
| 8192 (LLaMA 70B) | 22016 | ~360M | ~540M |
> 在 LLaMA 等 SwiGLU 模型中，`d_ff` 通常设为约 `8/3 × d_model`（而非 4×），以补偿 GLU 变体引入的额外参数。
---
## 三、激活函数演进路线
```
2017 ─→ 2019 ────→ 2020 ──────→ 2025
ReLU GELU SwiGLU PolyGLU / 动态路由
│ │ │ │
│ │ │ └─ 每个神经元学自己的激活函数
│ │ └─ 门控线性单元，当前生产标准
│ └─ 平滑版 ReLU，不再死神经元
└─ 简单粗暴，负值直接清零
```
### 3.1 ReLU（原始 Transformer）
$$\text{ReLU}(x) = \max(0, x)$$
```
│
2 ┤ ╱
1 ┤ ╱
0 ┼════●──────── ← 负半轴完全为零
│ ╱
-1 ┤ ╱
└────────────
```
| 优点 | 缺点 |
|---|---|
| 计算极快，硬件原生支持 | **死神经元**：一旦输出为零，梯度为零，永不恢复 |
| 稀疏激活（约 50%） | 负值信息完全丢失 |
> **死神经元问题**：如果某个神经元的输出始终 ≤ 0（因为权重初始化或学习偏差），ReLU 的梯度永远为 0，这个神经元就"死了"——再也不会更新。
### 3.2 GELU（GPT-2 / BERT 时代）
$$\text{GELU}(x) = x \cdot \Phi(x) = x \cdot \frac{1}{2}\left[1 + \text{erf}\left(\frac{x}{\sqrt{2}}\right)\right]$$
```
│
2 ┤ ╱
1 ┤ ╱╱
0 ┼────●───────── ← 负半轴有小的非零输出
-1 ┤╱╱
└────────────
```
| 优点 | 缺点 |
|---|---|
| 平滑可微，梯度流更好 | 计算比 ReLU 慢（erf 函数） |
| 负值有概率性"门控"而非直接清零 | 所有输入用同一个函数处理 |
| 缓解死神经元问题 | |
> **GELU 的直觉**：把输入值 `x` 乘以它"来自正半轴的概率"——如果 x 很可能是负的，输出很小但不为零。
### 3.3 SiLU / Swish
$$\text{SiLU}(x) = x \cdot \sigma(x) = \frac{x}{1 + e^{-x}}$$
```
│
2 ┤ ╱
1 ┤ ╱╱
0 ┼─────●───────── ← 负半轴有"负沟"（non-monotonic）
-0.3┤ ╱ ╲ ← 这个沟是 SiLU 的独特特征
└────────────
```
| 关键特性 | 说明 |
|---|---|
| **自门控** | 每个值决定自己通过多少：`x · σ(x)` |
| **非单调** | 负半轴先下降再回升，能捕获复杂模式 |
| **无界正值** | 正半轴可以无限大（不像 sigmoid 有上限） |
| **平滑** | 处处可微，梯度流极好 |
> SiLU 和 Swish 是**同一个函数**的两个名字。Google 叫它 Swish，PyTorch 叫它 SiLU。
---
## 四、GLU 门控线性单元：范式转变
### 4.1 从"单路激活"到"双路门控"
```
标准 FFN： GLU FFN：
x x
│ ┌────┴────┐
W₁ W_gate W_up
│ │ │
Act σ │
│ │ │
W₂ └────┬────┘
│ ⊗ (逐元素相乘)
输出 │
W_down
│
输出
```
### 4.2 为什么乘法比加法强？
> 门控 = 逐元素乘法 = 引入**二阶交互项**
```
GLU(x) 包含 xᵢ · xⱼ 项（不同维度之间产生交互）
FFN(x) 只有 σ(Wx) 项（每个维度独立处理）
类比：
FFN = 每个特征独立打分
GLU = 特征之间可以"对话"——"我是形容词，如果前面是名词就激活我"
```
### 4.3 SwiGLU（2020→至今的生产标准）
$$\text{SwiGLU}(x) = \text{SiLU}(x W_{\text{gate}}) \otimes (x W_{\text{up}}) \cdot W_{\text{down}}$$
```python
# SwiGLU 的实际代码（也是 LLaMA、DeepSeek、Mistral 等主流模型的实现）
class SwiGLU(nn.Module):
def __init__(self, dim, hidden_dim):
super().__init__()
# 三个权重矩阵（不是标准的两个）
self.gate_proj = nn.Linear(dim, hidden_dim, bias=False) # 门控通路
self.up_proj = nn.Linear(dim, hidden_dim, bias=False) # 值通路
self.down_proj = nn.Linear(hidden_dim, dim, bias=False) # 降维
def forward(self, x):
# gate: 门控信号（SiLU 激活）
# up: 值信号（无激活，直接通过）
return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
```
### 4.4 参数量补偿：为什么 d_ff 变小了
| 方案 | 矩阵数 | 参数量 | d_ff（等参） |
|---|---|---|---|
| 标准 FFN | W₁, W₂ (2个) | 2 × d × d_ff | 4d |
| SwiGLU | W_gate, W_up, W_down (3个) | 3 × d × d_ff | **8d/3 ≈ 2.67d** |
```
等参数量下：
标准 FFN：d_ff = 4d → 2 × d × 4d = 8d²
SwiGLU：d_ff = 8d/3 → 3 × d × 8d/3 = 8d²
↑
参数总量相同，但 SwiGLU 表达能力更强
```
> 实际中，即使参数相当，SwiGLU 的困惑度（Perplexity）也比 GELU 低约 **8.3%**（文本任务）——这是"免费的性能提升"。
---
## 五、GLU 变体对比
| 变体 | 门控激活函数 | 公式 | 特点 |
|---|---|---|---|
| **GLU（原始）** | Sigmoid | `σ(xW_g) ⊗ (xW_u)` | 门控有上限(0,1)，表达受限 |
| **ReGLU** | ReLU | `ReLU(xW_g) ⊗ (xW_u)` | 最快，但仍可能死神经元 |
| **GeGLU** | GELU | `GELU(xW_g) ⊗ (xW_u)` | 视觉/多模态任务稍好 |
| **SwiGLU** | SiLU/Swish | `SiLU(xW_g) ⊗ (xW_u)` | **文本生成 SOTA，生产标准** |
### 选择指南
| 场景 | 推荐 | 原因 |
|---|---|---|
| LLM 文本生成 | **SwiGLU** | 困惑度最低，LLaMA/DeepSeek/Mistral 全部使用 |
| 视觉编码器 | GeGLU 或 GELU | 分类任务上略优（~2% Top-1 提升） |
| 延迟敏感 | ReGLU | Relu 计算成本最低，硬件原生支持 |
| 混合模态 | 编码器 GELU + 解码器 SwiGLU | 各取所长，推理可提速 ~15% |
---
## 六、FFN = 知识的"键值记忆"
> 这个视角将 FFN 从"无聊的全连接层"升级为"模型的知识存储系统"
### 联想记忆假说
```
FFN(x) = W₂ · Act(W₁ · x)
W₁ 的每一行 = 一个"键"（Key），检测特定模式
W₂ 的对应列 = 一个"值"（Value），存储该模式对应的输出
过程：
1. W₁·x → 将输入与所有"键"匹配（内积 = 相似度）
2. Act → 过滤：只保留匹配度高的模式
3. W₂· ... → 激活的模式"写出"对应的值
```
### 实验证据
| 发现 | 说明 |
|---|---|
| **知识定位** | FFN 的特定神经元可以对应具体的事实（如"埃菲尔铁塔在巴黎"） |
| **可编辑性** | 修改 FFN 权重可以精确修改模型存储的事实（模型编辑） |
| **稀疏激活** | 对每个 Token，FFN 中只有少数神经元真正激活（和 MoE 思路一致） |
| **层间分工** | 浅层 FFN → 语法/局部模式、深层 FFN → 语义/全局知识 |
---
## 七、2025 前沿：激活函数本身也"可学习"
### 7.1 PolyGLU（2025年3月）
> **不再固定用一种激活函数，而是让每个神经元学习自己最适合的激活函数**
```
PolyGLU(x) = [ Σ g_k · σ_k(x·W_gate) ] ⊗ (x·W_up)
其中 σ_k 从候选池中选择：
{ ReLU, Tanh, SiLU, GELU }
g_k = 路由权重（每个神经元不同），训练中自动收敛
```
**训练后的层间分布（19K步训练）**：
```
层 0-2（浅层）： GELU 35-40% | Tanh 15-25% | SiLU 15-20% | ReLU ~5%
层 3-14（中层）： GELU 为主，逐步过渡
层 15-27（深层）： Tanh 50-65% ← 深层网络偏好对称有界激活！
```
> 关键发现：深层网络的神经元**自发偏好 Tanh**（对称、有界），浅层偏好 GELU（概率性门控）。这暗示不同深度的层确实需要不同"类型"的非线性变换。
### 7.2 动态激活选择（LLaMA 4）
LLaMA 4 实验在 SwiGLU 和 GELU 之间做**输入级动态切换**：
- 用轻量门控网络根据输入内容选择激活函数
- 复杂推理任务 → 倾向于 SwiGLU（更强的特征交互）
- 简单模式匹配 → 倾向于 GELU（更快的计算）
---
## 八、DeepSeek 风格的实际实现
### 标准 SwiGLU（如 LLaMA）
```python
class LlamaMLP(nn.Module):
def __init__(self, config):
super().__init__()
self.gate_proj = nn.Linear(config.hidden_size, config.intermediate_size, bias=False)
self.up_proj = nn.Linear(config.hidden_size, config.intermediate_size, bias=False)
self.down_proj = nn.Linear(config.intermediate_size, config.hidden_size, bias=False)
def forward(self, x):
return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
```
### DeepSeek-V3 的 MoE + SwiGLU
```python
# 每个专家就是一个 SwiGLU FFN
class DeepSeekExpert(nn.Module):
def __init__(self, dim, moe_intermediate_size):
super().__init__()
self.gate_proj = nn.Linear(dim, moe_intermediate_size, bias=False)
self.up_proj = nn.Linear(dim, moe_intermediate_size, bias=False)
self.down_proj = nn.Linear(moe_intermediate_size, dim, bias=False)
def forward(self, x):
return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
# MoE 层：N 个专家 + 路由器
class DeepSeekMoE(nn.Module):
def __init__(self, dim, n_routed_experts=256, n_shared_experts=2, top_k=8):
super().__init__()
self.shared_experts = nn.ModuleList([
DeepSeekExpert(dim, dim * 2) for _ in range(n_shared_experts)
])
self.routed_experts = nn.ModuleList([
DeepSeekExpert(dim, dim * 2) for _ in range(n_routed_experts)
])
self.gate = nn.Linear(dim, n_routed_experts, bias=False)
def forward(self, x):
# 共享专家（始终激活）
shared_out = sum(e(x) for e in self.shared_experts)
# 路由专家（稀疏激活 Top-K）
router_logits = self.gate(x)
topk_weights, topk_ids = torch.topk(router_logits.softmax(-1), self.top_k)
routed_out = 0
for i, expert_id in enumerate(topk_ids):
routed_out += topk_weights[i] * self.routed_experts[expert_id](x)
return shared_out + routed_out
```
> DeepSeek-V3 有 256 个路由专家 + 2 个共享专家，每个专家内部都是 SwiGLU FFN。详见 [[MoE 混合专家架构]]。
---
## 九、进化总览
```
标准 FFN GLU 系列
──────── ────────
非线性来源： 激活函数 门控乘法
通路数： 单路 双路（值 + 门控）
交互阶数： 一阶 二阶（xᵢ·xⱼ）
参数效率： 基准 显著更优
参数量： 2 × d × d_ff 3 × d × d_ff
生产标准： 已过时 SwiGLU（2025年）
未来方向
────────
激活函数选择： 可学习、每个神经元不同
实现： PolyGLU、动态路由
目标： 让模型自主发现最优非线性
```
---
## 十、一句话总结
```
FFN 不是"无聊的全连接层"——
它是 Transformer 中参数最密集、负责存储世界知识的核心组件。
ReLU → GELU → SiLU → SwiGLU → PolyGLU 的进化线，
本质上是"从固定非线性到可学习、动态、输入感知的门控机制"的演进。
你正在用的 LLaMA、DeepSeek、Mistral、Qwen 的每一层中，
SwiGLU 正在用乘法门控默默地做着模型 2/3 的"思考"。
```
---
## 相关链接
- [[Transformer 架构详解]] — FFN 在完整架构中的位置
- [[大模型架构基础]] — 各组件全景概览
- [[MoE 混合专家架构]] — FFN 的稀疏化扩展：用 N 个 SwiGLU 替代 1 个
---
*最后更新：2026-08-05*
大模型/MoE 混合专家架构.md
+289
View File
@@ -0,0 +1,289 @@
# MoE 混合专家架构
> Mixture of Experts — 用稀疏激活实现"参数量 vs 计算量"的解耦，是 DeepSeek V4、GPT-4、Mixtral 等旗舰模型的核心架构
---
## 一、为什么要 MoE？
### 密集模型的困境
传统 Transformer 中，每个 Token 流经**所有** FFN [^FFN] 参数：
```
Token → FFN（全部参数参与计算）→ 输出
```
参数量越大 → 每次推理计算量越大 → 训练和推理成本线性增长。
### MoE 的核心思想
> **"参数多，但每次只用一小部分"**
```
Token → 路由器 → 选择最相关的几个专家 → 只激活它们 → 输出
↑
其他专家保持休眠
```
| | 密集模型 | MoE 模型 |
|---|---|---|
| **总参数量** | 100B | 可以到 1.6T（16倍） |
| **每次推理计算量** | 100B | 仅约 36B |
| **训练效率** | 基准 | 更高（同算力下能训练更大模型） |
| **推理延迟** | 基准 | 需要加载更多权重到显存 |
---
## 二、MoE 层的工作原理
### 数学公式
$$
\text{MoE}(x) = \sum_{i \in \text{TopK}(G(x), k)} G(x)_i \cdot E_i(x)
$$
其中：
| 符号 | 含义 |
|---|---|
| `G(x)` | 路由器/门控网络，输出每个专家的"置信度分数" |
| `TopK(G, k)` | 选择分数最高的 k 个专家（通常 k=2~8） |
| `E_i(x)` | 第 i 个专家（一个 FFN [^FFN] 子网络） |
| `G(x)_i` | Softmax 归一化后的专家权重 |
### 一句话总结
> 输入 Token → 路由器打分 → 选 Top-K 专家 → 加权合成输出
### 结构图解
```
输入 Token x
│
▼
┌───────────┐
│ 路由器 G │ ← 一个小型线性层，输出 N 个分数
│ (Gate) │ (N = 专家总数)
└─────┬─────┘
│ Softmax 归一化
│ 选出分数最高的 k 个
▼
┌─────────────────────────────────────┐
│ N 个专家（Expert） │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐│
│ │ E₁ │ │ E₂ │ │ E₃ │... │ Eɴ ││
│ │💤 │ │🔥 │ │💤 │ │🔥 ││
│ └─────┘ └──┬──┘ └─────┘ └──┬──┘│
│ │ │ │
│ 只激活 k=2 个专家! │ │
└─────────────┼─────────────────┼─────┘
│ │
└─── 加权求和 ────┘
│
▼
输出 MoE(x)
```
---
## 三、MoE 层 vs 标准 FFN 层
```
标准 Transformer 块： 使用 MoE 的 Transformer 块：
注意力层 [^Attn] 注意力层 [^Attn]
↓ ↓
FFN（全部参数） 路由器 → 选择专家
↓ ↓
注意力层 [^Attn] 被选中的专家（稀疏激活）
↓ ↓
FFN（全部参数） 注意力层 [^Attn]
↓
路由器 → 选择专家
↓
被选中的专家（稀疏激活）
```
> **只在 FFN 层引入 MoE**，注意力层保持不变（注意力机制本身就负责 Token 间信息交互，无需稀疏化）。
---
## 四、关键设计维度
### 1. 专家粒度
| 类型 | 说明 | 示例 |
|---|---|---|
| **粗粒度** | 少量大专家（如 8 个，每个完整 FFN 大小） | 早期 MoE、Mixtral 8×7B |
| **细粒度** | 大量小专家（如 384 个微专家，每个很小） | DeepSeek-V3/V4（64 个微专家/层，激活 6 个） |
细粒度的优势：
- 路由组合更灵活：从 N 选 k 变为 mN 选 mk，组合数暴增
- DeepSeek V4 每层约 **3630 万种**可能的专家组合
- 同等总参数下，每个专家更小，训练/推理更灵活
### 2. 共享专家 vs 路由专家
| 类型 | 说明 |
|---|---|
| **共享专家** | 始终激活，捕捉通用模式（语法、基础常识） |
| **路由专家** | 按 Token 动态选择，负责特定领域（数学、代码、翻译...） |
DeepSeekMoE 采用两层设计：
- 2 个共享专家（always on）
- 62 个路由专家（每个 Token 激活 6 个）
共享专家提升训练稳定性，但可能降低专家专门化程度。
### 3. 路由器设计
```
简单线性路由器（当前主流）：
router_logits = W_g · x ← 一个小矩阵，N × d_model
topk_experts = TopK(softmax(router_logits), k)
```
实际推理时的路由模式：
- 每个 Token **独立**路由（不考虑上下文）
- 序列中相邻 Token 可能路由到不同专家
---
## 五、负载均衡 — MoE 的核心挑战
### 问题
> 如果路由器"偷懒"，总是选固定的几个专家 → 其他专家闲置 → 退化为密集模型
### 传统方案：辅助损失（Auxiliary Loss）
$$
L_{total} = L_{主任务} + \alpha \cdot L_{负载均衡}
$$
强制惩罚专家使用不均匀的情况。**问题**：梯度冲突，可能导致训练不稳定。
### 2025 前沿：无梯度负载均衡
```python
# 动态偏置调整 — 不干扰主损失梯度
logits_i(t+1) = W_g · x + b_i(t) - γ · (f_i(t)/f̄(t) - 1)
```
其中：
- `f_i(t)`：当前被路由到专家 i 的 Token 比例
- `f̄(t)`：理想平均比例 = 1/N
- 效果：专家使用率的变异系数 < 0.1，无梯度冲突
---
## 六、2025 年前沿进展
### 1. DAG-MoE [^DAG]（ICML 2026）
> 不是简单加权平均专家输出，而是把选中的专家排列成**有向无环图（DAG, Directed Acyclic Graph）**，实现结构化的专家聚合（DAG 聚合）
```
传统 MoE： E₁↘
E₂ → 加权平均 → 输出
E₃↗
DAG-MoE： E₁ → E₃ ↘
E₂ → E₄ → E₆ → 输出（信息流经多个专家）
```
- 允许**单层内多步推理**
- 模型学习最优的专家聚合结构（每个输入不同）
- 同等 FLOPs 下更强的表达能力
### 2. MoLE：查找表专家（ICML 2025 Oral）
> 将训练好的 FFN 专家**重新参数化**为查找表（LUT），专家计算变为查表操作
- 推理速度接近密集模型
- 大幅降低显存占用
- 使 MoE 在内存受限设备上部署成为可能
### 3. MoE + MLA（Multi-head Latent Attention，多头潜在注意力） [^MLA]
正交瓶颈联合优化：
| 瓶颈 | 方案 |
|---|---|
| FFN 计算量大 | MoE 稀疏激活 |
| 注意力 KV 缓存大 | MLA 低秩压缩 |
- ρ = 1/2 时：KV 缓存减少 **68%**，推理加速 **3.2×**
- 困惑度仅下降 0.8%
- DeepSeek V4 使用此组合
### 4. MoE-X：可解释 MoE（ICML 2025）
- 将 MoE 层理解为等效的大型稀疏 MLP
- 强制专家内部也做稀疏激活
- 可解释性超越 Sparse Autoencoder（SAE）方法
---
## 七、主流 MoE 模型对比
| 模型 | 总参数 | 激活参数 | 专家数 | 激活数 | 特点 |
|---|---|---|---|---|---|
| **Mixtral 8×7B** | 46.7B | 12.9B | 8 | 2 | 经典粗粒度 MoE |
| **DeepSeek-V3** | 671B | 37B | 256 | 8 | 细粒度 + 共享专家 |
| **DeepSeek-V4 Pro** | 1600B | 36B | 384/层 | 6 | 细粒度 + MLA + DSpark |
| **DeepSeek-V4 Flash** | 284B | 13B | 精简 | 精简 | Pro 的轻量版 |
| **GPT-4**（传闻） | 1.8T | ~280B | 16（推测） | 2 | 早批大规模 MoE |
> 趋势：专家数量越来越多，每个专家越来越小（细粒度），激活参数占比越来越低。
---
## 八、MoE 的代价
| 代价 | 说明 |
|---|---|
| **显存占用** | 所有专家都在 VRAM 里，即使大部分不激活 → 需要更多 GPU |
| **通信开销** | 多 GPU 部署时，Token 需要跨 GPU 路由到专家 |
| **训练不稳定** | 负载均衡损失与主损失可能冲突 |
| **微调困难** | 稀疏激活 → 梯度更稀疏 → 微调更难收敛 |
| **批次大小** | 每个专家实际收到的 Token 少 → 需要较大 batch size |
---
## 九、总结
```
MoE = 用路由器在大量专家中选择少数激活，实现"参数膨胀但计算可控"
关键取舍：
优势：同等算力下更大的模型容量、更好的性能/成本比
代价：更高显存、更复杂的工程、训练和微调挑战
2025 年趋势：
细粒度 → DAG 聚合 → 可解释 → 查找表推理 → 与 MLA 协同
```
---
## 相关链接
- [[Transformer 架构详解]]
- [[大模型架构基础]]
- [[DeepSeek V4 系列]]
---
---
## 脚注
[^FFN]: **FFN（Feed-Forward Network，前馈神经网络）**：Transformer 中每个位置的独立全连接子网络。结构为两层 MLP：`W₂ · Act(W₁ · x + b₁) + b₂`，参数量约占整个 Transformer 块的 2/3，是模型"知识存储"的主要位置。现代模型多使用 SwiGLU 激活的变体。详见 [[FFN 前馈网络详解]]。
[^Attn]: **注意力层（Attention Layer）**：Transformer 的核心机制，负责 Token 之间的信息交互。通过 Q（Query）、K（Key）、V（Value）三个投影矩阵，让每个 Token "看到"并加权所有其他 Token，从而捕获上下文依赖关系。多头注意力（Multi-Head Attention）并行运行多组 Q/K/V，每组关注不同的语义模式。
[^MLA]: **MLA（Multi-head Latent Attention，多头潜在注意力）**：DeepSeek 提出的注意力压缩技术。核心思路是将 K 和 V 首先投影到一个低维潜在空间（`d_latent << d_model`），再从中展开供注意力计算使用。这大幅减少了 KV 缓存的显存占用——在 ρ = 1/2 时可缩减 68%，且对模型质量影响极小（困惑度仅降 0.8%）。MLA 与 MoE 是正交优化：MoE 省 FFN 计算，MLA 省注意力显存，两者叠加效果倍增。
[^DAG]: **DAG 聚合（DAG Aggregation）**：将选中的专家按有向无环图（DAG）的结构进行串联/并联组合，而非传统的简单加权平均。每个输入路由到一组专家后，模型学习这些专家之间最优的信息流动路径——例如 E₁ 的输出作为 E₃ 的输入，E₂ 的输出则直接进入最后阶段。这允许在单层 MoE 内完成**多步推理**，表达能力强于传统加权求和，同等 FLOPs 下能取得更好性能。DAG-MoE 发表于 ICML 2026。
大模型/Transformer 架构详解.md
+425
View File
@@ -0,0 +1,425 @@
# Transformer 架构详解
> 2017 年，"Attention Is All You Need" 论文用自注意力取代了 RNN/LSTM，开启了现代大语言模型时代。
---
## 一、Transformer 之前：RNN 的困境
```
RNN 的处理方式（串行）：
Token₁ → Token₂ → Token₃ → ... → Tokenₙ
5ms 5ms 5ms 5ms = 5×n ms（无法并行）
Transformer 的处理方式（并行）：
Token₁ ↘
Token₂ → 所有 Token 同时互相"看到" → 并行计算
Token₃ ↗ ≈ 5ms（与 n 无关）
```
| 问题 | RNN/LSTM | Transformer |
|---|---|---|
| **并行性** | 串行，无法并行训练 | 完全并行，GPU 友好 |
| **长距离依赖** | 梯度消失/爆炸，远距离信息丢失 | 每个 Token 直接关注任意位置的 Token |
| **训练速度** | 慢（序列越长越慢） | 快得多 |
| **可解释性** | 难以解释隐藏状态 | 可直接可视化注意力权重 |
---
## 二、整体架构：编码器-解码器
原始 Transformer 用于机器翻译，包含编码器和解码器两部分。
```
┌─────────────────────────────────┐
│ 编码器（Encoder） │
│ ┌───────────────────────────┐ │
"我 爱 北京" → │ │ Encoder Block × 6 │ │
│ │ Self-Attn + FFN │ │
│ └───────────────────────────┘ │
└──────────────┬──────────────────┘
│ 编码后的表示（K, V）
▼
┌─────────────────────────────────┐
│ 解码器（Decoder） │
│ ┌───────────────────────────┐ │
│ │ Decoder Block × 6 │ │
│ │ ① Masked Self-Attn │ │ → "I love Beijing"
│ │ ② Cross-Attn (用 K,V) │ │
│ │ ③ FFN │ │
│ └───────────────────────────┘ │
└─────────────────────────────────┘
```
### 一个 Block 内部（原始设计）
```
输入 x
│
├──→ Multi-Head Self-Attention ──→ ⊕ ──→ LayerNorm ──→
│ ↑ ↑
│ 残差连接 x 输出
│
└──→ Feed-Forward Network ──→ ⊕ ──→ LayerNorm ──→ 输出
↑ ↑
残差连接 传给下一层
```
### 两种主流归一化位置
| 方式 | 归一化位置 | 代表模型 | 特点 |
|---|---|---|---|
| **Post-LN** | 残差之后 | 原始 Transformer | 训练不稳定，需要 warmup |
| **Pre-LN** | 子层之前 | GPT 系列、LLaMA | 训练更稳定，无需大量 warmup |
```
Post-LN：x + Attn(LayerNorm(x)) ← 原始论文
Pre-LN： x + Attn(LayerNorm(x)) 错 — 实际上是：
Pre-LN：LayerNorm(x + Attn(x)) 错 — Pre-LN 是：
Pre-LN 实际：x + Attn(LayerNorm(x)) — 等等，让我用图表示清楚：
Post-LN： x → SubLayer → Norm → + → 输出
Pre-LN： x → Norm → SubLayer → + → 输出
```
> Pre-LN 先将输入归一化再送入子层，然后做残差。GPT/LLaMA 全系使用 Pre-LN（或 RMSNorm + Pre-LN 变体）。
---
## 三、自注意力机制：完整推演
### 3.1 从"查字典"理解 Q/K/V
| 投影 | 类比 | 数学 | 含义 |
|---|---|---|---|
| **Q（Query）** | 你的搜索关键词 | `X · W_Q` | "我在找什么信息？" |
| **K（Key）** | 所有条目的索引 | `X · W_K` | "每个词身上有什么标签？" |
| **V（Value）** | 条目的实际内容 | `X · W_V` | "每个词的实际信息是什么？" |
### 3.2 逐步计算示例
假设输入句子 "我 爱 NLP"，模型维度 d=4，头维度 d_k=2：
**Step 1 — 输入嵌入**
```
我: [0.1, 0.3, 0.5, 0.2]
爱: [0.4, 0.1, 0.3, 0.6]
NLP: [0.2, 0.5, 0.1, 0.3]
```
**Step 2 — 计算 K 和 Q（只演示一个头的投影）**
```
K = X · W_K （3×4）×（4×2） = 3×2 矩阵
K_我 = [0.8, 0.2]
K_爱 = [0.3, 0.9]
K_NLP = [0.5, 0.4]
Q_爱 = [0.6, 0.3] （"爱"这个位置的 Query）
```
**Step 3 — 计算注意力分数（Q_爱 × K^T）**
```
Q_爱 · K_我 = 0.6×0.8 + 0.3×0.2 = 0.48 + 0.06 = 0.54
Q_爱 · K_爱 = 0.6×0.3 + 0.3×0.9 = 0.18 + 0.27 = 0.45
Q_爱 · K_NLP = 0.6×0.5 + 0.3×0.4 = 0.30 + 0.12 = 0.42
scores = [0.54, 0.45, 0.42]
```
**Step 4 — 缩放 + Softmax**
```
scaled = scores / √2 = [0.38, 0.32, 0.30]
weights = softmax(scaled) = [0.35, 0.33, 0.32]
```
**Step 5 — 加权求和 V**
```
V_我 = [0.7, 0.1]
V_爱 = [0.2, 0.8]
V_NLP = [0.4, 0.5]
output_爱 = 0.35×[0.7,0.1] + 0.33×[0.2,0.8] + 0.32×[0.4,0.5]
= [0.245, 0.035] + [0.066, 0.264] + [0.128, 0.160]
= [0.439, 0.459]
```
> 位置"爱"的输出融合了"我"(35%)、"NLP"(32%)和自身(33%)的信息——这正是"理解上下文"的本质。
### 3.3 矩阵形式（实际实现）
$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V$$
- **QK^T**：N×N 的注意力矩阵，每对 Token 一个分数
- **÷ √d_k**：缩放因子。d_k 越大点积值越大 → softmax 趋向 one-hot → 梯度消失。除以 √d_k 保持方差 ≈ 1
- **Softmax**：沿最后维（Key 维度）归一化，每行和为 1
- **× V**：用注意力权重对 Value 加权求和
---
## 四、多头注意力：并行多个"视角"
### 4.1 为什么需要多头？
```
单头可能只学到一种注意力模式：
"我" → 关注了 "爱"
"爱" → 关注了 "北京"
所有头都只关注相邻词 ← 浪费了注意力的表达能力
多头允许并行学习多种模式：
头 1：语法结构（主语→谓语）
头 2：长距离共指（"它"→ 前文的"北京"）
头 3：语义关联（"医生"→ "医院"→ "病人"）
头 4：位置模式（局部上下文窗口）
```
### 4.2 数学公式
$$\text{head}_i = \text{Attention}(Q W_i^Q, K W_i^K, V W_i^V)$$
$$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, ..., \text{head}_h) W^O$$
每个头有自己独立的投影矩阵 W_Q、W_K、W_V，维度为 d_model × d_k（其中 d_k = d_model / h）。
### 4.3 计算量并不是 h 倍！
| | 单头 (d_model=512) | 8头 (每头 d_k=64) |
|---|---|---|
| Q投影参数 | 512×512 = 262K | 8×512×64 = 262K |
| K投影参数 | 同上 | 同上 |
| V投影参数 | 同上 | 同上 |
| 总参数 | ≈ 786K | ≈ 786K + W_O(512×512) ≈ 1M |
> 计算量大致相同，只是**把工作分给多个头并行做**，每个头在更小的空间（d_k）中关注不同的模式。
### 4.4 生产实践中的头数配置
| 模型 | d_model | 头数 | d_k |
|---|---|---|---|
| 原始 Transformer | 512 | 8 | 64 |
| GPT-3 | 12288 | 96 | 128 |
| LLaMA 70B | 8192 | 64 | 128 |
| DeepSeek-V3 | — | — | 使用 MLA 替代标准多头 |
---
## 五、位置编码：告诉模型"顺序"
注意力机制本身是**置换不变**的——打乱输入顺序，注意力分数矩阵只是行列交换，输出值不变。所以必须显式注入位置信息。
### 方案对比
| 方案 | 原理 | 优点 | 缺点 | 代表模型 |
|---|---|---|---|---|
| **Sinusoidal（正弦）** | 不同频率的正弦/余弦波叠加 | 可外推、无参 | 固定模式 | 原始 Transformer |
| **Learned** | 可学习的 pos_embed 表 | 灵活 | 不能超出训练长度 | BERT、ViT |
| **RoPE（旋转位置编码）** | 用旋转矩阵编码相对位置 | 天然编码相对位置、可外推 | 长序列扩展需技巧 | LLaMA、Qwen、DeepSeek |
| **ALiBi** | 给注意力分数加线性偏置 | 简单、外推最强 | 表达能力有限 | BLOOM |
### RoPE 核心思想
> **不是往 embedding 里加位置向量，而是把 Q 和 K "旋转"一个角度，角度大小取决于位置。**
```
位置 m 的 Q：旋转 m×θ
位置 n 的 K：旋转 n×θ
Q·K = (rotated_Q_m)·(rotated_K_n) = 关于 (m-n) 的函数
↑
只依赖相对位置！
```
RoPE 扩展：
- **NTK-aware scaling**：调高基频（如 10000→500000），让旋转更慢，支持更长上下文
- **YaRN**：NTK + 额外微调，将 Llama 从 4K 扩展到 128K
---
## 六、三种架构变体：选哪种？
### 6.1 编码器-only（如 BERT）
```
输入："我 [MASK] 北京" → 编码器 → 每个位置的上下文表示 → 预测 [MASK] = "爱"
特点：
- 双向注意力（能看到整个句子）
- 适合：分类、实体识别、语义搜索
- 不能做生成（没有解码器）
```
### 6.2 解码器-only（如 GPT、LLaMA、DeepSeek V4）
```
输入："今天天气" → 因果注意力（只看左边）→ 预测下一个 Token "真"
"今天天气真" → ... → 预测 "好"
特点：
- 因果掩码（Causal Mask）：每个 Token 只能看自己和左边
- 适合：对话、代码生成、创意写作
- 自回归生成，输入=输出（训练时位移一位即可）
- 现代 LLM 几乎全部使用此方案
```
**因果掩码示意**：
```
注意力分数矩阵（× = 被 mask 为 -∞）：
我 爱 北京 天安门
我 ✓ × × × ← "我"只能看到自己
爱 ✓ ✓ × × ← "爱"能看到"我"和自己
北京 ✓ ✓ ✓ × ← ...
天安门✓ ✓ ✓ ✓
```
### 6.3 编码器-解码器（如 T5）
```
编码器（双向）：处理源语言 → 生成 K、V
解码器（因果 + 交叉注意力）：用 K、V 辅助生成目标语言
交叉注意力（Cross-Attention）：
解码器的 Q ← 来自解码器自身（"这句话接下来该说什么？"）
解码器的 K,V ← 来自编码器（"原文说了什么？"）
```
| 架构 | 自注意力方式 | 能否生成 | 代表 | 适合任务 |
|---|---|---|---|---|
| 编码器-only | 双向 | ❌ | BERT | 理解/分类 |
| 解码器-only | 因果（单向） | ✅ | GPT, LLaMA | 生成/对话 |
| 编码器-解码器 | 双向 + 交叉 | ✅ | T5, BART | 翻译/摘要 |
---
## 七、训练与推理
### 7.1 训练：Teacher Forcing
```
输入： "今天 天气 真" 目标： "天气 真 好"
↑
模型被训练来预测每个位置的下一个 Token
实际一次性计算：
输入 [今天, 天气, 真]
→ 因果掩码确保"今天"看不到后面
→ 输出 [P(天气), P(真), P(好)]
→ Loss = CrossEntropy(预测, 实际目标)
```
> 训练时**一次前向**算出所有位置的预测，因为目标已知、且有因果掩码保护。
### 7.2 推理：自回归生成
```
训练时可以并行（目标已知），推理必须串行（目标未知）：
Step 1: "今天" → 预测 "天气"
Step 2: "今天天气" → 预测 "真"
Step 3: "今天天气真" → 预测 "好"
Step 4: "今天天气真好" → 预测 <eos>
每次都要重新计算全序列？→ 不，用 KV Cache！
```
### 7.3 KV Cache：推理加速的关键
```
未使用 KV Cache：
Step 1：计算 "今天" 的 Q、K、V ──────────── 1个Token
Step 2：计算 "今天天气" 的 Q、K、V ──────── 2个Token ← 重新算了"今天"！
Step 3：计算 "今天天气真" 的 Q、K、V ────── 3个Token ← 又重算了！
...
使用 KV Cache：
Step 1：计算 "今天" → 缓存 K₁、V₁
Step 2：只算 "天气" 的 Q、K、V + 用缓存的 K₁、V₁ → 缓存 K₁K₂、V₁V₂
Step 3：只算 "真" 的 Q、K、V + 用缓存的 K₁K₂、V₁V₂ → ...
...
每个 Step 只算 1 个新 Token！开销从 O(n²) 降到 O(n)（单步）。
```
> KV Cache 的代价：显存占用随序列长度线性增长。MLA（多头潜在注意力）通过低秩压缩解决此问题——详见 [[MoE 混合专家架构#MLA（Multi-head Latent Attention，多头潜在注意力）|MLA 详解]]。
---
## 八、高效注意力变体
标准自注意力是 **O(n²)** 复杂度（n = 序列长度）。对长序列需优化：
### 8.1 FlashAttention（事实标准）
> **IO 感知的精确注意力算法**——数学结果完全等价于标准注意力，但通过算子融合大幅减少显存读写。
```
标准计算： FlashAttention：
QK^T → 写回 HBM 将 Q、K、V 分块（tile）
Softmax → 写回 HBM 每个块在 SRAM 中完成全部计算
乘 V → 写回 HBM 只有最终结果写回 HBM
↑ 3次 HBM 读写 ↑ 约 1/n 的 HBM 读写
```
实测效果：相比朴素实现，吞吐量提升 **~32%**（A100），现为 PyTorch 2.0+ 默认后端。
### 8.2 稀疏/线性注意力（长序列场景）
| 方案 | 策略 | 复杂度 | 代表 |
|---|---|---|---|
| **Longformer** | 局部滑动窗口 + 全局 Token | O(n) | 文档级 NLP |
| **BigBird** | 局部 + 全局 + 随机 | O(n) | — |
| **Performer** | 随机特征近似 softmax | O(n) | — |
| **Mamba/SSM** | 状态空间模型替代注意力 | O(n) | 超长序列 |
> 经验法则：序列 < 4K Token → 标准注意力 + FlashAttention 即可。长文档/代码库场景才需稀疏注意力或 SSM。
---
## 九、现代生产优化总览
| 优化手段 | 效果 | 代价 |
|---|---|---|
| **混合精度（bf16/fp16）** | 训练/推理速度翻倍 | 质量损失可忽略 |
| **梯度检查点** | 显存降低 50%+ | 训练慢 20% |
| **FlashAttention** | 推理加速 ~30%，显存降低 | 无（数学等价） |
| **算子融合（RMSNorm, xFormers）** | 减少 kernel launch 开销 | 无 |
| **序列分桶** | 减少 padding 浪费 | 实现复杂度增加 |
| **量化（INT8/INT4）** | 显存降低 4-8× | 轻微质量下降 |
---
## 十、总结
```
Transformer 的核心思想就三条：
1. 自注意力（Self-Attention）
Q·K 算关联 → Softmax 归一化 → ×V 合成上下文
每个 Token 直接"看到"所有 Token
2. 多头（Multi-Head）
并行跑多个注意力，每个头学不同的关系模式
总计算量不变，表达能力翻倍
3. 位置编码（Positional Encoding）
注意力不感知顺序 → 注入位置信息
RoPE 是当前主流：Q/K 旋转角度 = 位置函数
Transformer 不只是一篇论文——
它是整个现代大语言模型时代的起点。
```
---
## 相关链接
- [[大模型架构基础]] — 大模型的各组件总览
- [[FFN 前馈网络详解]] — Transformer 中参数量最大的组件
- [[MoE 混合专家架构]] — 如何用稀疏专家替代 FFN
- [[多模态大模型]] — Transformer 如何扩展到图像/音频
- [[DeepSeek V4 系列]] — Transformer + MoE + MLA 的实际应用
---
*最后更新：2026-08-05*
大模型/多模态大模型.md
+140
View File
@@ -0,0 +1,140 @@
# 多模态大模型（Multimodal LLM, MLLM）
## 什么是多模态？
**模态（Modality）** = 数据的感知/表达形式。人类通过多种模态理解世界：
| 模态 | 示例 |
|---|---|
| **文本** | 文章、代码、对话 |
| **图像** | 照片、图表、截图 |
| **音频** | 语音、音乐、环境声 |
| **视频** | 连续图像帧 + 音频 |
**多模态大模型** = 能同时理解和处理**多种模态数据**的 AI 模型，而非仅限于文本。
---
## 为什么需要多模态？
> 纯文本模型只能"读文字"，无法"看图片"、"听声音"。
现实世界的信息天然是多模态的：
- 医生既要看病历（文本），也要看 CT 片（图像）
- 自动驾驶需要同时处理摄像头（图像）、雷达（点云）、地图（结构化数据）
- 社交媒体帖子包含文字 + 图片 + 视频
---
## 基本架构（三大组件）
```
┌─────────────────────┐
│ 视觉编码器 │ ← 处理图像/视频输入
│ Vision Encoder │ (如 ViT、SigLIP)
└────────┬────────────┘
│ 视觉特征
▼
┌─────────────────────┐
│ 投影器/连接器 │ ← 将视觉特征映射到语言空间
│ Projector │ (如 MLP、Q-Former)
└────────┬────────────┘
│ 对齐后的 token
▼
┌─────────────────────┐
│ 大语言模型 │ ← 核心推理引擎
│ LLM Backbone │ (如 DeepSeek、LLaMA、Qwen)
└─────────────────────┘
```
### 工作流程
1. 图像 → 视觉编码器 → 视觉特征向量
2. 视觉特征 → 投影器 → 对齐到语言模型的 token 空间
3. 文本 token + 视觉 token → LLM → 生成回复
---
## 核心能力
| 能力 | 说明 | 示例 |
|---|---|---|
| **视觉问答（VQA）** | 根据图片回答问题 | "这张图里有几只猫？" |
| **图像描述** | 自动生成图片文字描述 | 为盲人描述照片内容 |
| **多模态对话** | 图文混合交互 | "分析这张财报图表" |
| **OCR 理解** | 理解图片中的文字 | 识别截图、海报、PDF |
| **视觉推理** | 多步骤逻辑推理 | "如果把这个方块旋转90°会怎样？" |
---
## 主流多模态模型（2025-2026）
| 模型 | 开发商 | 特点 |
|---|---|---|
| **GPT-4V / GPT-4o** | OpenAI | 原生多模态，实时语音+视觉 |
| **Gemini 系列** | Google | 原生多模态，Ultra/Pro/Flash/Nano 全系覆盖 |
| **Claude 系列** | Anthropic | 强大的图像理解、图表分析能力 |
| **Qwen-VL 系列** | 阿里通义 | 开源，中英双语 |
| **InternVL 系列** | 上海 AI 实验室 | 开源，CVPR 2025 发表 Mono-InternVL |
| **DeepSeek-VL** | DeepSeek | 注意：V4 系列目前 **仅文本**，视觉版待发布 |
| **LLaVA 系列** | 学术界 | 开源先驱，推动 MLLM 研究方向 |
---
## 2025 年前沿方向
### 1. 高效/轻量化 MLLM
- 视觉 Token 压缩（降低 Transformer 二次复杂度）
- MoE 架构（如 MoE-LLaVA）
- 边缘设备部署（MobileVLM、TinyLLaVA、Gemini Nano）
### 2. 单体式 MLLM（Monolithic MLLM）
- **Mono-InternVL**（CVPR 2025）：将视觉编码直接集成到 LLM 内部
- 减少 67% 首 Token 延迟，解决灾难性遗忘
### 3. 长链视觉推理
- **Insight-V**：多智能体系统（推理 agent + 总结 agent）
- 跨 7 个基准平均提升 7.5%
### 4. 统一多模态表征
- **UnifiedMLLM**：单一模型处理多种多模态任务
---
## 主要挑战
1. **长序列效率**：一张图 = 数百到数千个 token，多图/视频成本极高
2. **幻觉问题**：模型可能"看到"不存在的物体
3. **计算成本**：训练和推理资源消耗远超纯文本模型
4. **评估困难**：多模态基准测试尚不成熟
5. **安全对齐**：视觉输入可能绕过文本安全过滤器
---
## 与纯文本模型对比
| 维度 | 纯文本 LLM | 多模态 MLLM |
|---|---|---|
| 输入 | 仅文本 | 文本 + 图像 + 音频 + 视频 |
| 参数量 | 较小（相对） | 需额外的视觉编码器参数 |
| 推理成本 | 较低 | 较高（视觉 token 开销大） |
| 应用范围 | 对话、写作、编程 | 医疗影像、自动驾驶、设计 |
| 成熟度 | 较高 | 快速发展中 |
---
## 总结
多模态是 AI 走向通用人工智能（AGI）的关键一步。当前的 V4 Pro/Flash 等纯文本模型虽强，但"看不到世界"仍是巨大局限。理解多模态架构和原理，是理解下一代 AI 的必要基础。
---
## 相关链接
- [[Transformer 架构详解]]
- [[DeepSeek V4 系列]]
- [[大模型架构基础]]
---
*最后更新：2026-08-05*
大模型/大模型架构基础.md
+248
View File
@@ -0,0 +1,248 @@
# 大模型架构基础
> 理解现代大语言模型的底层架构 — Transformer、注意力机制与关键组件
---
## 发展脉络
```
2017 Transformer 论文
│ "Attention Is All You Need"
▼
2018 GPT-1 / BERT
│ 解码器-only / 编码器-only
▼
2020 GPT-3（175B）— Scaling Law 确立
▼
2022 ChatGPT / GPT-3.5 — RLHF 对齐
▼
2023 GPT-4 / LLaMA / Claude 2
│ 多模态、MoE 兴起
▼
2024 LLaMA 3 / Qwen 2.5 / DeepSeek-V3
▼
2025 GPT-5 / Claude Opus 5 / DeepSeek-V4
大规模 MoE、混合注意力、推理时扩展
```
---
## 一、Transformer 架构
现代大语言模型的基石，发表于 2017 年。核心思想：用**自注意力机制**取代循环/卷积，实现并行计算。深度讲解见 [[Transformer 架构详解]]。
### 架构总览
```
┌──────────────┐
输入文本 → │ Embedding │ → Token 向量
└──────┬───────┘
▼
┌─────────────────────────────┐
│ Transformer Block × N │ ← 重复 N 层（数十到数百层）
│ ┌───────────────────────┐ │
│ │ Multi-Head Attention │ │ ← 核心：自注意力
│ │ + Layer Norm + 残差 │ │
│ ├───────────────────────┤ │
│ │ Feed-Forward (FFN) │ │ ← 逐位置的全连接网络
│ │ + Layer Norm + 残差 │ │
│ └───────────────────────┘ │
└─────────────┬───────────────┘
▼
┌──────────────┐
│ 输出头 │ → 预测下一个 Token
└──────────────┘
```
### 三种变体
| 类型 | 代表模型 | 特点 |
|---|---|---|
| **编码器-only** | BERT、RoBERTa | 双向注意力，适合理解任务（分类、NER） |
| **解码器-only** | GPT 系列、LLaMA、DeepSeek | 因果注意力（只看左边），适合生成任务 |
| **编码器-解码器** | T5、BART | 融合两者，适合翻译、摘要 |
> 现代大语言模型**几乎全部使用解码器-only**（自回归生成）。
---
## 二、自注意力机制（Self-Attention）
### 直观理解
> 让每个词"看到"句子中所有其他词，并决定应该关注哪些。
```
"我 爱 北京 天安门"
│ │ │ │
└─────┼──────┼───────┘
│ │
每个词都和所有词计算关联度（注意力权重）
```
### 数学过程
对每个输入的 Token 向量，计算三个投影：
| | 符号 | 含义 |
|---|---|---|
| **Q（Query）** | 查询 | "我在找什么？" |
| **K（Key）** | 键 | "我有什么？" |
| **V（Value）** | 值 | "我的实际内容" |
$$
\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V
$$
步骤：
1. **Q × K^T** → 计算每对 token 之间的关联分数（注意力矩阵）
2. **÷ √d_k** → 缩放，防止梯度消失
3. **Softmax** → 归一化为概率分布
4. **× V** → 用注意力权重加权求和，得到输出
### 多头注意力（Multi-Head Attention）
> 不是做一次注意力，而是并行做多次（如 8/16/32 个头），每个头关注不同的语义模式。
- 头 1 可能关注"语法结构"
- 头 2 可能关注"实体关系"
- 头 3 可能关注"长距离依赖"
---
## 三、关键组件
### 1. Token 与 Tokenizer
| 概念 | 说明 |
|---|---|
| **Token** | 文本被拆分的最小语义单元 |
| **Tokenizer** | 将文本切分为 Token 的工具（BPE、SentencePiece 等） |
| **词表大小** | 通常 32K ~ 256K，DeepSeek V4 使用了更大词表 |
```
"Hello, world!" → ["Hello", ",", " world", "!"]
"你好世界" → ["你好", "世界"]
```
### 2. 位置编码（Positional Encoding）
Transformer 本身**不感知顺序**，需要额外注入位置信息：
| 类型 | 说明 | 代表 |
|---|---|---|
| **绝对位置编码** | 每个位置有唯一的向量 | 原始 Transformer 的正弦编码 |
| **相对位置编码** | 编码 token 之间的相对距离 | T5 的相对偏置 |
| **旋转位置编码（RoPE）** | 对 Q/K 做旋转，编码相对位置 | LLaMA、DeepSeek、Qwen 主流方案 |
### 3. 前馈网络（Feed-Forward Network, FFN）
```
FFN(x) = Act(W₂ · Act(W₁ · x + b₁) + b₂)
```
- 两层全连接，中间有激活函数（GELU/SwiGLU）
- 参数量占比最大（约 2/3）
- SwiGLU 是现代模型的首选激活函数
- 深度讲解见 [[FFN 前馈网络详解]]
### 4. 残差连接（Residual Connection）
```
输出 = LayerNorm(x + SubLayer(x))
```
- 缓解深层网络的梯度消失
- 让模型可以"跳过"不必要的变化
- GPT 使用 Pre-LN（层归一化在子层之前）
### 5. 层归一化（Layer Normalization）
- 对每个样本的特征维度做归一化
- 稳定训练、加速收敛
- 现代主流：**RMSNorm**（去掉均值中心化，更快更简单）
---
## 四、训练范式
```
┌──────────────┐
│ 1. 预训练 │ 海量互联网文本，无监督学习（预测下一个 Token）
│ Pretraining │ 数十 TB 数据，数万 GPU，数周到数月
└──────┬───────┘
▼
┌──────────────┐
│ 2. 监督微调 │ 高质量人工标注的指令-回复对
│ SFT │ 让模型学会"对话格式"和"遵循指令"
└──────┬───────┘
▼
┌──────────────┐
│ 3. 对齐训练 │ RLHF / DPO / RLVR
│ Alignment │ 让模型输出更安全、更有用、更符合人类偏好
└──────────────┘
```
### 关键概念
| 概念 | 说明 |
|---|---|
| **Scaling Law** | 模型性能随参数量、数据量、计算量幂律增长 |
| **涌现能力** | 大模型独有的、小模型没有的能力（如思维链推理） |
| **RLHF** | 基于人类反馈的强化学习 — 训练奖励模型指导策略优化 |
| **DPO** | 直接偏好优化 — 更简单地对齐方法，不需要单独的奖励模型 |
---
## 五、推理时技术
### 自回归生成（Autoregressive Generation）
```
输入："今天天气" → 预测下一个 Token "真"
"今天天气真" → 预测下一个 Token "好"
"今天天气真好" → 预测下一个 Token "<eos>"（停止）
```
每次生成一个 Token，直到输出结束符或达到最大长度。
### 关键概念
| 概念 | 说明 |
|---|---|
| **Temperature** | 控制随机性，越高越随机（创造性高），越低越确定 |
| **Top-p（核采样）** | 只从累积概率 ≥ p 的最少 Token 集合中采样 |
| **Top-k** | 只从概率最高的 k 个 Token 中采样 |
| **KV Cache** | 缓存已生成 Token 的 Key/Value，避免重复计算，加速推理 |
| **上下文窗口** | 模型能同时"看到"的最大 Token 数（现在主流 128K~1M） |
---
## 六、当前主流架构扩展
### MoE（混合专家）
> 详见 [[MoE 混合专家架构]]
- 不是所有参数都参与每次推理
- 每个 Token 只路由到少数"专家"子网络
- 总参数极大但计算量可控
### 多模态扩展
> 见 [[多模态大模型]]
- 在 LLM 基础上添加视觉/音频编码器
- 通过投影器对齐不同模态的 Token
---
## 扩展阅读
- 原始论文：[Attention Is All You Need (2017)](https://arxiv.org/abs/1706.03762)
- [The Illustrated Transformer](https://jalammar.github.io/illustrated-transformer/) — 图文详解 Transformer
---
*最后更新：2026-08-05*