索未 · 阅读 ｜ 周读·深度书评

8.14 | 周读 |《Build a Large Language Model (From Scratch)》

前两期，我们分别从《AI Engineering》和《Hands-On Large Language Models》理解了两个层面的问题。

第一层是：怎样把基础模型真正做成可以评估、部署和持续改进的 AI 应用。

第二层是：Token、Embedding、Transformer、语义搜索和 RAG 这些组成部分，究竟怎样共同支撑今天的大语言模型应用。

但还有一个更基础的问题没有真正回答：

一个大语言模型本身，到底是怎样被制造出来的？

我们每天使用 ChatGPT、Claude、Gemini 或者各种开源模型，可以讨论提示词、RAG、Agent、上下文工程，却很少真正接触模型内部。

一句自然语言是怎样被转换成数字的？

Attention 到底计算了什么？

几十层 Transformer 为什么能够从海量文本中学习语言模式？

所谓“预训练”，模型究竟在优化什么？

一个只会续写文本的基础模型，又怎样变成一个能够按照用户要求回答问题的助手？

Sebastian Raschka 的《Build a Large Language Model (From Scratch)》就是围绕这条路径展开。

它没有让读者调用某个现成的大语言模型 API，也没有依赖成熟的 LLM 开发框架，而是使用 Python 和 PyTorch，从文本处理开始，一步一步实现一个 GPT 式语言模型，再经历预训练、分类微调和指令微调。

作者的官方配套资料将全书核心路径概括为：文本数据 → Embedding → Attention → GPT 模型 → 预训练 → 微调。

这也是这本书最重要的价值：

把“大语言模型”从一个黑盒产品，重新还原成一套可以被拆解、计算、训练和验证的工程系统。

· · ·

今天如果只是想开发 AI 应用，从零训练一个模型通常并不是最经济的路线。

通过 API 或者开源权重，我们已经能够直接获得性能远高于书中教学模型的基础模型。

因此，这本书的目的不是告诉普通企业：“以后不要调用模型 API，自己训练一个模型。”

恰恰相反。

它解决的是理解问题，而不是模型采购问题。

作者在官方资料中明确说明，这本书构建的是一个规模较小但功能完整的教学模型，其训练与开发过程在基本方法上模拟了大型基础模型的构建路径，同时也演示了怎样加载更大的预训练模型权重进行后续微调。

这很像学习汽车原理。

日常开车的人不需要自己制造发动机，但如果一个人希望真正理解动力系统，就需要知道燃烧、传动、制动和控制系统分别做什么。

AI 也是如此。

如果只停留在应用层，我们很容易形成一些模糊甚至错误的认识：

“模型记住了互联网。”

“模型理解了整本书。”

“微调就是把企业资料训练进去。”

“上下文越长，模型就知道得越多。”

“参数越大，回答一定越好。”

而真正亲手实现 Tokenization、Attention、Loss Function 和训练循环之后，会发现这些说法都过于简单。

模型并不是以人类理解知识的方式“学习”。

它实际上在不断解决一个极其朴素的问题：

根据前面已经出现的 Token，预测下一个 Token。

现代大语言模型令人惊讶的能力，很大程度上就是从这个训练目标逐步涌现出来的。

· · ·

很多人学习大语言模型时会直接跳到 Attention。

但一个模型首先面对的问题，其实更基础：

计算机怎样处理一句话？

模型不能直接读取“人工智能正在改变工作方式”这句话。

它必须先经过 Tokenizer。

Tokenizer 将文本拆成 Token，再将这些 Token 映射为整数 ID。

例如，一段文本可能经过类似这样的转换：

自然语言 ↓ Token 序列 ↓ Token ID ↓ Embedding 向量 ↓ Transformer

《Build a Large Language Model》第二章集中处理文本数据、Byte Pair Encoding、Embedding 以及训练输入与目标序列的构造。作者的章节地图也把这些内容明确放在 Attention 之前。

这一顺序非常重要。

因为它揭示了一个经常被忽略的事实：

模型训练的对象并不是“文章”，而是一串 Token 之间的统计关系。

假设训练数据包含：

模型在训练过程中可能看到：

“人工智能正在改变企业的工作”

然后被要求预测：

“方式”。

当然，真实训练过程中会存在大量滑动窗口和批次数据，但核心机制类似。

模型不断看到：

前面的 Token 是什么？

正确的下一个 Token 是什么？

我预测的概率分布与正确答案差多少？

然后通过反向传播调整内部参数。

这就是语言模型训练最基础的循环。

· · ·

Token ID 仍然只是编号。

比如：

"AI"对应 1532，

“模型”对应 8241，

“企业”对应 2917。

这些编号本身不存在语义。

1532 并不比 8241“更接近 AI"。

所以模型还需要 Embedding 层。

Embedding 把每个 Token 映射成一个由大量数字组成的向量。

这样，语言就从离散符号进入了一个可以通过矩阵运算处理的连续空间。

但这里有一个特别容易混淆的地方。

我们在上一期《Hands-On Large Language Models》中讨论 Embedding 时，更多是在讨论语义检索 Embedding：把一句话或者一段文档转成能够进行相似度比较的向量。

这里的 Token Embedding 更加基础。

它首先是神经网络内部用于表示 Token 的一组可学习参数。

随着模型训练，这些参数不断调整，使模型能够更有效地预测语言。

此外，还要加入位置信息。

因为：

“客户购买产品”

与：

“产品购买客户”

即使包含同样几个 Token，意义完全不同。

因此模型不仅需要知道是什么 Token，还必须知道Token 出现在什么位置。

这也是为什么 Position Embedding 或者其他位置编码机制，是 Transformer 架构不可缺少的一部分。

模型看到的从来不是一个词表集合，而是一个有顺序的 Token 序列。

· · ·

如果只能记住这本书中的一个公式之外的概念，我认为应该是：

Attention 解决的是当前 Token 应该怎样利用上下文信息的问题。

例如：

当模型处理“它”时，需要判断“它”更可能指向什么。

是“苹果公司”？

“新的模型”？

还是其他对象？

Self-Attention 允许一个 Token 根据上下文中的其他 Token 计算新的表示。

Sebastian Raschka 在第三章从最简单的 Self-Attention 开始，逐步加入可训练权重、Scaled Dot-Product Attention、因果遮罩、Dropout 和 Multi-Head Attention，然后才进入完整 Transformer Block。

这个学习顺序非常值得保留。

因为很多解释一上来就给出：

Query、Key、Value。

然后是三个矩阵。

再接 Softmax。

初学者很容易知道公式，却不知道模型到底在解决什么。

从直觉上看，我们可以把它理解成三个问题：

当前 Token 正在寻找什么信息？

其他 Token 能够提供什么信息？

Query、Key 和 Value 正是围绕这些关系进行计算。

每个 Token 产生自己的 Query、Key 和 Value 表示。

Query 与其他 Token 的 Key 进行匹配，计算相关程度。

经过 Softmax 后形成 Attention Weight。

再根据这些权重，对 Value 进行加权组合。

最终，当前 Token 得到一个融入上下文的新表示。

这一步看似只是矩阵运算，却是 Transformer 能够处理上下文关系的关键基础。

· · ·

如果模型只有一个 Attention Head，相当于每次只能通过一组投影方式观察 Token 之间的关系。

Multi-Head Attention 的思想是：

让模型同时从多个表示子空间观察上下文。

不同 Head 可以学习不同类型的关联模式。

但需要谨慎理解。

不能简单地说：

“第一个 Head 学习语法。”

“第二个 Head 学习事实。”

“第三个 Head 学习情绪。”

某些 Attention Head 确实可能表现出较明显的结构模式，但这些关系不是人为预先规定的。

它们是在训练过程中形成的。

书中从单头 Attention 一步一步构建到 Multi-Head Attention，就是为了让读者看到：

复杂 Transformer 并不是突然出现的神秘结构。

它只是很多简单数学操作逐层组合后的结果。

这也是"From Scratch"方法最大的价值之一。

当复杂系统被拆解到足够小的时候，神秘感会迅速下降。

· · ·

只有 Attention 还不是 GPT。

完整 Transformer Block 中还包括 Feed-Forward Network、Layer Normalization、残差连接等组件。

多个 Transformer Block 进一步堆叠，才形成 GPT 式网络。

在书中第四章，作者正式实现 GPT 模型，将 Embedding、Multi-Head Attention、Feed-Forward Network、LayerNorm、Shortcut Connection 和输出层组合起来。

这里有一个很重要的认识：

模型参数不是“知识数据库里的事实条目”。

一个大语言模型可能拥有数十亿甚至更多参数，但这些参数不是按照：

参数 1 = 北京是中国首都 参数 2 = 水在标准条件下某温度沸腾 参数 3 = 某公司的 CEO 是谁

这样的形式保存知识。

参数更像是一个巨大的分布式统计结构。

训练数据中的模式被压缩到大量权重之间。

因此，我们不能像查询数据库一样，要求语言模型必然精确返回某条事实。

这也是为什么：

语言模型擅长模式生成，

却仍然可能产生事实错误。

理解这一点之后，“大模型幻觉”就没有那么神秘了。

模型的基础训练目标并不是：

输出真实事实。

而是：

预测合理的后续 Token。

真实性必须通过数据质量、对齐训练、检索、工具调用、验证和应用层控制进一步提高。

· · ·

构建模型架构之后，真正训练还没有开始。

模型必须有办法知道：

自己的预测到底有多差。

假设正确的下一个 Token 是：

“模型”。

但模型给出的概率可能是：

“系统”：30%

“模型”：25%

“工具”：15%

“算法”：10%

……

模型并不是简单输出“对”或者“错”。

它输出的是整个 Vocabulary 上的概率分布。

训练过程中通常使用 Cross-Entropy Loss 衡量模型预测分布与正确 Token 之间的差距。

Loss 越高，说明预测越差。

接下来通过反向传播计算：

参数应该往哪个方向改变？

然后 Optimizer 更新参数。

这个过程不断重复：

Forward Pass → 计算 Loss → Backpropagation → 更新参数 → 下一批数据

经过大量训练步骤，模型预测下一个 Token 的能力不断提升。

书中第五章集中讨论预训练、训练 Loss、文本生成、采样以及预训练权重加载。

这一章实际上回答了一个最核心的问题：

语言模型所谓的“学习”，从数学上究竟是什么？

就是让预测误差逐渐下降。

· · ·

这是理解现代大语言模型最关键的区别之一。

经过海量文本进行 Next-Token Prediction 之后，我们得到的是：

Base Model。

Base Model 擅长续写。

例如输入：

它可能续写：

但如果输入：

未经指令训练的 Base Model 并不一定像今天的 AI 助手一样，自动理解：

“现在应该按照用户要求完成任务。”

它甚至可能继续模拟类似训练语料中的后续文本。

所以：

预训练让模型学会语言。

但：

并没有自动让模型学会成为助手。

这也是从基础模型走向 ChatGPT 式应用必须经历的第二阶段。

· · ·

这本书第六章和第七章非常值得连起来理解。

Classification Finetuning。

Instruction Finetuning。

二者都是微调，但目标完全不同。

分类微调，是让模型执行特定任务。

例如判断：

Spam / Not Spam。

模型原本负责预测下一个 Token，现在通过调整模型结构和训练数据，使它能够输出类别。

这属于任务适配。

Instruction Finetuning 则不同。

它让模型学习：

收到一个指令之后，应该生成什么样的回答。

训练数据大致呈现：

Instruction

→ Expected Response

• Input

例如：

Instruction：

“把下面一句话翻译成英文。”

Input：

“人工智能正在改变工作方式。”

Response：

"Artificial intelligence is changing the way we work."

当模型接触大量这样的指令—回答样本后，才逐渐形成今天我们熟悉的：

“用户提出任务，我执行任务。”

这是一种极其关键的能力转变。

因此：

会生成文本，不等于会遵循指令。

会遵循指令，也不等于具备可靠推理能力。

具备推理能力，也不等于事实一定正确。

这些能力需要被分开理解。

· · ·

当人们第一次了解微调时，很容易产生一个想法：

企业有很多资料，把所有资料拿去 Fine-tune 即可。

但真正阅读完整流程后，会发现这条路线存在很大误区。

Fine-tuning 的数据不是越多越好。

关键在于：

数据是否代表我们真正希望模型学习的行为。

如果训练集中：

指令表达混乱，

回答质量参差不齐，

格式不一致，

存在错误事实，

不同案例互相矛盾，

那么模型会学习这些问题。

人工智能领域有一句非常朴素却长期成立的原则：

Garbage in, garbage out。

数据问题不会因为模型更强而自动消失。

反而可能被模型大规模复制。

这也意味着未来企业拥有的重要 AI 资产，不只是 PDF、产品文档和数据库。

更有价值的可能是：

高质量的输入—输出样本。

例如：

真实客户问题 → 高质量人工回答；

技术问题 → 经专家审核的标准解释；

失败回答 → 修改后的正确版本；

复杂任务 → 高质量执行过程；

模型错误 → 人工纠正结果。

这些数据开始成为企业训练、评估和改进 AI 系统的重要基础设施。

· · ·

如果一个模型有几十亿甚至几百亿参数，对全部参数进行 Fine-tuning，需要巨大的显存和计算资源。

但很多时候，我们并不需要修改模型的全部参数。

LoRA，也就是 Low-Rank Adaptation，提供了一种参数高效微调方法。

书中专门在 Appendix E 提供了 LoRA 实现。

其核心思想可以简单理解为：

保留原有模型的大部分参数不动。

在部分权重层旁增加规模很小的可训练矩阵。

训练时只更新这些新增参数。

这样能够显著减少需要训练的参数数量。

从企业应用角度看，它代表一种很重要的方向：

模型适配并不一定意味着重新训练整个模型。

随着开源模型生态成熟，Parameter-Efficient Fine-Tuning 使企业能够以相对更低成本针对特定领域和任务进行模型适配。

但这仍然不意味着：

“以后所有企业都应该 Fine-tune 自己的模型。”

是否需要微调，仍然应该先回答：

现成模型具体哪里做不好？

Prompt 是否已经充分优化？

是否是知识缺失问题？

是否应该通过 RAG 解决？

是否存在稳定且足够大的高质量训练集？

微调之后怎样评估收益？

如果这些问题没有回答，LoRA 降低训练成本也无法解决项目目标不明确的问题。

· · ·

模型越大，一般意味着拥有更高的表示容量。

但参数增加会直接带来：

训练成本增加，

推理成本增加，

显存需求增加，

数据需求增加。

书中的教学模型能够在普通电脑环境中运行，作者也明确将主章节代码设计成尽可能可以在常规笔记本电脑上完成学习，而不是要求专业训练集群。

这是一种非常聪明的教学策略。

因为学习目标不是：

训练一个可以挑战最先进商业模型的系统。

而是理解：

如果把一个 GPT 模型缩小几千倍，它的基本结构是否依然一样？

答案在很大程度上是肯定的。

Token Embedding 依然存在。

Attention 依然存在。

Transformer Block 依然存在。

Cross-Entropy Loss 依然存在。

Backpropagation 依然存在。

Pretraining 依然存在。

Fine-tuning 依然存在。

规模不同，但很多基础原理仍然相通。

这让普通学习者第一次可以真正“看见”大模型内部。

· · ·

这里需要特别强调一个阅读边界。

《Build a Large Language Model (From Scratch)》使用 GPT 式模型作为教学主线，这非常适合建立 Transformer 基础。

但到了 2026 年，现代大模型架构已经出现大量新的工程变化。

Sebastian Raschka 自己也持续扩展这本书的官方配套资料。目前作者的 2026 版伴读中心已经增加了现代 Attention 架构、MQA、GQA、MLA、Sliding-Window Attention、Mixture-of-Experts、SwiGLU，以及 Qwen 等现代模型结构的进一步讲解。

官方代码仓库还继续加入了 Llama、Qwen、Gemma 等架构的扩展实现，以及 KV Cache、MoE、现代 Attention、DPO、推理时扩展和强化学习等后续材料。

这反而说明这本书的正确阅读方式：

不要把 GPT-2 式架构当作 2026 年最先进模型的完整结构。

应该把它视为 Transformer LLM 的“基础解剖课”。

就像学习计算机组成原理时，我们不会要求教材里的 CPU 架构与今天的数据中心芯片完全一致。

我们学习的是：

哪些基础机制决定了系统如何工作。

掌握这些之后，再进入现代模型架构，理解 GQA、MoE、RoPE、SwiGLU、KV Cache 或者推理模型，就会容易很多。

· · ·

看起来，这本书几乎没有重点讲 Agent。

但我认为，它对理解 AI Agent 反而非常重要。

因为 Agent 最终仍然建立在语言模型之上。

Agent 的规划、判断、工具选择和任务分解，本质上仍然受到基础模型能力的约束。

理解模型训练机制之后，我们会更加清楚：

为什么 Agent 会出现不稳定决策；

为什么同一个任务重复运行可能产生不同路径；

为什么模型可能错误调用工具；

为什么长流程中早期错误会不断放大；

为什么 Agent 需要验证器、权限控制和人工审批；

为什么不能简单认为“推理模型更聪明，所以可以完全自主执行”。

Agent 不是突然获得了确定性。

它只是：

让一个概率模型拥有了行动能力。

因此，从 AI Engineering 到 LLM From Scratch，再到 Agent Engineering，这三层知识其实是一条连续路线：

模型层负责产生能力。

工程层负责管理能力。

Agent 层负责把能力转化成行动。

三者缺一不可。

· · ·

从零构建模型之后，有两种极端认识都会被削弱。

第一种是：

"AI 只是随机猜下一个词，所以没有真正价值。”

这显然低估了现代大语言模型。

当模型在巨大数据和高维参数空间中学习 Token 之间的统计结构后，Next-Token Prediction 能够产生非常复杂的语言、代码、知识表示和推理行为。

第二种则是：

"AI 已经像人一样理解世界。”

这同样缺乏足够依据。

模型的学习方式、内部表示方式和训练目标，都与人类认知存在根本差异。

更准确的理解应该是：

大语言模型是一种通过大规模参数学习语言和数据模式，并利用这些模式进行预测和生成的复杂计算系统。

它展现出非常强大的能力。

但能力强大，并不意味着它的认识方式与人类完全相同。

只有保持这种中间立场，我们才能既不低估 AI，也不神化 AI。

· · ·

基础模型正在越来越商品化。

企业很难仅仅因为“能调用某个模型”形成长期竞争优势。

真正可能沉淀下来的，是围绕模型形成的企业资产：

业务知识，

结构化数据，

高质量问答，

专家反馈，

客户真实问题，

失败案例，

人工修改记录，

评估标准，

流程数据，

权限体系。

这些内容既可以用于 RAG，也可以用于 Evaluation，还可以在条件成熟时用于 Fine-tuning。

于是，一个企业的 AI 建设路径逐渐变得清晰：

不是先问：

“我们要不要训练自己的大模型？”

而是先问：

“我们有没有值得训练和评估的数据？”

如果一家企业甚至不知道：

什么叫正确答案，

那么无论购买多先进的模型，都很难形成稳定的 AI 能力。

高质量模型可以购买。

高质量业务数据和组织经验却必须长期积累。

· · ·

这一周真正值得完成的任务，不是搭建一个复杂 AI 应用。

而是亲手完成一次模型训练流程。

可以直接使用作者官方 GitHub 仓库和配套 Notebook，因为作者已经为第二至第七章提供了完整代码、练习和扩展材料。

建议只完成这样一个最小闭环：

• [ ] 准备一小段文本训练数据
• [ ] 使用 Tokenizer 观察文本如何被拆成 Token
• [ ] 查看 Token ID 和 Embedding 维度
• [ ] 运行一次 Self-Attention 计算
• [ ] 查看一个完整 Transformer Block
• [ ] 初始化一个小型 GPT 模型
• [ ] 在训练前生成一次文本
• [ ] 观察训练 Loss 如何下降
• [ ] 再进行一次文本生成
• [ ] 比较训练前后的输出差异
• [ ] 加载预训练权重
• [ ] 完成一次简单 Instruction Finetuning

这里真正需要观察的不是最终生成结果有多漂亮。

而是整个变化过程：

随机参数 → Loss 很高 → 不断训练 → Loss 下降 → 语言结构逐渐形成 → 微调后开始遵循具体任务。

当你真正看到这条过程之后，“大模型训练”会从一个抽象概念，变成可以被理解的计算过程。

这也是这本书最大的学习价值。

· · ·

连续读完《AI Engineering》《Hands-On Large Language Models》和《Build a Large Language Model From Scratch》之后，我认为三本书刚好构成了三个不同视角。

《AI Engineering》告诉我们：

怎样把模型变成应用。

《Hands-On Large Language Models》告诉我们：

怎样理解和使用语言模型的各种能力组件。

而《Build a Large Language Model From Scratch》回答：

这些能力最初是怎样从模型内部产生出来的。

这三种视角缺少任何一个，都容易形成偏差。

只学应用工程，容易过度依赖黑盒模型。

只学模型原理，可能脱离真实业务需求。

只学 AI 工具，又容易把短期产品功能误认为长期能力。

真正成熟的 AI 知识体系，应该至少包含：

模型原理、系统工程与业务应用。

未来还需要增加第四层：

AI Agent 与自主执行系统。

以及第五层：

AI 治理、安全、评估与组织管理。

最终，它们会形成一套完整的 AI 能力框架。

· · ·

《Build a Large Language Model (From Scratch)》最重要的价值，不是让每个人都成为基础模型研究员。

而是让我们第一次真正看到：

一个今天看起来近乎神奇的大语言模型，其实可以被拆解成一个又一个非常具体的步骤。

文本被 Tokenizer 拆解。

Token 变成 Embedding。

Attention 建立上下文关系。

Transformer Block 不断堆叠。

模型预测下一个 Token。

Loss 衡量预测错误。

Backpropagation 修改参数。

预训练形成基础语言能力。

Instruction Finetuning 让模型学会按照人类要求回答。

Parameter-Efficient Finetuning 进一步降低模型适配成本。

当这些步骤被连接起来后，所谓"AI 黑盒”并没有完全消失，但它已经不再那么神秘。

我们也会更加清楚地知道：

语言模型不是知识数据库。

模型参数不是一条条事实。

生成文字不等于理解真相。

预训练不等于指令遵循。

微调不等于补充最新知识。

模型能力强大，也不意味着系统天然可靠。

这正是理解 AI 最重要的一步。

不是因为理解了模型内部，我们就能够预测 AI 未来的一切。

而是因为当新的模型、架构和产品不断出现时，我们终于拥有了一套相对稳定的基础框架，可以判断：

究竟什么发生了变化，

什么只是工程优化，

什么真正构成能力突破，

以及这些变化最终会怎样影响真实世界。

真正理解 AI，不应该只从它能做什么开始。

有时候，还需要回到更基础的问题：

它究竟是怎样学会做这些事情的？

· · ·

下期预告

周读：《Co-Intelligence: Living and Working with AI》·Ethan Mollick

前三期，我们一直在理解 AI 本身。

下一期开始转向一个更接近每个人的问题：

当越来越强的 AI 已经进入现实工作与生活，我们究竟应该怎样与它协作？

重点讨论的将不再是 Transformer 和模型参数，而是：

如何把 AI 真正变成老师、协作者、教练与工作伙伴，同时保留人的判断、责任与独立思考。