让流浪汉都能学会的大模型教程——Transformer：输入是怎么“变”成输出的？

在第二章里，我们讲了大型语言模型（LLMs）是怎么把文本看成一个个基本单位，也就是「tokens」的。现在，我们要来聊聊：模型在看到这些 token 之后，接下来会做什么？

大语言模型生成文本的方式，其实和人类形成句子的过程非常不一样。LLM 是在处理 token，但它又不像人类那样理解字母之间的关系。

比如你看到“magic”、“magical”、“magician”这几个单词，很自然就能看出它们是“魔法”这个主题的变体，意思是相关的。但 LLM 看到的只是几个数字（每个 token 对应一个整数），它并不知道这些词是一个词根变化而来，除非你专门“教”它怎么去理解这些连接。

这就导致模型需要走一条“非人类”的路径来完成任务：
它会先把 token 转成一堆数字（模型能处理的形式），然后再从这些数字里“算”出下一个 token，再变成文本。
这个循环会一直重复：
👉 Token ➜ 数字 ➜ 新 Token ➜ 数字 ➜ 再下一个 Token...

听起来是不是有点像：你说一句话，每说一个词前都要按计算器？如果你身边同事说个话还得做几道数学题，你可能会劝他赶紧去医院了😅。

但这，就是 LLM 正常的工作方式。

本章我们会从两个层次来解释这个过程：

1️⃣ 先从宏观角度，带你整体了解 LLM 是怎么一步步生成文本的，构建起你心中的“运行模型”。
2️⃣ 然后，我们会用这个心智模型为框架，深入拆解 Transformer 的核心组件 —— 这些设计是怎么帮助模型学会语言里的上下文关系、词与词之间的关联，最终生成我们熟悉的高质量文本输出。

3.1 Transformer 模型到底是什么？

你现在看到的很多大语言模型（LLM），比如 ChatGPT、Gemini、Claude，背后其实都有一个共同的“核心引擎”——它们用的都是叫做 Transformer 的架构。

你可以把 Transformer 想成一套用来“理解”和“生成”语言的软件系统，它的本质其实是通过一堆算法 + 数据结构，把文本转换成数字，然后用神经网络来处理这些数字，最后再把它变回文本。

Transformer 本质上在干嘛？

一句话：它就是在预测下一个 token 是啥。

虽然我们常说它在“理解语言”、“推理”、“聊天”，但它自己其实并不真的懂语法或句意，它只是在根据你说的话，猜你接下来可能说什么。

Transformer 有三种不同的工作方式，我们重点会讲最出名的 GPT 架构（也就是 decoder-only 模型），但还是先简单了解一下另外两种：

🔹 Encoder-only 模型

这种模型不是用来生成文本的，而是为了把一句话变成一个“更好用的数值形式”。它不会续写文本，而是“压缩”句子的意思，方便其他模型用。
常用于研究和分析任务，比如问答、分类之类的。
代表作：BERT、RoBERTa

🔹 Decoder-only 模型（我们熟的 GPT 就是这个）

这个模型干的活就是：给我一个开头，我来猜接下来该说啥。
也就是：你写一半，我续一段。它非常擅长“生成”语言，适合写文章、对话、创作等等。
代表作：GPT、Gemini

🔹 Encoder-Decoder 模型

这种模型的玩法是：你给我一整段，我给你一段“对应的输出”。比如你给我一段英文，我输出一段中文；你给我一篇长文，我写个摘要。
训练成本高，使用也复杂些，但有明确输入输出的任务，它往往比 decoder-only 模型表现更好。
代表作：T5、Google Translate 背后的模型

不管是哪种 Transformer，其实内部构造都很像。你可以把它们比作汽油车的发动机 —— 每家可能用法不太一样，但基本零件差不多，都是那些活塞、气缸、传动轴。

那神经网络的“层”到底是啥意思？

我们经常说“神经网络”、“多层网络”，听起来好像和大脑有关对吧？但其实，它跟人脑关系不大。

“神经网络”这个名字更多是一种比喻——我们是受了点人脑的启发，比如说大脑是靠神经元之间传递信号的，那我们就也来搞“节点”和“连接”这样一套。但别当真，它不是生物学，是工程！

更确切地说，“神经网络”更像是建筑工程：你要建一个房子，有地基、有墙面、有天花板，每一层就是一段结构。

每种“层”（Layer）有自己的功能，比如有的层是用来“感知语义”，有的层是用来“做注意力机制”。

Transformer 模型也是这样，用很多种“层”拼在一起，搭成一个能理解和生成语言的强大系统。

3.1.1 Transformer 的三大核心组件

Transformer 模型主要由三大部分组成：

1. 嵌入层（Embedding Layer） ：
   把 token 转换成有“意义”的数字表示，类似把“猫”、“狗”这样的词变成模型能理解的向量。
2. Transformer 层（Transformer Layer） ：
   真正的大脑，用来理解词与词之间的关系，推断上下文，决定下一个 token 是谁。
3. 输出层（Output Layer） ：
   把模型内部那些复杂的数值结果转回成我们人类能读懂的文字。

在上文我们简单介绍了 Transformer 模型的结构，现在我们来把每一层的工作原理详细讲一讲：

🧱 1. 嵌入层（Embedding Layer）

这个层负责的事情听起来简单，但非常重要——把每个 token（词或词的一部分）变成有“意义”的数字表示。

你可以理解成：
就像我们大脑知道“狗（dog）”和“狼（wolf）”有点像，而“狗”和“法国（France）”就完全没关系，嵌入层的任务，就是把这种“语义上的关系”变成“数字上的相似”。

比如，在数字空间中，“dog” 和 “wolf” 之间的向量距离会很近，而 “dog” 和 “France” 就会远得多。
这让模型能更像人一样“感知”出词汇之间的关系。

📌 类比一下：嵌入层就像是你大脑看到书页上某个词的时候，把它“翻译”成脑海中的概念。

⚙️ 2. Transformer 层（Transformer Layer）

这是 LLM 真正开始“干活”的地方，也是最关键的计算核心。

它的工作是：根据上下文分析每个词之间的关系，理解句子结构，进而判断下一个词应该是什么。

一个 LLM 通常只有一层嵌入层、一个输出层，但可能有几十层甚至上百层的 Transformer 层——模型越大，这一部分越多、越复杂。

很多人会说 Transformer 层是模型的“思考器”，听起来好像它在“思考”语言。但别误会：它不会像人一样思考，它只是每次都用一套固定的规则，处理每一组输入。

💡 你可以把 Transformer 层想成一个由很多“模糊规则”组成的引擎：

• 模糊，是因为它允许词义上的相似（比如“dog” ≈ “wolf”）。
• 规则，是因为它训练完之后，每次处理都一模一样，没有临时“变通”的能力。

所以，它不是“想了一下再说”，而是“按公式走流程”。

🔁 3. 输出层（Output Layer）

当 Transformer 层完成了计算，得出了一个“答案”的数值表示后，输出层就上场了。

它的任务是：把这个“概念空间”里的数值结果，重新翻译成人类能读懂的“token”。

换句话说：

• 嵌入层是“词 → 向量”，
• 输出层是“向量 → 词”。

而这个翻译过程，也叫“反嵌入（unembedding）”。

💡 可以类比成：你脑子里已经想好了要说什么内容，现在要把它组织成一句通顺的语言表达出来，用最合适的词来呈现你脑子里的意思。

3.2 深入探索 Transformer 架构：一步步看清它怎么“想事情”

为了更清楚地理解 LLM 这个大家伙在内部到底做了啥，我们可以把之前讲过的内容，换个角度看——把整个过程分解成七个明确的步骤，就像流水线那样。

书中提到图 3.2（当然我们这里没有图，不过没关系），它列出了这七个关键步骤。我们也会在后面对每一步一一解释，要么回顾前文讲过的知识，要么补充新的细节。

⚠️ 友情提示：这一章节信息量比较大，但别担心，我们会像剥洋葱一样一层一层慢慢来，把每个点都讲明白，不急着一口吃成胖子。

想弄懂 LLM 怎么“思考”和生成内容，我们可以把它的处理过程拆解成下面这 7 步：

1️⃣ 把文本转换成 token（标记） —— 这个我们在第 2 章已经讲过了。

2️⃣ 把这些 token 映射到“嵌入空间”中 —— 也就是把它们变成模型能理解的数字表达（这一节的新内容，我们马上会讲）。

3️⃣ 给每个 token 加上它在原句子中的“位置信息” —— 因为模型虽然是看“词”的，但它自己是没啥顺序感的，需要我们手动告诉它哪个词排在哪儿。

4️⃣ 把数据输入到 Transformer 层中，重复 L 次 —— Transformer 层是模型“思考”和处理信息的主要地方。

5️⃣ 通过“反嵌入层”计算可能作为输出的 token 列表 —— 也就是模型现在来猜：“下一个词我可能会说啥？”

6️⃣ 从这些可能的 token 中采样一个，作为下一个生成的词 —— 这个采样过程，其实有点像“掷骰子”，有随机性也有概率权重。

7️⃣ 把最终的 token 列表翻译回人类能读懂的文本 —— 又回到了第 2 章讲的解码步骤。

3.2.1 嵌入层（Embedding Layers）：让模型看懂 token 的含义

token 虽然是模型能识别的“词”，但说到底它只是个编号，比如 “apple” 可能是 token 编号 14325。但是！神经网络不直接操作这些编号，它们只处理数字向量（可以加减乘除的那种），而不是固定的整数。

为什么要用向量来表示 token？

因为：

• 模型处理的是连续数值（像 0.3、-2.7、3.1415 这种），不是简单的“编号”。
• 每个 token 不止一个意思，比如 “bank” 可以是“银行”也可以是“河岸”，我们光用一个数字没法表达出这种“模糊但相关”的语义关系。
• 所以，我们用一组数字（也就是一个向量）来表示每个 token，这样可以捕捉更多“语义层面”的信息，比如“狗”和“狼”就会在向量空间里很接近，而“狗”和“冰箱”就差得很远。

你可以把嵌入层想象成：模型大脑的语言感官系统，它负责把字词转化成一种“概念意义的数字表达”，让后面的模型能“理解”这些词背后的意思。

举个例子，假设我们现在有个 token 是 “stock”（股票） ，我们随便决定给它赋个数字，比如 5.2。那如果我们遇到跟它意思相近的词，比如 “capital”（资本） ，那也许我们就会想给它一个差不多的值，比如 5.3，因为它俩意思挺接近的。

那问题来了：

• 如果我们想表达“相反的意思”，是不是可以用负数呢？比如“rare”（稀有的）是“stock”（库存、常见）的一种反义词，那我们给它 -5.2。
• 但“capital”（资本）的反义词是“debt”（债务），我们是不是也该给它负数，比如 -5.3？

可你一算会发现：这时候“rare”和“debt”在数轴上就很接近了，好像它俩意思也差不多一样了。但你一听就知道这完全说不通 —— “稀有的”和“债务”哪有关系？！

这就说明了一个很严重的问题：
👉 如果你只用一个数字来表示每个词，那你根本没法正确表达词与词之间复杂又多变的关系。

我们这里还只是用了四个词，问题就已经开始绕得不清不楚了。如果是几万个词，那就更别提了。

聪明的做法是：用多个数字来表示一个 token，这样就能更好地刻画词语之间各种复杂的关系。

比如说，在图 3.4 中，我们用两个数字来表示每个词，就能看到一些挺有意思的现象：

• “bland”（平淡的）这个词，离“rare”（生的）和“well-done”（熟的）都差不多远，这就体现出它的“中性”意味；
• “bank”（银行）跟“rare”“well-done”这种描述食物的词完全无关，它反而更接近“stock”（股票）——因为它们属于金融领域；
• 我们还可以继续加入更多词，维度越多，就能表达越丰富的语义关系。

💡 在这个语境下，“多个数字”被称为“维度（dimension） ”，你可以把它想成词的“思想坐标”，坐标越丰富，它在“意义空间”里的位置就越精准。

什么是“维度的诅咒”？

那你可能会问： “既然维度越多越好，那我用几百几千个维度不就完美了吗？”

问题来了 —— 这时候就遇到著名的“维度的诅咒”。

这个概念是数学家 Richard E. Bellman 提出来的，意思是：

• 当维度变多时，你需要的计算资源、内存、训练数据量和训练时间都会呈指数级爆炸；
• 你的“语义空间”就像是个越吹越大的气球，里面空得很，想学懂每个角落的意义就会变得非常困难。

所以虽然我们希望 embedding（词向量）能表达更多意思，但现实是你受限于计算能力，不能“无限堆维度”。

在 LLM 的语境中，我们通常把“用来表示 token 的数字列表”叫作 embedding（嵌入向量） ，每个 embedding 就是一串浮点数（比如 [0.1, -2.3, 3.5, ...]）。每个数字就对应一个“维度”。

这种多维的表示方法可以让词与词之间形成有意义的空间关系。
比如：

• 同义词会被“拉”得比较近；
• 反义词就“推”得比较远；
• 还可以做一些很酷的“向量变换”。

一个经典的例子：

在图 3.5 中有个特别著名的案例：

king - man + woman ≈ queen

什么意思呢？

• 我们用 embedding 的方式来减去“男性”的概念，再加上“女性”的概念；
• 这时你会发现，“king”（国王）就自动变成了“queen”（女王）！

类似的变换你还能套在“actor（男演员）”身上，就能得出“actress（女演员）”。

这说明在这种高维语义空间里，模型确实可以同时“维护”多种关系：性别、职业、领域、情感色彩等等。

令人震惊的是，我们并不能保证模型在训练过程中一定能学到这些“语义关系” 。
很多人以为，词向量之间的这种逻辑关联（比如“king - man + woman = queen”）是训练必然的结果，但其实不是，它只是**“刚好学出来了” ，而且确实挺有用的**。

不过，这也意味着：
➡️ 语义空间里的关系并不是百分百准确或可靠的，它并不反映“真理”，而是反映了你给模型喂的文本数据中的偏见。

举个例子：

• 如果训练数据中，“doctor”（医生）大多数时候被描述成男性，而“nurse”（护士）经常和女性联系在一起，
• 那么模型也会自动学习到：“doctor” ≈ 男性，“nurse” ≈ 女性。

这显然不是世界的真相，而是现实世界数据的刻板印象被模型“继承”了。

正因为 Transformer 本身没啥“顺序感” ，所以我们需要在 embedding 这一步手动补上。

所以，embedding 层其实会做两件事：

1️⃣ 首先，它会生成一个 词向量，代表这个词的“含义”——比如 “dog” 可能是 [0.3, -0.7, 0.2, …]
2️⃣ 然后，它还会生成一个 位置向量，告诉模型这个词是句子里的第几个——比如“排第3”的词，对应位置向量 [0.1, 0.4, -0.2, …]

这两个向量会被加在一起，变成一个新的、融合了“词义”和“位置”的向量，送进后面的模型里。

我们可以想象成：
➡️ 你说“狗追猫”，模型拿到的不是单纯的“狗”、“追”、“猫”这三个词的含义，而是“第一个词是‘狗’”、“第二个词是‘追’”……
这样一来，模型才知道“谁在前谁在后”，不至于把“猫追狗”搞混了。

这些内容差不多就把「如何把 token 变成可以喂给 transformer 的向量」这块讲清楚了。
你可能会觉得：“这也太简单了吧？就只是向量相加？”
确实挺朴素的，但神奇的是，这种“全都转成向量然后加起来”的方式，居然效果非常好。

而且这个套路不仅能用在文本，连图像、视频都能搞——所以虽然看起来傻傻的，它却因为“好用、通用”而变成了业界主流做法。

3.2.2 Transformer 层：模型真正开始“干活”的地方

接下来进入 transformer 模型的核心——transformer layer，这是真正“做运算”的地方。

之前的 embedding 更像是准备食材，这里才是下锅炒菜。

传统的神经网络层（比如 embedding 层）通常会预设一些对世界的“信念”，
比如「相邻的词更相关」、「图像要考虑邻近像素」之类的。
如果这些预设符合现实，那模型能用更少的数据训练出好结果。

而 Transformer 干脆不管这些，它的思路是：
“我不预设任何偏见，只要你喂我够多的数据，我自己能学会！”

那它到底是怎么学的呢？Transformer 的核心机制是 注意力机制（Attention） ，这玩意背后有三大主角：

• Query（查询） ：你想找什么？由当前这个 token 的向量生成；
• Key（钥匙） ：你能选什么？代表其它 token 的特征；
• Value（值） ：你能得到什么？这个值会影响输出。

是不是有点像 Python 里的字典查值？但 Transformer 的 attention 查得更“聪明”：
它不是“一对一”的查，而是“模糊匹配”——每个 key 都会参与进来，但贡献不一样。

举个例子：

你问：“这句话的主语是啥？”（Query）
然后模型会去看看“他（key1）”、“吃（key2）”、“香蕉（key3）”哪个更像你想找的答案，
越像的就给更高的权重（attention 分数），最后加权组合这些 value，输出结果。

这就像你开会时听你老板讲话（query），突然火警响了（key），你注意力立刻切换到了“火警”上。
Transformer 也是这样——会自动把注意力集中在“关键内容”上，不重要的词就少给点关注。

🧠 也就是说：

每次要生成一个新 token，Transformer 都会：

1. 拿这个位置的 Query
2. 拿之前所有 token 的 Key
3. 对比一下 Query 和每个 Key 的相似度，算出权重
4. 用这些权重加权 Value，得出当前 token 的输出向量

这个 Attention 的过程，就是 Transformer 学会“哪些词和哪些词有关联”的关键！

Attention 的数学到底是啥？

说实话，如果真的把 Attention 的数学细节全展开，会占掉不少篇幅（而且很多书已经讲得很详细了）。
如果你想追求技术细节，可以去看《Inside Deep Learning》这本书的第 11 章，我们作者在那里面专门讲了 Attention 和 Transformer 的底层机制。

但如果你只是想知道个大概，那这里有个简化版的公式：

$Attention = Softmax(Q · Kᵗ / √d) · V  (公式 3.1)$

什么意思呢？简单讲：

• Q 是 Query，K 是 Key，V 是 Value，它们都是向量矩阵。
• Q · Kᵗ 是矩阵点乘，表示“这个词和别的词有多像”。
• 除以 √d（向量的维度）是为了防止值太大，softmax 不稳定。
• Softmax 会把一堆相似度值变成权重（加起来等于 1），这就是“注意力”的本质。
• 最后用这些权重乘以 Value（V），得到你最终想关注的信息。

如果你用过 Python 的字典，可以这么理解：

Attention 就像你模糊查字典，“找最像的那个 key，然后把它的值拿出来”，只不过是“多个 key 加权合并”而不是找一个精确值。

---

接着还有一个公式：

$Output = x + Norm(Attention(x)) + Norm(Feedforward(x))  (公式 3.2)$

这是什么意思？

这是 Transformer 的“跳跃连接 + 残差结构”：

• 把原始输入 x 保留下来（跳跃连接）
• 把 Attention(x) 和 Feedforward(x) 做归一化处理（Norm）
• 全部加起来，作为这一层的输出

这结构的目的是为了防止深层模型“梯度消失”、“信息丢失”等问题——可以理解为“保留一些原汁原味的信息 + 加点新加工的东西”。

如果你没听说过 “layer normalization” 或 “feedforward 网络”，不用担心。
这不是读懂本书的必备知识——只要知道“Attention 会帮模型决定关注谁，最终生成结果”就可以了。

Transformer 有很多层，但不是每层都在“写字”

一个 Transformer 模型，往往由几十甚至上百个 transformer layer 组成。

不过，真正负责“写出下一个词”的，只有最后一层。

前面那些中间层，其实只是反复做同一个动作——对输入做变换、提取信息、做一些“内部加工”。
但正是这种堆叠，才让模型能学会像“推理、归纳、分类、排序”这些复杂任务。

可以这么理解：

前面几层负责准备逻辑和线索，最后一层才落笔成词。

3.2.3 Unembedding：把向量变成词

Transformer 层的输出，仍然是向量，咱们还得把它变成真正的词或者 subword，才能输出给用户。
这一步就叫 Unembedding，有时候也叫 Decoding（解码） 。

你可以这样理解：

“我已经想好要说啥了（有了一个意思的向量），现在我要挑选一个词把这个意思表达出来。”

这个步骤很关键，因为：

1. 它直接决定了现在这个 token 是什么；
2. 下一步要生成啥，也会参考这个 token；

所以，这就是所谓的 自回归生成（autoregressive generation） ：
下一个 token 的生成依赖于之前已经生成的所有 token。

图 3.10 里展示的，就是这个“一个一个生成 token”的过程——一步步猜词、一步步拼句子。

你可能会好奇：模型怎么知道啥时候该停下来？

其实很简单 —— 在构建词表（vocabulary）的时候，我们会特地加几个“特殊 token”，这些词在自然语言中不会出现，比如一个专门表示“结束”的词，叫 EoS（End of Sequence） 。

模型在训练的时候，就学会了：

“如果看到这个 EoS token，那就代表这句话讲完啦。”

所以，当模型在生成文本的过程中，某一轮它挑中了 EoS 这个 token，我们就知道该收工了，把它生成的内容返回给用户就行了。

当然，万一模型抽风，一直没生成这个结束符怎么办？
没关系，实际部署时我们一般还会设置一个“最大输出长度”作为兜底，比如最多生成 2048 个 token，防止模型无限循环。

怎么从向量里选出词来？

前面我们说了，Transformer 最后输出的是一串向量，那怎么从这堆数字中挑出一个词（token）来呢？

这就到了非常关键的一步：采样（sampling） 。

采样的核心思想是：根据模型对“下一个词可能是什么”的预测概率，在词表里挑一个词出来。注意，不是总是挑概率最高的那个，而是用点“随机性”。

这个过程其实分两步：

1️⃣ 计算概率：对词表里的每个 token，算出它作为“下一个词”的概率有多大。
2️⃣ 抽签决定：按这些概率去“随机抽一个词”作为模型当前要生成的 token。

你如果用过 ChatGPT 可能会发现：同样的问题，问好几次，有时候回答会不一样。

为什么？原因就在这步——采样引入了随机性。

你可能会想：

“不对啊，AI 不应该是确定性的嘛？为啥还要随机选？”

但其实，这种随机性正是让回答更自然的关键。

想象一下：

你对一个人说 “I love to eat”（我喜欢吃…），结果对方每次都接一句 “sushi”，那听起来就怪怪的对吧？

我们平时交流会说：

• “I love to eat sushi.”
• “I love to eat pizza.”
• “I love to eat noodles.”

这些都是合理的选项。如果模型每次都死板地选概率最高的那个（比如 sushi），听起来就像是个复读机。

所以，为了模拟人类那种“有选择性但又不完全重复”的表达方式，模型必须引入采样 + 概率机制。

图 3.11 展示了这个过程：
一句话到了 “I love to eat” 的时候，模型脑子里会出现好多备选词：

• 🍣 sushi（40%）
• 🍕 pizza（25%）
• 🥡 noodles（15%）
• 🍔 burgers（10%）
• ……

然后，它会按这个分布“抽一个出来”作为下一个词。

这就是为什么你问同一个问题，AI 不总给你一模一样的回答 —— 它不是变傻了，是变得更“像人类”了。

在前面的图 3.11 中你可能已经注意到了，有些词（token）明显不合逻辑，比如 “42”，但它依然被赋予了一个极小的概率。这是因为我们得给词表里的每个 token 都分配一个概率，这样模型才知道哪些词是“可能出现的”，哪些是“基本不可能”的。

那么，模型是怎么给 token 分配概率的呢？

每个可能作为“下一个词”的 token，模型都会给它打一个分数（score） 。

这个分数是怎么来的？简单说：

• 模型会拿当前上下文的信息（Transformer 最后输出的向量），
• 然后跟词表里每个 token 的 embedding（向量）进行比较，
• 比得越像，分数就越高。

分数的范围是 -∞ 到 ∞，可以很小也可以很大。

但这些原始分数不是概率本身，而是用来生成概率的依据。

我们关心的是相对差异，比如：

Token	Score	概率（约）
“sushi”	65.2	约 50.5%
“pizza”	65.1	约 49.5%
“chalk”	-5.0	几乎为 0

无论分数是 65 和 64，还是 0.2 和 0.1，只要差值一样，概率分布就差不多。我们只关心谁更高。

为什么偶尔模型会说出奇怪的话？

因为即使是“几率非常低”的 token，也不是“绝对为 0”。所以：

• 偶尔模型会“抽签抽中”这些冷门选项；
• 一旦选择了一个奇怪的词，后面的生成也会尝试“自圆其说”。

比如模型说了句：

“I love to eat chalk.”（我喜欢吃粉笔。）

这听起来怪怪的，对吧？但模型可能接着写下去：

“This could be a symptom of pica…”（这可能是异食癖的表现…）

你会发现，它确实跑题了，但好像也能说得通 —— 这是所谓的“罕见但合理” 。当然，也有时候会完全离谱，那就看采样机制怎么设定了。

怎样让模型不说蠢话？

一种比较常见的方法叫 核采样（nucleus sampling 或 Top-p sampling） 。

它的做法是：

1. 模型先算出所有 token 的概率；
2. 然后只保留最可能的一部分词（比如累计概率达到 95%）；
3. 然后在这些“高概率词”里随机抽一个。

这样既能保留一定的随机性，又不会说出“chalk”这种冷门离谱词。

所以，如果你在做 LLM 应用，了解你的模型用了什么采样方式非常重要，这直接影响它的输出稳定性与“胡说八道”的可能性。

3.3 创意 vs 稳定：温度的权衡

LLM 输出的“风格”其实可以调的，其中最重要的一个控制参数叫 temperature（温度） 。

Temperature 控制的是输出的“随机程度”。

• 温度越高（接近 1） ，输出越有创意，也越不稳定；
• 温度越低（接近 0） ，输出越稳重保守，也更靠谱但缺乏惊喜。

举个例子：你在做什么应用？

🔸 如果你是拿 LLM 做产品创意头脑风暴 ——
你希望模型跳脱一些、给点你没想到的奇怪点子，那就该设个 高温度，比如 0.9。

🔸 如果你是让 LLM 做离线查资料（比如手机上离线版 ChatGPT） ——
你希望模型回答简洁、准确、不要乱编，那就该用 低温度，比如 0.2 或 0.3。

温度的形象比喻：一杯水

想象一杯水，里面是很多分子：

• 如果温度是 0度（接近绝对零度） ，水分子几乎不动，那么你每次从水面捞上来的那个分子可能都是同一个（稳定）。
• 如果温度升高到水都 开始沸腾，水分子疯狂乱跳，那么你捞起来的就是完全随机的一个（充满变化）。

这就好比：

• 温度低：每次生成结果都差不多（稳定、理性）；
• 温度高：每次都有可能不一样（创意、惊喜，也可能翻车）。

3.4 Transformer 是怎么玩起来的？

这一章我们讲了很多内容——
从 嵌入层（embedding layer） 到 transformer 层 再到 反嵌入层（unembedding layer） ，这些就是让大语言模型能“动起来”的核心模块。

我们还聊了：

• 模型是怎么用向量表示词义的；
• 是怎么知道词和词之间谁离谁近的；
• 又是怎么一层一层堆叠 Transformer 来“读懂”句子的结构；
• 最后一步步生成看起来挺像人写出来的回答。

这些都是理解 LLM 怎么抓住文本信息、生成优质内容的关键。

但我们还没讲完！

你可能会问：

“那这些层是怎么来的啊？
模型怎么知道哪个词是什么意思？怎么知道谁该离谁近？”

这就要说到 训练（training） 了。

我们得把大量大量的文本数据喂进去，
让模型从中自己“悟”出规律，
学会哪些词经常出现在一起、哪些词有什么关系、下一个词该怎么接等等。

下一章，第 4 章，我们就会讲清楚这个过程：
怎么把数据送进模型里，
又怎么“引导”模型去学会有用的语言规律，
最终把它变成一个能用的大语言模型。

准备好了吗？咱们下一章见！

小结：这一章我们都学了啥？

咱们之前说过，大语言模型（LLM）是靠 token 来理解语言的。
但在模型内部，其实这些 token 都会被转成一串数字，也就是所谓的 向量（embedding vectors） 。
这些向量能表示出“词和词之间的关系”——比如谁和谁意思差不多、谁是反义词、谁彼此不怎么相关等等。

不过有个问题：
Transformer 模型天生不懂词的顺序，也就是说它本来不清楚哪个词是第一个、哪个是第二个。

解决办法也很简单粗暴：
我们再搞一组向量专门表示“第几个词”，然后把这个位置向量加到原本的词向量里，这样模型就能知道顺序了。

然后重点来了——Transformer 层 是整个模型的大脑，它的工作方式有点像“模糊查字典”。
你给它一个关键词（叫 Query），它会拿去和之前的所有词（叫 Key）比一比，
然后根据相似度，算出一个“权重”，从而决定到底要参考谁（这个值叫 Value）。
这整套玩法就叫 注意力机制（Attention） 。

你可以把它想成一个会模糊比对的词典，找的不是“唯一答案”，而是“谁最像我想找的那个词”。

还有一点：
ChatGPT 属于 Decoder-only Transformer，也就是专注于“接着写下去”的那种。
除了它之外，还有 Encoder-only（比如 BERT）和 Encoder-Decoder（比如 T5、Google Translate）这两类，分别更适合做信息提取、翻译这种输入输出不对称的任务。

最后，LLM 是一种 自回归模型（autoregressive model） ，意思就是它是一个词一个词慢慢生成的。
每次生成新词，都会把前面已经生成的所有词再重新喂进去，预测下一个词该是什么。
简单说，就是： “下一个词，得看我前面说了啥。”