用通俗语言理解算力

人工智能、硬件与供应链入门指南

本课程面向学过计算机科学基础、希望理解现代人工智能如何工作以及其供应链如何运转的读者。你不需要具备机器学习或芯片设计背景。每个概念第一次出现时，正文都会先用日常语言解释，因此没有技术背景的读者也应当能够理解课程的大部分内容。

核心观点很简单：AI 产品不只是一套模型。每个答案背后都有一条由软件、芯片、内存、网络、数据中心、电力、制造和融资组成的链条。链条中任何一环受到限制或发生延迟，都可能影响用户体验和服务成本。

AI 给出的答案看起来像是凭空出现的，但它实际上由物理机器完成。AI 模型是一套通过学习得到的计算系统，它把输入变成预测或其他输出。大型语言模型专门用来大规模处理和生成语言，其中可能包含数十亿个通过训练学到的数字。运行模型需要在内存中搬运数据、执行运算并消耗电力；这些物理条件共同决定速度和成本。

本课程遵循从用户向外的链条：

你的要求
-> 模型预测答案
-> 芯片移动数据并进行算术运算
-> 数据中心提供电力、冷却和连接
->有人为这个过程的每一秒付费

在你了解芯片必须完成的工作之前，芯片规格毫无意义。在你知道该小时产生多少有用答案之前，每 GPU 小时的价格意义不大。第 0 部分介绍了全文使用的单位。课程的其余部分遵循紧凑的地图：

• 工作负载，第 1-3 部分： 推理、训练和智能体。
• 机器，第 4-9 部分： 图形处理器工作原理、内部结构、内存、数字格式、制造和连接。
• 决定，第 10-11 部分： 选择硬件并了解经济学。

AI 的性能从来都不是一个数字。一个系统可以具有快速的算术和缓慢的内存、廉价的芯片和昂贵的功率，或者有用的工作永远无法达到的令人印象深刻的最大速度。对于重复性工作，最受限的所需资源通常会限制系统每秒完成的工作量；多个阶段仍可能会增加一个请求的延迟。

如何处理事实。 来源为真实产品、型号和市场数据，并且波动数据均注明日期。用“假设”引入的示例是说明性算术，而不是市场报价。无法支持或无法有效限定的主张将被省略。

第 0 部分 — 大系统的小词汇

这个开头介绍了整个课程中使用的四个量：算术、存储和移动的数据、功率和能量以及词元。将每个金额与其费率分开。

0.1 工作与速度不同

一项工作有固定的工作量，而机器有一个尝试该工作的速率。混淆两者就像混淆英里和每小时英里一样。

许多 AI 计算都可以表示为小数的乘法和加法。工程师把这些算术步骤计为浮点运算，简称 FLOP。按照大多数硬件规格采用的惯例，一次加法或一次乘法各算一次运算；融合乘加包含乘法和加法两个步骤，因此算两次。速率可以写成 FLOP/s，意思是每秒完成多少次浮点运算。为了避免把总量和速率混在一起，本课程通常会写出完整的“运算次数”和“每秒运算次数”。

假设一个作业需要 1,000 个操作，而处理器实际上每秒完成 100 个操作。仅算术一项就需要 10 秒：

时间=工作量÷实际速度
= 1,000 次操作 ÷ 每秒 100 次操作
= 10 秒

达到了 这个词很重要。规范通常给出硬件对于特定类型的数字和操作可以达到的最高速率。真实的程序可能会花费部分时间等待数据、另一个处理器或其下一步所依赖的结果。因此，每秒峰值操作数是规定条件下的上限，而不是每个程序都会以该速度运行的承诺。

0.2 存储的数据与移动的数据不同

内存容量 询问有多少数据适合。内存 带宽 询问每秒有多少数据可以通过指定点。一个仓库可以容纳一百万个箱子，但仍然有一个狭窄的装货门。第一个事实描述了容量；第二个描述带宽。

假设一台机器必须从内存中读取 100 GB 的文件，并且每秒可以维持 50 GB 的速度。如果没有其他东西使用该路径，则传输至少需要两秒钟。将内存容量加倍可以让机器容纳更多文件，但不会使传输速度更快。将带宽加倍可以减少传输时间，但不会为更大的文件创造空间。后面的部分将这种区别应用于模型权重：权重必须适合，交付速度才重要。

位表示两个值之一，通常为零或一。八位组成一个字节。在十进制单位中，一千兆字节 (GB) 正好是十亿字节；2³⁰ 字节是 1 吉比字节 (GiB)。所引用的每秒 100 GB 带宽意味着每秒 1000 亿字节，但标注时必须说明该速率是理论最大值还是实测值。网络规格通常使用比特而不是字节。除以八可以把单位换算为字节；网络数据的格式与传输开销还会降低真正可用的速率。NIST 在此定义了十进制和二进制数据单位。

0.3 功率与能量不同

电力 告诉你设备在某一时刻使用能量的速度。它以瓦特为单位测量。 电能 告诉你一段时间内的使用量。电费通常以千瓦时为单位收费。

跟踪一台加速器服务器一小时。假设作业运行时消耗一千瓦：

能量=功率×时间
= 1 千瓦 × 1 小时
= 1 千瓦时

电力成本 = 1 千瓦时 × 每千瓦时 0.10 美元
                 = $0.10

如果同一台服务器在相同功率下运行10小时，则消耗10千瓦时。它的功率并没有变成“10千瓦”；该设备消耗一千瓦的时间更长。同样，额定功率为一千瓦的设备不一定每时每刻都消耗这个电量。

服务器并不是整个设施。风扇、水泵、电力转换设备、网络和其他支持系统也使用电力。当有人引用功率或能量数字时，问三个问题：它是最大值还是测量值？在什么时期？它描述的是一颗芯片、一台服务器、一个机架还是整个数据中心？

0.4 模型读取和生成词元

语言模型不会将文本接收为页面上的单词。 分词器 首先将文本划分为名为 词元 的片段，并为每个片段分配一个整数标识符。词元可能是整个常见单词、不太常见单词的一部分、标点符号，甚至是连接到附近文本的空格。确切的片段来自该分词器的词汇和规则。

出于直觉，想象一下分词器划分“难以置信！”分为 un、believ、able 和 !。这些是说明性的片段，而不是关于特定分词器的声明。该模型接收相应的标识符，然后生成服务将其转换回文本的标识符。两个模型可以以不同的方式划分同一个句子，因此字数统计无法确定确切的词元计数。

对于 OpenAI 分词器，有用的纯英文指南是每个词元大约四分之三的单词。该比率随语言、文本、模型和分词器的变化而变化。 OpenAI 解释了这一估计及其局限性。

模型还包含称为 参数 的学习值。许多参数都是数字 权重，控制一组数字影响另一组数字的强度；参数也可以包括其他学习的调整。根据其发布者的计数惯例，“700 亿参数模型”包含大约 700 亿个学习值。这些值不是 700 亿个句子或数据库条目。它们在模型的计算中协同工作。

词元描述输入和输出长度。参数描述模型学习状态的大小。即使参数计数保持固定，具有更多词元的请求通常也需要更多工作。当其设计和数字格式具有可比性时，具有更多参数的模型通常需要更多的存储和算术。这两个数字本身都不能衡量答案的质量。

保持两个习惯：附加“根据什么？”对每个速率，并询问该数字是理论最大值还是测量结果。

第 1 部分 — 推理：答案是怎样生成的

大多数面向聊天的语言模型通过选择下一个词元、将其添加到序列中并重复来生成文本。他们通常不会一次性准备出完整的答案。这个过程解释了流文本和长对话的部分内存成本。一起处理请求可以降低成本，但并不能保证一定会降低成本。使用经过训练的模型产生输出称为 推理。

1.1 从按回车键到看到文字

按 Enter 不会将单词直接发送到模型中并接收返回的完成段落。服务首先准备请求，然后模型一次预测一个输出词元。整个旅程分为五个阶段：

1. 路由请求。 Web 服务可以检查谁在调用，执行其规则，并将请求发送到可以访问模型的机器。
2. 组装模型输入。 该服务选择指令、早期消息、检索到的材料、工具结果和新消息。该历史记录在逻辑上是当前调用的一部分，即使服务缓存了其中的一部分；该模型不会在独立调用之间保留类似人类的记忆。
3. 将文本变成编号的片段。 分词器根据其词汇和规则划分文本，然后将每个分词映射到一个整数标识符。模型系列之间的词汇和分割规则有所不同。此转换称为 词元化。
4. 处理输入并选择第一个答案。 该模型为其词汇表中的每个词元生成一个数字分数，解码规则使用这些分数来选择下一个词元。它可能会选择“Rise”而不是“Sourdough”来响应“命名我的面包店”。处理提示并准备可重用的注意力数据称为 预填充。
5. 一次构建其余部分。 在普通的自回归生成中，所选词元成为序列的一部分，并且模型运行另一个步骤。此答案构建阶段称为 解码。生成可以在结束词元、配置的词元限制或其他停止规则处停止。然后，该服务将词元标识符转换为可读文本。

输入：说出一家只销售酵母的面包店的名称。

阅读完整的输入 -> “Rise”
读取输入加上“Rise”->“and”
读取输入加上“Rise and”->“Loaf”
通读“Rise and Loaf”-> 结束词元

输出：发酵和面包

因为每个接受的输出词元都取决于它之前的输出词元，所以普通答案生成按顺序进行。这创建了两个服务阶段，如下所述。

1.2 首词元等待与后续生成阶段

答案之前的暂停和后面词元之间的间隔是两种不同的延迟。一项服务可以改进其中一项而不改善另一项，因此单个“速度”数字可以隐藏用户的感受。

单击发送第一个词元最后一个词元
    |--------------------------|---|---|---|---|---|--------|
输出词元之间的第一个词元间隙的时间

第一跨度可以包括网络旅行、等待机器、准备请求、处理提示以及选择第一词元。后面较小的跨度显示了普通答案生成的速度。

在预填充期间，模型会一起处理提示词元，因此许多工作可以并行运行。较长的提示通常需要更多的工作。 第一个词元的时间 是从提交请求到收到第一个输出词元所经过的时间；它可以包括网络传输、等待、文本转换、请求设置和预填充。 NVIDIA 在其推理指标指南中定义了此测量边界。

在普通解码期间，输出词元按顺序提交，并且每个步骤再次使用模型的学习参数。输出词元之间的经过时间为 词元间延迟，这对用户来说表现为打字速度。

为什么算力巨大的芯片生成速度仍然很慢？对于一个或几个请求，每个生成步骤可能必须从内存中获取模型的大部分权重并仅使用一次。获取这些数字可能比进行算术花费更长的时间。限制为 内存带宽：内存每秒可以提供多少字节。这种模式很常见，但并不普遍。

考虑一个故意乐观的单用户示例。假设这样的模型的权重占用 70 GB，而 加速器（一种用于高效执行 AI 计算的处理器）的峰值内存带宽为每秒 3,350 GB。如果每个解码步骤必须流式传输这些权重一次，则仅权重流量就给出每秒 3,350 ÷ 70 的上限，即大约 48 个步骤，因此大约有 48 个输出词元。当峰值带宽无法持续时，实际吞吐量会较低，因为缓存读取、临时值、同步和其他工作也会消耗时间和带宽。带宽数字与 NVIDIA 发布的 H100 服务器模块配置峰值相匹配，而不是测量的应用程序结果。 NVIDIA H100 规格，2026 年 7 月访问。

估计的意义比确切的数字更重要。在指定机器上，主要受算术吞吐量限制的工作为 受计算限制；主要受内存流量限制的工作是 内存带宽限制。长预填充或批量预填充可能会受到计算限制，而仅为少数请求生成词元通常会受到内存带宽限制。提示长度、模型设计、同时请求的数量、软件和硬件都可能改变结果。

1.3 Transformer 如何使用 KV cache

先记住结论：Transformer 每次只预测下一个词元，把选中的词元接到已有序列后面，然后再次预测。为了避免每次都从头计算，推理服务会保存模型已经为早期词元算出的部分结果。这些结果叫作键值缓存，通常写作 KV cache。

KV cache 不是聊天记录的摘要，也不会替模型作出预测。每生成一个新词元，模型仍然要运行全部模型层。缓存省掉的是另一项重复工作：不必为所有早期词元再次计算相同的键和值。新词元仍然要读取这些缓存数据并与它们比较。因此，KV cache 会减少运算量，但也会占用内存和内存带宽。Hugging Face 的实现说明展示了每个注意力层如何分别读写缓存。

第一步：看懂一次“下一词元”预测

假设提示词是：

音乐家在音乐会前给钢琴调了音。随后，她弹起了

模型可能把 钢琴 选为下一个词元。这个答案合理，但不是必然结果。为了让例子容易阅读，下面暂时把每个词都当作一个词元；真实的分词器可能采用不同的切分方式。模型大致经过六步：

1. 把词元变成数字。 每个词元标识符会查到一组学到的数字，叫作嵌入表示。它是该词元进入模型时的起始表示。模型还要表示这个词元在序列中的位置；不同 Transformer 采用的位置表示方法并不完全相同。
2. 让不同位置交换信息。 注意力让当前位置结合自身和前面位置的信息，但不能读取还没有生成的后文。在这个例子里，结尾“弹起了”的表示可能受到前面的“音乐家”“调音”和“钢琴”等位置影响。
3. 分别处理每个位置。 前馈块对每个位置再执行一组学到的计算。注意力负责在位置之间传递信息，前馈块则继续加工每个位置当前保存的信息。
4. 重复注意力和前馈计算。 一个注意力块加一个前馈块，可以看作模型层的简化核心。Transformer 会连续通过很多层；越靠后的层，使用的是前面各层已经加工过的表示。
5. 给所有候选词元打分。 最后一层把末尾位置的表示转成词表中每个候选词元的分数，再把这些分数转成概率。
6. 选择并接上一个词元。 解码规则可能选中 钢琴，把它加到序列末尾。模型随后再次运行，预测“钢琴”后面应该出现什么。

这个讲解顺序借鉴了 3Blue1Brown 的 Transformer 可视化课程：先把词元表示成数字，再通过注意力和前馈计算反复改变这些表示，最后得到整个词表的分数并选出新词元。原始 Transformer 论文是注意力和前馈结构的主要来源。视频重点解释 Transformer 的直觉；下面继续说明推理服务怎样利用 KV cache。

进一步理解：查询、键和值分别表示什么

在一个注意力层中，模型会根据词元当前的表示计算出三组数字：查询、键和值。它们合称注意力中的查询—键—值（QKV）：

• **查询（query）**表示当前位置想寻找什么信息。
• **键（key）**表示某个位置可以用什么特征与查询匹配。
• **值（value）**携带匹配后可以贡献给当前位置的信息。

它们只是三种数值角色，并不是人写下的标签或句子。模型把查询与可用的键比较，得到匹配分数；再把分数变成总和为一的权重，用这些权重混合相应的值。匹配越强，那个位置的值对结果影响越大。具体匹配模式由训练学得，并会随模型层、注意力头、提示词和模型而变化。

一个注意力头完成一组查询与键的比较以及值的混合。真实模型的一层通常并行运行多个注意力头，让不同的头学习不同的比较方式，然后再合并结果。

现在就能看出为什么缓存的是 K 和 V。新词元会产生一个新查询，并用它与早期位置的键比较，再混合早期位置的值，所以旧的键和值还会再次使用。旧的查询却不再需要：它们在各自位置被处理时已经完成任务。因此，推理服务缓存 K 和 V，而不是 Q。Transformer 论文正式定义了查询与键的比较以及对值的加权使用。

预填充阶段建立第一份缓存

在*预填充（prefill）*阶段，完整提示词逐层通过 Transformer。同一层内，硬件可以并行处理提示词中的许多位置；与此同时，模型从左到右的规则会阻止一个位置读取它后面的内容。每个注意力层都会为每个提示词元计算一个键和一个值，推理服务把它们保留下来，供之后生成输出词元时使用。

缓存并不是一份通用笔记。每个模型层都有自己的一对数组：

第 1 层缓存：提示位置 1 ... N 的 K 和 V
第 2 层缓存：提示位置 1 ... N 的 K 和 V
...
最后一层缓存：提示位置 1 ... N 的 K 和 V

所以，同一个可见词元在不同模型层会有不同的缓存数字。这些数字表示某一层要怎样匹配和使用该位置；它们不是原文、模型权重，也不是用自然语言写成的摘要。

解码阶段读取并扩展缓存

预填充选出第一个输出词元后，*解码（decode）*会重复以下过程：

1. 只把刚选出的新词元送入模型；早期词元不必再次逐层计算。
2. 在第一层中，为这个新词元计算新的查询、键和值。
3. 把新查询与第一层缓存的旧键以及当前词元的新键比较，再用得到的权重混合对应的旧值和新值。
4. 把当前词元的新键和值加入第一层缓存，使缓存多出一个位置。
5. 让注意力结果继续通过这一层的其余部分，包括前馈块。
6. 在后面的每一层重复同样的过程，但使用各层自己的缓存。词元表示逐层变化，因此每一层都会计算属于自己的新查询、键和值。
7. 把最后一层的结果转成词表概率，选出一个词元，然后开始下一次解码。

回到音乐家的例子。假设简化后的提示词包含 N 个词元，预填充就在每一层建立 N 个键值位置，并根据提示词最后位置的分数选出 钢琴。下一轮中，模型处理新选出的 钢琴，把它的键和值加入每一层缓存，并可能选出一个句号。缓存此时在每层都有 N + 1 个位置。处理句号后再增加一个位置，于是序列按 N → N + 1 → N + 2 增长，而模型不必重算最初 N 组键和值。

KV cache 改变了什么，又没有改变什么

模型仍然要运行全部模型层，创建最新的查询、键和值，读取保留的缓存，并选择下一个词元。缓存复用减少的是重复工作，不会改变 Transformer 预测下一词元的基本任务。缓存也属于当前序列：每个活跃序列通常需要自己的缓存条目，不过服务系统有时可以让开头完全相同的请求共享一部分。Hugging Face 说明了逐层缓存及其增长方式，vLLM 论文则介绍了一种在生产系统中管理和共享缓存内存的方法。

用真实尺寸做一次内存计算

KV cache 的大小取决于模型结构、保留的词元数，以及每个数字占用的字节数。Meta 的 Llama 3 报告指出，其 70B 模型有 80 层和 8 个键/值头。注意力计算把宽度为 8,192 的词元表示分给 64 个注意力头，所以每个头的宽度是 8,192 ÷ 64，也就是 128。每个键/值头使用相同宽度。假设每个缓存数字占两个字节，那么保留一个词元需要：

80 层
× 8 个键/值头
× 每个头 128 个数字
× 2 个数组（一个键数组、一个值数组）
× 每个数字 2 字节
= 每个保留词元 327,680 字节
≈ 每个保留词元 0.328 MB

如果保留 128,000 个词元，一个序列的键和值就占 41,943,040,000 字节，按十进制单位约为 41.9 GB。作为比较，以 700 亿参数这个四舍五入后的模型规模计算，若每个参数使用两个字节，参数本身约占 140 GB。这不表示每个部署都会精确分配这些容量：软件可能按内存块预留空间、采用不同数字格式、共享相同的提示词开头，或实际保留少于模型上限的词元。

这些尺寸来自 Meta Llama 3 报告的表 3；Llama 3.1 模型卡记录了 70B 模型和 128K 词元上下文。最重要的结论仍然是取舍：缓存减少了重复计算，但保留较长序列会占用大量内存，而且这些缓存数据之后仍然要被读取。

1.4 同时服务更多用户会改变成本结构

一起处理请求可以使昂贵的模型的每个答案变得更便宜，因为一次权重读取可以帮助多个请求。代价是每个请求都会消耗内存，并且可能会等待组形成。

首先考虑对话已处于解码阶段的四个用户。如果没有批处理，加速器可以一个接一个地处理它们：

没有批处理
读取权重块 → 生成 A 的下一个词元
读取相同的权重 → 产生 B 的下一个 词元
读取相同的权重 → 生成 C 的下一个 词元
读取相同的权重 → 生成 D 的下一个词元

带批处理
读取一次权重块
├─ 将其用于 A 的下一个词元
├─ 将其用于 B 的下一个词元
├─ 将其用于 C 的下一个词元
└─ 用它作为 D 的下一个词元

配料 表示在一个模型操作中处理多个请求。这些请求不共享答案或对话历史记录。他们有机会在模型的权重被另一个块替换之前使用这些权重。这种重用对从内存中移动的每个字节执行更有用的算术，这可以提高 吞吐量：每单位时间完成的总工作量。

服务系统通常不能等待四个对话到达完全相同的点。请求到达的时间不同，提示的长度也不同，并且有些答案会提前完成。因此，现代服务软件可以删除已完成的请求并在生成步骤之间添加新的就绪请求。实现细节各不相同，但目的是相同的：在加速器上保留有用的工作，而不会让早期请求等待太长时间以获得完美匹配的组。

批处理有三个限制：

1. 等待： 在批量表单时保留请求可以增加第一个词元的时间。
2. 内存： 每个活跃序列都需要临时状态，其中包括自己的 KV cache 条目；只有相同的开头有时可以共享。并发请求增多后，系统可能在算术单元完全忙碌之前就先耗尽内存。
3. 工作不均匀： 较长的提示或未完成的答案可能比较短的请求更持久。服务软件必须替换已完成的工作或使部分批次闲置。

结果是真正的权衡。较大的批次可以降低每个词元的加速器成本并提高每秒词元总数，同时增加用户看到的延迟。因此，有用的服务报告会给出指定请求负载下的吞吐量和面向用户的延迟。 vLLM论文 记录了一个服务系统，该系统以块的形式管理 KV cache 内存并批量更改请求组。

1.5 从加速器租金到每词元成本

有用的经济问题不是“芯片每小时的成本是多少？”问题是“带薪工作时间能产生多少可接受的产出？”一台便宜但大部分闲置的机器比一台保持高效忙碌的更昂贵的机器每次回答的成本更高。

人们经常将三种不同的价格混合在一起：

以下计算仅涵盖第一行。

基本换算为：

原始加速器-每百万输出词元的租赁成本
= 每小时加速器总价格
除以一小时内产生的词元
乘以 1,000,000

假设一个加速器的租金为每小时 2.20 美元，该服务每秒为其服务的所有用户生成 2,500 个输出词元。它每小时产生 2,500 × 3,600，即 900 万个输出词元。将 2.20 美元除以 9，得出每百万输出词元约为 0.24 美元。结果回答了一个狭隘的假设性问题：在这些假设下，加速器租金对每百万产出词元贡献约 24 美分。

这不是客户价格。提供商还必须支付输入处理、空闲期、网络、电力、员工、失败请求和利润的费用。低延迟的聊天服务可能会使用小批量且成本较高。通宵工作可能会使用大批量且成本较低。在算术达到极限之前，长上下文可能会耗尽内存。

任何服务 基准（受控性能测试）都应报告三个结果：第一个词元之前的延迟、后面词元之间的延迟以及所有用户每秒的词元总数。它还应该命名模型、硬件、输入和输出长度以及同时请求的数量。当只有少数请求共享使用其所有参数组的模型时，服务通常会流式传输每个步骤的大部分权重数据。批处理和 KV cache 内存会极大地影响可以共享加速器的序列数量。

第 2 部分 — 训练：模型怎样学到参数

训练会改变模型学到的参数，从而改善其预测。它重复三个步骤：做出预测、测量误差并调整学习到的数字。在大量文本中重复此操作需要大量的算术和额外的内存来存储每次调整所需的信息。在某个时间点保存的学习状态称为 检查点。初始训练通常从随机选择的值开始；继续训练或微调从之前学到的参数值开始。

2.1 训练完成的模型由架构和学到的参数共同组成

代码和配置描述了模型的设计。训练学习其 参数：检查点中保存的数值。许多参数都是名为 权重 的矩阵中的条目；其他人则做出不同的学习调整。

一个权重参与计算；它不应该被视为一个存储的事实。考虑一个虚构的点积示例：

输入：[2,5,1]
权重：[3, -1, 4]

分数 = (2 × 3) + (5 × -1) + (1 × 4) = 5

该示例将匹配值相乘并将结果相加。许多学习到的权重被排列为称为 矩阵 的矩形数组。将矩阵乘以向量或另一个矩阵并对乘积求和称为 矩阵乘法。

神经网络 通过一系列称为 模型层 的阶段应用学习的计算。当前大多数大型语言模型都使用称为 Transformer 的设计。Transformer重复包含注意力的块，这是第 1 部分中引入的机制，用于让每个词元使用较早的文本。

参数计数是发布者对单个学习数字的计数。假设一个 700 亿个参数的模型将每个参数存储在两个字节中。参数占用约140GB。作为比较，所引用的 NVIDIA H100 配置具有 80 GB 内存，因此如果不进行压缩、分片或将某些数据移动到其他地方，就无法在 H100 上进行分配。 NVIDIA H100 规格，2026 年 7 月访问。

推理加载并使用学习的参数。训练或微调会改变它们。

2.2 训练就是重复预测和修正

训练步骤不仅仅告诉模型答案是错误的。它必须计算每个学习参数对误差的影响，然后进行小的协调调整。这个过程就是重复预测和修正：

对于一个虚构的示例，假设训练文本包含“The cat sat on the mat”。该模型看到“猫坐在”上，并将概率分配给可能的下一个词元。如果它给出“roof”40％和“mat”2％，则它为观察到的下一个词元“mat”分配的概率很小。评分规则将错误转化为数字。对于此处使用的下一个词元分数，越低越好。它被称为 训练损失。

从输入到预测和损失的计算是向前传球。训练会保留一些中间值，并且稍后可能会重新计算其他值，因为下一阶段需要它们。

然后系统通过连接的计算进行反向工作。对于每个参数，它都会估计小幅增加或减少是否会使损失变得更好或更差，以及增加或减少多少。该方向和大小信号称为 梯度。这不是更新本身。通过向后计算这些信号的模型是反向传播，通常缩写为向后传递。

最后，优化器 使用梯度和更新规则来更改参数。广泛使用的优化器称为 亚当 保持每个参数梯度的移动平均值及其另一个平方梯度，然后在计算更新时使用两者。 最初的 Adam 论文定义了这些一阶矩和二阶矩估计。

批 是一组一起处理的训练样本。系统可以在优化器更新之前合并几个较小组的结果。训练规则奖励参数，使观察到的答案更有可能在示例中出现。这与将句子存储为显式数据库记录不同，尽管模型仍然可以记忆和重现一些训练示例。

2.3 一个公式估算训练所需的运算量

对于为每个词元使用所有学习参数的传统Transformer来说，训练工作大致随着模型大小和训练词元数量的增加而增长。将其中任何一个加倍，估计的工作量都会大致增加一倍。一个有用的估计是：

训练操作 ≈ 6 × 参数数 × 训练词元数

源公式将主Transformer块与学习表分开计数，这些表将词元标识符转换为起始表示和最终分数。这些表通常只占大型模型参数的一小部分，因此使用发布者的总参数计数会稍微改变估计值。该快捷方式还省略了较小的且依赖于设计的计算。仅将其用于粗略规划。 DeepMind 的 计算优化训练研究 的附录 F 给出了完整的核算。

为什么估算中包含数字 6？在简化的计算中，前向传递对每个词元的每个参数大约使用两次操作：将值乘以权重，然后将结果添加到运行总计中。后向传递必须计算损失如何随层的输入及其权重变化，大约增加前向工作的两倍。这给出了大约两次前向传播操作和四次反向传播操作，总共六次。真正的 Transformer 包含此快捷方式无法精确计数的操作，因此 6 是一个估计规则，而不是一个物理常数。

该规则对大规模运行有何预测？对于在 15 万亿个词元上训练的 700 亿参数模型：

6×700亿×15万亿
= 约 6.3 次10²⁴ 次运算 (6.3 × 10²⁴)

十进制是 1 后面跟着 24 个零。要将这个令人生畏的计数转化为经过的时间，请将工作量除以加速器的合计实际速度：

时间 = 总操作数
÷（加速器数量 × 每个峰值速率 × 达到的峰值份额）

假设 4,096 个加速器可以使用 bfloat16（一种紧凑的两字节数字格式）每秒执行 1000 万亿次适用操作，完整的运行平均为理论速率的 40%。该划分给出了大约 385 万秒，即 44.5 天。按照加速器每小时 2 美元的假设租赁价格计算，仅加速器租金就约为 875 万美元。

“假设”之后的每个数字都是说明性假设，而不是真实训练运行或市场价格的报告。该示例的目的是将模型大小和训练数据与时间和金钱联系起来：即使是数千个快速芯片也可能保持忙碌数周。故障、存储、网络、数据准备和人员都会增加工作量或成本。当处理每个值时，1 千万亿的速率是根据 NVIDIA 发布的 H100 bfloat16 速率进行舍入的。同一个表中较大的标题率假定硬件可以跳过选定的零值的受支持模式。 NVIDIA H100 规格和脚注，2026 年 7 月访问。

2.4 训练需要比成品模型更多的内存

首先是要点：训练可能比服务需要更多的内存，因为它保留模型以及更新模型所需的信息。在一份记录的 NVIDIA NeMo 配方中，大多数计算都使用 bfloat16，缩写为 BF16，这是一种保留较少细节的两字节格式。更新在 32位浮点 中保留了更详细的四字节副本，缩写为 FP32。这种使用多种格式的方式称为 混合精度训练。本例中的优化器 Adam 还为每个参数保留两个运行估计。 NVIDIA 的 NeMo 25.02 指南指定了两字节参数和梯度以及四字节主参数和优化器状态 和 Adam 论文定义了两个每个参数的运行估计。

这个说明性设置为每个学习参数保留了五个项目。该表在添加其大小之前解释了每个选项存在的原因：

梯度在2.2节中介绍过，最后两行是Adam的运行估计。重要的想法是，这个配方在大部分算术中使用较小的值，同时保留更多更新细节。它的五个项目每个参数总共使用 16 个字节。因此，在计算临时结果和软件开销之前，700 亿个参数需要 1.12 太字节或 1.12 TB。这是一个可行的方法，而不是法律：其他系统使用不同的格式、优化器或划分和重新定位数据的方式。

具有 80 GB 内存的 H100 至少需要 14 路完美除法才能容纳 1.12 TB。真正的运行需要更多的设备，因为临时值、通信缓冲区、不均匀的分割和软件也必须适合。 NVIDIA H100 规格，2026 年 7 月访问。

拆分大型数组以便每个处理器仅存储一部分称为 分片。它节省了每个处理器上的内存，但当计算需要完整数组时，处理器必须交换数据。

当输入通过网络时，训练还会创建中间数字数组。这些值称为 激活。向后传递需要选定的激活，或足够的信息来重新计算它们。它们的内存取决于模型设计、示例的数量和长度、层宽度、数字存储、工作分配方式以及保存哪些值。

系统可以保存选定的中间值子集，并在向后传递期间重新计算省略的前向操作。这个激活检查点，也称为重新计算，用额外的算术换取较低的激活内存。成本和节省取决于重复哪些操作；没有普遍的百分比。

因此，推理和训练具有不同的内存消耗。推理可以保留每个权重的一份紧凑副本以及第 1 部分中的每个会话缓存。上面的特定 16 字节训练设置为每个权重保留的持久字节数是两字节推理权重加上激活的八倍。其他训练设置有不同的比率。为模型提供良好服务的芯片并不一定是训练模型的最佳芯片。

2.5 数千个处理器成为一台脆弱的机器

仅当额外的并行工作超过通信、同步、不平衡、数据加载和故障开销时，添加处理器才能缩短训练运行时间。从大规模来看，网络和可靠性可能会严重限制已完成的工作。

从四个加速器的示例开始。每个加速器都有一个相同的模型副本，但读取训练批次的不同季度。所有四个人同时进行向前和向后传球。他们现在有四个不同的梯度阵列，因为他们看到了不同的例子。在任何副本更新其权重之前，加速器会对这些数组进行相加或平均，并将组合结果返回给每个参与者。只有这样，所有四个才能应用相同的更新并保持相同。这种安排就是数据并行。

额外的处理器减少了每个处理器在训练示例上执行的计算，但它们增加了通信步骤并等待最慢的参与者。划分模型的其他方式会创建其他交换：

有几种直观的方法来划分运行：

大规模运行结合了这些方法。数据并行梯度通信通常在每个更新或一组累积批次中发生一次，而张量并行通信可以在每个Transformer块内发生多次。后者通常对链路延迟更敏感，但消息大小、数据移动时的计算能力、连接布局和处理器数量都很重要。第 9 部分解释了由此产生的网络层次结构。

该表是一张地图，而不是词汇测试。处理器可以划分示例、层组、层内的操作或存储的参数和训练状态。

数以千计的处理器也会出现个别罕见的故障。在一份为期 54 天的 Llama 3 训练快照中，Meta 记录了 466 次中断：47 次是计划内的，419 次是意外的。因此，平均每 3.1 小时就有一次意外中断。此次运行使用了多达 16,384 个 H100 加速器的集群。 Meta 的 Llama 3 报告，第 3.3.4 节。

为了进行恢复，系统会定期保存足够的持久状态（例如模型、优化器、计划和进度信息），以便从保存的点恢复。此恢复 检查点 与激活检查点不同：一个支持故障恢复，而另一个则减少计算期间的内存。更频繁的恢复检查点可以减少故障后的重复工作，但会增加存储、输入/输出和同步开销。引用的 Meta 报告将花在有用训练上的实际经过时间所占的比例称为“有效训练时间”，并报告超过 90%。

2.6 大规模文本训练结束后还要继续训练

仅经过训练以继续广泛文本的模型已经学会了强大的下一个词元任务，但它并没有自动学习人们期望助手的行为。如果提示包含一个问题和几个可能的延续，则模型的基本目标奖励可能的延续，而不一定是最有帮助、最诚实或最安全的响应。

训练后会改变大型常规训练后的行为。简化的管道如下所示：

1. 展示所需行为的示例。 训练人员准备提示和适当的回应。更新这些对上的模型为 监督微调。
2. 比较可能的反应。 人员、自动检查或其他模型可以对候选答案进行排名或评分。这会创建偏好或奖励信息。
3. 朝着首选行为进行训练。 方法使用该信息来更新模型。根据人类反馈进行强化学习和 直接偏好优化 是两种不同的方法；真实的管道可以使用其中之一，也可以两者都使用，或者都不使用。
4. 评估并重复。 开发人员测试功能和不良行为，修改数据或目标，并生成另一个检查点。

InstructGPT 论文记录了一种使用监督微调的流程，然后根据人类反馈进行强化学习，而 直接偏好优化论文 引入了一种不同的方法来直接从首选和拒绝的响应中学习。这些论文只是示例，并不是通用的方法。

对于具有可检查结果的任务，系统可以生成候选解决方案并通过测试对其进行评估。 强化学习 是一个更广泛的方法系列，可以改善行为以增加预期奖励；并非每个生成和过滤过程都是强化学习。对候选人进行抽样可以使推理成为后续训练的重要组成部分。

已发布的检查点包含推理服务通常在转换、分片或量化之后加载的固定学习状态。普通推理不会更新这些参数。提供商可以单独保留交互，并随后在另一次训练中使用选定的数据，具体取决于其政策。

这种区别关闭了循环：

训练 = 使用数据和目标来更新学习参数
推理=使用固定参数来计算输出

训练是一个集中的项目，需要大量的运算、内存、通信和可靠性成本。推理是每次使用训练完成的模型时反复发生的成本。它们共同解释了为什么AI 硬件需要快速的运算、宽敞的内存、快速的链接、可靠的操作和充足的电力。

第 3 部分 — 从提示词到完成任务

在本课程中，AI 智能体 是指重复调用模型并可以使用外部工具的软件。该模型提出下一步要说什么或做什么。此处称为 智能体运行时 的协调程序保持任务状态，运行批准的工具，将其结果返回给模型，并决定何时停止。模型本身不会单击浏览器或运行命令；它产生普通软件可以执行的文本或结构化工具请求。一个简短的答案可能需要一次模型调用，而研究或编码可能需要多次调用，其中包括搜索、文件读取、编辑和测试。 “智能体”没有统一的通用行业定义；这就是本课程的工作意义。 OpenAI 在此处记录了模型-工具-结果流程 和 Anthropic 在这里将固定工作流程与智能体区分开来。

3.1 整个智能体在一个循环中

该循环有五个部分。

1. 运行时收集模型所需的材料：用户的请求、相关对话历史记录、指令、可用工具和最近的工具结果。该捆绑包是 模型上下文。
2. 模型读取该上下文并生成答案或建议的工具调用。工具调用是结构化请求，例如“搜索此短语”、“读取此文件”或“运行这些测试”。
3. 精心设计的运行时会检查所请求的工具是否存在、验证其参数并强制执行用户的权限。后续行动，例如发送电子邮件或花钱，也可能需要明确批准。
4. 如果允许调用，该工具将在模型外部运行。搜索引擎搜索，浏览器点击，或者测试运行器运行。该工具返回观察结果：页面、屏幕截图、命令输出、文件或错误。
5. 运行时将该观察添加到任务状态并再次调用模型。当模型给出最终答案、用户必须做出决定或者安全或资源限制停止任务时，循环结束。

在研究任务中更容易看到循环。假设用户要求与来源进行比较。第一个模型调用可能会提出两个搜索。运行时运行它们并返回结果。下一个模型调用可能会注意到一个来源是营销页面，并请求更权威的文档。稍后的调用可能会使用计算器。只有在证据充足后，模型才会给出答案。

3.2 一次模型调用期间会发生什么

一个智能体任务可以包含许多模型调用，并且每次调用都是一个新的推理请求。运行时必须组装该调用所需的材料；该模型不会默默地记住运行时遗漏的早期调用的结果。

遵循简单的研究任务。用户询问：“比较两个加速器并引用官方规格。”

1. 第一个模型调用： 运行时提供可用搜索工具的请求、指令和描述。在 预填充 期间，模型处理这些词元。在 解码 期间，它会生成搜索第一个规范的结构化请求。
2. 工具工作： 运行时检查请求并在模型外部运行搜索。结果可能包含多个链接和片段。
3. 第二个模型调用： 运行时将原始目标加上有用的搜索结果发送回模型。该调用有自己的预填充和解码。该模型可能会请求官方页面而不是依赖于片段。
4. 更多工具和模型调用： 第二个加速器、计算和源检查重复循环。
5. 最终模型调用： 运行时提供答案所需的证据。该模型一次生成一个词元所引用的比较。

调用 1 上下文：目标 + 说明 + 工具描述
调用 2 上下文：目标 + 所需历史记录 + 搜索结果
调用 3 上下文：目标 + 所需历史 + 官方规范
最终背景：目标+选定的证据+要检查的结论

后面的上下文不必包含所发生的一切的逐字副本。运行时可以保留确切的证据、总结旧的讨论、重新打开源或丢弃不相关的结果。每个选择都有代价：丢弃信息可能会删除所需的事实，而携带所有信息会使后面的提示变得更长。

第 1 部分中的 KV cache在处理特定序列时会有所帮助，有时可以让服务软件重用相同的提示开头。它不是持久的智能体内存。运行时仍然必须决定哪些信息属于稍后的模型调用。

因此，长时间的智能体任务可能会在两个方面花费更多：它们进行更多的调用，并且稍后的调用可能会处理更多的输入词元。粗略的任务账单是每次调用的输入和输出成本加上付费工具和其他服务的总和。即使重试没有产生有用的最终结果，也会增加费用。

端到端时间还包括模型之外的工作。测试、搜索、网站、批准等待和其他服务可能比推理需要更长的时间。这就是为什么对智能体来说有意义的性能衡量标准通常是已完成和检查的任务的时间、成本和成功率，而不是一个模型调用中每秒的词元数。

3.3 四个任务，一个循环

经济教训很简单：低词元价格并不能保证低任务价格。假设一个模型执行了 20 个失败的步骤，而另一个模型则用了 4 个步骤完成了相同的任务；较低的词元价格仍可能产生较高的总任务成本。这些数字仅供参考，并非基准结果。对于智能体工作，跟踪整个任务的成本、所用时间和成功率。

3.4 进一步阅读

• OpenAI 的函数调用指南 为软件开发人员展示了相同的模型调用、工具、结果和模型调用循环。
• Anthropic 的《构建有效 AI 智能体》指南解释了固定工作流程与由模型决定下一步行动的系统之间有什么不同。

检查点。 智能体并不是一种新的模式。这是模型提出、普通软件检查并采取行动、结果返回给模型的重复循环。

第 4 部分 — 为什么 GPU 适合多种神经网络计算

AI 模型对大量数字重复相同的计算。图形处理单元（GPU）是为了同时执行许多类似的计算而构建的；中央处理单元（CPU）旨在快速处理更广泛的任务和逐步决策。两者都不是普遍更好：AI 系统通常使用 GPU 进行并行运算，使用 CPU 进行操作系统、请求处理和串行控制。

GPU 成为主要的 AI 计算平台，是因为它的硬件和软件适合许多神经网络计算。其他专用处理器也会采用不同设计来完成相关工作。

4.1 提高速度的两种方法

想象一下一家超市正在决定如何缩短排队时间。它可以聘请一名出色的收银员来快速处理难缠的顾客，也可以为 100 名提着类似购物篮的顾客开设 100 条普通结账通道。第一种方法减少了复杂作业的等待时间。第二个增加了每分钟完成的作业数量。

计算机设计者将这些目标称为 延迟 和 吞吐量。延迟是指定作业所花费的时间。吞吐量是单位时间完成的工作。两者都需要明确的测量边界和单位。

高性能 CPU 内核投入大量硬件来跟踪不规则的程序逻辑，并在一条指令必须等待时寻找其他指令来运行。这些功能可以减少处理许多决策和依赖性的延迟。 CPU 还包含多个内核，并且可以执行并行工作，因此“CPU 有利于延迟”描述的是一种趋势，而不是定义。

GPU 将许多小单元组织成组，这些单元通常针对不同的数据接收相同的指令。控制硬件、附近的内存和专用矩阵单元支持该工作。性能取决于提供足够的类似工作并避免太多不同的决策路径或等待数据。

4.2 图形渲染提供了早期的大规模并行任务

GPU 最初并不是作为AI 处理器。它们围绕图形问题发展：屏幕包含许多图片元素或像素，其中许多像素需要对不同数据进行相同类型的计算。

考虑画一个亮着的红球。软件首先描述球的形状、位置和表面。然后，图形处理器必须确定球覆盖哪些屏幕位置以及每个可见位置应该是什么颜色。对于数千或数百万个位置，它可以将相关计算应用于不同的坐标、颜色和照明输入。并非每个图形步骤都是独立的，但工作负载提供的类似操作远多于一个通用 CPU 内核可以按顺序有效执行的操作。

有用的进展是：

许多屏幕位置
→ 对不同数据应用相关计算
→ 并行运行许多小型工作单元
→ 以交互速度完成图像

神经网络提供了不同的工作和类似的硬件机会。它们不是计算许多屏幕位置的颜色，而是在大型数组中重复乘法和相加数字。数据意味着不同的东西，但处理器可以再次将相关指令立即应用于其中的许多部分。

神经网络被证明包含许多合适的操作。 2012 年，一个名为 AlexNet 的图像识别网络在两个 GPU 上进行训练，并以大幅优势赢得了一场大型图像分类竞赛。 最初的 AlexNet 论文报告了硬件和结果。 图像模型和语言模型有所不同，但两者都包含可以利用并行硬件的大型数组操作。

4.3 为什么模型会创建如此多的重复算术

第 2 部分将模型描述为组织成层的学习参数。其中许多参数位于称为矩阵的矩形数字表中。 矩阵乘法 将一个表中的行与另一个表中的列组合起来形成一个新表。

从一行一列开始：

输入的行：[2, 5, 1]
学习权重列：[3, -1, 4]

(3 × 2) + (-1 × 5) + (4 × 1) = 5

该乘加链在输出表中生成一个数字。下一个输入行可以与相同的权重列组合以产生另一个输出数字。同一输入行还可以与另一个权重列组合。大层在许多行和列上重复这种模式，从而创建大量相关计算。

权重栏
C1 C2 C3
输入行 R1 → O11 O12 O13
输入行 R2 → O21 O22 O23
输入行 R3 → O31 O32 O33

O23 由输入行 R2 和权重列 C3 构建。

许多输出位置可以同时处理，因为它们使用不同的行和列对。如果总和很长，工作人员还可以计算该总和的各个部分并将其部分结果组合起来。这就是 GPU 利用的并行结构。

高效的软件不会为每个输出单独获取每个数字。它将小块输入值和权重加载到更快的片上存储中，将每个块用于多个输出数字，然后移动到下一个块。第 5 部分通过加速器跟随这些块之一（称为图块）。

Transformer 中的注意力和前馈块会执行多次矩阵乘法，但模型层还要对数值做归一化、应用其他函数、协调注意力并搬运数据。“Transformer 包含大量矩阵乘法”是准确的；“Transformer 只有矩阵乘法”则不准确。原始 Transformer 论文说明了注意力和前馈块所使用的可学习矩阵投影。

4.4 搬运数字往往比计算数字更昂贵

算术只是工作的一半。在计算器可以将两个数字相乘之前，数字必须达到它。从内存中取出一个值比执行使用该值的乘法需要更多的时间和精力。确切的差异取决于芯片和数据搬运的距离，因此不存在诚实的通用比率。持久的结论更简单：重用附近的值比从更远的地方再次获取它更便宜。

想想厨房。如果洋葱已经放在柜台上，切洋葱会很快。如果厨师必须步行到仓库去制作每一片，那么添加更多的刀具并不会让晚餐更快到达。 GPU 有很多“刀”。它的核心设计问题是保持成分足够接近以便使用它们。

矩阵乘法展示了重用如何发挥作用。假设一小块输入数字有助于八个不同的输出块。一个糟糕的程序可以从大内存中获取该输入块八次。更好的程序将其一次提取到附近的小内存中并重复使用它八次。算术不变，但七次长途旅行消失了。这就是为什么即使芯片的峰值算术保持不变，数据布局和软件也可以改变速度。

这就是为什么接下来的部分如此关注内存和封装。芯片上有多种小型存储器，而旁边的高带宽存储器则提供更大的容量。软件可以将临时值保存在较小的存储器中，并减少对较大存储器的访问。

相对于指定的程序和机器，受内存流量限制的工作为内存带宽限制；受算术吞吐量限制的工作是 受计算限制。大型矩阵乘法可能会受到计算限制，而仅为少数请求生成文本通常会受到内存带宽限制。这些都是常见情况，而不是模型的永久标签。

4.5 为什么 CPU 不能简单地变得更快

几十年来，通过缩小晶体管，设计人员可以在芯片上安装更多的微型电子开关，同时提高时钟速度。电压可能会随着尺寸的变化而下降，从而有助于控制热量。

到 2005 年左右，由于功率和热量的限制，降低电压变得更加困难，时钟速度的增长也减慢了。 IBM 的 Robert Dennard 的历史描述了这一转变。 摩尔定律 是关于可以经济地集成的组件数量增长的单独观察；这不是物理定律。 英特尔总结了摩尔的观察及其后来的修订。

功率限制鼓励设计人员在专门用于特定计算的多个内核和单元上花费额外的晶体管。 GPU 已经存在；功率限制加速了并行和专业计算，而不是导致 GPU 的发明。

进一步阅读：

• 3Blue1Brown 的神经网络课程 直观地展示了重复的乘法和加法运算如何成为一个网络。
• Mark Horowitz 的能耗成本表比较了某一代芯片技术中算术与数据搬运的能耗。表中的数字是历史示例，不是当前硬件不变的常数。

要记住什么： GPU 并不是普遍更快的 CPU。当工作负载暴露足够多的类似并行操作时，其面向吞吐量的执行和内存系统使其有效。许多神经网络操作都是如此；其他部分可能仍然受到串行工作、内存或通信的限制。下一个挑战是为并行硬件提供数据。

第 5 部分 — AI 加速器内部发生了什么

仅当加速器的算术单元接收数据并准备好工作时，加速器才有用。实际限制可能是算术吞吐量、内存流量或许多工作之间的协调。本部分在介绍任何特定于供应商的名称之前解释了这三种可能性。

可以把芯片想成一座工厂。算术单元是工人，微小的片上存储是工作台，加速器的大容量设备内存是库房。GPU 调度器是一套控制硬件，负责选择接下来运行哪个已经就绪的工作组。这个类比只用来说明各部分的角色，并不是每种加速器的精确结构图。

5.1 GPU 把同一座“小工厂”复制很多遍

GPU 设计人员会在一块称为裸片的硅上重复布置处理模块。重复很重要，因为一个模块可以处理数组的一部分，而其他模块可以同时处理其他部分。

遵循一段矩阵乘法：

1. 软件将大矩阵划分为小工作块。
2. 控制硬件将就绪的工作块分配给 GPU 上的处理块。
3. 该处理块中的工作人员将所需的数字加载到寄存器和小型共享工作内存中。
4. 算术路径和矩阵引擎对这些数字进行乘法和加法。
5. 该块将完成的结果写入更大的设备内存或将其传递到另一个计算。

每个处理块包含算术路径、调度硬件、立即值寄存器和少量片上工作存储器。不同的块可以位于该序列中的不同点，同时共享更大的内存系统。

缓存 保留较慢内存中的数据副本。当稍后的访问在那里找到所需的值时，它会有所帮助，因此软件通常会安排工作以重用附近的数据。确切的块和内存名称因供应商而异；稳定的想法是由本地存储层次结构支持的重复并行处理。 NVIDIA 的编程指南 和 AMD 的硬件术语表 记录了两种具体设计。

5.2 多个工作单元可以执行同一条指令

一个硬件路径可以对一组值执行操作。 GPU 通过向一组小型工作人员提供通用指令，然后将其应用于不同的数据来减少控制开销。组名称和大小因供应商而异。

想象一下，一群面包师收到“添加两杯面粉”的指令，每人加一个不同的碗。一条指令可以协调许多有用的操作。当每个碗都需要相同的步骤时，这是有效的。当一半面包师需要搅拌而另一半需要等待时，效率就会变得很低；该组可能必须轮流执行这两条路径。

下面的规则比标签更重要：当一组工作人员需要相同的指令时，GPU 的效率最高。如果他们采用不同的决策路径，则硬件必须单独处理这些路径，而一些工作人员则处于闲置状态。现代 NVIDIA 硬件并不要求每个工作人员都按照字面上的“同步”前进，因此熟悉的速记法会产生误导。 NVIDIA GPU 编程指南。

5.3 数据传输过程中芯片切换工作

设备内存的响应时间可能比算术运算要长得多。 GPU 无法消除该延迟，因此它会保持多个线程组处于就绪状态。当一个组等待数据时，调度程序可以从另一个就绪组发出工作。

想象一个有几张桌子的餐厅服务员。在厨房下了一桌的订单后，服务员不会停下来直到食物出现。他们从另一张桌子上点菜，给第三张桌子送一杯饮料，然后在第一顿饭准备好后返回。尽管每次厨房都有延误，但足够的独立桌子仍可保证服务员的工作效率。

工程师将此称为 延迟隐藏：在延迟期间处理其他事情。简化的时间线如下所示：

A组：请求数据──────────等待──────────计算
B组：计算→请求数据──────等待
C组：计算→请求数据

处理器：有用的 A/B/C 工作填补了一些等待期

内存响应并没有变快。处理器只是找到准备好的独立工作。仅当程序提供足够的此类工作并且每个组留下足够的寄存器和片上内存以供其他组保持准备状态时，延迟隐藏才会成功。如果一组几乎消耗了附近所有的存储空间，那么适合的替代方案可能就太少了。如果每个组都等待相同的缺失结果，则没有任何内容可以切换。 NVIDIA 的 GPU 编程指南 记录了活动线程组的硬件调度和资源限制。

5.4 专用矩阵单元承担主要的 AI 运算

现代 AI 加速器包含专门执行第 4.3 节矩阵运算的电路。NVIDIA 把自己的版本称为 Tensor Core；其他供应商使用不同名称。Tensor Core 不是一颗单独运行整个模型的处理器，而是 GPU 内部对小型数字分块执行受支持矩阵运算的算术单元。

加速器处理一个大的矩阵：

1. 将输入矩阵和权重矩阵划分为名为 瓷砖 的小矩形块。
2. 将匹配的图块从大型设备内存加载到更快的片上存储中。
3. 将这些图块交给矩阵引擎，该引擎执行许多乘法和加法步骤。
4. 将部分结果添加到输出图块中。大的输出可能需要来自多对输入图块的贡献。
5. 重复使用任何有助于另一个输出的图块，然后存储已完成的输出图块。

大输入矩阵 大权重矩阵
┌───┬───┬───┐          ┌───┬───┐
│ A │ B │ C │ │ D │ E │
└───┴───┴───┘          └───┴───┘
↓ 选择匹配的瓷砖
矩阵引擎执行小型矩阵运算
↓ 重复并添加部分结果
一个输出图块

确切的图块形状、可接受的数字格式和说明取决于产品。稳定的想法是，专用接线可以比将每个乘法和加法作为不相关的指令发出更有效地执行公共矩阵算术块。

规格表通常报告规定的 数字格式 的最高理论矩阵速率（用于对数字进行位编码的规则），并且可能假设支持的零模式。代码必须使用受支持的操作并保持为单元提供数据以接近该速率。因此，该数字并不描述任意代码或保证应用程序速度。 NVIDIA 的 H100 表 说明了规定的速率如何随格式和稀疏性而变化；它的 编程指南 描述了Tensor Core矩阵运算。

5.5 本地内存有几个级别

在一个加速器内，存储根据访问时间和带宽来交换容量和芯片面积：

最接近算术

为各个线程注册立即值
片上工作存储器 用于一个处理块的小型可重复使用的块
缓存来自较大内存的数据副本
设备内存模型权重和其他大型数组

离算术更远

寄存器 是算术指令直接使用的微小存储单元。接下来的级别使用第 6 部分中解释的快速片上存储器技术。大型设备存储器使用那里介绍的其他技术。确切的大小、名称和访问成本取决于加速器。

另一个加速器上的内存、主计算机的内存和存储是通过附加链接到达的单独池。它们不是保证容量增加的额外梯级，并且它们的顺序可以根据产品以及阅读器是否比较延迟或传输速率而改变。快速软件将有用的数据加载到附近的存储中，重复使用它，并避免不必要的传输。

5.6 每项工作都会碰到两种上限之一

要预测一段代码是否能够正常运行，请问两个问题：

1.它执行了多少算术运算？ 2. 必须移动多少数据才能执行该算术？

如果一个操作多次使用每个获取的值，则算术单元可能会成为限制。添加更快的内存不会有太大帮助，因为计算器已经满了。该操作受计算限制。

如果某个操作对每个获取的值几乎不起作用，则数据到达的速度太慢而无法填充计算器。添加更多的算术单元不会有太大帮助，因为现有的算术单元正在等待。该操作受内存限制。

工程师用算术强度衡量跨过指定内存边界的每个字节对应多少运算。简化的 Roofline 模型给出这两个上限：

可达到的算术速率不大于以下较小者：

1. 峰值算术吞吐量
2.内存带宽×每字节算术运算数

训练和提示处理中的大型矩阵运算通常会重复使用足以受到计算限制的值。当只有少数请求共享使用其所有参数组的模型时，词元生成可以为读取的每个字节权重执行相对较少的工作，并受到内存带宽限制。模型设计、上下文长度、同时请求的数量、软件和硬件都可以改变任一结果。

使用小型说明机来查看该规则。假设它每秒最多可以执行 1,000 次操作，并且其内存每秒提供 100 字节。

• 每字节执行两个算术步骤的操作每秒最多可提供 100 × 2 = 200 操作。内存设置了下限，因此操作受内存限制。
• 每字节执行 20 个算术步骤的操作的内存上限为每秒 100 × 20 = 2,000 操作。该机器只能执行 1,000 次，因此算术设置了下限，并且该操作受计算限制。

当软件增加重用、数字格式减少字节或机器发生变化时，相同的操作可以从一侧移动到另一侧。该标签属于特定系统上的特定工作负载和实现。

由于协调、调度或其他开销，真实程序可能低于这两个上限。Roofline 模型告诉你哪类资源设定了理论上限，并不保证软件真的能够达到它。

5.7 更好的软件可以消除整个内存往返

GPU 核心 是 GPU 在许多并行工作线程上运行的小程序。一种简单的实现可以运行一个内核，将中间结果保存到大设备内存中，然后运行另一个立即将其读回的内核。

内核融合 组合了兼容的步骤，因此可以消除中间结果或保留在寄存器、片上工作存储器或缓存中：

单独的步骤：
设备内存 → 步骤 1 → 设备内存 → 步骤 2 → 设备内存

融合步骤：
设备内存 → 步骤 1 + 步骤 2 → 设备内存

融合可以减少内存流量和启动独立程序的开销，但占用过多片上资源也可能拖慢速度。FlashAttention就是一个真实例子：它重新组织注意力计算，减少大容量内存与小型片上内存之间的数据搬运，同时得到数学上等价的结果；由于计算顺序改变，数值上仍可能出现极小差异。

这就是为什么软件支持是实际硬件性能的一部分。库和编译器选择矩阵运算、数据布局、内存重用、融合和调度。峰值规格给出了规定条件下的上限；应用程序只能达到其完整实施所能维持的程度。

进一步阅读：

• 原始 Roofline 报告定义了这种双上限性能模型。
• FlashAttention 论文是减少内存流量这一案例的主要来源。

要记住什么： GPU 将算术分组为重复的处理块，保持多个线程组准备好覆盖延迟，并使用矩阵引擎来支持操作。计算、本地内存流量或协调是否是最严格的限制取决于工作负载和实施。

第 6 部分 — 内存：能装下多少，能搬得多快

内存有两个独立的工作。它必须足够大以容纳模型及其临时工作数据，并且必须足够快地传递这些数据以保持处理器的可用性。第一个属性是 内存容量。第二个是带宽。

想想一个供水系统。容量是指水箱的大小；带宽是管道的宽度。一个带有狭窄管道的大水箱可以储存大量的水，但输送速度很慢。连接到小水箱的宽管可以快速输送，直到水箱用完。AI 系统通常需要一个大水箱和一条宽管道。

6.1 快速内存容量小，大容量内存离计算单元更远

没有任何一种内存可以为处理器提供无限的容量、即时访问、低功耗和低成本。因此，设计者构建了一个层次结构：靠近算术运算的一点快速存储和远离算术运算的更多存储。

处理器上的寄存器、缓存和小型工作存储通常使用静态随机存取存储器（SRAM）。只要持续供电，SRAM 单元就能保持数据，不需要像 DRAM 那样定期刷新，因此适合快速的片上访问。但每个存储位需要更多晶体管和芯片面积。要用 SRAM 装下大型模型，会消耗当前设计难以接受的硅面积和成本。

大型设备存储器使用动态随机存取存储器或动态随机存取存储器。 DRAM 单元存储必须被感测和刷新的电荷。其更密集的设计可以在给定区域容纳更多位，但与小型片上存储器相比，访问涉及更多延迟。在高端加速器中，DRAM 是在单独的内存芯片上制造的，并通过封装连接到处理器。 三星内存概览 解释了 DRAM 存储和刷新，并将其密度与 SRAM 进行了比较。

有用的类比是一张桌子和附近的图书馆。办公桌很快就能到达，但只放着今天的工作文件。图书馆藏书远多，但每次参观都需要时间。好的程序会将一组有用的文件带到办公桌上，反复使用它们，并仅在必要时返回它们。第 5.4 节和第 5.7 节通过矩阵图块和融合计算准确地描述了这种策略。

接下来介绍的高带宽存储器是通过异常宽的接口排列和连接的DRAM。这并不是不同的存储原理。

6.2 高带宽内存通过许多短连线并行传输数据

高带宽内存（或 HBM）主要通过在非常广泛的短连接上移动数据来提高传输速率。该包并不要求相对较少的线路以更高的速率运行，而是并行传输许多数据。

一个 HBM 堆栈分阶段组装：

1. 多个 DRAM 芯片存储实际位。
2. 芯片被堆叠，并且垂直的电气路径连接各层。
3. 基础层或接口层将堆栈连接到封装。
4. 密集封装布线将堆栈连接到加速器的计算芯片。
5. 处理器上的内存控制器协调宽接口上的读取和写入。

内存在封装中靠近处理器，但它不是处理器芯片的一部分。在算术单元可以使用数据之前，数据仍然必须经过存储单元、堆栈、封装布线和处理器的存储系统。

图形双倍数据速率（或 GDDR）存储设备通常安装在电路板上的 GPU 封装周围。 GDDR 使用更窄的连接，在每条线上以比 HBM 更高的速率传输数据。光靠名字并不能确定哪种产品更快、更大或更便宜。确切的容量和带宽取决于存储器代数、设备数量、接口宽度和完整系统。

封装布线不一定是一整层硅。现有设计可以使用大型硅中介层、由其他材料制成的精细布线，或小型局部硅桥。因此，HBM 容量取决于内存裸片制造、堆叠、封装布线、组装和测试，而不只是连接传统内存模块。SK hynix 解释了堆叠内存和垂直连接，TSMC 则记录了几种封装布线方法。

6.3 容量回答“模型适合吗？”

假设一个模型包含 700 亿个参数，并将每个参数存储在两个字节中。权重有效负载为 70 billion × 2 = 140 billion bytes，即十进制单位为 140 GB。仅这些权重就超过了所引用的 H100 配置中的 80 GB，并且适合 AMD MI300X 中的 192 GB。 NVIDIA H100 规格 和 AMD MI300X 数据表 提供这些功能。完整推理还需要临时工作空间，通常还需要 KV cache，因此 192 GB 并不能保证每组请求和上下文长度都适合。

检查的顺序很重要：

可用设备内存
− 模型权重
− 活动序列的 KV cache
− 临时工作空间和软件分配
= 剩余安全裕度

如果结果是否定的，则服务不能简单地在相同的分配上“运行得慢一点”。它必须更改存储的内容或存储的位置。第 1.3 节计算了特定 700 亿参数模型上的一个 128,000 个词元序列的 KV cache约为 41.9 GB。这就是为什么随着上下文长度或批量大小的增长，权重合适的模型仍然会耗尽内存。

如果所有必需的数据不适合，系统可以跨加速器分割选定的状态，将某些状态移动到较慢的内存，降低数值精度，缩短上下文，或选择较小的模型。这些选择可能会增加通信、延迟、软件工作或质量损失。因此，容量可以改变系统的架构和成本。

训练需要的不仅仅是权重。它通常存储梯度、优化器状态（例如 Adam 的运行平均值）以及称为激活的中间数组。系统可以在加速器之间划分某些状态。 激活检查点，也称为重新计算，仅保存选定的中间结果，并在向后传递过程中重新创建其他结果，以额外的计算换取较低的内存使用。 PyTorch 的激活检查点文档。

通俗易懂的规则是：当内存匮乏时，工程师要么划分数据，更紧凑地存储数据，要么重复一些计算而不存储结果。

6.4 带宽回答“模型的读取速度有多快？”

当只有少数请求共享一个为每个输出词元使用大部分参数的模型时，每个生成步骤可能会流式传输大部分权重，同时每字节执行的工作相对较少。内存带宽可能成为限制。一起服务更多请求可以共享权重读取，而其他模型设计可以改变数据移动量。

如果解码步骤必须读取一次 140 GB 权重文件，则理想的 3,000 GB/s 内存接口每秒最多可以提供大约 21.4 次完整的权重文件读取：3,000 ÷ 140。它使用十进制单位并假设峰值带宽、每步一次完整读取、没有竞争流量、并且没有通信或算术开销。一个低批量流通常会比较慢。当批次共享每次读取时，每秒的聚合词元可能会更高，因此这不是通用的词元率上限。

这个例子给带宽数字提出了一个问题和一个基线。单独来看，“每秒 3 TB”听起来非常巨大。与必须一次又一次地重新访问的 140GB 模型相比，它成为读者可以感受到的限制。

处理器运算速度与内存供数速度之间不断扩大的差距叫作内存墙。缓存和数据复用可以减少外部内存流量，较低精度可以减少搬运的字节数，HBM 等更宽的接口则可以提高带宽。哪种方法有效取决于工作负载。Wulf 和 McKee 最早系统讨论了这个术语。

6.5 内存供应会限制加速器供应

加速器供应商不能仅仅因为存在处理器芯片就推出 HBM 产品。所需的内存必须通过自己的链：

制作 DRAM 芯片
→ 测试它们
→ 组装并连接堆栈
→ 测试堆栈
→ 使其符合客户平台的资格
→ 组装并测试完整的加速器封装

HBM 堆栈包含多个内存芯片、许多垂直连接以及将其连接到封装的接口层。芯片、连接、堆叠组件或后续封装中的故障可能会减少可用成品零件的数量。分几个阶段进行测试可以减少组装已知失败组件的机会，但它不能消除所有集成风险。

HBM 生产和 客户认证（测试组件是否满足客户平台要求）是专门阶段。因此，即使处理器芯片可用，产量太少、被拒绝的堆栈太多或认证缓慢也会减少可用的加​​速器供应。供应声明应始终注明 HBM 生成和日期。

对于关注该行业的读者来说，实际问题很简单：每个加速器承载多少内存？它能以多快的速度搬运其中的数据？供应商可以生产多少经过测试的电池组？这三个问题将模型、硬件和供应链联系起来，无需 HBM 版本名称目录。

进一步阅读：

• SK hynix 的 HBM 说明介绍了堆叠 DRAM、垂直连接和宽接口。
• AMD MI300X 数据表 是容量和带宽如何出现在产品规格中的具体示例。

要记住什么： 容量决定权重和工作数据是否相符。带宽限制了内存提供数据的速度。 HBM 通过堆叠 DRAM 和宽封装接口提高带宽，增加了要求严格的内存、组装、测试和封装阶段。

第 7 部分 — 为什么 AI 使用位数更少的数字

许多训练和推理系统用更少的位数存储或计算一些数组，同时在需要的地方保留更多细节。更少的位数可以减少存储和内存流量，并可以增加匹配硬件的吞吐量。较小的格式可以消除附近值之间的细微差异，或者无法保存超出其范围的数字。任一问题都可能改变模型质量，因此可用的格式取决于模型、任务和操作。

实际问题不是“最小的格式是什么？”它是“哪种格式满足此工作负载的测量质量目标？”如果没有格式、质量结果和测量条件，性能声明是不完整的。

7.1 数字格式在表示范围和精细程度之间分配位数

计算机将数字存储为位模式，即第 0 部分中介绍的零或一值。更多位允许更多可能的模式。设计师必须决定这些图案的含义。

对于可能非常大或非常小的值，计算机通常使用类似于科学记数法的方案。十进制表达式 3.14 × 10² 将有效数字与小数位数分开。二进制 浮点 格式同样记录符号、比例和有意义的数字。

这两个作业是 范围 和 细节。范围决定了格式可以表示的大小。细节决定了它在给定比例下区分附近值的程度。

想象一下只保留三位有效数字的微小十进制格式。它可以存储3.14，但值3.14159必须四舍五入。接近 3 时，它无法区分 3.14 和 3.15 之间的所有可能值。具有更多有效数字的格式可以保留更多的差异。另外，较大的指数字段允许格式在更广泛的幅度范围内移动小数点（或者在计算机中为二进制点）。

因此，为指数提供更多位可以允许更广泛的大小范围。为有效数字提供更多位可以保留附近值之间更细微的差异。减少总位数可以使存储和支持的算术更便宜，但会增加舍入以及值太大或太小而无法表示的可能性。

由电气电子工程师学会发布的 IEEE 754 标准定义了一种名为 binary32 的 32 位格式，通常称为 FP32，每个数占四个字节。BF16 使用 16 位，保留近似的数值范围，但能区分的细节更少。FP8 是一组单字节格式的统称，不同格式会在范围与精细程度之间作出不同取舍。四位格式只有在紧密打包时才会让每个值占半个字节；缩放信息和其他元数据还会增加存储量。IEEE 754、Google 的 BF16 指南和 FP8 格式论文说明了这些区别。

7.2 较小的数字可以节省空间、移动和算术

对于 700 亿个参数，仅打包权重有效负载就大约需要以下十进制千兆字节。元数据、填充、KV cache、工作区和其他运行时状态被排除：

每个权重两个字节：140 GB
每个权重一个字节：70 GB
每个权重半字节：35 GB

将有效负载从 2 个字节减少到 1 个字节会将 140 GB 更改为 70 GB，因此仅权重就适合 80 GB 的设备。一旦包含元数据、KV cache、工作区和其他分配，完整的服务可能无法容纳。如果权重流量是唯一的限制，那么将这些字节减半可以得到接近权重传送速率两倍的理想界限；实际加速可能更小。支持的低精度矩阵单元也可以具有更高的规定吞吐量。

量化 将较大集合中的值映射到较小的可表示值集合中。拍摄许多精确的温度读数并以最接近的整数度记录每个读数。记录变得更简单，但几个略有不同的读数现在共享一个存储值。AI 量化使用更复杂的映射，并且通常存储值组的缩放信息，但核心权衡是相同的：存储的选择越少意味着数据越少，近似值越高。

量化可以应用于权重、临时值或 KV cache。它可以减少存储和流量并加速支持的计算，但质量和速度取决于方法、模型、任务和硬件。 PyTorch 的量化概述 解释了用于用更少的位数表示更大的数值范围的映射和比例。

训练会反复更新权重，并且必须表示梯度和累积的优化器状态，​​因此混合精度配方通常会为所选值保留更高的精度。推理通常允许激进的仅权权重化，但可接受的精度仍然取决于模型和任务。 “支持 4 位 AI”并不能证明整个训练或推理工作负载以可接受的质量使用了 4 位。

7.3 如何诚实地阅读加速器规格

从工作负载开始，然后比较匹配的测量结果。五个问题消除了大部分困惑：

1. 什么样的数字进入计算，什么样的数字保存运行总计？仅当两种格式和操作相同时才比较费率。
2. 峰值是否假设零以硬件可以跳过的确切模式出现？这称为 结构化稀疏性。相同条件下比较结果；任意零不会自动获得所宣传的加速。
3. 总数是一个处理器包、一台服务器还是整个​​机架的总数？较大的方框自然会产生较大的标题。 4.工作负载最需要算术、内存容量还是内存带宽？每秒峰值操作数无法回答另外两个问题。
4. 在可接受的质量和响应时间下，真实模型上发生了什么？当其设置符合预期用途时，基准比理论上限提供更多信息。

除了吞吐量和延迟之外，还报告功率或能量，因为功率受限的设施可能关心每瓦特或每机架的工作量。报告软件和基准测试版本，因为应用程序性能取决于可用的内核、编译器和库。

因此，有用的比较保持操作、格式、稀疏性假设、工作负载质量和测量条件不变。它报告算术吞吐量、内存容量和带宽、链路带宽和延迟、功率、应用程序吞吐量和响应延迟。

进一步阅读：

• 电气和电子工程师协会的浮点概述 是传统格式的正式来源。
• NVIDIA 的低精度入门说明解释了低位数格式的乘法如何与缩放信息和更高精度的累加结果配合使用。

要记住什么： 更少的位可以减少打包大小和内存流量，并可以提高支持的硬件上的吞吐量。它们还可能降低测量模型的质量。比较相同的操作、格式、稀疏性假设、工作负载和质量目标，而不是幻灯片上的最大数字。

第 8 部分 — 加速器是如何制造的

本部分重点介绍使用 HBM 的高端数据中心加速器。裸片是一块已经加工、内部包含电路的硅。封装保护一个或多个裸片并把它们连接到系统其他部分；某些加速器封装还包含附近的内存堆栈。先进封装则是用密集布线把这些部件组装起来的独立制造环节。

因此，成品供应取决于处理器芯片、合格的内存、封装组装和测试。即使其他部件可用，任何所需阶段的短缺、高废品率或认证问题也会限制加速器的成品。 英特尔定义芯片和封装，而TSMC 记录了当前的 HBM 封装结构。

8.1 从工作负载的需求开始

如果先从加速器封装必须解决的问题出发，它就更容易理解。封装不是任意堆在一起的硅片；每个主要部件都在回应一种工作负载需求。

计算芯片包含第 5 部分中介绍的矩阵引擎、通用算术路径、控制硬件和片上存储器。HBM 堆栈提供更大的存储器容量和带宽。这些组件下面和之间的密集布线承载着许多间隔很近的信号，这些信号很难通过普通服务器主板进行路由。其他电路提供电源并将封装连接到服务器的其余部分。

从上面看，结果就像一个小城市中心。主处理器位于中间。内存堆栈位于其周围。下面的密集布线层在它们之间传输流量，并且更大的底座将整个组件连接到服务器。

此城市图片描述了一种常见的 HBM 加速器布置，而不是所有加速器。封装不需要包含存储器，并且不同的产品以不同的方式放置和连接其组件。

8.2 从硅晶圆到一块块裸片

芯片制造将空白硅晶圆转变为复杂电路的许多副本。它无法用一种微小的工具雕刻出完整的晶体管。相反，工厂通过重复的涂层、图案化、添加和去除材料的顺序逐层构建和连接结构。

一个简化的旅程是：

1. 准备晶圆。 制造从高纯度硅制成的圆形 晶圆 开始。就规模而言，英特尔表示其使用的现代晶圆宽度为 12 英寸（即 300 毫米）。 英特尔的制造术语表 提供了该示例。
2. 添加光敏涂层。 这种涂层在光线到达的地方会发生变化。
3. 投影一种电路图案。 光刻 使用光和图案掩模来曝光选定区域。显影涂层会在晶圆上留下临时图案。
4. 改变暴露的材料。 其他设备可以去除材料、添加薄材料或更改选定的电性能。确切的操作取决于正在构建的层。
5. 重复许多层。 晶体管首先形成，然后导电层将它们连接成电路。每一层都必须与前面的一层对齐。
6. 测试并分离裸片。 探针测试可识别满足指定电气限制的芯片。将晶圆切割或切割成单独的芯片。合格的芯片将继续进行封装和进一步测试。

前沿工艺对选定的关键层使用极紫外光；其他层可以使用不同的光刻系统。 ASML解释涂层、曝光、显影和重复层过程，包括沉积、蚀刻和本介绍中省略的其他步骤。

上述步骤省略了数百个专门的操作和检查。心智模型才是最重要的：一个晶圆带有许多重复的电路，每个电路都是通过许多对齐的层构建的，并且成品晶圆仍然需要进行测试和划分。有些设计可以禁用错误的重复块，但仍然满足支持的较低配置；不符合支持规格的裸片将被丢弃。

许多加速器公司设计芯片，但聘请一家名为 晶圆代工厂 的专业制造商来制造芯片。这就是为什么一家代工厂的计划可能会影响多家竞争芯片公司的原因。

8.3 “3 纳米”是工艺代号，不是单一尺寸

代工厂给制造世代命名，例如 7 纳米、5 纳米或 3 纳米。这代命名为 工艺节点。现代节点名称不衡量一种物理特征，来自不同代工厂的标签无法直接比较。

这意味着以“3 纳米”名义出售的芯片并不包含仅仅 3 纳米宽的重要部分。几十年前，节点标签更密切地跟踪特定的设备尺寸。现代晶体管及其布线有几个相关的尺寸，制造商使用节点名称来区分一代设计和制造技术。

对于特定设计，比较适合的电路数量、速度和能效、通过测试的芯片比例以及成本。更新的工艺可能会改进这些特性的某些组合，但结果取决于电路和设计选择；开发、掩模、晶圆和封装的成本也可能更高。

当两个产品使用不同节点时，替换“哪个纳米数更小？”有四个问题：

1. 完整芯片在相同工作负载下的表现如何？
2. 产生该结果需要多少功率？
3. 成品芯片和封装的尺寸和成本有多大？
4. 制造商可以生产多少可用零件？

因此，较小的标签并不能保证成品加速器更便宜。设计人员可以使用可用的晶体管进行更多算术、控制、存储器或链接，但受面积、功率和成本限制。片上内存也变得更难缩小。将节点视为一项制造输入，而不是产品性能分数。 英特尔解释现代节点命名。

8.4 更大的裸片功能强大但更难生产

两个限制使得大芯片变得昂贵。

首先，光刻扫描仪一次只能打印有限的矩形。 光罩尺寸上限 限制了在一个曝光区域中制作的传统芯片的尺寸。 ASML系统规格。

其次，在制造过程中会出现微观缺陷。想象一下从含有一些烧焦斑点的托盘中切布朗尼蛋糕。如果布朗尼饼很小，每个烧焦的地方都会毁掉一小块，并留下许多好的碎片。如果布朗尼蛋糕很大，那么同一个地方可能会毁掉更有价值的巧克力蛋糕。大型裸片也存在同样的问题。

晶圆的圆形边缘还会造成另一种损失。靠近边缘的矩形裸片无法完整放下，因此裸片越大，一片晶圆上通常能排下的完整裸片就越少；制造缺陷还会进一步减少合格数量。准确结果取决于裸片尺寸、晶圆排布、缺陷分布和设计可以容忍的故障。这个类比只解释变化方向，并不是良率公式。

裸片良率是制造出的裸片中通过所需测试的比例。设计人员可能加入冗余或可关闭的模块，因此带有局部缺陷的裸片仍可能满足某种受支持的配置。制造商随后测试合格部件，并把它们归入不同产品或性能档位；这种分类叫作分档。较低档位的部件可能功能完整，只是达不到更高的速度或功率等级。

这些影响就是为什么晶圆数量不能直接转化为相同数量的优质零件以及为什么相关产品可能会暴露不同数量的工作单元。良率、缺陷容限和分档是相关的，但不能互换。 英特尔的制造术语表。

8.5 芯粒把一个大难题拆成几个小难题

当一个大芯片变得太难打印或太浪费时，设计人员可以将其分成几个较小的芯片并将它们连接在一个封装内。这些小块裸片称为 芯粒。

布朗尼蛋糕的类比显示了一个潜在的好处：局部缺陷会影响较小的一块。可以在组装之前对裸片进行测试，以减少封装不良裸片的机会。封装还可以将采用不同工艺制造的芯片组合在一起，例如，较新的算术芯片与将数据移入或移出封装的成熟电路相结合。总体经济效益仍然取决于有多少封装组件通过了测试。

想象一个需要四个重复算术区域的设计。单芯片版本将所有四个芯片放在一个大矩形上。芯粒版本制造四个较小的算术芯片并将可接受的芯片连接到一个封装中。损坏一个芯粒的缺陷不会在组装前自动丢弃其他三个芯片，工厂可以先测试这些部件。但完成的封装现在需要所有四个部件之间的工作链接、足够的布线来传输数据，以及在整个组件中提供电力和散热的方法。

芯粒增加了芯片间通信、封装布线、电源、散热、组装和测试要求。尽管确切的成本取决于接口和封装，但跨越芯片边界可能会比一个芯片内的通信花费更多的延迟和能量。硬件、固件、编译器或应用软件必须管理它们可以看到的布局的任何部分。芯粒将部分问题从一个大芯片转移到集成中。 UCIe 记录了一种标准化芯片间接口。

8.6 先进封装把处理器和内存连接起来

制造生产独立的计算和内存芯片。先进的封装通过将这些部件作为一个组件进行放置、连接、保护、供电和测试，将它们变成一个可用的加速器。

沿着一次内存读取。 HBM 芯片中的存储单元通过堆栈的垂直连接提供位。信号通过堆栈的接口并穿过密集的封装布线到达计算芯片的内存控制器。控制器将请求的数据传送到处理器的内存层次结构中，算术单元最终可以使用它。该路径上的每个物理连接都必须以所需的速率工作。

普通服务器主板无法直接路由宽 HBM 接口所需的所有紧密间隔信号。因此，供应商使用更密集的封装布线，例如硅 中介层、由其他材料制成的精细图案布线或小型嵌入式硅桥。中介层是组件之间的中间布线结构；它携带信号但不执行模型的算术。

组装顺序因产品而异，但依赖关系是共同的：合格的计算裸片和内存堆栈只有经过封装连接并通过测试，才成为完整加速器。因此，封装环节也有自己的设备、产能、良率和认证限制。TSMC 记录了几种当前布线方法以及处理器与 HBM 的布局。

因此，完成的 HBM 加速器取决于处理器芯片制造和测试、内存芯片制造、HBM 堆叠和测试、封装组装和测试以及随后的主板或服务器集成。任何所需阶段的短缺、高拒绝率或认证延迟都会限制可用系统。

进一步阅读：

• ASML的光刻概述 解释了电路图案如何到达晶圆。
• TSMC CoWoS 概述 区分基于硅、再分布层和桥接的封装结构。

要记住什么： 可用的 HBM 加速器取决于处理器芯片、内存、封装、测试和系统集成。较大的芯片会降低裸片良率。芯粒可以降低一个大芯片的风险，但会增加集成工作。最严格的生产阶段要求可能会限制成品供应。

第 9 部分 — 为什么多个加速器需要快速连接

大型模型和训练工作通常分布在加速器上。然后，通信成为计算的一部分，并且处理器可以在等待另一处理器时处于空闲状态。

设计人员尝试在紧密耦合的加速器组内保持频繁的、对延迟敏感的通信，并跨服务器或组使用更广泛的集群网络。第一个排列称为 扩大规模；第二个是横向扩展。它们描述系统组织和通信范围，而不仅仅是两个物理距离。

9.1 纵向扩展使附近的加速器表现得像一台更大的机器

想象一下四个人组装一个拼图。如果他们坐在同一张桌子上，他们可以毫不延迟地传递棋子并指出比赛。如果每个人坐在不同的建筑物中，即使每个人工作速度相同，相同的协调也会变得慢得多。

纵向扩展网络将紧密耦合的加速器组与专为高带宽和低延迟而设计的链路连接起来。 NVIDIA 将其版本称为 NVLink，并使用交换芯片将其扩展到支持的系统。其他供应商使用其他设计。纵向扩展组可以位于一台服务器内部或跨机架延伸；软件仍然必须划分和协调工作。

横向扩展网络通过交换机连接服务器或纵向扩展组。 以太网 是数据中心网络技术的标准化系列。 InfiniBand 是一种交换网络设计，专为高数据传输速率和短延迟而设计。与本地纵向扩展网络相比，横向扩展路径通常为每个加速器提供更少的带宽和更多的延迟，但确切的速率、共享和连接布局取决于所部署的系统。 NVIDIA 文档 NVLink 和 InfiniBand贸易协会 文档 InfiniBand。

纵向扩展：紧密耦合的加速器组

[GPU] ===== [GPU]
     ||           ||
[GPU] ===== [GPU]

横向扩展：许多服务器和机架，它们之间的网络交换机

[服务器] --- [交换机] --- [交换机] --- [服务器]

任何一层都不会取代另一层。大型 簇（一组为共享工作而管理的连接计算机）可以使用紧密耦合的加速器组，然后通过更广泛的网络连接这些组。

9.2 直接比较各个通信路径

对于指定系统，分别比较本地HBM、纵向扩展Fabric和横向扩展网络。本地 HBM 通常为每个加速器提供最多的带宽，但每个指标没有通用的比率或排序。产品、方向、拓扑、链路计数以及数字是每个端口还是聚合数据都很重要。

安全的教训是有条件的：当本地内存中已经存在相同的值时，使用它通常可以避免链接传输。当数据是远程时，询问有多少字节通过哪个链路、多久一次以及所引用的速率是理论值还是测量值。

这就是为什么“模型适合八个 GPU”并不是性能结果。如果设备在几乎每一层之后都交换大型数组，则通信可能会主导运行时间。如果他们独立工作较长时间并交换小总结，较慢的路径可能就足够了。

考虑一个划分为两个加速器的简化模型层。加速器 A 保存权重矩阵的左半部分，加速器 B 保存右半部分。两者都接收层的输入并同时计算输出的不同部分。如果下一次计算需要完整的组合结果，则两个设备必须交换或组合其部分数组，然后才能继续。

同层输入
├─→ 加速器A使用权重分片A ─→ 部分结果A ─┐
└─→ 加速器B使用权重分片B ─→ 部分结果B ─┤
                                                              ↓
交换/合并
                                                              ↓
下一步计算

因为两个处理器分担了运算，算术部分可能更快，但这一层现在多出通信步骤。如果交换数据所花的时间超过节省的计算时间，加入第二个加速器反而会让该层变慢。真实的张量并行会拆分特定矩阵，并使用不同的集体通信操作，但依赖关系相同：远端的部分结果到达之前，下一步有时无法开始。Megatron-LM 论文是把 Transformer 层中的矩阵运算拆到多个 GPU 上的主要来源之一。

布局应遵循经过衡量的通信：在满足其需求的路径上保持大容量、对延迟敏感的交换，并在更广泛的网络中传播更多独立的工作。连接布局是工作负载设计的一部分，而不是装饰性服务器规范。

9.3 集体通信也有反复出现的模式

在数据并行训练中，每个工作人员处理一组不同的示例并计算 渐变：描述损失如何随模型参数变化的数组。在下一次更新之前，工作人员会合并这些数组，以便他们的模型副本保持一致。

全部归约 将每个参与者的数组与选定的操作组合起来，并将组合后的数组返回给每个参与者。假设四名工作人员计算一个说明性梯度值：

工人 A：2 名 工人 ​​B：4 名 工人 ​​C：6 名 工人 ​​D：8 名
加法全减
                                      ↓
每个工人收到：2 + 4 + 6 + 8 = 20
如果需要，框架形成平均值：20 ÷ 4 = 5

真正的梯度是大数组，而不是一个数字。通信库将这些数组划分为块，沿着可用路径移动块，然后将它们组合起来。操作是集体的，因为每个工人都参与，每个工人都需要结果。加法对于梯度来说很常见，但该标准支持其他缩减操作。 消息传递标准定义了 all-reduce。

全部到全部 移动不同的数据而不是一个组合结果。每个参与者将其输入分为每个目的地的一个块，发送这些不同的块，并从每个其他参与者接收一个块。之后，工人并不都持有相同的数组。这种模式创造了广泛的流量。如果一个模型将更多的词元路由到一个专门部分而不是另一个，则即使通信模式允许每一对进行交换，一个目的地也可能会接收更多数据并进行工作。

之前：A 持有[对A，对B] B 持有[对A，对B]
全部到全部
之后： A 保持 [A→A，B→A] B 保持 [A→B，B→B]

通信库可以改进消息的拆分、发送以及与计算重叠的方式，但硬件和连接布局仍然有限。结果还取决于每个工作单元的计算量、发送的数据量、等待其他工作单元的时间、任务分配是否均匀，以及剩余的软件开销。因此，增加加速器并不一定带来同比例加速。NVIDIA 的集体通信操作指南。

9.4 拓扑说明谁与谁相连

拓扑结构 是连接图：哪些处理器和交换机通过哪些链路连接。小型本地系统可以在每个加速器之间提供直接或交换路径。大型集群使用交换机层，而不是每对使用单独的物理电缆。

初学者不需要记住树布局或开关名称。有用的问题是：交换最多数据的加速器能否在没有拥挤路径的情况下相互到达？当多个组同时通信时会发生什么？当链路或交换机出现故障时系统能否继续工作？

对于买家来说，连接图改变了产品。单独租用一台加速器、八台具有快速本地链接的加速器以及具有构建良好的集群网络的许多服务器可能使用相同的芯片但支持不同的工作负载。省略链接的价格比较是不完整的。

进一步阅读：

• NVIDIA 的 NVLink 概述 展示了一种商业纵向扩展设计。
• NVIDIA 集体通信操作指南在前面的通俗解释之后给出了常见集体通信的正式定义。

要记住什么： 多个加速器必须进行通信。纵向扩展结构连接紧密耦合的组；横向扩展网络连接服务器或组。在具有所需带宽和延迟的路径上保持大容量、延迟敏感的通信，并验证拓扑和应用程序结果，而不是假设加速器数量可以预测速度。

第 10 部分 — 按工作负载选择硬件

不存在普遍最好的AI 芯片。最好的选择是以所需的速度、可靠性和成本完成特定工作的系统。

这就是为什么产品名称列表严重老化且教益甚少的原因。一款非常适合训练大型模型的芯片对于训练小型模型可能会造成浪费。如果模型不适合内存或软件团队无法运行其代码，赢得基准测试的设计可能无法使用。从作品开始，而不是从徽标开始。

10.1 先问芯片必须完成什么工作

硬件的选择应针对可衡量的工作，而不是一般的“AI”。训练、互动聊天、大批量离线生成可以奖励不同的系统品质。

训练通过应用矩阵运算和调整学习参数来创建或更新模型。大型运行通常会将工作划分到许多芯片上并在它们之间交换数据，因此它们依赖于算术性能、芯片间通信、用于训练状态的足够内存以及长期运行时保持可靠的软件。一项小型训练工作可能只使用一个芯片。

推理使用完成的模型来回答请求。第一阶段读取提示；第二个每次产生一个词元的答案。快速处理可以大量使用算术单元。词元生成通常花费更多时间从内存中移动模型学习到的数字，而不是进行算术运算。最好的推理系统取决于短提示和长提示的组合、一起服务的用户数量以及向每个用户承诺的响应速度。

因此，三个示例买家可以得出不同的答案：

一行的基准无法自动回答其他行。在指定作业、规模和响应时间目标之前，“最快”是不完整的。

10.2 再问内存必须装下什么

加速器需要附近的内存来存储模型参数和临时工作数据。高端训练和大模型推理加速器通常使用高带宽内存（HBM）；其他设计使用图形内存或共享系统内存。

容量回答了一个是或否的问题：模型及其工作数据是否同时拟合？计算权重、KV cache或训练状态、临时工作空间和安全裕度。如果总数超过可用内存，操作员可以跨设备拆分工作、将一些数据移动到速度较慢的内存、使用更少的位、压缩对话缓存、缩短保留的上下文或选择较小的模型。根据补救措施，成本可能表现为更多的沟通、延迟、软件工作或模型质量下降。

带宽回答了一个速度问题：内存提供数据的速度有多快？当模型使用其大部分参数一次生成一个词元时，它通常会在每个步骤中读取大量数据。即使峰值算术没有改变，更多的带宽也可以提高响应速度。批处理、压缩、缓存和仅激活选定参数的模型会改变平衡。

10.3 再问数据必须传多远

一块芯片很少能讲述全部故事。大型模型和大型训练运行使用芯片组，因此中间结果必须在它们之间移动。附近芯片之间的连接是加速器互连。如果无法跟上，昂贵的处理器就会等待数据而不是工作。

使用三个距离作为清单：

1. 芯片上已经有： 寄存器、片上内存、缓存和本地设备内存是最接近的来源。软件应尽可能重用此处的值。
2. 在附近的另一个加速器上： 纵向扩展链路可以承载紧密耦合组内的部分层结果、共享状态或其他频繁交换。
3. 跨服务器或机架： 横向扩展网络连接更大的集群。对于大型作业来说这是必要的，但会引入交换机、共享路径以及更多延迟或拥塞的机会。

假设模型仅在其权重分配到两个加速器后才适合。容量已经解决，但每个跨设备依赖性现在都成为响应时间的一部分。具有更强相关路径的稍慢的芯片可以击败花费更多时间等待的更快的芯片。正确的比较测量整个系统上的完整模型。

相关问题不仅仅是“网络速度有多快？”首先询问重要的通信是否保留在紧密连接的服务器或机架内。然后询问当流量穿过机架之间更广泛的网络时，适用什么带宽、延迟和共享链路竞争。在更强的路径上保持频繁通信的系统可以优于算术等级较高但连接较弱的系统。

10.4 再问软件是否已经可用

仅当支持软件可以将模型转化为高效的芯片指令时，处理器才有用。这种支持包括把模型转换为芯片程序的编译器、经过测试的常见计算实现、跨芯片划分工作的工具以及服务请求的系统。

通用图形处理单元（GPU）受到主要机器学习框架的支持，但“支持”并不能保证相同的速度或可靠性。实际的问题是，确切的模型及其分布式功能是否在当今提议的硬件上运行良好，以及需要多少软件工作。

谷歌的张量处理单元和亚马逊的 Trainium 芯片是专门为机器学习设计并与其所有者的云软件集成的处理器的例子。它们是否合适取决于买方模型的测量结果以及使软件适应该环境的成本。

这些是经验法则，而不是产品保证：

10.5 相同条件下比较系统

标题算术不是购买决定。仅当两个性能数字使用相同的型号、数字格式、输入和输出长度、一起服务的请求数、响应时间目标、软件和优化级别、功耗模式以及硬件数量时，它们才具有可比性。

在查看供应商结果之前，将这些条件写入一页测试中。对于交互式推理，说明性要求可能使用 1,000 个词元的提示和 200 个词元的答案。它可能需要每 100 个请求中至少有 95 个在两秒内接收第一个词元，然后询问成功的请求和每小时的总成本。重点是在选择基准之前定义买方单位的成功。

功率和可用性也属于比较范围。假设一个系统速度提高了 10%，但在六个月内无法交付：它无法完成今天的工作。这些数字是说明性的。需要数据中心无法冷却的机架的系统不是可部署的选项。租金价格、工程时间和故障率都属于速度之外。

从工作量开始
        |
+-- 模型和工作数据是否相符？
        |
+-- 芯片交换数据的速度足够快吗？
        |
+-- 软件在真实模型上运行良好吗？
        |
+-- 系统能否满足速度、功率和价格目标？

10.6 按此顺序做出决定

严格的购买或租赁决定遵循与本部分相同的顺序：

1. 写下真实的工作量和成功目标。
2. 计算内存中必须容纳的内容，包括工作数据和安全裕度。
3. 确定哪些数据必须跨越芯片、服务器或机架边界。
4. 使用预期的软件运行精确的模型，而不仅仅是有利于硬件的小操作。
5. 在相同条件下测量面向用户的延迟、总吞吐量、质量、可靠性、功耗和完整成本。

在对幸存者进行排名之前，拒绝任何不符合所需条件的选项。不适合模型、不满足响应时间承诺或不可靠运行软件的系统无法通过低价或高峰值速率变得可行。

进一步阅读：

• Google 的张量处理单元架构指南 解释了为什么专门用​​于矩阵运算的处理器与通用处理器不同。
• Amazon Web Services 的 Trainium 文档 展示了计算、内存、连接和编程支持如何出现在一种设计中。
• MLPerf 推理 提供受控基准测试结果。条件和系统描述与最高分数一样重要。

检查点。 选择硬件时，应询问硬件必须完成哪些工作、内存中必须容纳哪些内容、数据必须传输多远、软件是否准备就绪以及整个系统的成本是多少。

第 11 部分 — 算力经济学

难以替代的瓶颈可能提高算力成本或减慢扩张速度，但瓶颈本身并不能直接决定价格。需求、竞争、合同、融资、运营成本和议价能力同样重要。受限投入可能是加速器、HBM、先进封装、网络，或具备供电和冷却能力的数据中心，而且瓶颈会随时间变化。

仅有稀缺性是不够的。仅当替代品较差时，投入才能决定步伐。只要另一根电缆能正常工作，一根电缆的短缺就无关紧要。芯片所需的内存短缺则不同：没有内存，芯片就无法发货。同样的逻辑适用于没有供电建筑物来运行它的可用 GPU。

11.1 从工厂到有用的输出

算力供应链包含多个功能环节。芯片制造厂生产处理器，内存厂商生产配套内存，先进封装把所需裸片和密集布线连接起来。服务器厂商再加入网络、存储、供电和冷却设备；数据中心运营商提供建筑与电网连接；云服务商出资购买设备并出租算力；模型提供商则把机器时间变成词元、答案或完成的任务。这是一张功能地图，并不表示每家公司或每份合同都严格沿着一条直线运作；同一家公司可能拥有多个环节。

一个所需的阶段可以限制整个链的输出。举个说明性的例子，假设封装工厂可以组装 10,000 个设备，而芯片工厂可以制造 15,000 个合适的处理器。除非生产发生变化或替代品出现，否则成品设备的产量不会超过 10,000 件。为额外的处理器支付更多费用并不能解决封装限制。尽管合同和竞争决定了额外利润的来源，但稀缺的产能可能会带来溢价。

结论很实用：当价格上涨时，向上游寻找无法快速添加或轻易替换的投入。不要假设最著名的公司或最昂贵的组件是当前的限制。

11.2 一个 GPU 小时的成本

GPU 小时是指一个图形处理器使用一小时。简化的所有者成本模型将设备、电力、运营和维护以及融资分开。真实会计还可以分配建筑物、冷却、网络、税收、保险、故障和闲置容量。

购买价格分摊在业主预计出售的时间段内。因此，客户实际支付的可用时间份额很重要。这个销售率不同于芯片繁忙的时间比例或它达到的峰值算术的比例。闲置的 GPU 仍然会老化并占用资金。

考虑一台示例机器，其设备和安装成本分配给每个 GPU 为 40,000 美元。如果所有者预期使用四年并出售 70% 的可用时间，则设备成本约为每售出小时 1.63 美元：

40,000 美元 ÷（4 年 × 8,760 小时 × 已售出 70%）= 每售出 GPU 小时 1.63 美元

假设在有偿工作运行时，服务器的电量为 1.2 千瓦，闲置设备已关闭，电价为每千瓦时 0.08 美元。每售出一小时电费增加约 0.10 美元。如果维护和员工费用增加 0.30 美元，融资费用增加 0.45 美元，则说明性所有者成本约为每售出小时 2.48 美元。

这些数字是假设，而不是市场报价。他们的目的是展示杠杆。如果销售的工时比例从 70% 下降到 35%，则设备部分将从 1.63 美元翻倍到 3.26 美元。仅在闲置设备断电的假设下，每份带薪工作的电费才保持在 0.10 美元；实际闲置消耗和设施开销会改变结果。因此，提供商可以接受承诺稳定使用的客户的较低每小时价格，因为该承诺降低了需求风险。

11.3 从 GPU 小时换算到词元成本

客户通常不需要 GPU 时间。他们想要模型输出。两者之间的转换需要知道系统在一小时内提供多少有用的输出。

假设一个服务系统每 GPU 小时的成本为 3 美元，并且每秒为一起服务的所有用户生成 600 个输出词元。一小时内产生 216 万个输出词元。因此，GPU 租赁部分约为每百万输出词元 1.39 美元：

600 个词元/秒 × 3,600 秒 = 216 万个词元/小时
3.00 美元 / 216 万 = 每百万输出词元 1.39 美元

“跨所有用户”这句话至关重要。当机器同时为许多用户提供服务时，一名用户每秒可能会看到 40 个词元。一起服务更多请求可以降低成本，但前提是等待时间变得不可接受。经济问题是在不让产品感觉缓慢的情况下填充机器。

计算在设计上是不完整的。提供商还为提示词处理、对话状态、CPU、网络、失败的请求、工程、支持和利润付费。输入和输出词元可能具有不同的成本，因为阅读提示和生成回复对系统的压力不同。

智能体任务将单位推得更进一步。它们的成本包括模型调用、付费工具使用、重试以及任务等待期间保留的任何计算或服务容量。一个有用的比较是每个经过验证的修复、研究报告或已解决的支持案例的美元金额。词元仍然是一种输入；完成的任务就是产品。

11.4 训练和推理是不同的业务

训练和推理都使用加速器，但买家经常购买不同的结果。该表显示了常见的模式，而不是严格的界限；训练服务可以是持续的，一次推理失败可能会影响很多用户。

一个简单的训练估算是加速器乘以小时数和每小时价格。例如，以每小时 2.50 美元的价格使用 1,000 个加速器 30 天，加速器租金为 180 万美元。存储、网络、人员、准备运行和失败时间是最重要的。

推理奖励稳定的付费需求。全天都有流量到达，用户期望快速响应。操作员可以一起处理多个请求，当模型和软件支持缓存时重复使用重复的提示前缀，并将请求路由到合适的硬件。他们面临的挑战是在不超出客户注意到的响应时间或质量线的情况下降低成本。

当推理量很大时，单位成本会在许多请求中重复出现小幅降低。这激励了一些大型云和模型公司为稳定的工作负载构建定制芯片。开发成本、软件支持和已售可用时间份额决定了投资是否有回报。

11.5 市场价格为何变动

市场价格与生产成本不一样。成本有助于确定供应商的承受能力；价格还反映了买家对产品的需求程度、他们有多少替代品以及供应的销售方式。

想象一下，两个提供商拥有相同数量的相同机器。提供商 A 大部分是按小时进行销售，并且存在长时间闲置的风险。提供商 B 有一位客户承诺稳定使用一年。提供商 B 可能会提供较低的小时费率，因为合同使未来的付费使用更加可预测。较低的费率并不能证明其电力或硬件更便宜。客户承担一些需求和承诺风险以换取折扣。

造成价格差异的因素通常有四种：

• 稀缺的硬件可以带来溢价。
• 稳定的需求使提供商可以保留更多机器来赚取收入。
• 更好的内存、连接、软件和操作可以增加同一芯片的有用输出。
• 长期承诺将需求风险从提供商转移到客户，并有助于为设备融资。

第五个问题是引文的内容。一个价格可能包括一组紧密连接的加速器、本地存储和支持；另一种可能描述的是具有单独电荷或较弱链路的裸设备。因此，如果系统完成的工作量较少或排除了买方所需的资源，那么较低的每小时价格可能没有什么价值。

买方应比较所需服务水平下每个有用结果的成本。卖方必须询问价格是否涵盖设备、操作、闲置时间、融资和系统预期寿命期间的风险。

11.6 电力虽然便宜但仍然是瓶颈

在上面的说明性计算中，电力是比设备和融资更小的小时项目。这种关系随着硬件、销售时间份额、电价、冷却和会计的变化而变化。电力供应仍然会限制扩张，因为大型站点需要许可证、改变电压的设备、电网连接、备用系统和冷却。

国际能源署的分析 将电网连接描述为对新数据中心的物质约束。预测会改变，但机制是持久的：金钱购买硬件的速度比受限地区建设传输和连接新站点的速度要快。

这解决了示例中明显的矛盾。根据其假设，一销售 GPU 小时的能源成本约为 10 美分，但在所需地点和时间的可靠电力容量可能很稀缺。能源费用以及连接和获取电力的能力是不同的限制。

再想想水。水本身可能很便宜，但如果没有足够大的管道来提供所需的流量，新工厂就无法运营。建造管道可能需要许可证、设备、施工和时间。同样，数据中心不仅需要全年提供千瓦时电力，还需要在其设备消耗电力时提供足够的电力，以及确保电力消耗安全可靠的电力和冷却基础设施。

11.7 怎样解读算力经济

从出售的结果开始。买家是为一小时的访问、一百万词元、已完成的任务还是训练活动付费？每个单位给卖方带来不同的成本和风险。

然后找到无法按所需时间表扩展或替换的输入。检查报价是否包括网络、存储、支持和可靠的服务水平。最后，将价格除以买方实际响应时间和质量要求下的有用产量。

• 国际能源署的 能源与AI 报告 给出了数据中心电力需求和电网约束的物理设置。
• Epoch AI 的数据中心成本模型 显示了如何分离设备、构造和功率假设。
• 公共云和专业云定价页面是有用的观察结果，但每个数据都应注明日期并检查区域、承诺长度、可用性和捆绑资源。

最后的检查点。 难以替代的瓶颈可能会限制供应并影响计算价格以及需求、合同、竞争和融资。仅当与有用的输出以及测量该输出的条件相关联后，GPU 小时价格才变得有意义。

完整术语表

完成本课程，而不是行业

本术语表涵盖了课程使用或解释其主要思想所需的技术术语。它故意不是每个AI 产品、公司、首字母缩略词或架构名称的目录。课程仍应在每个必要术语第一次出现时对其进行解释；本节是一个紧凑的参考。

加速器 (Accelerator)

设计用于高效执行特定类别工作的处理器。在本课程中，AI 加速器可能是 GPU 或其他专为神经网络计算而构建的处理器。 来源。

激活值 (Activation)

神经网络处理输入时产生的中间数字数组。训练必须保留一些激活，或稍后重新创建它们，以计算模型应如何改变。 来源。

激活检查点与重计算 (Activation checkpointing and recomputation)

一种训练方法，仅保存选定的中间结果，并在向后计算期间重新创建或重新计算其他结果。它交换额外的算术以减少内存使用；它与保存恢复检查点不同。 来源。

Adam 优化器

一种训练更新方法，保持每个学习参数的最近梯度和梯度平方的运行平均值。这些额外的数组是优化器状态的一部分并消耗内存。 来源。

先进封装 (Advanced packaging)

使用密集布线将一个或多个芯片组装到一个封装中的制造工作。一些先进封装还包括附近内存。它与硅芯片的制造是分开的。 来源。

AI 智能体与智能体运行时 (Agent and agent runtime)

在本课程中，智能体是一个可以重复调用模型并让它请求外部工具的软件。 智能体运行时 是普通软件，用于保持状态、检查和执行允许的工具请求、返回结果并决定何时停止。 来源。

全归约 (All-reduce)

一种群组通信操作，其中每个参与者贡献一个数组，通过加法等操作将数组组合起来，然后每个参与者接收组合结果。分布式训练通常使用它来组合梯度。 来源。

全交换 (All-to-all)

一种群组通信操作，其中每个参与者向每个参与者发送不同的数据块并从每个参与者接收一个数据块。其成本取决于数据量、连接图和实现。 来源。

算术强度 (Arithmetic intensity)

对跨指定内存边界移动的每个字节执行的算术运算数。值的高低仅与特定机器和内存级别相关。 来源。

注意力 (Attention)

一种神经网络计算，让词元从选定的词元位置提取不同数量的信息。在普通文本生成期间，词元可以使用其自身和较早的词元，但不能使用较晚的词元。 来源。

注意力头 (Attention head)

一组并行的学习计算，用于创建查询、键和值向量并用它们执行注意力。一个层可以运行多个头，因此它可以学习不同的比较模式，然后组合它们的输出。 来源。

自回归生成 (Autoregressive generation)

一次生成一个已接受的项目的序列，每个新项目取决于已接受的项目。普通的语言模型解码就是这样生成词元的。 来源。

反向传播与反向计算 (Backpropagation and backward pass)

反向传播 通过神经网络向后应用链式法则来计算损失如何随每个参数变化。执行这项工作的计算通常称为 向后传递；优化器稍后使用生成的梯度来更新参数。 来源。

带宽与内存带宽 (Bandwidth and memory bandwidth)

带宽 是指定连接上的最大或测量的数据传输速率。 内存带宽 是处理器和指定级别内存之间的速率；每个数字都应该说明它是理论的还是测量的，以及它包括哪些方向或操作。 来源。

批次与批处理 (Batch and batching)

批 是一组一起处理的示例或活动请求。 配料 可以重用数据并提高总吞吐量，但较大的批次也会使用更多内存，并且可能会使单个请求等待。 来源。

基准测试 (Benchmark)

用于比较规定条件下的性能的受控测试。有用的基准测试包括工作负载、硬件、软件、数字格式、输入和输出大小、同时请求的数量和测量规则。 来源。

Bfloat16 (BF16)

B浮点16 是 16 位浮点格式。它涵盖与 32 位浮点大致相同的幅度范围，但记录附近值之间的细微差别较少。 来源。

分档 (Binning)

对制造出来的芯片进行测试，并根据其满足的规格（例如工作特性、频率或功率）将其分类为产品等级。较低的档位不一定是有缺陷的芯片。 来源。

位与字节 (Bit and byte)

位表示两个值之一，通常为零或一。一个字节包含八位；在十进制单位中，1 GB 等于 10 亿字节。来源。

缓存 (Cache)

将数据副本保存在消费者附近的存储，以便以后访问可以避免速度较慢的源。缓存仅在包含所需数据时才有用。 来源。

内存容量 (Memory capacity)

内存系统可以保存的数据量。内存容量决定所需权重和工作数据是否相符；它没有说明它们的阅读速度有多快。 来源。

检查点 (Checkpoint)

保存的模型或训练状态的集合。它可能是已发布的模型或用于恢复运行的恢复快照；它也可以跨文件或机器分割。这个含义与激活检查点不同，激活检查点减少了一次计算时的临时内存。 来源。

芯粒 (Chiplet)

一种设计为与其他芯片组合在一个封装中的芯片。芯粒可以划分一种功能或提供不同的功能，并且物理尺寸不必很小。 来源。

集群 (Cluster)

一组相互连接的计算机，共同完成共享任务或服务。将系统称为集群本身并不指定其连接速度、大小或可靠性。 来源。

计算受限 (Compute-bound)

可用算术吞吐量是指定程序和机器的主要性能限制的情况。在另一个实现中，存储器流量、通信或依赖性可以是单独的限制。 来源。

模型上下文 (Model context)

为当前模型计算提供的输入中表示的信息。服务可以根据指令、消息、检索到的材料和工具结果构建模型上下文；模型不会自动使用所提供输入之外的信息。 来源。

CPU

中央处理器：运行操作系统和各种程序的通用处理器。 CPU 可以执行并行工作，但高性能内核还投入大量硬件来减少不规则和决策密集型代码的延迟。 来源。

客户认证 (Customer qualification)

在更广泛使用之前，由客户测试并批准组件满足客户的平台和可靠性要求。通过供应商的内部测试并不会自动完成客户的资格认证过程。 来源。

数据并行 (Data parallelism)

一种训练方法，工作人员处理不同的示例并结合它们的梯度或更新。模型参数可以在每个工作人员上复制或除以分片变体。 来源。

解码 (Decode)

在自回归语言模型服务中，在处理提示后生成输出词元的阶段。接受的输出词元是按顺序生成的，尽管实现可能会同时测试多个候选词元。 来源。

裸片 (Die)

包含已制造电路的一块半导体材料。从处理过的晶圆上切下芯片，随后可以与封装内的其他芯片组合。 来源。

DRAM

动态随机存取存储器：存储必须刷新电荷的单元中的每一位的存储器。 GDDR 和 HBM 是 DRAM 系列； DRAM 密度更高，但通常比用于小型存储器的片上 SRAM 慢。 来源。

嵌入表示 (Embedding)

一个项目的学习向量表示。在本课程中，词元嵌入是在Transformer层将上下文添加到该表示之前由词元标识符选择的学习数字列表。 来源。

以太网 (Ethernet)

从本地网络到数据中心使用的标准化有线网络技术系列。引用的以太网速率是链路速率；数据包和协议开销可能会降低有用的应用程序吞吐量。 来源。

浮点数 (Floating-point)

一种使用符号、称为指数的标度和有效数字对数字进行编码的方法。不同的浮点格式会根据它们可以表示的幅度范围来交换存储和精度。 来源。

前馈块 (Feed-forward block)

在注意交换位置信息后，Transformer层的一部分将相同的学习神经网络计算分别应用于每个词元位置。Transformer设计在其使用的精确计算方面有所不同。 来源。

浮点运算 (FLOP)

浮点运算（或 FLOP）是按照规定约定进行的一次算术运算；融合乘法和加法通常算作 2。 浮点运算/秒 是一个速率，除非说明数字格式、操作和任何稀疏性假设，否则它是不完整的。 来源。

前向传播 (Forward pass)

从模型输入到预测以及训练过程中的损失的计算。训练保留或稍后重新创建选定的中间结果，以便向后传递可以计算梯度。 来源。

晶圆代工厂 (Foundry)

制造电路的半导体制造商，通常采用其他公司提供的设计。纯晶圆代工厂主要生产客户设计，而不是销售自己的芯片设计。 来源。

FP8

一系列单字节浮点格式，在数值范围和精细细节之间以不同的方式划分位。使用 FP8 的声明必须指定确切的格式、操作和累积方法。 来源。

32 位浮点数 (FP32)

标准化 32 位二进制浮点格式的通用名称。每个值使用四个字节并比 BF16 记录更多的数字细节，但更高的精度并不能保证更好或更快的模型结果。 来源。

GDDR

图形双倍数据速率：用​​于图形和一些AI 系统的高数据速率 DRAM 系列。其容量和带宽取决于代数和系统设计。 来源。

GPU

图形处理单元：为图形开发并为高吞吐量并行工作而组织的处理器架构。许多神经网络运算适合其矩阵和矢量硬件，但性能仍然取决于软件和数据移动。 来源。

梯度 (Gradient)

数字显示参数的微小变化会如何改变训练损失。优化器使用梯度来计算更新；梯度不是更新本身。 来源。

HBM

高带宽内存：具有非常宽连接的堆叠式DRAM，通常与高端加速器放置在同一封装中。 HBM 提高了带宽，但增加了要求较高的内存堆叠、打包和测试工作。 来源。

推理 (Inference)

使用经过训练的模型根据新输入计算输出，而无需对其参数执行普通训练更新。输出可以是文本、预测、图像、嵌入或其他模型结果。 来源。

InfiniBand

专为高数据传输速率和短延迟而构建的交换网络设计。它广泛应用于高性能计算和AI 集群，可以直接在计算机内存之间移动数据，而 CPU 几乎不需要做任何工作。 来源。

加速器互连 (Accelerator interconnect)

在紧密耦合系统中的附近加速器之间传输数据的连接。它的带宽、延迟、连接图和软件支持会影响芯片之间的工作分配情况。 来源。

中介层 (Interposer)

一种中间布线结构，可在封装内的芯片之间创建密集连接。中介层可以通过不同的方式构建，并且并非每个 HBM 封装都使用相同的类型。 来源。

词元间延迟 (Inter-token latency)

两个生成的输出词元之间经过的时间。它与第一个词元的时间不同，也与在整个响应中计算的每个词元的平均时间度量不同。 来源。

GPU 内核 (Kernel)

GPU 在许多并行工作线程上运行的小程序。该词在操作系统中还有其他含义，因此本课程仅在 GPU 意义上使用它。 来源。

内核融合 (Kernel fusion)

将兼容的计算组合到一个 GPU 内核中，以便临时结果可以保留在芯片上或被消除，而不是写入大型设备内存并读回。 Fusion 可以使用更多片上资源，但速度并不总是更快。 来源。

键值缓存 (KV cache)

每个注意力层已经为早期词元计算出键和值数组。在解码期间重用它们可以避免重新计算那些较早的键和值，但随着保留序列的增长，缓存会消耗更多内存。 来源。

延迟 (Latency)

从操作或请求开始到规定的完成点所经过的时间。延迟数据是不完整的，除非它准确说明了测量的开始和结束时间。 来源。

延迟隐藏 (Latency hiding)

保持其他工作准备就绪，以便处理器可以在一组等待数据或早期操作时运行它。这减少了空闲时间，但不会使潜在的延迟消失。 来源。

模型层 (Model layer)

神经网络的一个阶段，使用学习参数和其他操作将输入值转换为输出值。现代模型通常按顺序应用许多模型层。 来源。

大型语言模型 (Large language model)

具有大量学习参数的语言模型。 “大”没有通用的数值门槛。 来源。

光刻 (Lithography)

一种芯片制造工艺，使用光和图案掩模来定义晶圆上光敏涂层的特征。然后通过沉积、蚀刻和其他步骤构建物理结构。 来源。

训练损失 (Training loss)

模型在示例或批次上的错误的数值分数。训练计算损失的梯度并使用它们来指导参数更新。 来源。

矩阵与矩阵乘法 (Matrix and matrix multiplication)

矩阵 是一个矩形数字数组。 矩阵乘法 将一个矩阵的行与另一个矩阵的列组合起来，生成一个新矩阵；许多神经网络层在这个操作上花费了大量的算术。 来源。

内存受限与内存带宽受限 (Memory-bound and memory-bandwidth-bound)

通过命名内存连接移动数据的情况是指定程序和机器的主要性能限制。更改批次、软件或硬件可以更改同一操作是否受内存限制。 来源。

内存墙 (Memory wall)

处理器执行算术的速度与内存系统提供数据的速度之间的不匹配日益严重。缓存、数据重用、较低的精度和更宽的内存连接解决了这个问题的部分问题。 来源。

混合精度训练 (Mixed-precision training)

使用多种数字格式的训练，根据操作和数字需要选择每种格式。常见模式对大部分算术使用紧凑值，对选定更新或累积结果使用更精确的值。 来源。

AI 模型 (AI model)

将输入映射到预测或其他输出的学习计算系统。训练调整AI 模型的参数；推理使用经过训练的模型来产生输出。 来源。

摩尔定律 (Moore's law)

行业观察表明，经济地放置在集成电路上的元件数量往往随着时间的推移而快速增长。它不是物理定律，也不保证每个程序都以相同的速度变得更快。 来源。

神经网络 (Neural network)

由连接层构建的模型，其行为取决于学习的参数。 “神经”是历史术语；该模型是数学计算，而不是生物大脑。 来源。

数字格式 (Number format)

规定位模式如何表示数字的规则。格式在存储大小、范围、精度和硬件支持的操作方面有所不同。 来源。

优化器 (Optimizer)

一种使用梯度和更新规则来更改模型参数的训练算法。包括 Adam 在内的一些优化器会保留早期步骤的额外状态。 来源。

封装 (Package)

保护一个或多个芯片并将它们连接到系统其余部分的结构。一些加速器封装还包括附近的 HBM，但存储器并不是每个芯片封装的一部分。 来源。

参数 (Parameter)

通过训练调整的数值，通常是权重或偏差。参数计数描述了模型具有多少个学习值，但其本身并不决定质量、文件大小或活动计算。 来源。

流水线并行 (Pipeline parallelism)

一种将连续的模型层组分配给不同设备的方法。中间结果在阶段中向前移动，而训练梯度则向后移动；闲置间隙和不等的阶段时间会降低效率。 来源。

电功率与电能 (Electrical power and electrical energy)

电力 是能源使用率，以瓦为单位；一瓦等于每秒一焦耳。 电能 是随时间累积的功率，因此一小时使用一千瓦等于一千瓦时。 来源。

精度 (Precision)

数字表示区分邻近值的精细程度。精度与范围不同，范围描述格式可以表示的最小和最大量值。 来源。

直接偏好优化 (Direct preference optimization)

一种训练后方法，通过比较首选和不太首选的响应来学习，而无需首先拟合单独的奖励模型。它不同于基于人类反馈的强化学习。 来源。

预填充 (Prefill)

语言模型推理阶段，处理提供的输入词元并在输出词元生成之前准备初始 KV cache。第一个词元的时间还包括可能的网络、队列、词元化和调度延迟。 来源。

工艺节点 (Process node)

一代晶体管和布线技术的代工厂名称。 “3 纳米”等现代标签无法衡量一种物理特征，也无法在代工厂之​​间直接进行比较。 来源。

提示词 (Prompt)

为一次调用提供给生成模型的输入。在构建模型的输入之前，服务可以将用户内容与指令、早期消息、检索到的材料和工具结果组合起来。 来源。

量化 (Quantization)

将较大集合中的值映射到较小的可表示值集合中，通常用于模型权重或中间结果。它可以减少存储和内存流量，但速度和质量影响取决于方法、模型和硬件。 来源。

查询—键—值 (QKV)

注意力中的三个数字角色。将查询与键进行比较以获得匹配权重；这些权重决定了相应的值如何混合到注意力输出中。学习计算根据当前词元表示创建 Q、K 和 V；它们不是人类书写的标签。 来源。

寄存器 (Register)

处理器指令直接使用的一个微小存储位置，用于存储立即需要的值。与设备内存相比，寄存器要小得多，更接近算术硬件。 来源。

强化学习 (Reinforcement learning)

一系列方法，智能体可以通过这些方法学习采取哪些行动来增加预期的累积奖励。人类偏好可以在一种应用中提供奖励信号，但它们不是一般定义的一部分。 来源。

光罩尺寸上限 (Reticle limit)

光刻扫描仪一次曝光的最大矩形区域的非正式简写。它限制了用一个曝光场制作的传统芯片的尺寸。 来源。

Roofline 模型

将机器的峰值算术速率与其内存带宽乘以算术强度进行比较的性能界限。这两个上限中较低的一个限制了简化模型中可达到的算术速率。 来源。

横向扩展 (Scale-out)

通过更广泛的网络连接多个服务器或紧密连接的加速器组。横向扩展描述了系统组织，而不是距离、速度或网络设计的保证。 来源。

纵向扩展 (Scale-up)

使用专为高带宽和低延迟设计的链路连接紧密耦合组内的处理器。该组可能位于服务器内部或跨机架延伸；该术语描述的是系统组织，而不仅仅是距离。 来源。

GPU 调度器 (GPU scheduler)

控制硬件选择接下来运行哪个就绪的 GPU 工作组。当一个组等待数据时，它可以发出另一个就绪组。 来源。

分片 (Sharding)

将指定的模型数据或训练状态分配给工作人员，以便每个工作人员仅持有一份。它降低了一个工人所需的内存，但在另一个工人需要一块时创建通信。 来源。

SRAM

静态随机存取存储器：用​​于小型片上缓存和工作存储器的快速存储器技术。与 DRAM 相比，它每个存储位使用更多的芯片面积，因此处理器占用的芯片面积要少得多。 来源。

结构化稀疏 (Structured sparsity)

一种模式，其中零以受支持的硬件可以跳过的精确排列出现。任意零不会自动限定广告稀疏率的计算。 来源。

监督微调 (Supervised fine-tuning)

对将输入与所需输出配对的示例进行额外训练。它可以向预训练模型传授任务或响应风格，而无需定义每个后续的训练后方法。 来源。

Tensor Core

NVIDIA 对执行受支持的矩阵乘法和累加运算的专用 GPU 单元的名称。它们所宣传的速率取决于数字格式，并且还可能采用受支持的稀疏模式。 来源。

张量并行 (Tensor parallelism)

一种跨设备拆分模型层内的操作（​​通常是矩阵乘法）的方法。设备必须经常交换部分结果，因此连接性能很重要。 来源。

分块 (Tile)

从较大的数字数组中剪下的一个小矩形块。 GPU 程序会移动并重复使用附近内存中的图块，因此许多计算可以共享相同的加载数据。 来源。

吞吐量 (Throughput)

每单位时间完成的工作量，例如每秒的请求或输出词元。它不同于延迟，即一个指定请求所花费的时间；批处理可以提高吞吐量，同时增加等待时间。 来源。

首词元延迟 (Time to first token)

从提交请求到第一个生成的输出词元到达所花费的时间。根据测量边界，它可能包括网络传输、排队、分词、调度和提示处理。 来源。

词元 (Token)

由模型的分词器生成的标识符，表示整个单词、单词的一部分、标点符号或其他文本片段。词元与单词的比率随语言、文本、模型和分词器的不同而变化。 来源。

分词与分词器 (Tokenization and tokenizer)

分词器应用固定词汇表和分割规则将输入映射到词元标识符； 词元化就是那个转换过程。不同的模型系列可以以不同的方式分割相同的文本。 来源。

工具调用 (Tool call)

来自模型的结构化请求，要求普通软件运行具有指定输入的命名外部函数。周围的应用程序（而不是模型）必须验证权限、执行函数并返回其结果。 来源。

拓扑 (Topology)

处理器、服务器和交换机之间的连接模式。拓扑与链路速率、路由和软件一起影响可用路径、拥塞、延迟和故障行为。 来源。

训练 (Training)

使用数据调整模型的参数，以便改善规定的错误或奖励措施。神经网络训练通常使用训练损失、反向传播和优化器；只有大批量生产才需要许多机器。 来源。

Transformer

2017 年推出的神经网络设计，将注意力和其他计算安排在重复的块中。当前大多数大型语言模型都使用基于Transformer 的设计，有许多变体。 来源。

晶体管 (Transistor)

可以切换或控制电信号的半导体器件。现代处理器结合了许多晶体管来构建算术、存储器和控制电路。 来源。

晶圆 (Wafer)

半导体材料的圆形切片，工厂在其上构建许多电路副本。处理后的晶圆经过测试并切割成单独的芯片。 来源。

权重 (Weight)

模型乘以另一个值的学习参数；许多权重都是矩阵中的条目。并非每个参数都是权重。 来源。

向量 (Vector)

有序的一维数字列表。词元嵌入和一个注意力头内的每个查询、键或值都是向量；条目数量取决于模型设计。 来源。

词表 (Vocabulary)

可用于分词器及其模型的一组分词片段和标识符。词元生成器将输入文本映射到该集合中的标识符，并且文本生成模型为每个允许的词汇词元分配输出分数。 来源。

裸片良率 (Die yield)

满足所需测试的制造裸片的比例。芯片良率取决于设计、缺陷率、工艺和测试标准；它与将可接受的零件分类为产品等级不同。 来源。