1.3 大语言模型如何生成内容#
前面两节,咱们已经知道模型能回答问题、能被 Prompt 影响,也知道它有时候会一本正经地胡说八道。
但是,模型到底是怎么把一句话"写"出来的?
这一节,咱们就把这件事拆开看。
先看一个每天都在发生的现象#
打开任意一个 AI 聊天窗口,问它一句:
用一句话介绍什么是 Agent。
然后盯着屏幕看。
你会发现,回答不是"啪"一下整段出现的,而是一个字、一个字往外蹦。就像有人在屏幕后面打字。
很多人第一反应是:哦,这是流式输出(SSE),前端做了一个打字机效果。
这个理解,对了一半。
前端确实可能做打字机动画,传输层确实可能是 SSE。但模型本身,就是一次只生成一个 Token 的。
哪怕你把 stream 关掉,等它全部生成完再一次性返回,模型内部依然是:生成一个 Token → 接到上下文后面 → 再生成下一个 → 直到遇到结束标记。
所以"逐字出现"不是前端装饰,而是生成机制本来的样子。前端只是把这个过程露出来了。
那问题来了:模型每一步,到底是怎么选出"下一个 Token"的?
做一个实验:下一个词是什么#
假设上下文是这句话:
周末我准备
让你补全,你会接什么?
学习、休息、出门、打游戏……都可以,对不对。
模型面对的也是同一件事:它不是从天上掉一个答案,而是先给出一批候选 Token,再给每个候选打分。
咱们用一个 Node 脚本把这件事模拟出来。代码在仓库里:
Node/第一章/03-llm-generation-demo/generation-loop.mjs先看数据部分(generation-loop.mjs:7-46):
const candidateMap = new Map([
[
'周末我准备',
[
['学习', 3.2],
['休息', 2.6],
['出门', 2.1]
]
],
[
'周末我准备学习',
[
[' Agent', 3.8],
[' Node.js', 2.7],
['英语', 1.6]
]
],
[
'周末我准备学习 Agent',
[
['。', 3.1],
['开发', 2.4],
['相关知识', 1.8]
]
],
[
'周末我准备学习 Agent。',
[
['<EOS>', 4.2],
['然后', 1.1]
]
]
])这里有几件事值得注意。
第一,Map 的 key 是当前上下文。上下文不同,候选表就不同。
第二,value 是一组 [候选 Token, Logit]。Logit 就是模型打出来的原始分数,还不是概率。
第三,' Agent' 前面有一个空格。因为 Token 是带空格的,这一点下一节讲 Token 时会展开。
Logit 不是概率,得先过一道 Softmax#
现在咱们手里有三组分数:
| 候选 | Logit |
|---|---|
| 学习 | 3.2 |
| 休息 | 2.6 |
| 出门 | 2.1 |
这些分数能直接当概率用吗?不行。
它们可能是负数,可能大于 1,加起来也不等于 1。要变成"概率分布",得做一次 Softmax。
代码在 generation-loop.mjs:49-76:
function softmax(candidates) {
// 找出最大的 Logit
const maxLogit = Math.max(...candidates.map(([, logit]) => logit))
// 对每个 Logit 做指数运算
const items = candidates.map(([token, logit]) => [
token,
Math.exp(logit - maxLogit)
])
// 计算所有指数值的总和
const total = items.reduce((sum, [, value]) => sum + value, 0)
// 返回每个候选 Token 对应的概率
return items.map(([token, value]) => [token, value / total])
}翻译成人话,Softmax 干了两件事:
- 把每个分数变成正数(
Math.exp); - 再除以总和,让所有候选的概率加起来等于 1。
那为什么代码里要先减去 maxLogit?
因为 Math.exp(1000) 会直接溢出成 Infinity。所有分数同时减去最大值,概率比例不变,但指数不会炸。这是一个纯工程上的数值稳定处理,跟模型"聪不聪明"没关系。
算完之后,三个候选大概是这样:
| 候选 | 概率 |
|---|---|
| 学习 | 53.14% |
| 休息 | 29.17% |
| 出门 | 17.69% |
注意,最高的也只有 53%,不是 100%。
这就是关键:模型每一步都在"一批可能里挑一个",而不是"查一个标准答案"。
挑一个,接到后面,再来一轮#
有了概率,接下来就是选择。
这个脚本用的是最简单的策略:谁概率高选谁。也就是贪心选择(generation-loop.mjs:79-85):
function chooseHighest(probabilities) {
return probabilities.reduce((best, current) =>
current[1] > best[1] ? current : best
)
}选中"学习"以后,把它拼到上下文后面:
context += selectedToken上下文从 周末我准备 变成 周末我准备学习。
下一轮,程序拿新上下文再去查候选表,得到新的三个候选:
| 候选 | 概率 |
|---|---|
| ' Agent' | 69.27% |
| ' Node.js' | 23.06% |
| '英语' | 7.68% |
再选、再拼、再查。直到某一轮,候选里出现 <EOS>,也就是 End Of Sequence,结束标记。
看到 <EOS>,生成就停。
这就是完整的生成循环:预测 → 选择 → 拼接 → 再预测。
跑起来看看#
这个脚本零依赖,直接跑:
cd Agent--Code/Node/第一章/03-llm-generation-demo
node generation-loop.mjs真实输出(节选):
第 1 步
当前上下文:周末我准备
┌─────────┬──────────┬──────────┐
│ (index) │ 候选内容 │ 概率 │
├─────────┼──────────┼──────────┤
│ 0 │ '学习' │ '53.14%' │
│ 1 │ '休息' │ '29.17%' │
│ 2 │ '出门' │ '17.69%' │
└─────────┴──────────┴──────────┘
本次选择:学习
第 2 步
当前上下文:周末我准备学习
│ 0 │ ' Agent' │ '69.27%' │
│ 1 │ ' Node.js' │ '23.06%' │
│ 2 │ '英语' │ '7.68%' │
本次选择: Agent
第 3 步
当前上下文:周末我准备学习 Agent
│ 0 │ '。' │ '56.53%' │
│ 1 │ '开发' │ '28.07%' │
│ 2 │ '相关知识' │ '15.40%' │
本次选择:。
第 4 步
当前上下文:周末我准备学习 Agent。
│ 0 │ '<EOS>' │ '95.69%' │
│ 1 │ '然后' │ '4.31%' │
本次选择:<EOS>
模型生成了结束标记,生成结束。
最终内容:周末我准备学习 Agent。输出要分三层看。
第一层,看每一步的候选表。 上下文一变,候选和概率全变。模型不是提前想好整句话,而是走一步看一步。
第二层,看"本次选择"。 每一步只多一个 Token,前面已经生成的内容不会被改写。这就是所谓的自回归:用自己刚生成的内容,当作下一步的输入。
第三层,看结束条件。 第 4 步 <EOS> 的概率是 95.69%,模型选择停。如果没有 <EOS>,也没有步数上限,这个循环就会一直转下去——所以脚本里写了 step <= 10 兜底。
改一处,再跑一次#
把初始上下文改成:
let context = '周末我准备休息'再跑。
输出会变成:
没有更多候选内容,生成结束。为什么?
因为 candidateMap 里只写了"学习"这条路,没有写"休息"后面接什么。程序查不到候选,只能停。
这个"失败"恰好说明了一件事:这个脚本是模拟,不是模型。它的候选表是咱们手写的,所以只有写过的路径能走通。
真实模型不是查表。它是把当前上下文整个喂进网络,现场算出一组 Logit,再采样。上下文只要变了,哪怕只多一个标点,算出来的分布都可能不同。
也正因为是"现场算",才会有咱们下一节要讲的东西:Token 怎么切、上下文有多长、温度怎么调。
几个容易误解的点#
PS 1:贪心选择不等于真实模型的行为。
真实模型常用 Temperature、Top-k、Top-p 采样,不一定选概率最高的。所以同一句话问两次,答案可能不一样。这个脚本为了演示稳定,固定选了最高概率,你每次跑结果都一样。
PS 2:概率高不等于"正确"。
53% 是"在这个上下文里,下一个 Token 是它的相对可能性",不是"这个答案的事实正确率"。模型可以非常自信地生成一个错误答案,这两件事下一节还会碰到。
PS 3:打字机效果有三种来源,别混。
模型逐 Token 生成、传输层流式返回、前端逐字渲染,是三件不同的事。看到逐字出现,不能直接断定用了 SSE;反过来,关了 SSE,模型也依然是一个 Token 一个 Token 生成的。
总结#
回到开头的问题:模型是怎么把一句话写出来的?
- 它先根据当前上下文,给一批候选 Token 打分(Logit)。
- Logit 经过 Softmax 变成概率。
- 按某种策略选一个 Token,拼到上下文后面。
- 用新上下文再来一轮,直到遇到
<EOS>或达到停止条件。
所以模型不是在"写一整句话",而是在一步一步预测下一个 Token。一句话是被"接"出来的,不是被"打印"出来的。
理解了这个循环,后面很多现象就顺了:为什么同样的输入会得到不同答案(采样)、为什么上下文一长就贵(每轮都要重新看上下文)、为什么模型会一本正经地错(它只负责预测,不负责核实)。
下一节,咱们把镜头再拉近一点:模型眼里的"字",到底是什么?也就是 Token。