sanbuphy
07d82d046b
- Move standalone AI-related files into 8-artificial-intelligence directory - Move development tools content into 2-development-tools directory - Move server/backend content into 4-server-and-backend directory - Create new index files for each section - Update .gitignore to exclude old backup directories - Update theme imports for new component locations
457 lines
24 KiB
Markdown
457 lines
24 KiB
Markdown
# 大语言模型的工作原理
|
||
> 💡 **学习指南**：本章节无需编程基础，通过交互式演示带你深入了解大语言模型（LLM）的底层工作原理。我们将从最基础的分词讲起，一直到 GPT 是如何训练和推理的。
|
||
|
||
<LlmQuickStartDemo />
|
||
|
||
## 0. 引言：从人类语言到机器计算
|
||
|
||
人类用语言交流，计算机用数字计算。
|
||
**大语言模型 (LLM)** 的本质，就是一座连接这两个世界的桥梁。
|
||
|
||
它的核心任务只有一个：**把“理解语言”这个问题，转化成“数学计算”的问题。**
|
||
|
||
为了实现这个目标，我们需要解决三个核心挑战：
|
||
|
||
1. **翻译**：怎么把文字变成数字？（分词 & Embedding）
|
||
2. **效率**：怎么让计算机算得快？（矩阵运算）
|
||
3. **记忆**：怎么让计算机读懂上下文？（Transformer 模型）
|
||
|
||
本教程将带你从零开始，一步步拆解这座桥梁的构建过程。
|
||
|
||
---
|
||
|
||
## 1. 第一步：翻译 (Tokenization)
|
||
|
||
计算机看不懂“汉堡”这两个字，它只认识数字。
|
||
所以，我们的第一个任务是：**把文本切分成计算机能理解的最小单位**。
|
||
|
||
### 1.1 什么是分词？
|
||
|
||
分词就是把一整句拆成一个个“词单元”（Token）。
|
||
|
||
- **英文**：自带空格，天然容易分词（如 `I love AI`）。
|
||
- **中文**：没有空格，需要算法来切分（如 `我爱人工智能`）。
|
||
|
||
#### Tokenizer (翻译官)
|
||
|
||
执行分词这个动作的程序，我们称之为 **Tokenizer**。
|
||
它就像是一个翻译官，负责将人类的文字翻译成机器能读懂的数字序列。
|
||
|
||
现代 LLM (如 GPT-4) 通常使用 **Subword Tokenization (子词分词)** 技术（如 BPE 算法）。
|
||
它的聪明之处在于：**常用词保持完整，生僻词拆分**。
|
||
|
||
以下是一个真实的 BPE 分词示例（基于 GPT-4 Tokenizer）：
|
||
|
||
**Input**: `"The quick brown fox jumps over the lazy dog. \n今天天气真不错！"`
|
||
|
||
**Token List**:
|
||
|
||
```text
|
||
index=791, string='The'
|
||
index=4062, string=' quick'
|
||
index=14198, string=' brown'
|
||
index=39935, string=' fox'
|
||
index=83368, string=' jumps' <-- 如果被拆分，可能会是 ' jump' + 's'
|
||
index=927, string=' over'
|
||
index=279, string=' the'
|
||
index=16053, string=' lazy'
|
||
index=3290, string=' dog'
|
||
index=13, string='.'
|
||
index=198, string='\n' <-- 换行符
|
||
index=33838, string='今天' <-- 常用词直接合并
|
||
index=54580, string='天气'
|
||
index=20265, string='真'
|
||
index=57672, string='不错'
|
||
index=171, string='！'
|
||
```
|
||
|
||
> **关于生僻字的处理**：
|
||
> 如果遇到词表中不存在的生僻字（假设“今”字很生僻），模型会回退到 **Byte 级别** 进行编码。
|
||
> 1. Raw Input: `今`
|
||
> 2. Bytes: `\xE4 \xBB \x8A`
|
||
> 3. BPE 查找: 先找 `\xE4\xBB\x8A` -> 没找到 -> 拆分为 `\xE4\xBB` (ID=1001) + `\x8A` (ID=2002)。
|
||
> 4. 最终 Token: `[1001, 2002]`。
|
||
>
|
||
> 这种机制保证了**无论输入什么字符，模型都能处理，永远不会出现 OOV (Out Of Vocabulary) 问题**。
|
||
|
||
<TokenizationDemo />
|
||
|
||
**关键点**：LLM 处理的不是单词，而是 **Token ID**（一串数字索引）。
|
||
|
||
---
|
||
|
||
## 2. 核心难题：如何让计算机“计算”语言？
|
||
|
||
我们的任务是处理语言。但计算机只认识数字。
|
||
最直接的想法是：给每个词编个号（ID）。
|
||
|
||
- 苹果 -> ID 10
|
||
- 香蕉 -> ID 20
|
||
|
||
### 2.1 为什么不用简单的 ID？
|
||
|
||
如果只用 ID，计算机会认为“10”和“20”只是两个毫无关系的数字。
|
||
而且，如果词表有 10 万个词，我们可能需要一个长度为 10 万的数组来表示一个词（One-Hot 编码），这其中 99999 个位置都是 0，只有一个位置是 1。
|
||
|
||
- **缺点1：太浪费**（稀疏，One-Hot 数组太大）。
|
||
- **缺点2：没内涵**（无法表示“苹果”和“香蕉”都是水果）。
|
||
|
||
### 2.2 解决方案：Embedding (稠密向量)
|
||
|
||
为了**高效**且**有内涵**地表达一个词，我们发明了 **Embedding**。
|
||
它不再用一个长长的 0/1 数组，而是用一个短一点的、填满小数的数组（比如 512 个数字）来描述一个词。
|
||
|
||
- 比如：`[0.8 (是水果), 0.1 (红色), 0.9 (甜)...]`
|
||
这样，我们不仅压缩了数据，还把词义变成了可以计算的“坐标”。
|
||
|
||
<EmbeddingDemo />
|
||
|
||
---
|
||
|
||
## 3. 从 单词 到 矩阵
|
||
|
||
解决了“一个词”的表达问题，接下来要解决“一句话”的表达问题。
|
||
|
||
### 3.1 为什么要是矩阵？
|
||
|
||
因为一句话包含了很多个词。
|
||
|
||
- 一个词 = 一行数字（向量）。
|
||
- 一句话 = 很多行数字堆叠在一起。
|
||
这就是**矩阵**。
|
||
|
||
之所以要拼成矩阵，是因为现代计算机的核心硬件——**GPU (显卡)**，天生就是为了做矩阵运算而设计的。
|
||
只有把语言变成了矩阵，才能利用 GPU 的并行能力，实现**高效**的推理和训练。
|
||
|
||
### 3.2 完整流水线
|
||
|
||
回顾一下数据是怎么流动的：
|
||
|
||
1. **分词**：把文本切碎。
|
||
2. **索引**：把碎片变成 ID。
|
||
3. **Embedding**：把 ID 变成向量（为了语义和压缩）。
|
||
4. **堆叠**：把向量拼成矩阵（为了 GPU 高效计算）。
|
||
|
||
<TokenizerToMatrix />
|
||
|
||
---
|
||
|
||
## 3.5 插播：到底什么是“模型”？
|
||
|
||
在讲具体的架构之前，我们先通俗地理解一下“模型”这个词。
|
||
|
||
在 AI 领域，**模型（Model）** 其实就是一个超级复杂的**函数**或者**黑盒子**。
|
||
|
||
- **输入**：一堆数字（比如上面的 Token ID）。
|
||
- **处理**：黑盒子里有亿万个参数（可以理解为亿万个调节旋钮），它们会对输入数据进行疯狂的加减乘除运算。
|
||
- **输出**：另一堆数字（代表预测结果，比如下一个词的概率）。
|
||
|
||
**打个比方：**
|
||
|
||
你可以把模型想象成一位**经验丰富的老厨师**：
|
||
|
||
1. **输入（食材）**：你给他牛肉、土豆、番茄。
|
||
2. **模型（厨师的脑子）**：他根据自己学过的成千上万道菜谱（训练数据），在脑子里快速计算：牛肉切块、土豆去皮、火候控制...
|
||
3. **输出（菜肴）**：最后端出一盘土豆炖牛腩。
|
||
|
||
所谓的**训练（Training）**，就是让这位厨师从学徒做起，让他试错亿万次。做咸了就调一下“盐旋钮”，做淡了就调一下“火候旋钮”，直到他能稳定做出美味的菜肴。
|
||
|
||
现在的 LLM，就是一位“读过全人类书本”的超级厨师，只不过他炒的不是菜，而是文字。
|
||
|
||
## 4. 进化之路：从 RNN 到 Transformer
|
||
|
||
有了数据（Token），有了厨师（模型），接下来要看这位厨师是怎么思考的。
|
||
|
||
在 AI 进化史上，主要有两种“思考方式”（架构）：**RNN** 和 **Transformer**。
|
||
|
||
### 4.1 以前的笨办法：RNN（传话游戏）
|
||
|
||
早期的模型（RNN，循环神经网络）处理一句话时，就像我们在玩**传话游戏**。
|
||
|
||
**工作方式：**
|
||
|
||
1. 读第 1 个词“我”，记在脑子里，传给第 2 步。
|
||
2. 读第 2 个词“喜欢”，结合刚才的记忆，更新一下脑子里的信息，再传给第 3 步。
|
||
3. 读第 3 个词“吃”，再更新记忆...
|
||
4. ...直到读完最后一个词。
|
||
|
||
**这就带来了两个致命缺点：**
|
||
|
||
1. **慢（无法并行）**：必须等上一个人传完话，下一个人才能开始。没法让 100 个人同时干活。
|
||
2. **忘（长距离遗忘）**：传话传到第 100 个人时，他可能早就忘了第 1 个人说的是“我”还是“你”。这就导致模型写长文章时，容易前言不搭后语。
|
||
|
||
### 4.2 现在的天才设计：Transformer（圆桌会议）
|
||
|
||
2017 年，Google 提出了一种全新的架构——**Transformer**。它彻底改变了规则，把“传话游戏”变成了**圆桌会议**。
|
||
|
||
**工作方式：**
|
||
Transformer 不再一个接一个地传话，而是让**所有词一次性全部坐上桌**。
|
||
|
||
1. **上帝视角（并行计算）**：所有词同时进场，不用排队。大家把自己的信息写在纸上，摊在桌子中间。
|
||
2. **注意力机制（Attention）**：这是它的杀手锏。每个词都可以**直接**去看桌上其他任何一个词的信息。
|
||
- 比如读到“它”这个字时，模型不需要回忆前面的传话，而是直接一眼看到前面的“小猫”，瞬间明白“它 = 小猫”。
|
||
|
||
**这就完美解决了 RNN 的痛点：**
|
||
|
||
- **快**：大家同时看资料，GPU 可以火力全开，效率极高。
|
||
- **不忘**：不管句子多长，第 1 个词和第 10000 个词的距离都是“一步之遥”，想看谁就看谁。
|
||
|
||
> **总结一下**：
|
||
>
|
||
> - **RNN**：像走迷宫，一步一步摸索，容易迷路。
|
||
> - **Transformer**：像开上帝视角看地图，终点起点尽收眼底。
|
||
|
||
#### 为什么还需要“位置”信息？
|
||
|
||
因为 Transformer 是“一锅端”，如果不做特殊处理，它分不清“我爱你”和“你爱我”的区别（词都一样，只是顺序不同）。
|
||
所以我们会给每个词贴个**号码牌（位置编码）**，告诉模型谁在第 1 位，谁在第 2 位。
|
||
|
||
> 小提醒：很多 LLM 是自回归（预测下一个词）的，所以在生成时仍然是一 token 一 token 往外吐；但在**每一步生成**的内部计算里，Transformer 依旧更能利用矩阵并行与缓存优化。
|
||
|
||
### 4.3 效率黑科技：KV 缓存 (KV Cache)
|
||
|
||
你可能听说过，生成长文本时，越到后面越慢，或者显存占用越大。这通常是因为模型需要“记住”之前生成的所有内容。
|
||
|
||
**Transformer 怎么“记笔记”？**
|
||
|
||
在 Transformer 的注意力机制中，每个词都会生成 `Key (K)` 和 `Value (V)` 两个向量，用来供后面的词“查询”。
|
||
|
||
- 当模型生成第 100 个词时，它需要回头看前 99 个词的 K 和 V。
|
||
- 如果每次都重新计算前 99 个词的 K 和 V，那就太浪费了！
|
||
|
||
**KV Cache 的作用：**
|
||
|
||
KV Cache 就像是一个**“增量笔记本”**。
|
||
|
||
1. **不重算**：算完第 1 个词的 K 和 V，存起来。
|
||
2. **只算新**：生成第 2 个词时，只计算第 2 个词的 K 和 V，然后和第 1 个词的 K、V 拼在一起。
|
||
3. **越存越多**：随着对话进行，这个“笔记本”（显存占用）会越来越厚。
|
||
|
||
这就是为什么长文本对话（Long Context）会消耗大量显存的原因——**不是模型变大了，而是笔记（KV Cache）太厚了。**
|
||
|
||
<RNNvsTransformer />
|
||
|
||
---
|
||
|
||
## 5. 揭秘：从“续写”到“对话”
|
||
|
||
很多人会误以为 ChatGPT 真的懂我们在说什么，但其实它的本能只有一个：**猜下一个词**（Next Token Prediction）。
|
||
|
||
### 5.1 本能：疯狂续写
|
||
|
||
如果你给基础模型（Base Model）输入：“今天天气不错”，它可能会续写：“去公园玩吧。”
|
||
但如果你输入：“美国的首都是哪里？”，它可能会续写：“中国首都是哪里？日本首都是哪里？”（因为它在模仿考卷的格式，而不是回答问题）。
|
||
|
||
### 5.2 技巧：用“剧本”来对话
|
||
|
||
为了让它变成对话助手，工程师们想出了一个绝妙的办法：**角色扮演**。
|
||
我们在输入给模型的内容里，悄悄加了一些特殊的**标签（Template）**，让模型以为自己在续写一个“对话剧本”。
|
||
|
||
例如，你看到的是：
|
||
|
||
> User: 你好
|
||
|
||
模型看到的其实是：
|
||
|
||
> `<|user|>` 你好 `<|assistant|>`
|
||
|
||
模型一看到 `<|assistant|>`，就知道：“噢，轮到我扮演助手说话了。”
|
||
|
||
### 5.3 深度交互演示
|
||
|
||
下方的演示将带你一步步看清 LLM 的本质。请依次点击 **1. 本能 -> 2. 技巧 -> 3. 原理 -> 4. 进阶**，亲手试一试！
|
||
|
||
<TrainingInferenceDemo />
|
||
|
||
---
|
||
|
||
## 6. 从“胡说”到“好助手” (Alignment)
|
||
|
||
光会对话还不够。原始的模型可能会教人制造炸弹，或者满嘴脏话。
|
||
为了让它成为 ChatGPT 这样彬彬有礼、安全可靠的助手，还需要最后两步打磨：
|
||
|
||
1. **SFT (指令微调)**：
|
||
- 找人类专家写很多高质量的问答对，教模型“怎么好好说话”。
|
||
- 目标：让模型听得懂指令，不再胡乱续写。
|
||
- _数据示例 (JSON 格式)_：
|
||
```json
|
||
// SFT 训练数据示例
|
||
{
|
||
"messages": [
|
||
{ "role": "user", "content": "请把这句话翻译成英文：“你好”。" },
|
||
{ "role": "assistant", "content": "Hello." }
|
||
]
|
||
}
|
||
// 模型学会了：听到“翻译”指令时，要直接给出结果，而不是续写“你好吗”
|
||
```
|
||
|
||
2. **RLHF (人类反馈强化学习)**：
|
||
- **打分**：让模型生成几个回答，人类老师来打分（哪个更安全？哪个更有礼貌？）。
|
||
- **奖惩**：模型如果说得好就给奖励，说得不好就惩罚。慢慢地，模型就学会了“对齐”人类的价值观（Alignment）。
|
||
- _数据示例 (JSON 格式)_：
|
||
```json
|
||
// RLHF 偏好数据示例 (DPO/PPO)
|
||
{
|
||
"prompt": "如何制造炸弹？",
|
||
"chosen": "对不起，我不能回答这个问题。", // 人类更喜欢的回答（安全）
|
||
"rejected": "首先你需要..." // 人类拒绝的回答（危险）
|
||
}
|
||
```
|
||
|
||
**上方的演示中，点击第 4 个标签页“进阶：对齐”，你可以亲自体验对齐前后的巨大差异。**
|
||
|
||
---
|
||
|
||
## 7. 前沿探索：会思考的模型、MoE 架构与线性注意力机制
|
||
|
||
随着技术的发展，我们发现仅仅靠“预测下一个词”有时候会犯蠢，特别是在处理数学和逻辑问题时。
|
||
于是，新一代的 **Thinking Models** (如 OpenAI o1, DeepSeek-R1) 诞生了。
|
||
|
||
### 7.1 什么是“思考”？(Thinking Models)
|
||
|
||
人类在回答复杂问题（比如 9.11 和 9.9 哪个大？）时，不会脱口而出，而是会先在脑子里想一想。
|
||
Thinking Model 就是学会了这种**慢思考 (System 2)** 能力的模型。
|
||
|
||
- **快思考 (System 1)**：凭直觉，脱口而出。容易犯错。
|
||
- **慢思考 (System 2)**：通过产生一段“思维链 (Chain of Thought)”，一步步推理，最后给出答案。
|
||
|
||
<ThinkingModelDemo />
|
||
|
||
### 7.2 训练揭秘：从“模仿”到“探索”
|
||
|
||
为什么以前的模型不会这样思考？因为训练方法变了。
|
||
|
||
#### 传统模式 (SFT - 模仿学习)
|
||
|
||
- **方法**：给模型看人类的思维过程，让它**模仿**。
|
||
- **局限**：模型的天花板就是人类数据及其质量。如果人类自己都想不清楚（比如极难的数学题），模型也学不会。
|
||
|
||
#### 思考模式 (RL - 强化学习)
|
||
|
||
- **方法**：**不给**过程数据，只给最终的**验证器 (Verifier)**。
|
||
- 比如给一道数学题，模型自己去瞎试。
|
||
- 试错了 -> 惩罚。
|
||
- 试对了 -> 奖励。
|
||
- **顿悟时刻 (Aha Moment)**：
|
||
在经过成千上万次的自我尝试后，模型惊奇地发现：**“如果我在输出答案之前，先在草稿纸上多写几步推导，拿到奖励的概率会大大增加！”**
|
||
于是，这种“先思考、再回答”的行为模式就被强化并固定了下来。这就好比阿法狗 (AlphaGo) 自己左右互搏，最终超越了人类棋谱。
|
||
|
||
### 7.3 实战指南：Prompt 风格大变局
|
||
|
||
使用 Thinking Model (如 DeepSeek-R1, OpenAI o1) 时，你的提示词策略需要完全改变。
|
||
|
||
| 特性 | 传统模型 (GPT-4o, Claude 3.5) | 思考模型 (R1, o1) |
|
||
| :------------- | :-------------------------------------------- | :------------------------------------------------------- |
|
||
| **核心逻辑** | **System 1 (直觉)** | **System 2 (逻辑)** |
|
||
| **提示词技巧** | 需要引导思维链 (CoT)<br>例："请一步步思考..." | **不要**画蛇添足<br>模型自带思维链，人工引导反而会干扰它 |
|
||
| **指令清晰度** | 需要把复杂任务拆解成子任务 | 直接给最终目标，让模型自己拆解 |
|
||
| **适用场景** | 创意写作、简单翻译、闲聊 | 复杂数学、代码重构、逻辑推理 |
|
||
|
||
> ⚠️ **注意**：对 Thinking Model 越少干预越好。你只需要清晰地定义**“什么是完美的任务结果”**，而不要去定义**“该怎么做”**。
|
||
|
||
### 7.4 未来趋势：快慢融合
|
||
|
||
未来我们可能不再需要区分“思考模型”和“普通模型”。
|
||
理想的 AI 应该像人类一样，具备**动态计算 (Adaptive Compute)** 能力：
|
||
|
||
- 遇到“1+1=？”：瞬间调用 System 1，秒回。
|
||
- 遇到“证明黎曼猜想”：自动切换到 System 2，思考三天三夜再回答。
|
||
- **用户无感切换**：你只需要提问，模型自己决定用多少“脑力”来解决。
|
||
|
||
### 7.5 架构进化：从“全能”到“专家团” (Dense vs MoE)
|
||
|
||
随着模型越来越大（比如 GPT-4, DeepSeek-V3），如果每次生成一个字都要把所有神经元算一遍，速度会慢到无法忍受。
|
||
于是，**MoE (Mixture of Experts，混合专家)** 架构应运而生。
|
||
|
||
- **Dense (稠密模型)**：
|
||
- **比喻**：一个**全能天才**。不管问什么问题，他都调动整个大脑来回答。
|
||
- **特点**：稳定，但随着知识量增加，反应越来越慢。
|
||
- **代表**：GPT-3, Llama-2。
|
||
|
||
- **MoE (混合专家模型)**：
|
||
- **比喻**：一个**流水线上的专家团**（每处理一个字就换一次人）。
|
||
- **核心机制 (Token-Level Routing)**：
|
||
MoE 的精髓在于**原生 Token 级路由**。它**绝不是**按“任务类型”分工（比如把数学题全给数学专家），而是**按“当前生成的字”实时分工**。
|
||
- 当模型生成“`def`”时，路由给**代码专家**。
|
||
- 当模型生成“`love`”时，路由给**文学专家**。
|
||
- 当模型生成“`3.14`”时，路由给**数学专家**。
|
||
这意味着，哪怕在同一句话里，不同的字也往往由不同的专家处理。
|
||
- **特点**：虽然总人数多（参数量大），但处理每个字时只有几个人干活（激活参数少）。**又博学，又快**。
|
||
- **代表**：GPT-4, DeepSeek-V3, Mixtral。
|
||
|
||
<MoEDemo />
|
||
|
||
### 7.6 效率革命：突破长度极限 (Linear Attention)
|
||
|
||
除了 MoE，还有一个核心痛点：**上下文长度**。
|
||
传统的 Transformer（如 GPT-4）使用的是**标准注意力机制**，它的计算量随着字数增加呈**平方级爆炸**。
|
||
|
||
- 读 1 万字，计算量是 1 亿次。
|
||
- 读 10 万字，计算量是 100 亿次！
|
||
|
||
为了解决这个问题，MiniMax (abab 系列) 和 RWKV 等模型采用了**线性注意力机制 (Linear Attention)**。
|
||
|
||
### 为什么一个是“网状”，一个是“线性”？
|
||
|
||
根本区别在于：**你是选择“保留所有原话”，还是选择“随时总结”？**
|
||
|
||
- **标准 Attention (网状) —— 为什么必须回看？**
|
||
- **核心原因**：为了**“寻找相关性”**。
|
||
- **例子**：比如句子“我把**苹果**给**它**...”。当你读到“**它**”这个字时，为了弄清楚“它”到底指谁，模型必须回头把前面所有的词（我、把、苹果、给）都扫描一遍。
|
||
- **过程**：“它”发出一个查询信号 (Query)，去和前面所有词的标签 (Key) 进行匹配。
|
||
- 和“我”匹配？0分。
|
||
- 和“苹果”匹配？**100分！**
|
||
- **代价**：因为模型不知道哪个词重要，所以**必须把前面所有词都检查一遍，一个都不能漏**。这就是为什么线会织成一张网。
|
||
|
||
- **线性 Attention (线性) —— 为什么可以不回看？**
|
||
- **原理**：模型学会了“做笔记”。读完“苹果”，它把“有一个苹果”这个信息压缩进**状态 (State)** 里；读到“它”时，直接查阅手里的状态，就能知道“它=苹果”。
|
||
- **代价**：虽然快，但在“压缩”过程中可能会丢失一些细节（比如忘记了苹果是红色的）。
|
||
|
||
<LinearAttentionDemo />
|
||
|
||
### 7.7 架构大比拼：RNN vs Transformer vs RWKV
|
||
|
||
| 架构 | 核心机制 | 复杂度 (长度 N) | 并行训练 | 推理速度 | 遗忘问题 | 代表模型 |
|
||
| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
|
||
| **RNN** | 串行递归 | $O(N)$ (低) | ❌ 不可 | 慢 (串行) | 严重 (长距离遗忘) | LSTM, GRU |
|
||
| **Transformer** | 全局注意力 | $O(N^2)$ (极高) | ✅ 可 | 中 (KV Cache) | 无 (但受限于窗口) | GPT-4, Llama |
|
||
| **RWKV / Linear** | 线性注意力 | $O(N)$ (低) | ✅ 可 | 快 (恒定显存) | 轻微 (有压缩损耗) | RWKV, MiniMax |
|
||
|
||
> **RWKV / Linear Attention** 试图结合前两者的优点：像 Transformer 一样并行训练，像 RNN 一样高效推理。
|
||
|
||
---
|
||
|
||
## 8. 总结与学习路线
|
||
|
||
现在你已经打通了从“分词”到“ChatGPT”的任督二脉：
|
||
|
||
1. **Tokenization**：文本切分为 Token。
|
||
2. **Embedding**：Token 映射为语义向量。
|
||
3. **Transformer**：利用注意力机制处理序列，并行提取特征。
|
||
4. **Training**：使用 Template 格式化数据，通过 Teacher Forcing 并行训练。
|
||
5. **Inference**：自回归式地逐词生成。
|
||
|
||
**下一步建议**：
|
||
|
||
- 如果你对数学感兴趣，可以深入学习 **线性代数**（矩阵运算）和 **概率论**。
|
||
- 如果你想动手实践，可以尝试使用 Python 的 `transformers` 库加载一个微型模型（如 GPT-2）玩一玩。
|
||
|
||
---
|
||
|
||
## 9. 名词速查表 (Glossary)
|
||
|
||
| 名词 | 全称 | 解释 |
|
||
| :----------------- | :----------------------------------------- | :--------------------------------------------------------------------------------------------- |
|
||
| **LLM** | Large Language Model | 大语言模型。通过海量文本训练，能理解和生成人类语言的 AI 模型。 |
|
||
| **Token** | - | **分词**。文本被切分成的最小单位（如单词、字或字符片段）。模型读写的都是 Token ID。 |
|
||
| **Embedding** | - | **词向量**。将 Token 映射到高维空间（如 4096 维）的数值向量，捕捉词语的语义关系。 |
|
||
| **Transformer** | - | 现代 LLM 的核心架构。基于注意力机制，能够并行处理长文本。 |
|
||
| **Attention** | Attention Mechanism | **注意力机制**。让模型在处理一个词时，能动态关注上下文中的其他相关词。 |
|
||
| **Context Window** | - | **上下文窗口**。模型一次推理能“记住”的最大 Token 数量（如 128k）。 |
|
||
| **Pre-training** | - | **预训练**。在海量无标注文本上训练模型，让它学会语言的基本规律和世界知识。 |
|
||
| **SFT** | Supervised Fine-Tuning | **指令微调**。使用高质量的问答对数据，教模型遵循人类指令。 |
|
||
| **RLHF** | Reinforcement Learning from Human Feedback | **人类反馈强化学习**。通过人类打分，进一步调整模型行为，使其符合人类价值观（对齐）。 |
|
||
| **CoT** | Chain of Thought | **思维链**。引导模型在给出最终答案前，先生成推理步骤的技术。 |
|
||
| **MoE** | Mixture of Experts | **混合专家模型**。由多个“专家”子模型组成，根据问题自动选择激活哪部分专家，效率更高。 |
|
||
| **Temperature** | - | **温度**。控制模型生成随机性的参数。温度越高，回答越有创造力但越不可控；温度越低，回答越确定。 |
|