大语言模型原理详解：从预测下一个词到智能涌现

Sat, 02 May 2026 00:00:00 +0000

引言

大语言模型看起来很神奇：能聊天、写代码、总结文章、翻译文本、分析日志，甚至能像助手一样完成复杂任务。

但如果把外壳拆开，它最核心的目标其实非常朴素：

`1`	`根据前面的内容，预测下一个 token。`

例如给模型一句话：

今天天气很

模型要做的是预测后面最可能接什么：

`1`	`好、热、冷、差、舒服……`

当这个能力被放大到海量数据、巨大参数、强大的 Transformer 架构和精心设计的训练流程上，就出现了我们今天看到的大语言模型。

这篇文章不追求堆公式，而是用尽量直观的方式讲清楚：

模型如何“读”文字
Transformer 为什么有效
注意力机制到底在注意什么
模型是怎么训练出来的
对齐为什么能让模型更像助手
推理参数如何影响回答
大模型为什么会幻觉、受上下文限制

一句话理解 LLM

大语言模型可以理解成一个巨大的概率预测器。

它接收一串 token，输出下一个 token 的概率分布：

输入：我 喜欢 吃
输出：
  苹果：0.31
  米饭：0.18
  火锅：0.12
  代码：0.01
  ...

然后系统从这个概率分布里选一个 token，接到原文后面，再继续预测下一个。

1
2
3

我喜欢吃 → 苹果
我喜欢吃苹果 → 。
我喜欢吃苹果。 → 今天

一句话、一段代码、一篇文章，都是这样一个 token 一个 token 生成出来的。

这听起来像“文字接龙”，但关键在于：为了准确预测下一个 token，模型必须学会大量隐含能力。

它要知道：

语法结构
词义关系
世界知识
常识推理
代码模式
对话格式
上下文约束

预测下一个 token 是训练目标，理解和推理是这个目标逼出来的能力。

Token：模型眼中的文字

模型不能直接读“文字”。它看到的是 token。

Token 可以是一个字、一个词、一个词的一部分，甚至是标点或空格。

例如：

1
2

原文：ChatGPT 很强
可能被切成：["Chat", "GPT", " 很", "强"]

不同模型的分词器不一样，所以同一句话在不同模型里可能切成不同 token。

为什么不用字或词

如果按字切，英文会很碎：

`1`	`transformer → t r a n s f o r m e r`

如果按词切，又会遇到新词、拼写变体、代码变量名：

`1`	`getUserProfileById`

现代模型通常使用子词分词。它在“太碎”和“太粗”之间折中：

`1`	`unbelievable → un + believe + able`

这样既能处理常见词，也能拼出没见过的新词。

Token 影响成本和上下文

上下文窗口不是按字数算，而是按 token 算。

如果模型上下文是 128K token，意思是一次最多能看到约 128K 个 token，包括：

系统提示
用户输入
历史对话
检索文档
工具结果
模型输出

token 越多，成本越高，推理越慢，上下文管理也越重要。

Embedding：把 token 变成向量

模型不能直接对 token 字符串做计算。它会先把每个 token 映射成一个向量。

1
2
3

"苹果" → [0.12, -0.38, 0.57, ...]
"香蕉" → [0.10, -0.35, 0.61, ...]
"数据库" → [-0.44, 0.72, 0.08, ...]

这个向量叫 Embedding。

可以把它理解成 token 在语义空间里的坐标。语义接近的 token，向量距离通常也更接近。

但在大语言模型里，Embedding 只是第一步。真正强大的地方在于：这个向量会经过很多层 Transformer，不断吸收上下文信息。

例如“苹果”这个 token，在不同句子里的含义不同：

1
2

我买了一个苹果。
苹果发布了新款芯片。

初始 Embedding 可能相同，但经过上下文处理后，模型会逐渐区分它是水果还是公司。

Transformer：LLM 的主干架构

现代大语言模型的核心架构基本都来自 Transformer。

一个简化版流程：

文本
  ↓
Tokenization
  ↓
Embedding
  ↓
Transformer Block × N
  ↓
输出下一个 token 的概率

Transformer Block 可以理解成一层“信息加工器”。每一层主要做两件事：

1
2

1. Attention：让每个 token 从其他 token 那里取信息
2. Feed Forward：对每个位置的信息做进一步加工

几十层甚至上百层叠起来后，模型就能从简单词义逐步抽象到语法、语义、推理和任务意图。

Attention：让 token 互相看见

Attention 是 Transformer 最核心的机制。

一句话理解：

Attention 让当前位置的 token 判断：我应该重点关注前文里的哪些 token。

例如：

`1`	`小明把书放进书包，因为它太重了。`

这里“它”指的更可能是“书”，不是“书包”。模型要理解这件事，就需要让“它”这个位置去关注前面的相关词。

Query、Key、Value

Attention 里常见三个词：Query、Key、Value。

可以用查资料来类比：

1
2
3

Query：我想找什么？
Key：每份资料的标签是什么？
Value：资料真正的内容是什么？

每个 token 都会生成自己的 Query、Key、Value。

然后当前位置的 Query 会和所有位置的 Key 做匹配，算出注意力分数。分数越高，说明越值得关注。最后再按这些分数加权汇总 Value。

简化成三步：

1
2
3

1. 当前 token 发出 Query：我需要什么信息？
2. 其他 token 提供 Key：我能提供什么线索？
3. 根据匹配程度汇总 Value：把有用信息拿过来。

Self-Attention

Self-Attention 的意思是：同一句话内部的 token 互相关注。

例如：

`1`	`张三告诉李四，他明天会来。`

模型需要判断“他”更可能指谁。这就需要结合上下文中的多个 token。

Self-Attention 的强大之处在于：任意两个位置之间都可以直接建立联系。不像 RNN 那样必须从左到右一步步传递信息。

Causal Mask

GPT 这类生成式模型在训练和生成时不能偷看未来。

预测第 5 个 token 时，只能看前 4 个 token，不能看第 6 个 token。

这靠 Causal Mask 实现。

1
2
3

位置 1 只能看 1
位置 2 只能看 1,2
位置 3 只能看 1,2,3

这样模型学到的才是“根据前文预测后文”，而不是提前看答案。

Multi-Head Attention：从多个角度看上下文

一个 Attention 头只能从一种角度关注上下文。

但一句话里有很多关系：

主谓关系
指代关系
时间关系
因果关系
代码里的变量引用
Markdown 里的结构层级

Multi-Head Attention 就是让模型同时用多个 Attention 头观察文本。

Head 1：关注语法
Head 2：关注指代
Head 3：关注代码变量
Head 4：关注段落结构

这些头的结果会被合并，让模型得到更丰富的上下文表示。

不需要把每个头想得太神秘。它们不一定真的严格分工成“语法头”“指代头”，但多头机制确实给了模型从不同子空间捕捉关系的能力。

Feed Forward：对信息做加工

Attention 负责“从哪里拿信息”，Feed Forward 负责“怎么加工信息”。

在每个 Transformer Block 中，Attention 汇总上下文后，会经过一个前馈网络。

可以粗略理解为：

1
2

Attention：把相关信息拿到当前 token 身边
Feed Forward：根据这些信息更新当前 token 的表示

很多研究认为，模型里的事实知识和模式记忆相当一部分保存在前馈网络参数中。

例如模型知道：

1
2
3

巴黎是法国的首都
Redis 的 zset 常用跳表
Go 的 goroutine 由调度器管理

这些知识并不是以数据库记录的形式存储，而是分散在大量参数里。

位置编码：让模型知道顺序

Attention 本身不天然知道顺序。

如果只看一堆 token 向量，模型并不知道谁在前谁在后。

所以模型需要位置编码。

1
2

我 爱 你
你 爱 我

这两句话 token 一样，但顺序不同，意思不同。

位置编码就是给每个 token 加上“我在第几个位置”的信息。

现代模型常用 RoPE 这类相对位置编码。你不必记住复杂数学，只要知道它解决的是：

`1`	`模型如何理解 token 之间的距离和顺序。`

残差连接与归一化：让深层网络稳定训练

Transformer 可以堆很多层，但层数越深，训练越难。

残差连接和归一化是两个稳定训练的关键技巧。

残差连接

残差连接就是让每层不要完全重写输入，而是在输入基础上做增量修改：

`1`	`输出 = 输入 + 本层加工结果`

这样信息可以更顺畅地穿过很多层，训练也更稳定。

LayerNorm

LayerNorm 用来让每层的数值分布更稳定。

可以类比成：每一层处理完后，把数据尺度整理一下，避免数值忽大忽小导致训练崩掉。

这些机制不直接决定模型“懂不懂”，但决定了模型能否被训练得足够深、足够大。

训练：从海量文本中学习规律

预训练阶段的任务很简单：

`1`	`给定前文，预测下一个 token。`

训练数据来自大量文本：

网页
书籍
代码
论文
问答
文档
论坛

模型一开始是随机参数，预测很差。每次预测错了，就根据误差微调参数。

这个过程重复数万亿 token 后，模型逐渐学会语言和世界知识的统计规律。

预训练学到什么

预训练让模型学会：

词和词如何搭配
句子如何组织
代码如何书写
常见事实
推理模式
不同领域的表达方式

但预训练模型本质上仍然是“续写器”。

你问：

`1`	`请解释什么是 Redis。`

Base Model 可能会继续补成一段网页、问答、代码注释，未必像助手一样回答你。

这就是为什么还需要指令微调和对齐。

指令微调：从续写器到助手

SFT（Supervised Fine-Tuning，监督微调）会用人工整理的指令数据继续训练模型。

数据长这样：

{
  "instruction": "解释什么是 Redis",
  "response": "Redis 是一种基于内存的键值数据库..."
}

模型通过这些样本学会：

用户提问应该回答
要遵循指令
要保持对话格式
要按要求输出结构
不要无意义续写

经过 SFT 后，模型才更像我们熟悉的聊天助手。

对齐：让模型更符合人类偏好

SFT 解决“会不会听指令”，但不完全解决“回答得好不好”。

同一个问题可以有很多回答：

1
2
3

太短：Redis 是数据库。
太长：从网络协议讲到源码实现。
刚好：解释核心概念、使用场景和特点。

对齐训练就是让模型更符合人类偏好。

常见方法包括：

RLHF：基于人类反馈的强化学习
DPO：直接偏好优化
RLAIF：用 AI 反馈辅助偏好数据

它们的共同目标是让模型更倾向于输出：

有帮助
准确
安全
不胡乱承诺
格式清晰
符合用户意图

可以把训练流程简化成：

1
2
3

预训练：学语言和知识
SFT：学会按指令回答
对齐：学会什么回答更好

推理：模型如何生成回答

训练完成后，模型参数固定。用户输入问题时，进入推理阶段。

推理流程：

用户输入
  ↓
转成 token
  ↓
模型计算下一个 token 概率
  ↓
采样或选择一个 token
  ↓
加入上下文
  ↓
继续预测

这个循环一直进行，直到模型输出结束符或达到最大长度。

Temperature

Temperature 控制随机性。

低 temperature：

`1`	`更稳定、更保守、更可复现`

高 temperature：

`1`	`更多样、更有创意、也更容易跑偏`

写代码、做问答通常用较低温度；写故事、头脑风暴可以适当提高。

Top-K

Top-K 表示只从概率最高的 K 个 token 中选择。

如果 K=5，模型只会在前 5 个候选里采样，低概率 token 会被排除。

Top-P

Top-P 也叫 nucleus sampling。

它不是固定取前 K 个，而是取累计概率达到 P 的候选集合。

例如 P=0.9，模型会从累计概率前 90% 的候选里采样。

Top-P 比 Top-K 更灵活，因为不同位置的候选分布可能差异很大。

上下文窗口：模型的工作记忆

模型不会真正“记住”当前对话之外的东西。它每次生成时，只能看到上下文窗口里的内容。

上下文包括：

系统提示
用户消息
历史对话
工具结果
RAG 检索文档
代码片段
记忆摘要

如果信息不在上下文里，模型就无法直接使用。

这也是为什么 RAG、记忆系统、上下文压缩很重要。它们本质上都在解决一个问题：

`1`	`该把什么信息放进模型当前能看到的窗口？`

上下文窗口变大不代表问题完全解决。信息越多，噪声也越多。真正关键的是上下文质量。

参数量、数据和算力

大模型能力提升通常来自三件事：

1
2
3

更多参数
更多高质量数据
更多训练算力

参数可以理解成模型内部可调的“旋钮”。参数越多，模型能表达的模式越复杂。

但参数不是越大越无脑好。

模型效果还取决于：

数据质量
训练 token 数
模型架构
对齐质量
推理成本
部署约束

一个训练得好的小模型，在特定任务上可能比一个泛用大模型更划算。

涌现能力：规模带来的质变

当模型规模、数据量和训练计算达到一定程度后，会出现一些小模型不明显的能力：

多步推理
代码生成
工具调用
少样本学习
指令泛化
跨语言迁移

这类现象常被称为涌现能力。

但“涌现”不等于魔法。它更像是大量统计规律、表示能力和训练目标叠加后，在某些任务上表现出突然变强的现象。

理解这一点很重要：大模型很强，但它不是全知系统。

为什么会幻觉

幻觉是大模型最典型的问题之一。

原因很简单：模型的目标是生成“概率上合理的下一个 token”，不是从数据库里查真相。

当它不知道答案时，也可能生成一个看起来像答案的回答。

幻觉常见于：

问题超出训练知识
需要最新信息
上下文缺少证据
用户要求编造式任务
检索结果不相关
模型被错误前提诱导

降低幻觉的方法：

RAG 引入外部证据
工具调用查询真实系统
要求引用来源
不确定时允许回答不知道
对高风险场景做人工审核

幻觉不能完全消除，只能通过工程手段降低。

为什么数学和逻辑会出错

LLM 不是传统符号推理引擎。

它可以学到很多推理模式，但本质上仍然在生成 token。

所以它可能：

算术中间步骤出错
忘记约束条件
被题目措辞误导
在长推理链中偏离目标
给出看似合理但错误的解释

解决方法通常不是“让模型更努力想”，而是结合工具：

计算器
代码执行器
定理证明器
SQL 查询
测试用例

模型负责理解问题和组织流程，工具负责精确计算和验证。

LLM 与 Agent 的关系

LLM 是大脑，但 Agent 是系统。

一个 Agent 通常包含：

LLM 推理
工具调用
记忆系统
任务规划
权限控制
错误恢复
评估与日志

LLM 本身只负责生成下一步内容或动作意图。Agent 工程负责把它放进可执行、可观察、可控制的系统里。

这就是为什么同一个模型，在不同产品里的表现差异很大。真正决定可用性的，不只有模型，还有上下文、工具、流程和评估。

小结

大语言模型的核心可以压缩成一句话：

`1`	`在大量文本上训练一个 Transformer，让它根据上下文预测下一个 token。`

但这句话背后包含一整套机制：

Tokenization：把文字切成模型能处理的单位
Embedding：把 token 变成向量
Attention：让 token 从上下文中取信息
Feed Forward：加工和存储模式
Position Encoding：让模型知道顺序
Pre-training：学习语言和世界规律
SFT：学会听指令
Alignment：学会更符合人类偏好
Decoding：一个 token 一个 token 生成答案
Context：决定模型当前能看到什么

理解 LLM，不需要一开始就陷进公式。先抓住主线：

`1`	`它如何读文本 → 如何理解上下文 → 如何训练 → 如何生成 → 为什么会出错`

这条线理清了，再去看 Transformer 细节、RAG、Agent、Tool Calling、模型部署，就会顺很多。

Transformer on 你怂你mua