Agent 全栈实战

1.3 大语言模型如何生成内容#

前面两节,咱们已经知道模型能回答问题、能被 Prompt 影响,也知道它有时候会一本正经地胡说八道。

但是,模型到底是怎么把一句话"写"出来的?

这一节,咱们就把这件事拆开看。

先看一个每天都在发生的现象#

打开任意一个 AI 聊天窗口,问它一句:

用一句话介绍什么是 Agent。

然后盯着屏幕看。

你会发现,回答不是"啪"一下整段出现的,而是一个字、一个字往外蹦。就像有人在屏幕后面打字。

很多人第一反应是:哦,这是流式输出(SSE),前端做了一个打字机效果。

这个理解,对了一半。

前端确实可能做打字机动画,传输层确实可能是 SSE。但模型本身,就是一次只生成一个 Token 的。

哪怕你把 stream 关掉,等它全部生成完再一次性返回,模型内部依然是:生成一个 Token → 接到上下文后面 → 再生成下一个 → 直到遇到结束标记。

所以"逐字出现"不是前端装饰,而是生成机制本来的样子。前端只是把这个过程露出来了。

那问题来了:模型每一步,到底是怎么选出"下一个 Token"的?

做一个实验:下一个词是什么#

假设上下文是这句话:

周末我准备

让你补全,你会接什么?

学习、休息、出门、打游戏……都可以,对不对。

模型面对的也是同一件事:它不是从天上掉一个答案,而是先给出一批候选 Token,再给每个候选打分。

咱们用一个 Node 脚本把这件事模拟出来。代码在仓库里:

text
Node/第一章/03-llm-generation-demo/generation-loop.mjs

先看数据部分(generation-loop.mjs:7-46):

js
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:

js
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 干了两件事:

  1. 把每个分数变成正数(Math.exp);
  2. 再除以总和,让所有候选的概率加起来等于 1。

那为什么代码里要先减去 maxLogit?

因为 Math.exp(1000) 会直接溢出成 Infinity。所有分数同时减去最大值,概率比例不变,但指数不会炸。这是一个纯工程上的数值稳定处理,跟模型"聪不聪明"没关系。

算完之后,三个候选大概是这样:

候选概率
学习53.14%
休息29.17%
出门17.69%

注意,最高的也只有 53%,不是 100%。

这就是关键:模型每一步都在"一批可能里挑一个",而不是"查一个标准答案"。

挑一个,接到后面,再来一轮#

有了概率,接下来就是选择。

这个脚本用的是最简单的策略:谁概率高选谁。也就是贪心选择(generation-loop.mjs:79-85):

js
function chooseHighest(probabilities) {
	return probabilities.reduce((best, current) =>
		current[1] > best[1] ? current : best
	)
}

选中"学习"以后,把它拼到上下文后面:

js
context += selectedToken

上下文从 周末我准备 变成 周末我准备学习。

下一轮,程序拿新上下文再去查候选表,得到新的三个候选:

候选概率
' Agent'69.27%
' Node.js'23.06%
'英语'7.68%

再选、再拼、再查。直到某一轮,候选里出现 <EOS>,也就是 End Of Sequence,结束标记。

看到 <EOS>,生成就停。

这就是完整的生成循环:预测 → 选择 → 拼接 → 再预测。

跑起来看看#

这个脚本零依赖,直接跑:

bash
cd Agent--Code/Node/第一章/03-llm-generation-demo
node generation-loop.mjs

真实输出(节选):

text
第 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 兜底。

改一处,再跑一次#

把初始上下文改成:

js
let context = '周末我准备休息'

再跑。

输出会变成:

text
没有更多候选内容,生成结束。

为什么?

因为 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。