1.1 计算机不认字#

计算机是一台计算器。它能处理 0 和 1，能做加减乘除，但它看不懂 你好 两个字。要让计算机处理人类语言，第一步就是把文字翻译成数字。

这个翻译过程叫做 Token 化（Tokenization）。翻译后的最小单位叫做 Token。

1.2 Token 不是 “字”，也不完全是 “词”#

你可能会想：一个汉字对应一个数字，不就行了？或者一个英文单词对应一个数字？

听起来合理，但实际操作中有问题。

按字拆分的问题：词汇表太大。中文常用字就有好几千，加上生僻字、专有名词，数量爆炸。而且单个字缺少语义信息，“人” 和 “工” 拆开后，模型很难知道它们组合起来是 人工。

按词拆分的问题：新词怎么办？“ChatGPT” 这个词在几年前根本不存在。如果词汇表里没有，模型就完全不认识它了。

所以，现代大模型采用了一种折中方案：BPE（Byte Pair Encoding，字节对编码）。

1.3 BPE：在效率和灵活性间平衡#

BPE 的思路很朴素：先把文本拆成最小的单元（字节或字符），然后统计哪些相邻的单元经常一起出现，把它们合并为一个新的 Token。反复合并，直到词汇表达到预定大小。

这就像你整理书架。一开始每本书单独放，然后发现《哈利·波特》七本总是一起借，干脆捆在一起算一组。

来看实际的 Token 化结果：

中文示例

人工智能很强大 被切分为：

1
["人工", "智能", "很", "强大"]

四个汉字组合被识别为两个有意义的词组，“很” 和 强大 各自独立。

英文示例

“artificial intelligence” 被切分为：

1
["art","ificial","intelligence"]

注意 “artificial被拆成了art”和”ificial”：因为”art” 是高频子词，单独做一个 Token 更高效。

1.4 Token 数量限制：上下文窗口#

每个大模型能处理的 Token 数量是有上限的，这个上限叫做上下文窗口（Context Window）。你可以把它理解为模型的 工作记忆，窗口越大，它能同时 看到 的内容越多。

不同模型的上下文窗口差异巨大：

1.5 粗略换算#

记住两条经验法则，够日常使用了：

• 1 个中文字 ≈ 1～2 个 Token
• 1 个英文单词 ≈ 1～1.5 个 Token

所以当你看到 “这个模型支持 128K Token” 时，大概意味着它能一次性处理约 6～10 万字的中文内容。

2.1 数字还不够，要有 意义#

Token 化之后，每个 Token 都有了一个编号。比如 人工 可能是 Token #8421，智能 可能是 Token #3057。

但编号只是 ID，没有任何语义信息。#8421 和 #3057 之间差了 5364，这个数字毫无意义。

需要一种方式，让数字本身能 表达含义。

2.2 向量：语义的坐标#

解决方案是把每个 Token 映射成一个向量（Vector）：一组高维的数字列表。在真实的大模型中，每个 Token 会被转换成一个几千维的向量。

什么是 维度？想象一下地图。地图上的每个城市有两个坐标：经度和纬度。这是 2 维。如果再加上海拔，就是 3 维。向量的维度类似，只不过大模型用的是几千个维度，每个维度描述 Token 的一个 语义特征。

这个转换过程叫做 Embedding（嵌入）。

2.3 经典例子#

假设把词汇映射到一个简化的向量空间（实际维度远高于此）：

你会发现一个神奇的规律：

1
国王 - 男性 + 女性 ≈ 王后

向量空间里的方向代表语义关系。国王 到 王后 的方向，和 男孩 到 女孩 的方向几乎平行，它们都表示 性别转换。

这就是 Embedding 的威力：语义相近的词，在向量空间里距离也近。“猫” 和 “狗 会靠在一起，而 猫” 和 民主 则相距甚远。

2.4 位置也很重要#

小明打了小红 和 小红打了小明，用的词完全一样，但意思截然不同。区别在哪里？词序。

所以模型不仅要知道每个 Token 是什么，还要知道它在句子里的位置。做法是给每个 Token 的向量再加上一个位置向量（Positional Encoding）：

1
最终向量 = 词义向量 + 位置向量

这样，同一个词出现在不同位置，最终的向量也不同。模型就能区分 小明打了小红 和 小红打了小明 了。

3.1 向量进入 加工厂#

到此为止，有了一组带有位置信息的向量。但这些向量还是 孤立 的：每个 Token 只知道自己的意思，不知道和上下文其他词的关系。

接下来，这些向量要进入模型的核心结构：Transformer。

你可以把 Transformer 想象成一家工厂的流水线。原材料（向量）从一端进去，经过一层又一层的加工，最后从另一端出来。每经过一层，向量中包含的信息就更丰富、更精确。

3.2 每层做两件事#

Transformer 的每一层都做两件事：

1. 自注意力计算（Self-Attention）

这是 Transformer 最核心的创新。自注意力让每个 Token 能 看到 句子里的所有其他 Token，并判断哪些 Token 跟自己关系最密切。

想象你在读一段话：

“那只猫坐在垫子上，它看起来很舒服。”

当模型处理到 “它 这个词时，自注意力机制会让 它” 去 关注 句子里的每个词，然后发现：它和 “猫 的关联度最高。于是 它 的向量会融入 猫 的语义信息，模型因此理解了 它” 指的是猫。

2. 前馈网络（Feed-Forward Network）

自注意力让 Token 之间交换了信息，前馈网络则负责对这些信息做进一步的加工和转换。你可以把它理解为 消化吸收 环节：把交换来的信息整合成更有用的表示。

3.3 浅层学语法，深层学语义#

一个大模型通常有几十到上百层 Transformer。不同深度的层 学到 的东西不一样：

• 浅层（第 1～10 层）：学习基础的语法结构。比如判断 我 是主语，吃 是动词，苹果 是宾语。
• 中层（第 10～50 层）：学习短语和句子层面的语义。比如理解 “我爱 AI” 表达的是积极态度。
• 深层（第 50 层以上）：学习复杂的推理和长距离依赖。比如理解一段话里前后呼应的逻辑关系。

GPT-4 有近百层 Transformer。每经过一层，模型对输入文本的 理解 就更深一层：就像你读一篇文章，第一遍看懂字面意思，第二遍理解作者意图，第三遍体会言外之意。

4.1 加工完成，开始 猜词#

经过几十到上百层 Transformer 的加工，每个 Token 的向量已经融合了丰富的上下文信息。现在，模型要用这些向量来完成它的核心任务：预测下一个 Token。

具体怎么做？模型拿到最后一个位置的向量，把它投射到整个词汇表上，算出每个候选 Token 的概率。

假设你输入 今天天气，模型会输出一张概率分布表：

很好 排第一，因为训练数据里 今天天气很好 出现得最多。紫色 几乎为零，因为 今天天气紫色 在任何正常文本中都不会出现。

4.2 采样策略：选哪个？#

现在有一张概率表，模型怎么从中选出最终的词？这就涉及到采样策略。

5.1 关键机制：用输出作为输入#

到这里你可能会问：模型一次只预测一个 Token，那一整段话是怎么生成的？

答案是自回归（Autoregressive）生成。流程是这样的：

1. 你输入 请写一首诗
2. 模型预测下一个 Token → “春”
3. 把 请写一首诗春 作为新的输入
4. 模型预测下一个 Token → “风”
5. 把 请写一首诗春风 作为新的输入
6. 模型预测下一个 Token → “拂”
7. ……
8. 直到模型输出一个特殊的 结束Token（EOS），或者达到最大长度限制

每一步，模型都要把前面所有的 Token 重新 “看” 一遍，然后预测下一个。这就像你写文章，每写一个字都要回头读一遍前面写的内容。

5.2 为什么输出有时很慢#

现在你理解了为什么 AI 的回答是 逐字打出 而不是一整段瞬间出现：因为它确实是一个 Token 一个 Token 生成的。每生成一个 Token，都要跑一遍那几十层 Transformer。

输出越长，需要的计算越多，速度自然越慢。这也是为什么你让 AI 写一篇长文，等待时间明显比回答 “1+1 等于几” 要长得多。

5.3 为什么会 跑题#

自回归生成有一个天然的隐患：错误会累积。

如果模型在第 50 个 Token 时选了一个不太恰当的词，后面所有的预测都建立在这个 歪了 的基础上。就像你走路时第一步偏了 1 度，走 100 步后就偏得很远了。

这就是为什么 AI 在生成长文本时有时会 跑题 或 前后矛盾：每一步微小的偏差，在自回归过程中会被不断放大。

6.1 大模型不是在 查资料#

很多人以为 AI 在回答问题时，会像搜索引擎那样去某个数据库里查找答案。这是一个常见的误解。

大模型没有一个 知识库 可以查询。它做的事情始终只有一件：根据上文，预测下一个最可能的词。它的 知识 全部编码在模型参数里，是训练过程中从海量文本中学到的统计规律。

6.2 两个场景对比#

场景 1：碰巧答对

你问：“OpenAI 的 CEO 是谁？”

训练数据里，“OpenAI”和”CEO后面经常跟着Sam Altman”。所以模型预测的下一个词大概率是”Sam Altman”，恰好是正确的。

但注意，模型并不 知道 Sam Altman 是谁，也不 知道 他是 CEO。它只是根据统计规律，发现这些词经常一起出现。

场景 2：自信编造

你问：“2026 年诺贝尔物理学奖得主是谁？”

训练数据里没有这个信息（假设训练数据截止到 2025 年）。但模型发现，诺贝尔物理学奖得主 这个短语后面，应该跟一个人名。于是它根据统计规律，编造 了一个看起来合理的名字。

更可怕的是，它编造时的语气和回答正确信息时一模一样：没有任何犹豫或不确定的标志。

6.3 幻觉的本质#

幻觉（Hallucination）不是 Bug，而是自回归文本生成器的固有特性。

模型在生成文本时，它的唯一目标是让输出在统计上看起来 合理。它不会检查自己说的是否真实，因为它根本没有 真实 这个概念。

用一个类比：大模型就像一个博学的演讲者，无论你问什么问题，他都能流畅地给出一个 听起来很对 的回答。但他没有笔记本可以查证，所有的回答都是凭记忆即兴发挥的。大多数时候他说对了，但有时候他会一本正经地胡说八道。

6.4 如何应对幻觉#

在关键场景中，永远不要盲信大模型的输出。几条实用建议：

• 重要信息交叉验证：让模型给出来源或依据，然后自己查证
• 接入外部知识库：使用 RAG（检索增强生成）技术，让模型先 查资料 再回答
• 限定输出范围：要求模型只从给定材料中提取信息，不要自行发挥
• 人工审核兜底：涉及法律、医疗、财务等领域，必须人工复核

7.1 擅长的事#

这些任务恰好契合 预测下一个词 的能力模型：

• 模式识别：识别文本中的模式和规律（比如情感分析、文本分类）
• 文本转换：翻译、改写、摘要、格式转换
• 补全生成：给定开头续写、给定问题回答、给定需求写代码
• 格式化输出：按指定格式整理信息（JSON、表格、Markdown）

7.2 不擅长的事#

这些任务超出了 统计文本生成 的能力范围：

• 精确计算：问 “3,847 × 2,916 等于多少”，模型会 猜 一个答案而不是真的计算。它没有计算器。
• 实时信息：训练数据有截止日期。模型不知道今天的新闻、实时的股票价格。
• 长链推理：需要 10 步以上严密逻辑推导的数学证明或编程题，容易在中间某步出错。
• 持续学习：模型参数在训练后固定。它无法从和你的对话中 学会 新知识（除非重新训练或微调）。

7.3 灰色地带#

有些能力模型 勉强可以，但不稳定：

• 常识推理：大多数时候正确，但偶尔会犯令人困惑的低级错误
• 创造性任务：能写出还不错的诗和故事，但很难真正 原创，更像是重组
• 个性化：可以模仿语气和风格，但没有真正的 个性

了解这些边界，能帮你把大模型用在正确的地方，避免不切实际的期待。

8.1 从 4K 到 1M+：一场记忆力的军备竞赛#

上下文窗口的大小，直接决定了模型能同时处理多少信息。这几年的演进堪称飞速：

这是什么概念？4K Token 大约是一篇短文章。128K Token 大约是一本小说。1M Token 则可以装下几十本书或一个中型代码仓库。

8.2 长上下文的意义#

上下文窗口的扩大，实实在在地改变了使用场景：

• 4K 时代：只能做短对话，稍长的文档就要手动截取
• 128K 时代：可以一次性分析一整份合同、一本技术文档
• 1M 时代：可以处理整个代码仓库、整本书，甚至让模型阅读几百页的会议记录后做总结

8.3 O(N²) 的瓶颈#

但扩大窗口不是免费的。Transformer 中自注意力机制的计算量，与序列长度的平方成正比，这就是 O(N²) 复杂度。

什么意思？如果上下文从 4K 扩大到 128K（32 倍），自注意力的计算量会增加 32² = 1,024 倍。

用生活类比：你在一个 10 人的聚会上，每个人要和其他 9 个人打招呼，总共 45 次握手。如果人数变成 320 人，握手次数变成 51,040 次。人数增加 32 倍，握手次数增加超过 1,000 倍。

8.4 优化方向#

研究者们一直在想办法解决这个问题：

• 稀疏注意力（Sparse Attention）：不是每个 Token 都关注所有 Token，而是只关注 重要的 那些
• 线性注意力（Linear Attention）：通过数学变换将复杂度从 O(N²) 降到 O(N)
• 滑动窗口注意力（Sliding Window Attention）：每个 Token 只看固定范围内的邻居
• Flash Attention：不改变数学原理，通过优化 GPU 内存访问来加速

这些优化让百万级别的上下文窗口从理论变成了现实。

9.1 重复计算的浪费#

回忆一下自回归生成的过程：模型每生成一个 Token，都要把前面所有 Token “看” 一遍。

假设模型已经处理了 1,000 个 Token，现在要预测第 1,001 个。按照原始逻辑，前 1,000 个 Token 的注意力计算要全部重新做一遍。但这些 Token 没有变化，上一轮已经算过了，全部重算是巨大的浪费。

9.2 KV Cache：记录中间结果#

KV Cache 的思路非常直觉：把已经算过的中间结果（具体来说是自注意力机制中的 Key 和 Value 矩阵）缓存起来，下次直接复用。

类比一下：你在做一道多步骤的数学题，每一步的结果你都记在纸上。做到第 5 步时，你不需要从第 1 步重新算，只要看纸上记的结果继续往下做就行。

有了 KV Cache，模型生成第 1,001 个 Token 时，只需要计算第 1,001 个 Token 与前面 1,000 个 Token 的关系，而前 1,000 个 Token 之间的关系直接从缓存中读取。

9.3 推理速度的提升#

KV Cache 带来的提速非常显著。没有 KV Cache 时，生成第 N 个 Token 的时间与 N 成正比，越往后越慢。有了 KV Cache，每一步的增量计算量基本恒定。

代价是显存。KV Cache 会随着上下文长度线性增长。对于 128K 上下文的模型，KV Cache 可能占用几十 GB 的显存。

9.4 其他优化技术#

除了 KV Cache，还有一些重要的推理优化技术：

Flash Attention

标准的注意力计算需要在 GPU 的高带宽内存（HBM）和计算核心之间来回搬运数据。Flash Attention 通过 分块计算（Tiling）减少数据搬运次数，在不改变数学结果的前提下大幅提速。

效果：速度提升 2～4 倍，显存占用也更低。

Speculative Decoding（推测性解码）

核心思路：用一个小而快的 草稿模型 先快速生成一串候选 Token，再用大模型一次性验证。如果大部分候选通过验证，就省去了大模型逐个生成的时间。

类比：写文章时先打一份草稿，再让主编一次性审阅。比主编一个字一个字地写，快得多。

10.1 模型太大，装不下#

GPT-4 据估计有超过 1,750 亿参数。每个参数用 16 位浮点数（FP16）存储，需要约 350 GB 显存。单张消费级显卡通常只有 8～24 GB，差了十几倍。

怎么办？一个有效的办法是量化（Quantization）。

10.2 量化：用低精度换高效率#

量化的核心思想：用更少的位数（Bit）来表示模型参数。

从 FP16 量化到 INT8，模型体积减半。从 FP16 量化到 INT4，体积只有原来的四分之一。

用照片类比：高清照片和标清照片，远看几乎一样，只有放大细节时才能看出差别。量化也一样，精度降了，但模型在大多数任务上的表现下降很小。

10.3 常见量化格式#

如果你想在自己的电脑上跑大模型，你会经常遇到这几个名字：

• GPTQ：GPU 上运行的量化格式，速度快，需要显卡
• AWQ：比 GPTQ 更新，对重要参数保留高精度，质量更好
• GGUF：CPU 上也能运行的格式，适合没有独立显卡的电脑

10.4 量化的意义#

量化技术让原本只能在数据中心运行的大模型，也能跑在普通电脑甚至手机上。例如：

• 一个 70 亿参数（7B）的模型，FP16 需要约 14 GB 显存。INT4 量化后只需要约 4 GB，一张普通显卡就够了。
• 许多开源模型（如 Llama、Qwen、DeepSeek）都提供了量化版本，让个人用户也能在本地体验大模型的能力。

11.1 四种定制层次#

很多人问：“我想让 AI 做某件事，应该训练一个模型吗？”

大多数情况下，答案是：不需要。

定制大模型的方式从简到繁，分为四个层次：

11.2 决策建议#

永远从最简单的方法开始。实际上，80% 的问题通过提示工程就能解决。

11.3 成本对比速查表#

看这张表，你应该能理解为什么大多数人和团队只需要前两种方式了。

11.4 Temperature 效果对比#

1
┌─────────────────────────────────────────────────────────┐
2
│  Temperature 对输出的影响                                  │
3
├─────────────────────────────────────────────────────────┤
4
│                                                         │
5
│  输入："用一句话形容春天"                                  │
6
│                                                         │
7
│  Temperature 0.1 (保守)                                  │
8
│  ████████████████████░░░░  "春天是万物复苏的季节。"       │
9
│  → 几乎每次输出一样，最 "安全" 的回答                       │
10
│                                                         │
11
│  Temperature 0.7 (平衡)                                  │
12
│  ██████████████░░░░░░░░░░  "春风拂面，花开满枝头。"       │
13
│  → 合理且有变化，每次可能略有不同                          │
14
│                                                         │
15
│  Temperature 1.5 (奔放)                                  │
16
│  ████████░░░░░░░░░░░░░░░░  "春天是大地打了个彩色的喷嚏。"  │
17
│  → 意想不到的表达，创造性强但可能 "离谱"                    │
18
│                                                         │
19
│  ──────────────────────────────────────                  │
20
│  █ = 确定性     ░ = 随机性                               │
21
│  ← 保守                              创造 →             │
22
└─────────────────────────────────────────────────────────┘

11.5 Token 和字有什么区别？#

Token 是模型处理文本的最小单位，但它不等于一个字或一个词。中文中，常见的双字词通常是一个 Token（如 人工），单字也可能独立成一个 Token（如 “很”）。英文中，一个长单词可能被拆成多个 Token（如 “artificial”→“art”+“ificial”）。你可以用 OpenAI Tokenizer 在线工具，输入任意文本查看实际的 Token 化结果。

11.6 为什么模型有时回答很慢？#

因为模型是逐 Token 生成的（自回归）。每生成一个 Token，都要跑一遍整个 Transformer 网络。回答越长，需要生成的 Token 越多，等待时间越久。此外，上下文越长（你输入的内容越多），每一步的计算量也越大。所以 给它一本书让它总结 会比 问它 1+1 等于几 慢得多。

11.7 Temperature 应该设置多少？#

取决于你的需求：

• 写代码、做翻译、提取信息：0.1～0.3（要精确）
• 日常对话、写邮件：0.5～0.8（自然流畅）
• 创意写作、头脑风暴：0.9～1.3（丰富多变）

如果不确定，从 0.7 开始尝试，觉得太 死板 就调高，太 胡来 就调低。

11.8 幻觉能彻底解决吗？#

目前不能。幻觉是自回归文本生成的固有特性：模型的目标是生成 统计上合理的文本，而不是 事实正确的文本。不过可以通过技术手段大幅缓解：RAG（让模型先检索再回答）、事实核查模块、输出结构化约束等。未来随着技术进步，幻觉的频率和严重程度会持续降低，但完全消除在理论上很难。

11.9 上下文窗口越大越好吗？#

不完全是。更大的上下文窗口确实能处理更多信息，但有几个问题：第一，计算成本更高（费用和速度）；第二，研究表明模型在超长上下文中可能出现 迷失在中间（Lost in the Middle）的现象，对开头和结尾的信息记得清楚，中间的容易忽略；第三，更多的上下文意味着更多的噪音，有时反而影响输出质量。最佳实践是给模型提供恰到好处的上下文，不多不少。

11.10 量化后模型会变笨吗？#

轻度量化（FP16 → INT8）在大部分任务上几乎没有可感知的性能损失。深度量化（INT4 甚至更低）在一些需要高精度推理的任务上可能有轻微下降，但对日常使用而言差别不大。好比你把一张 4K 照片压缩到 1080p，日常看完全够用，只有放大到像素级别时才能看出区别。对于大部分用户来说，量化带来的便利（更低的硬件要求、更快的速度）远大于性能损失。