[翻译] How LLMs Actually Work

原文：How LLMs Actually Work，作者 0xkato，发布于 2026 年 6 月 1 日。本文为翻译。

这篇文章会带你走一遍 LLM 是如何工作的。现代 LLM 基本上都是通过一层又一层堆叠 transformer block 构建出来的，所以只要理解 transformer 这套机制，就已经走完了大半段路。

我会介绍现代基于 transformer 的 LLM 内部的核心机制，但不会塞进过多繁复的数学细节。别误会，你当然应该学习数学，但这篇文章可以作为一个入门。

大多数现代 LLM 都共享同一套 transformer 家族的骨架。它们之间的差异来自训练数据、规模和配置选择，以及在基础模型之上做的后训练。读完之后，你应该能够阅读很多现代 LLM 论文或 model card，并知道每一节讨论的是架构里的哪一块。

路径如下：

1. Tokens：一串文本如何变成一串整数。
2. Embeddings：这些整数如何获得意义。
3. Positional encoding：模型如何知道 token 出现的顺序。
4. Attention：token 之间如何共享信息。
5. Multi-head attention：模型如何同时追踪多种关系。
6. Feed-forward network：模型中很大一部分存储结构位于哪里。
7. Residual stream 和 layer normalization：是什么让深层堆叠可以训练。
8. Predicting the next token：模型实际输出什么，以及生成循环如何工作。
9. Architecture vs trained weights：现代 LLM 中哪些东西大体共享，哪些东西彼此不同。

文中会穿插一些小解释，这样无论背景如何都可以跟上。

---

Tokenization

模型并不直接阅读文本。它们阅读的是整数 ID。第一步，就是把你的 prompt 转换成这些整数组成的序列。

这个转换步骤叫做 tokenization。tokenizer 接收一个字符串，输出一串整数，其中每个整数都指向固定词表中的一个条目。现代 LLM 的词表通常包含几万到几十万个条目。

小解释：token ID

token ID 是模型用于表示某个词表条目的整数。模型处理的是这个数字，而不是词本身的书写形式。

token 通常不是完整单词。它们通常是 subword pieces。比如单词 “tokenization” 可能被拆成 [“token”, “ization”]，单词 “running” 可能被拆成 [“run”, “ning”]。原因是效率。完整单词词表太大，而且无法很好泛化到新词；字符级词表又太小，会迫使模型从零开始学习最简单的模式。subword tokenization 位于两者之间。

最常见的片段会变成单独 token，而罕见词或新词则由更小的片段组合出来。

小解释：vocabulary

vocabulary 是 tokenizer 固定的片段列表。每个片段都有一个 ID，模型只能直接接收这个列表里的 ID。

这种取舍会出现在很多人意想不到的地方。经典例子是：问一个 LLM “strawberry” 里有几个 R。过去的 LLM 经常答错。这并不是模型不会计数，而是模型并不是直接在字母上操作；它只是在 token ID 上操作，而这些 ID 恰好拼出了一个人类会逐字母拆分的单词。

不同模型家族使用不同的 tokenizer。GPT 模型使用 Byte Pair Encoding 的变体。SentencePiece 在 LLaMA 风格的模型中很常见。选择哪种 tokenizer 会影响计算量，因为 token 越少工作量越小；也会影响多语言覆盖等问题。但基本形状是一样的：输入文本，输出整数。

现在 prompt 已经变成了一串整数，下一步就是赋予这些整数意义。

---

Embeddings

像 1024 这样的 token ID 只是一个行索引。它本身没有任何意义。赋予它意义的东西，是一张被称为 embedding matrix 的巨大表。

每个模型都有一张这样的表。词表中的每个条目对应一行，每一行都是一串很长的数字向量。每一行的长度就是模型的 hidden size。在很多 7B 级别的模型中，这意味着每个 token 有 4096 个数字。更大的模型通常会使用更宽的向量。

小解释：vector

vector 是一串数字。在 transformer 中，每个 token 都会变成一个 vector，这样模型才能对它做数学运算。

当 tokenizer 把一个整数交给模型时，模型会查找这一行，并使用对应的向量。这个向量就是该 token 的 embedding。它是模型对这个 token “含义”的表示，是在训练过程中学出来的。

小解释：embedding matrix

embedding matrix 是一张查找表。输入 token ID，输出学习到的向量。

这些 embedding 有一个有趣的性质：语义相似的 token 最终会拥有相似的向量。比如 “king” 的向量在空间中会靠近 “queen” 的向量，“Paris” 的向量会靠近 “France”。这些都不是硬编码出来的。它们来自在足够多文本上训练后的自然结果；模型之所以学出这些位置，是因为这样能帮助它更好地预测文本。

你可以对 embedding 做算术运算，而且有时候真的有效。著名例子是 king - man + woman ≈ queen。embedding 空间的几何结构携带着真实的语义结构，尽管从来没有人明确告诉模型要这样构建它。

这里需要说清楚：在这个阶段，每个 token 都已经被替换成了它的 embedding，但 embedding 本身并不说明这个 token 位于序列的什么位置。“dog” 的向量是一样的，不管 “dog” 是 prompt 中的第一个词，还是第五个词。这就是问题所在。

positional encoding 要填补的就是这个空缺。

---

Positional encoding

普通 self-attention 没有内置的词序表示。如果没有某种位置信号，它就没有直接方式知道 “dog” 是出现在 “bites” 前面还是后面。

词序会改变意义。所以模型还需要另一块东西：它需要一种方式，把每个 token 的位置注入到数学计算中。

小解释：positional encoding

positional encoding 是模型获得顺序信息的方式。它告诉模型每个 token 位于序列中的哪里。

原始 transformer 论文（Vaswani et al. 2017）通过给每个位置分配一组独特的数字模式来做到这一点，并在任何其他处理之前，把这组位置模式直接加到每个 token 的 embedding 上。位置 1 有一种模式，位置 5 有另一种模式，位置 100 又有另一种模式。这些模式来自不同频率的正弦和余弦波。

这样，“dog” 在位置 1 的 embedding 就不同于 “dog” 在位置 5 的 embedding，仅仅因为加进去的位置模式不同。

这个方法有效。选择 sinusoidal encoding 的部分原因，是它可以外推到训练时未见过的精确序列长度之外。但随着模型扩大，加性位置方案仍然暴露出两个重要问题。

第一，embedding 必须用同一组数字同时携带意义和位置。能塞进去的东西总是有限的。

第二，尤其是 learned absolute position embeddings，并不能干净地泛化。如果你训练时最多只见过 2048 个 token 的 prompt，那么模型从未在训练中见过位置 5000，那个位置的 embedding 也就不是以同样方式学到的。

现代模型大多使用另一种方案，叫做 Rotary Position Embeddings，也就是 RoPE。它由 Su 等人在 2021 年提出，现在被 LLaMA、Mistral、Gemma、Qwen 以及大多数其他开放权重模型家族使用。直觉是：不要把位置信息加到每个 token 的向量里，而是根据位置用一个角度旋转向量。位置 1 的 token 转动一点点，位置 100 的 token 转动更多。

当两个 token 之后在 attention 中进行比较时，重要的是它们旋转之间的差异，而这种差异编码了它们相距多远。

小解释：RoPE

RoPE 代表 Rotary Position Embeddings。它不是添加位置向量，而是旋转 token 向量，让相对距离在 attention 中显现出来。

实际优势很明显。RoPE 能自然编码相对位置，而这更接近 attention 真正需要的东西。它对更长上下文的泛化更好。而且它不会给模型增加新的参数。

即便有很好的 positional encoding，现代 LLM 仍然存在一个有文献记录的 “lost in the middle” 问题（Liu et al. 2023）。它们比起埋在中间的信息，更可靠地使用长 prompt 开头和结尾的信息。这就是为什么“把重要上下文放在最前面”或“在末尾重复关键信息”这类 prompt engineering 技巧真的有帮助。模型并不是同等良好地使用你 prompt 中的每一部分。

当 token 的意义和位置都被编码之后，下一个问题就是：token 之间到底如何交换信息？

---

Attention

这就是赋予这个架构名字的机制：attention。

在每一个 transformer layer 内部，attention 只做一件事：它让每个 token 查看自己被允许看到的其他 token，并决定哪些 token 对接下来要发生的事情重要。

它通过让每个 token 同时扮演三种角色来做到这一点。每个 token 会被转换成三个新的向量，分别叫做 Query、Key 和 Value，也就是 Q、K、V。

小解释：Q, K, V

Query 表示“我在找什么”，Key 表示“我能匹配什么”，Value 则是在匹配很强时被复制的信息。

Query 会问：“我想从其他 token 那里寻找什么？”

Key 会说：“这是我提供给看向我的 token 的东西。”

Value 携带的是：“当匹配发生时，会被传递出去的就是这些信息。”

同一个 token 会同时扮演这三种角色。Q、K、V 的变换都是学出来的矩阵，所以模型会在训练过程中弄清楚每个 token 应该寻找什么，又应该提供什么。

匹配通过相似度分数发生。每个 token 的 Query 会与它被允许看到的每个 token 的 Key 进行比较，使用的是 scaled dot product。直观地说，这衡量的是两个向量有多么对齐。缩放操作则是在 softmax 之前保持数值稳定。

小解释：dot product

dot product 是一种给两个向量的对齐程度打分的简单方式。对齐越高，匹配越强。

然后，匹配分数会通过 softmax 转换成权重。softmax 接收任意一组数字，并把它们转换成一种类似概率分布的东西，总和为 1。匹配分数更高的 token 会获得更高权重，随后这些权重会用来对 value vectors 做加权平均。

小解释：softmax

softmax 把原始分数转换成总和为 1 的权重。大分数得到大权重，小分数得到小权重。

举个例子。考虑句子 “The cat that I saw yesterday was sleeping.” 当模型处理 “was” 时，它需要弄清楚是谁在睡觉。“was” 的 Query 向量会和它被允许看到的 token 的 Key 向量进行比较。它和 “cat” 的 dot product 很高，因为模型已经学到，像 “was” 这样的动词需要一个主语，而像 “cat” 这样的主语会产生与之很好对齐的 Key 向量。它和 “yesterday” 的 dot product 则很低。

softmax 会把这些分数变成权重，“cat” 得到高权重，“yesterday” 得到低权重。然后模型会对相应的 value vectors 做加权求和，所以 “cat” 的 value 会主导结果。“was” 的新表示现在主要由 “cat” 的 value 塑造。这就是一个隔着好几个位置的 token 如何成为指代对象。

GPT 风格语言模型有一个特定约束：它们从左到右生成文本。位置 5 的 token 只能 attend 到位置 1 到位置 5。它不能 attend 到位置 6、7、8，因为这些 token 还没有被生成。这叫 causal masking。实现很简单：未来 token 的匹配分数会被设置得极低，以至于 softmax 之后权重实际上为零。

小解释：causal masking

causal masking 会隐藏未来 token。它防止 decoder-only 语言模型在预测下一个 token 时偷看未来。

可解释性研究中一个最有趣的发现，是 Anthropic 在 2022 年发现的一类特殊 attention head，叫做 induction heads。这些 head 会学习识别 prompt 中形如 “A B … A” 的模式，并预测接下来会出现 B。当模型第二次看到 “A” 时，induction head 会回看前一次 “A” 出现的位置，观察它后面跟着什么，然后把那个东西复制过来。

它们是目前已知的、最清晰的 in-context learning 机制之一。所谓 in-context learning，就是 LLM 能从你的 prompt 中拾取一个模式，并继续这个模式。

小解释：induction head

induction head 是一种 attention head，它会注意 prompt 中重复出现的模式，并帮助模型延续这些模式。

attention 有一个很大的成本。完整 attention 中，每个 token 都要和自己被允许看到的所有 token 比较，所以 prompt 长度翻倍时，工作量大致会变成四倍。这就是为什么长 prompt 运行起来很贵，也解释了为什么很多近期研究都在尝试让 attention 更高效，比如 FlashAttention、sparse attention 和 linear attention。

但一个 attention head 只能给模型一种学习到的关系视角。

---

Multi-head attention

一次单独的 attention pass 只给模型提供一种方式，用来决定哪些 token 对其他 token 重要。这还不够。语言中同时发生着许多关系：主语和动词一致、代词和它所指代的名字、句子之间的长距离引用、词序和局部短语。

multi-head attention 通过并行运行多次 attention 来解决这个问题，每个并行 pass 都在自己的较小空间中运行。每个并行 pass 叫做一个 head。

小解释：attention head

attention head 是一次独立的 attention pass，拥有自己学习到的投影。

这里有一点经常被讲错，很多教程里也会错。每个 head 并不是拿到了原始 token 向量的一个字面切片。每个 head 都有自己学习到的投影矩阵，把完整 token 向量映射到自己更小的 Q、K、V 向量空间中。所以如果一个模型每个 token 有 4096 个数字，并且有 32 个 head，那么每个 head 通常在 128 维空间里工作；但这 128 个数字是从完整 4096 维向量中学习投影出来的，而不是一个固定切片。

它们是同一个 token 的不同“视图”，而不是不同“块”。

每个 head 独立运行自己的 attention pass。然后，所有 head 的输出会被拼接起来，再通过最后一个线性层混合回一个完整尺寸的向量。这个最终混合也是模型学出来的。

有趣之处在于，不同 head 通常会形成部分专门化。模型从来没有被告知每个 head 应该做什么。专门化是在训练中自然涌现的。研究人员发现过追踪语法的 head，比如把动词连接到宾语、把冠词连接到名词；也发现过弄清楚代词指向哪个名字的 head、追踪位置模式的 head、induction heads，以及更多类型。单个 transformer layer 可能有 32 个 head。

现代前沿模型有几十层。所以一个典型 LLM 总共有成千上万个 attention heads，每个 head 都添加了自己的学习视角。

还有一个实际成本问题推动了近期的架构变化。每个 head 都需要把已经生成的所有 token 的 Key 和 Value 向量保存在内存里，这样当新 token 被生成时，模型就不需要从头重新计算所有东西。这叫 KV cache，它是长上下文长度下运行 LLM 的主要内存成本。

小解释：KV cache

KV cache 在生成过程中存储旧的 Key 和 Value 向量。它让模型不必每次添加 token 时都重新计算整个 prompt。

现代 decoder-only LLM 大多使用一种叫做 Grouped-Query Attention（GQA）的变体。不是每个 head 都拥有自己的 keys 和 values，而是多组 heads 共享同一组 key/value heads。LLaMA-2 70B 有 64 个 query heads，但只有 8 个 key/value heads。Mistral 7B 有 32 个 query heads 和 8 个 key/value heads。结果是在准确率几乎接近完整 multi-head attention 的同时，显著降低内存压力和推理成本。

小解释：GQA

Grouped-Query Attention 让多个 query heads 共享更少的 key/value heads。这样可以减少 KV-cache 内存，同时保留多个 query 视角。

---

Feed-forward network

attention 完成 token 之间的信息混合之后，每一层还有第二个步骤，而这个步骤没有那么多人谈论：feed-forward network。

attention 关注的是 token 之间彼此交谈；feed-forward network 关注的是每个 token 独立地做更多处理。它会独立运行在每个 token 的向量上，不做跨 token 混合。

feed-forward network 按顺序做三件事：

1. 把 token 的向量扩展到更大的尺寸。原始 transformer 使用 4 倍扩展，而现代 SwiGLU 模型经常使用不同的扩展大小。
2. 应用一个非线性函数。
3. 再把向量压缩回原始尺寸。

中间那个非线性步骤做的事情很具体，值得理解。非线性是一个会弯折输入的函数。最简单的例子是 ReLU：对任何负数输出零，对正数则原样通过。

小解释：non-linearity

non-linearity 是防止网络坍缩成一个巨大线性变换的函数。

没有它，FFN 就只是两个线性层叠在一起，而纯线性数学一旦堆叠就会坍缩。连续两个线性层在数学上等价于一个线性层；连续一百个线性层仍然等价于一个线性层。非线性阻止了这种坍缩，这也是 FFN 能做出比单次矩阵乘法更丰富事情的原因。

原始 transformer 使用 ReLU。GPT 和 BERT 转向 GELU。LLaMA、Mistral、PaLM 等现代模型使用 SwiGLU。扩展再压缩的结构保留下来了，被持续迭代的是非线性本身。

dense transformer 模型中的大多数参数位于 FFN 中，而不是 attention 中。很大一部分权重都在 feed-forward layers 里。

而且这些参数并不是泛泛而谈的。模型中许多已存事实和语义结构就位于这里。研究人员发现，FFN 内部的一些神经元和特定概念或事实强相关。某个神经元可能在与埃菲尔铁塔相关的文本上强烈激活，另一个可能在编程语言上激活，再另一个可能在过去式动词上激活。当一个模型“知道”巴黎是法国首都时，这个事实会在特定层的 FFN 权重和激活中以分布式方式表示出来。

这种存储记忆的性质带来一个有趣后果。研究人员已经找到了直接编辑训练后模型中某些事实的方法，而不需要重新训练模型。像 ROME（Rank-One Model Editing）这样的方法，可以通过对某个特定 FFN 权重矩阵做定向低秩编辑，把 “the Eiffel Tower is in Paris” 改成 “the Eiffel Tower is in Rome”。之后模型往往会生成与编辑后关联一致的文本。

一些现代前沿模型已经开始把 dense FFN 替换成 Mixture of Experts（MoE）。模型不是每层只有一个 feed-forward network，而是拥有许多并行 FFNs，也叫 experts，再用一个很小的 router network 选择哪些 experts 处理每个 token。Mixtral 8x7B 每层有 8 个 experts；任意给定 token 只激活其中 2 个。总参数量大幅增加，但每个 token 的计算量增长慢得多，因为只有少数 experts 真正运行。

这就是如何扩大参数量，而不让推理成本按比例扩大。

小解释：MoE

Mixture of Experts 意味着模型有多个 feed-forward networks，并且每个 token 只被路由到其中少数几个。

Mixtral 8x7B 总共有 46.7B 参数，但每个 token 大约只使用 12.9B 参数。这已经成为超大模型的常见选择，因为它让你可以继续增加参数数量，而不让推理成本按比例增长。

---

Residual stream and layer normalization

residual stream 让模型变成“相加式”，而不是“替换式”。attention 运行后，或者 feed-forward network 运行后，结果通常不会替换 token 的向量。它会加到原来的向量上，逐位置相加。新向量等于旧向量加上子模块输出。

小解释：residual connection

residual connection 会把一个 block 的输出加回它开始时的向量。它给信息和梯度提供一条穿过网络的捷径。

跨过三十层、五十层或一百层，每一层的贡献都会累积起来，而不是简单覆盖前一层向量。这个持续累积的总和叫做 residual stream，它有一个奇特性质：原始输入 embedding 仍然有一条直接的加性路径通向后面的层，并且在途中与每个子模块的贡献混合在一起。

residual connections 并不是为 transformer 发明的。它们来自 ResNet（He et al. 2015），最初用于图像识别。动机是深层网络几乎无法训练。训练信号穿过许多层回传时会变得太弱，有时又会变得太强。模型无法真正从自己的错误中学习。添加一条 shortcut path 之后，信号就可以从输出直接流回输入。突然之间，你就可以训练拥有数百层的网络了。

transformers 继承了同样的技巧。

在现代可解释性研究中，residual stream 已经成为核心对象。每个 component、每个 attention head、每个 feed-forward network，甚至最后的 unembedding step，都会从 residual stream 读取，并写回 residual stream。

第二块是 layer normalization，它存在的原因更加实际。没有它，residual stream 不会保持稳定。数字经过几十次相加后，往往要么向上爆炸，要么坍缩到零附近。无论哪种情况，训练都会失败。layer normalization 会在子模块之间，把每个 token 的向量重新缩放回一个受控范围。

小解释：layer normalization

layer normalization 会重新缩放 token vector，让其中的数字在模型训练时保持稳定范围。

原始 2017 transformer 在每个子模块之后应用 normalization，也就是 post-norm。它对浅层模型有效，但随着深度增加会更难可靠训练。现代 transformers（从 GPT-2 之后，到 LLaMA、Mistral）通常在每个子模块之前应用 normalization，也就是 pre-norm。这是让非常深的 transformers 更容易训练的重要变化之一。

这个函数本身也发生了变化。许多现代开放模型（LLaMA、Mistral、Gemma、Phi）使用一种更简单的变体，叫 RMSNorm。原始 layer normalization 一次做两件事：先把每个向量向零移动，再重新缩放数字大小。RMSNorm 去掉了 shift 步骤，只保留 rescaling。经验上，rescaling 携带了大部分收益，同时计算更便宜。

小解释：RMSNorm

RMSNorm 是一种更便宜的 normalization 方法，它会重新缩放向量大小，但不会先减去均值。

所以这就是那些不那么光鲜的机械结构。没有 residual connections，非常深的模型会难得多；没有 layer normalization，持续累加的结果可能爆炸或坍缩。有了二者，你就能得到拥有数百层的模型。

---

Next-token prediction

当所有 attention 和 feed-forward 处理层都完成之后，模型会为序列中的每个 token 得到一个向量。在生成时，为了预测下一个词，它只取最后一个 token 的最终向量。

这个最后的向量会被转换成每个可能下一个 token 对应的一个数字。如果词表有 100,000 个 token，那就是 100,000 个数字。这些数字叫 logits。它们还不是概率。它们可以是任意大小，可以为正也可以为负。

小解释：logits

logits 是每个可能下一个 token 的原始分数。只有经过 softmax 之后，它们才会变成概率。

softmax 会把这些 logits 转换成模型对可能下一个 token 的概率分布。和之前是同一个操作，只是发生在模型的另一个位置。

模型通常不会每次都直接选择概率最高的 token。解码设置控制输出有多确定或多变化。temperature 会改变分布的尖锐程度。top-k 和 top-p 会把选择限制在最合理的一组下一个 token 中。这就是为什么同一个模型在一种设置下显得精确，而在另一种设置下更有创造性。

小解释：temperature

temperature 控制采样时的随机性。低 temperature 让模型更保守，高 temperature 让模型更多样。

一旦选中一个 token，它就会被添加到输入中。模型会在更长的序列上运行下一步，通常复用 KV cache，这样就不用从头重新计算整个前缀。新 token 有新的 attention、新的 feed-forward、新的最终向量、新的预测。这个循环会持续下去，直到模型输出 end-of-sequence token，或者达到长度限制。一整段文字只是这个循环一次一个 token 地重复。

这个单一目标，也就是预测下一个 token，是 base LLM 的核心训练信号。base model 并不是直接针对事实准确性、对话能力、推理或写代码训练的。它是在海量文本上训练去预测下一个 token。后续 post-training 才会再把模型调向指令遵循、偏好、安全和对话行为。

还有一个值得知道的重要效率创新，叫做 speculative decoding。一个小而快的模型先提前提出若干 token。大模型并行验证它们。如果这些提议 token 在大模型概率下被接受，就接受它们；如果没有，就回退到大模型。正确实现时，输出分布与单独运行大模型一致，但生成循环可以快很多。

小解释：speculative decoding

speculative decoding 使用一个小 draft model 先向前猜测，然后让更大的模型一次性验证多个猜测 token。

next-token prediction loop 是架构中最简单的一部分，但它让整个系统工作起来。

---

Architecture vs trained weights

我们已经走过了核心机制：tokens、embeddings、positional encoding、attention、multi-head attention、feed-forward network、residual stream 和 normalization，以及输出端的 next-token loop。这就是基本架构的一次完整遍历。

那么 GPT、Claude、Gemini 和 LLaMA 之间真正不同的是什么？公开细节各不相同，专有模型也不会发布每个架构选择。但在本文讨论的层级上，它们大体都位于同一个 transformer-family 设计空间内。

大多数现代基于 transformer 的 LLM 都使用同样的宽泛结构：tokenization、embeddings、positional encoding、堆叠的 transformer layers（每层包含 multi-head attention 和 feed-forward network）、residual streams、layer normalization，以及 next-token prediction。

模型之间变化的是：

1. 训练出的 weights 本身，也就是从不同训练数据和不同规模中学到的东西。
2. 配置：层数、词表大小、head 数、参数量、MoE 还是 dense。
3. post-training：instruction tuning、从人类反馈中学习，以及应用在 base model 之上的安全控制。

小解释：weights

weights 是模型内部学习到的数字。训练会改变这些数字，直到模型能很好地预测文本。

2023 到 2025 年的 “modern transformer” stack，在许多严肃的前沿模型和开放权重模型中逐渐收敛到了一组共同选择，尽管不同团队是独立到达这些选择的。pre-norm placement、RMSNorm、RoPE、SwiGLU、Grouped-Query Attention，以及一些最大模型中的 Mixture of Experts。这些东西并不是一次性发明出来的。它们是在原始 2017 设计之上，经过大约五年持续精炼累积起来的。

---

Where this is going

机器学习历史中，围绕 transformer-family 架构的这种收敛很不寻常。在这个领域的大部分生命里，每个问题都有自己的专门网络。图像识别用一种，语言用另一种，音频用第三种。视觉团队和语言团队几乎不共享方法。

现在，transformer 风格模型出现在语言、视觉、音频和多模态系统中。transformer 吸收了这个领域的巨大一部分。

这可能会改变。Mamba 和其他 state-space models 是可信的替代方案，尤其是在非常长的序列上。混合架构也正在被探索。Mixture-of-experts 已经改变了前沿模型中“架构”这个词的含义，而这在五年前还会被认为非常陌生。

但这篇文章中的核心机制，也就是 tokens、embeddings、positional encoding、attention、feed-forward network、residual stream 和 normalization，以及 next-token prediction，是更持久的部分。即使架构发生变化，这些仍然是任何序列模型都必须以某种形式解决的问题。

如果你已经读到了这里，那么你现在可以阅读许多现代 transformer 论文或 model card，并知道每一节在讨论哪一块。这就是目标。

作者非常欢迎反馈。如果你对这些内容感兴趣，可以在 X 上联系作者。作者很喜欢结交新朋友。