Token 深度解析

背景

很多刚开始接触大模型的朋友，经常会看到”消耗了 XXX tokens”、”超出 token 限制”这样的提示。但到底什么是 Token？为什么大模型要用 Token 而不是直接理解整段话？本文将深入浅出地解答这些问题。

---

一、Token 是什么？

Token 是大模型处理文本的最小单位。可以把它理解为文本世界的”乐高积木块”——模型不是逐字逐句读取，而是先把文本拆成一块块 Token，再逐块处理。

1.1 通俗理解

想象你在读一本书：

阅读方式	特点
字符级别	一个字母一个字母读 → 太慢，无法理解语义
单词级别	一个单词一个单词读 → 更合理，但词汇量太大
Token 级别	介于两者之间，灵活切分 → 效率与能力的平衡点

1.2 具体例子

英文句子 I love artificial intelligence：

按字符：20 个字符（含空格）
按单词：4 个单词
按 Token：约 5-6 个 Token（取决于分词器）

中文句子 我爱人工智能：

按字符：6 个汉字
按 Token：约 6-10 个 Token（每个汉字可能单独成 Token）

---

二、为什么使用 Token 而不是”理解整段话”？

这个问题触及了大模型的核心原理。答案很简单：计算机只能处理数字，不能直接理解文字。

2.1 大模型的工作流程

文字 → Token → 数字（向量）→ 计算 → 预测 → Token → 文字

每一步都必须是有限、可枚举的。

2.2 如果是”整段话处理”

假设模型要直接处理”整段话”，会遇到以下问题：

问题	说明
无限组合	一段话可能有任意长度、任意组合，无法穷举
无法对齐	“我爱AI”和”我 爱 AI”算同一段话吗？
无法计算	神经网络本质是矩阵乘法，需要固定维度的输入
存储爆炸	要存储所有可能的句子组合，内存直接撑爆

2.3 Token 方案的优势

优势	说明
有限词汇表	常用 Token 约 5-10 万个，可以穷举并编号
可数学化	每个 Token 对应一个向量（如 4096 维），可以计算
灵活组合	像乐高一样，有限积木块能拼出无限造型
长短皆可	Token 序列可以处理任意长度的文本

2.4 语言的组合性原理

语言有一个核心特点：有限符号，无限组合。

英语：26 个字母 → 无数句子
中文：几千常用字 → 无数句子
Token：几万个 Token → 无数句子

大模型的设计正是利用了这个特性：

如果 Token 只有 5 万个，但能组合出无限句子，那么模型只需要学会这 5 万个 Token 的”表示”和”关系”，就能理解所有可能的句子。

这比试图记忆所有可能的句子要高效得多。

---

三、Token 的产生背景与历史

3.1 为什么不按”单词”处理？

早期自然语言处理确实尝试过按单词处理，但遇到两个问题：

问题一：词汇量爆炸

英语有超过 100 万个单词，而且每天都在增加新词。要让模型记住所有单词，词汇表会无限膨胀。

问题二：罕见词无法处理

遇到没见过的单词（如 unprecedented），模型直接”不认识”。

3.2 子词分词的诞生

研究者提出子词分词的概念：

常见词 → 整体作为一个 Token
罕见词 → 拆成多个子词 Token

例如：

单词类型	处理方式	例子
常见词	整体作为一个 Token	the, is, hello, love
罕见词	拆成多个 Token	unprecedented → un + pre + ced + ented
新词	用已知 Token 组合表示	chatgpt → chat + g + pt

3.3 主流分词算法

目前主流的分词算法有三类：

算法	全称	特点	代表模型
BPE	Byte Pair Encoding	合并频率最高的相邻符号	GPT 系列
WordPiece	WordPiece	基于概率的分词，用 ## 标记子词	BERT 系列
Unigram	Unigram Language Model	基于统计概率，选择最优分词	T5、XLNet

3.4 BPE 分词示例

BPE 的核心思路是迭代合并：

初始状态：每个字符都是一个 Token
        ["u", "n", "p", "r", "e", "c", "e", "d", "e", "n", "t", "e", "d"]

迭代 1：合并频率最高的字符组合 "e" + "d" → "ed"
        ["u", "n", "p", "r", "e", "c", "ed", "e", "n", "t", "ed"]

迭代 2：合并 "un"
        ["un", "p", "r", "e", "c", "ed", "e", "n", "t", "ed"]

迭代 N：最终得到
        ["un", "pre", "ced", "ented"]

通过这种方式，模型既能高效处理常见词，又能”认识”从未见过的罕见词。

---

四、Token 计量规则

4.1 不同语言的 Token 效率

这是很多中文用户最容易困惑的地方：

语言	Token 效率	估算公式
英文	1 Token ≈ 0.75 个单词 ≈ 4 个字符	Token 数 ≈ 单词数 × 1.3
中文	1 Token ≈ 0.6-0.8 个汉字	Token 数 ≈ 字数 × 1.5-2
代码	1 Token ≈ 4 个字符	Token 数 ≈ 字符数 ÷ 4

4.2 为什么中文 Token 数更多？

原因在于分词器的训练数据。主流分词器（如 GPT 系列）主要基于英文语料训练：

• 英文：artificial 可能是 1 个 Token（常见词）
• 中文：每个汉字 人、工、智、能 可能各自成为 1 个 Token

这导致同样内容，中文 Token 数通常是英文的 1.5-2 倍。

4.3 实例对比

同样的内容用不同语言表达：

内容	语言	Token 数估算
The future of artificial intelligence is bright	英文	约 7-8 个
人工智能的未来很光明	中文	约 10-12 个

这就是为什么用中文对话可能更快消耗 Token 配额。

4.4 不同模型的 Token 效率对比

模型系列	中文 Token 效率	特点
GPT-4	较低（约 2 字/Token）	英文优化，中文拆字多
Claude	中等（约 1.5 字/Token）	多语言平衡
DeepSeek	较高（约 1 字/Token）	中文专项优化
Qwen	较高（约 1 字/Token）	中文原生模型

---

五、Token 在大模型中的作用方式

5.1 完整处理流程

以句子 "人工智能很强大" 为例：

步骤 1: 分词
"人工智能很强大" → ["人工", "智能", "很", "强大"]

步骤 2: 编号（在词汇表中查找）
["人工", "智能", "很", "强大"] → [3821, 567, 89, 4521]

步骤 3: 向量化（每个编号对应一个向量）
3821 → [0.12, -0.34, 0.56, 0.78, ...]（4096 维向量）
567  → [0.23, 0.45, -0.11, 0.89, ...]
89   → [0.67, -0.23, 0.34, 0.12, ...]
4521 → [0.45, 0.67, 0.23, -0.45, ...]

步骤 4: 神经网络计算
向量输入 Transformer 模型，计算"下一个 Token 是什么"
- 注意力机制：计算 Token 之间的关联关系
- 前馈网络：提取和变换语义信息

步骤 5: 预测输出
模型输出概率分布 → "的"（概率最高）

步骤 6: Token 转文字
["的"] → "的"

完整输出："人工智能很强大" + "的" → "人工智能很强大的..."

5.2 向量化是什么？

每个 Token 都有一个向量表示——可以理解为这个 Token 的”数学身份证”。

Token "人工智能" 的向量（简化示例）：
[0.12, -0.34, 0.56, 0.78, 0.23, 0.45, -0.11, 0.89, ...]

这个向量有 4096 个数值（或更多）
每个数值代表这个 Token 在某个语义维度上的"坐标"

向量的神奇之处：语义相似的 Token，向量也相似。

Token "狗" 的向量：[0.8, 0.2, 0.1, ...]
Token "猫" 的向量：[0.7, 0.3, 0.2, ...]
Token "汽车" 的向量：[0.1, 0.9, 0.5, ...]

计算相似度：
"狗" vs "猫" → 高相似度（都是动物）
"狗" vs "汽车" → 低相似度（语义差异大）

5.3 为什么是 5 万个 Token 而不是 5 万个单词？

关键区别在于覆盖能力：

单词方案：
- 词汇表：5 万个单词
- 遇到新词：直接"不认识"

Token 方案：
- 词汇表：5 万个 Token（子词）
- 遇到新词：用已知 Token 组合表示
- 例：新词 "deepseek" → ["deep", "seek"]（都是已知 Token）

这就是 Token 方案的核心优势：有限词汇表 + 无限组合能力。

---

六、Token 量化方法

6.1 方法一：在线可视化工具

最直观的方式是使用官方提供的 Tokenizer 工具：

工具	链接	特点
OpenAI Tokenizer	https://platform.openai.com/tokenizer	GPT 模型分词可视化
Anthropic Console	https://console.anthropic.com	Claude 模型分词查看

这些工具可以让你直观看到文本是怎么被拆成 Token 的。

6.2 方法二：代码计算

使用 Python 进行精确计算：

# 方案 1：使用 tiktoken（OpenAI 官方库）
import tiktoken

enc = tiktoken.encoding_for_model("gpt-4")
text = "我爱人工智能"
tokens = enc.encode(text)
print(f"Token 数量: {len(tokens)}")
print(f"Token 列表: {tokens}")
print(f"Token 文本: {[enc.decode([t]) for t in tokens]}")

# 方案 2：使用 transformers（通用方案）
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
text = "我爱人工智能"
tokens = tokenizer.encode(text)
print(f"Token 数量: {len(tokens)}")

6.3 方法三：API 返回值

调用大模型 API 时，返回结果通常包含 Token 使用量：

from openai import OpenAI

client = OpenAI(api_key="your-key")

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "介绍一下人工智能"}]
)

# Token 使用量
print(f"输入 Token: {response.usage.prompt_tokens}")
print(f"输出 Token: {response.usage.completion_tokens}")
print(f"总 Token: {response.usage.total_tokens}")

6.4 方法四：经验估算（快速估算）

当你没有工具时，可以用经验公式：

语言	估算公式	示例
英文	Token ≈ 单词数 × 1.3	100 单词 ≈ 130 Token
中文	Token ≈ 字数 × 1.5-2	100 字 ≈ 150-200 Token
代码	Token ≈ 字符数 ÷ 4	400 字符 ≈ 100 Token
混合	各部分分别估算再相加	英文 + 中文 + 代码

---

七、Token 限制与成本

7.1 各模型的 Token 限制

模型	上下文窗口	最大输出
GPT-4o	128K Token	16K Token
GPT-4 Turbo	128K Token	4K Token
Claude 3.5 Sonnet	200K Token	8K Token
Claude Opus 4.6	200K Token	32K Token
DeepSeek V3	200K Token	8K Token

7.2 Token 与 API 成本

API 费用通常按 Token 计算：

成本 = 输入 Token × 输入单价 + 输出 Token × 输出单价

例：GPT-4o
- 输入：$2.5 / 1M Token
- 输出：$10 / 1M Token

对话消耗 1000 输入 Token + 500 输出 Token
成本 = 1000 × $2.5/1M + 500 × $10/1M = $0.0075

7.3 超出 Token 限制会怎样？

情况 1：输入超出上下文窗口
→ API 报错：context_length_exceeded
→ 解决：截断历史消息或分段处理

情况 2：输出超出最大输出限制
→ 输出被截断，不完整
→ 解决：设置合理的 max_tokens 或分段生成

---

八、实用技巧：如何节省 Token

8.1 语言选择

同样的内容，用英文表达 Token 数更少：

内容	中文 Token	英文 Token
请帮我写一篇关于人工智能的文章	约 15-20	约 8-10

技巧：如果不需要输出中文，可以用英文提问和回答。

8.2 Prompt 精简

❌ 冗长版本（约 50 Token）：
"请帮我写一篇非常详细的、包含多个方面的、内容丰富的关于人工智能发展历史的文章，要涵盖从早期研究到现在的发展历程"

✅ 精简版本（约 15 Token）：
"写一篇 AI 发展史，涵盖早期到现在的关键节点"

8.3 避免重复上下文

每次对话都会带上历史消息，Token 消耗会累积：

第 1 轮：100 Token 输入
第 2 轮：100 + 50（历史）= 150 Token 输入
第 3 轮：100 + 50 + 50 = 200 Token 输入
第 N 轮：线性增长...

技巧：

• 定期开启新对话，清除历史
• 只保留必要的历史消息
• 使用 System Prompt 存储固定指令

8.4 System Prompt 的妙用

System Prompt 只计算一次，不会重复：

# 每条消息都重复指令（浪费 Token）
messages = [
    {"role": "user", "content": "请用简洁的语言回答：什么是 AI？"},
    {"role": "assistant", "content": "AI 是..."},
    {"role": "user", "content": "请用简洁的语言回答：什么是机器学习？"},  # 重复了指令
]

# 使用 System Prompt（高效）
messages = [
    {"role": "system", "content": "请用简洁的语言回答所有问题"},  # 只算一次
    {"role": "user", "content": "什么是 AI？"},
    {"role": "assistant", "content": "AI 是..."},
    {"role": "user", "content": "什么是机器学习？"},
]

8.5 图片的 Token 消耗

图片也会消耗 Token，计算方式较复杂：

图片 Token ≈ (图片宽度 ÷ 512) × (图片高度 ÷ 512) × 基础 Token 数

例：1024×1024 图片
Token ≈ 2 × 2 × 85 = 340 Token（大致估算）

技巧：

• 压缩图片尺寸
• 只传必要的图片
• 使用低分辨率版本

---

九、Token 与上下文窗口的关系

9.1 上下文窗口是什么？

上下文窗口是模型能”记住”的最大 Token 数：

模型上下文窗口 = 128K Token
     ↓
意味着：
- 输入 + 历史对话 + 输出 的总 Token 数不能超过 128K
- 超过部分会被截断或报错

9.2 为什么需要长上下文？

场景	Token 需求
简单问答	100-500 Token
代码分析	5K-20K Token
长文档总结	50K-100K Token
复杂 Agent 任务	100K-1M Token

9.3 长上下文的代价

上下文越长：
- 计算成本越高（Transformer 是 O(n²) 复杂度）
- 响应速度越慢
- API 费用越高

---

十、总结

10.1 Token 的核心概念

概念	说明
Token	大模型处理文本的最小单位，类似”积木块”
分词器	把文本拆成 Token 的工具，不同模型分词方式不同
词汇表	所有已知 Token 的集合，通常 5-10 万个
向量	每个 Token 的”数学身份证”，用于计算

10.2 为什么选择 Token

原因	说明
计算机只认识数字	文字必须转换成数字才能计算
有限词汇表	5 万个 Token 可以穷举和编号
无限组合能力	有限积木块拼出无限造型
处理新词	用已知 Token 组合表示未见过的词

10.3 Token 计量要点

语言	估算公式
英文	Token ≈ 单词数 × 1.3
中文	Token ≈ 字数 × 1.5-2
代码	Token ≈ 字符数 ÷ 4

10.4 实用建议

• 用英文对话可以节省 Token
• 精简 Prompt，避免冗长描述
• 使用 System Prompt 存储固定指令
• 定期清理历史对话，避免累积
• 压缩图片尺寸减少 Token 消耗

---

附录：Token 可视化体验

想直观感受 Token 是怎么”切”文本的？试试这些工具：

1. OpenAI Tokenizer：https://platform.openai.com/tokenizer

   • 输入中英文混排的内容
   • 看看模型是怎么”切”的
   • 每个 Token 用不同颜色高亮显示

2. Anthropic Console：https://console.anthropic.com

   • Claude 模型的 Token 计数
   • 支持实时估算

3. 本地体验：

   import tiktoken
   enc = tiktoken.encoding_for_model("gpt-4")
   text = "你的测试文本"
   print(enc.encode(text))
   print([enc.decode([t]) for t in enc.encode(text)])

---

参考资源：

• OpenAI Tokenizer 文档
• tiktoken GitHub
• BPE 算法原论文