前言与使用指南

从一句输入的处理过程出发，逐步理解模型计算、智能体执行，以及支撑可靠应用的工程方法。

每个新机制先说明处理的对象及其来源，再展开计算。公式中的W、X、A等字母只是局部命名；不同章节复用字母时，应以当前定义为准。遇到陌生记号，可从公式与对象指南查看完整来龙去脉，而不是只猜英文缩写。

读者与学习目标

本书面向希望理解并改进AI工具使用方式的研发人员和技术学习者。阅读起点是加减乘除、行列计数和一般电脑操作，不要求已经学过线性代数、微积分或机器学习。代码实验需要基本的Python阅读能力；它不是阅读理论正文的前提。

学习目标不仅是记住术语，还包括解释输入和输出是什么、逐步描述中间过程、计算小型例子、识别成立条件，并在真实任务中选择合适的验证方式。

全书结构

基础篇建立数字表示、模型计算、训练、协议、状态、检索和评测所需的概念。每节先解释对象，再用小例子演示，最后给出课后自检。系统篇围绕具体问题展开内部过程、公式、实现边界与连续追问。综合案例将单个机制连接成完整执行过程。专题研修提供进一步的代码实现、故障实验与应用设计；拓展阅读按研究主题组织中文讲义。

建议阅读顺序

首次阅读从F01：文字、数字、模型与程序开始，沿章节末尾的“下一节”前进。完成F06后，阅读“从两句话到三维表示”的综合示例，再继续F07。基础篇结束后进入系统篇；模型生成、工具执行、知识流转和系统诊断分别配有完整案例。

已有基础的读者可以依据目录与学习路径选择主题，但应先检查对应的预备知识。F编号标识基础课，Q编号标识系统篇问题；这些编号用于检索和交叉引用，不表示能力等级。

怎样读懂一个机制

每读完一段，先指出它处理的对象和输出结果，再按顺序复述操作。遇到形状，说明每个轴在计数什么；遇到公式，用一组小数字算出中间结果；遇到执行流程，说明谁保存状态、谁执行动作、失败后依据什么继续。最后改变一个条件，检查原有结论是否仍成立。

例如，不能只记住缓存“用于加速”，还应解释保存了什么、哪些计算得以复用、何时失效，以及如何与不使用缓存的结果比较。也不能只记住“失败后重试”，而应区分动作尚未执行、明确失败，以及外部结果未知三种情况。

术语、符号与参考答案

术语在基础课中结合动作与例子说明。正文中的虚线链接通向术语与符号速查，各深入问题提供所需基础的本地入口。速查用于回忆，不能代替完整推导。自检题默认只显示题目。先独立思考或计算，再点击“查看参考答案”核对过程；答案可随时收起。

事实、教学例子与实验结果

论文和官方文档用于支持注明范围内的公开机制；手算数字、假想仓库和任务情景用于教学；程序结果只证明相应输入与断言下的行为。三者分别标明。产品行为受版本、配置与运行环境限制，闭源内部实现未公开的部分不以推测补充。

出处在参考资料与适用范围中列出，阅读中文正文不依赖外部网页。本书不是各来源的逐句全文翻译，也不声称复现全部论文实验、提供商业模型排名或完成生产安全审计。

离线阅读与实验

解压资料包后打开index.html即可阅读。搜索在本地浏览器中运行，字号与已读标记使用本机存储，不自动同步到其他设备；浏览器不允许存储时，正文仍可正常打开。

交互实验可以直接修改数字查看结果。基础与运行链路实验使用Python标准库；专题实验另行注明NumPy、PyTorch等依赖。可选在线示例与离线实验分开标注，运行前应阅读其数据与费用说明。

目录与学习路径

先建立基础，再解释内部过程，最后通过案例与实验形成工程判断。

默认顺序为：前言 → 基础篇 → 系统篇 → 综合案例。专题研修与拓展阅读用于进一步研究，不是首次阅读的先修要求。各题列出的基础入口可用于复习具体概念。

阅读辅助：公式、术语与对象来源贯穿基础篇与系统篇。F07先学系数表的乘法，F10区分参数与运行数据，F11再推导完整Q/K/V链。

基础篇：对象、计算与工程概念

输入与表示

模型计算与生成

训练与计算资源

智能体与上下文

知识与可靠执行

评测与生产判断

系统篇：内部机制与连续追问

综合案例

实验与专题

附录

动态图解：把每一步看清楚

从一条输入开始，沿着数值、消息、证据和执行状态逐步看系统怎样运作。

图解中的输入与条件始终在图前说明。主张“保持结果相同”的优化会说明保持什么、在哪些假设下成立；近似优化则显示它改变了什么。

数字与输入表示

模型计算、生成与结束

训练与计算资源

Agent、协议与上下文

检索、记忆、协作与可靠交付

评测、安全与生产

优化的原因、方法与代价

公式与术语：先认识对象，再理解运算

阅读数学式之前，先分清五类对象

公式不是缩写词竞赛。一个符号可能是本次输入、模型参数、计算出的中间值、尺寸或下标、执行规则或函数。先给对象分类，再读它们的关系。下面的例子只解释记号，是独立的符号微例，不替换任何课程的主算例。

“权重”有两种常见含义。 参数矩阵W中的权重是模型保存的系数；注意力表A中的权重是当前输入算出的信息份额。它们都参与乘法，但来源和生命周期不同。“参数”一词也有两层：模型参数是学习出来的数；工具调用参数则是一次请求的字段，不能混同。

先用一句中文读完XW，再看矩阵尺寸

Y=XW读作：“把X的每一行，按W每一列提供的系数组合，产生Y的各列。”例如X有两行、每行三个数，W有三行、每行两个数：

X[2,3] @ W[3,2] → Y[2,2]
Y[i,j] = X[i,0]W[0,j] + X[i,1]W[1,j] + X[i,2]W[2,j]

这里i选X的哪一行，j选输出哪一列。不是把i和j传给另外一个模型。若X表示两个Token的位置，一个输出格子的来源仍可追溯到同一输入位置的三个特征。如果要跨Token混合，还需要另外沿位置轴进行的运算，例如注意力份额表乘Value表。

Wq、W_Q和某些资料的W^Q都可能用来命名查询投影参数。它们是记号写法，不是三种独立算法。反过来，长得相同的字母在另一章节可能承担不同角色，因此本书不以字母外观代替局部定义。

大小写、下标、上标怎样读

从0开始的下标是一种编程约定。若另一个算例明确从1开始，就按它的声明读；不要把“第1号位置”和“第一项”未经说明地视为同一个对象。

不能把重复出现的字母永久固定成一个意思

如果一个章节从“两个Token的向量”转向“十篇文档的检索排名”，应当明确建立新输入。数学上两组数字都可以求和，不代表它们来自同一个运行过程。

函数名不是另一个神秘数据表

Norm(X)表示调用规范化运算；FFN(X)表示调用前馈网络；softmax(S)表示按指定轴把分数转为份额。函数可能内部使用可学习参数，但函数名本身不是一排权重。

以U=X+Attention(Norm(X))为例，应按顺序读：先对X规范化，Attention处理该结果，把注意力输出与原X相加，最后把整份结果叫U。U只是给临时结果起名。另一段公式也用U，不代表数值自动共享。连续算例若沿用U，会明确指向上一行。

高级接口还可能把投影前的数据命名为query/key/value；底层接口的同名参数则可能是投影后的数据。查看“接口内部是否已经做了W变换”比只看参数名重要。公式与程序还可能分别采用右乘参数表和存转置后的权重布局；应先对齐布局，再对比数值。

程序里的数据、请求与状态也需要身份

“模型记住了”也至少分三层：推理缓存里的一组K/V、当前会话中的事实与摘要、跨会话检索出的长期记忆。应该问它保存的是哪种对象、什么时候写入、什么时候失效，而不是把三个层次都当成模型参数更新。

从基础到系统的依赖路径

模型计算路径： 数字容器与形状 → Token编号与Embedding → 行列乘法 → 参数与中间结果 → Query/Key/Value → 分数与读取份额 → 掩码与位置 → 多头、输出投影、残差与前馈 → 输出Token与缓存。

训练路径： 前向结果 → 正确标签与损失 → 导数和链式法则 → 各参数梯度 → 优化器状态与更新 → 后训练目标。不会导数时仍可以先读懂W怎样参与前向，不需要把“权重来自训练”误认为“必须先理解所有强化学习算法”。

Agent路径： 请求与结构化数据 → 模型输出项 → 工具调用标识 → 权限与执行 → 事件与状态 → 上下文再组装 → 压缩恢复 → 多Agent协作。

知识和质量路径： 原始证据 → 分块及索引 → 召回与重排 → 版本和权限 → 生成与引用 → 记忆生命周期 → 可检查的任务结果 → 统计比较与运行成本。

进入一个新机制时，能回答“输入是哪个对象、参数从哪里来、实际算什么、结果供哪一步用”，再进入公式。下方概念索引为本书容易混淆的术语提供就地可读的定义、独立微例和对应的完整课程。

概念索引：对象、来源、用途与独立微例

以下微例只解释术语，不接续其他章节的输入。点击课程入口可阅读完整计算链。

定义的依据与边界

Dropout、BatchNorm及logsumexp补充对照：PyTorch Dropout · PyTorch BatchNorm1d · PyTorch logsumexp。正文以中文解释为主；外部链接仅供追溯。

F01｜先分清：文字、数字、模型和运行它的程序

从具体对象与小例子开始，理解计算过程与适用条件。

从信息对象认识AI系统

理解一个AI系统的运行，首先要知道每一步处理的是什么东西。输入框里的文字、发给服务器的请求、模型内部的数字、磁盘上的代码文件，并不是同一个对象。它们会互相转换，但不能把名称混用。

先看一个没有数学门槛的任务：“读一下文件，告诉我函数为什么报错。”编辑器可以直接把你选中的代码附在请求里，也可以只发送问题，等模型提出读文件要求后再读。这两种情况最后都可能给出答案，但取证过程不同。

这里的“对象”只是当前被处理的信息或实体，不要求你先学面向对象编程。

模型不是一位住在电脑里、直接看见所有文件的人

模型可以先理解为一个很大的、由许多数字和计算规则组成的函数。函数就是“给定输入，按规则产生输出的东西”。例如规则“输入乘2”，给3便得6；语言模型复杂得多，但输入输出仍由实际计算连接。

推理是使用已有参数计算输出；训练是根据例子和误差调整参数。普通聊天时把新信息放入本轮输入，不等于永久改写模型参数。你后来再问它，能否继续知道，取决于历史或外部记忆是否再次提供。

Agent宿主程序是调用模型、读取文件、执行命令、保存状态的外围程序。模型可以输出“请调用读取文件工具”，宿主检查参数和权限后才真正读取，再把结果交给模型。这里先认识这条关系，具体协议在F22以后展开。

用三个容易混淆的句子检查边界

“模型说文件已修改”只是一份输出；“文件内容确实改变”是环境事实；“新文件通过对应测试”又是一份验证事实。第三件事不能从第一件事推出。把这些对象分开，你才能理解为什么Agent需要工具结果和测试，而不是只靠它自我确认。

同理，“请求包含了一段材料”不保证模型正确利用它；“有一个会话编号”不保证旧消息永远都在；“缓存存在”不保证其内容适合当前模型和当前任务。

本书的数字是怎么来的

后文用很小的词表和向量做手算。词表是文本片段与整数编号的对照表；向量先理解为有顺序的一排数，下一课正式解释。为了看清运算，教材会人为给数字，它们不是某款商业模型的参数或真实语义。

例如写“我→1、爱→2”，只说明本教材演示用这样的编号。现实分词器可能把一个字拆成多个片段，也可能把多个字符合成一个片段。不能把教学编号搬进实际模型。

阅读准备

默认你会加减乘除、能阅读普通程序式步骤；不默认你会线性代数、微积分、概率论或深度学习。前置课会在用到它们以前介绍必要部分。代码是帮助核对过程的第二种表达，不运行代码也可以读完正文。

接下来的次序是：先认识数字怎样摆放，再看文字如何获得编号，接着看几条输入怎样放在一起，以及一个编号怎样被换成一排数。读完这些基础概念，示例中的[2,128,4096]就不再是一串无来由的符号。

课后自检

机制依据：[F-TENSOR][CHAT][TOOLS]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F02｜一排数、一张表和一叠表：读懂张量与形状

从具体对象与小例子开始，理解计算过程与适用条件。

先不背“张量是多维数组”

单个数7可以叫标量。一排有顺序的数[7,2,9]叫向量。两排这样的数组成一张有行有列的表，叫矩阵：

A = [[7,2,9],
     [4,8,1]]

这张表有2行、每行3个数，形状（shape）写作[2,3]。这里的[2,3]是在描述大小，不是表里真的只存2和3。区分“内容”和“形状”是第一道关口。

在机器学习程序里，张量（tensor）是存放规则排列数字的通用数据结构。标量、向量、矩阵都可以用张量表示。这里不需要数学和物理中更抽象的张量变换定义。

从两张表理解三个轴

假设两句话各有3个文本片段，每个片段用4个数描述。第一句话对应一张3行4列的表，第二句话也对应一张3行4列的表。把两张表放在一起，就是形状[2,3,4]的张量：

第0句话：[[0.2,-0.1,0.7,0.4],    第1句话：[[0.1,-0.5,0.9,0.3],
          [-0.3,0.8,0.1,0.5],              [-0.3,0.8,0.1,0.5],
          [0.6,0.2,-0.4,0.9]]              [0,0,0,0]]

每个决定“往哪个方向数”的位置叫一个轴（axis）。这三个轴依次是“第几句话”“第几个片段”“这个片段的第几个数”。最后一个轴不是把编号转换成4位二进制；它是因为每个文本片段从单个编号换成了4个数值特征。这些特征可以是小数、负数，不要求只有0与1。具体查表过程在F05完整展开。轴的意义由你怎样组织数据决定，不是张量自己知道中文句子是什么。

因此[2,3,4]含2×3×4=24个数。一般地，把形状中的各个长度相乘，得到规则密集张量的元素总数。

方括号中的数字不是同一种“维度”

“这是一个三维张量”通常说它有3个轴；“每个Token是4096维向量”说每排有4096个数。这两句话里的“维”指的不是同一个层次。

后面采用统一写法：B是本批有多少条输入，T是每条输入安排多少个位置，d是每个位置用多少个数描述。于是[B,T,d]就是“B张表，每张T行，每行d个数”。

当B=2,T=128,d=4096时，它仍然只有3个轴，并不是4096个轴；元素总数为1,048,576。4096是每个位置那一排数的宽度，不是有4096个汉字，也不是模型一共只有4096个参数。

怎么找到里面的一个数

本书代码使用从0开始的下标。A[0,1]指第0行、第1列，在上面的矩阵A中是2。方括号用在变量名后面时常表示索引；独立写“shape=[2,3]”时才是在说大小，要看上下文。

对H形状[2,3,4]：H[1]取第二句话，剩下一张[3,4]表；H[1,0]取第二句话第一个片段，剩一排4个数；H[1,0,2]再取第三个特征，得到单个数。用哪个下标取出数据，哪个轴就被选定了。

冒号表示“这一轴都要”。H[1,:,2]取第二句话每个片段的第三个数，得到长度3的一排数。H[:,:,0]取所有句子所有位置的第一个特征，得到[2,3]。

符号不认识时怎样读公式

x_i读“x的第i个数”；x²是x乘x；Σ表示“把后面规定的一组数加起来”；∈表示“属于”；R在公式中常表示实数。X∈R^(B×T×d)只是“X是一份形状B、T、d的实数数据”。这不是要求你当场解一个方程。

代码里的=常是“把右边结果保存到左边”；数学里的=常是“左右相等”。:=强调定义；≈表示近似相等。公式中大写T可能是序列长度，上标ᵀ却是转置符号，转置会在F07解释，不能混读。

课后自检

机制依据：[F-TENSOR][F-LINALG]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F03｜文字为什么要先变成Token编号

从具体对象与小例子开始，理解计算过程与适用条件。

字符、字节和Token先分开

你看到的“爱”是一个字符。计算机保存文字需要编码规则；例如UTF-8会把它表示为若干字节，字节是8个二进制位的存储单位。一个字符不必只占一个字节。

Token是分词器处理的片段单位。Tokenizer（分词器）是把文本按约定规则变成Token编号序列、以及把编号解回文本的工具。Token可能覆盖一个词、一部分词、标点、空格，甚至只是一个字符的部分字节，因此不等于字数。

模型内部处理数字而不是屏幕字形。分词器先回答“它是词表中的哪一项”，后面的Embedding再回答“用哪一排数表示这一项”。这两个步骤不能合成一句含糊的“转成向量”。

一张教学词表和两条输入

为方便手算，定义以下小词表。<PAD>表示稍后填空位的特殊项。

假设教学分词规则把“我爱学习”切成“我、爱、学习”，就得到[1,2,3]；把“你爱”切成“你、爱”，得到[4,2]。编号大小没有语义大小：4不比1聪明，也不能通过4−1=3推导“你减我等于学习”。

词表有6项，用符号N=6表示。后文也会见到论文用V表示词表大小；Attention里的V又表示Value矩阵。本书在基础例子中用N，避免你把两者混淆。

BPE的“学习词表”和“编码输入”不是同一阶段

BPE是一类常见的子词构建方法。先从基础符号出发，在训练语料中反复统计相邻符号组合，选择组合并合并。例如语料中a b经常相邻，就可以增加ab这一项，再重新统计下一轮组合。这一阶段产生词表和合并规则。

使用已经准备好的分词器时，不会每收到一句话都重新统计整个世界的文本。它按固定规则把新输入拆成已有片段，并查出编号。实际实现还有预切分、特殊标记和可能的规范化步骤，不能把它理解成随意切词。

为什么代码很难按字符数估算Token？因为user_id和随机串x7b9q2的可用子词组合不同；换行、缩进和空格也可能影响切分。实际预算要使用对应模型的计数规则，教学词表只是为解释机制。

聊天角色怎样成为输入的一部分

聊天原来是带角色的消息，比如“用户问什么”“助手答什么”。聊天模板负责把这些角色与正文组织成模型训练时认识的形式。模板可能加入表示角色开始、消息结束的控制标记，这些标记也可能占Token。

普通字符串里写“system:”不自动等于真正的系统角色；模型接口如何组织消息，决定服务怎样处理它。不能把人类看见的聊天气泡逐字拼接，就声称复现了商业服务最终输入。

编码后还没发生什么

拿到[1,2,3]时，只是找到了编号；还没有得到每个位置的上下文表示，没有计算下一Token概率，也没有读任何外部文件。分词是表示转换，不是“理解已完成”。

反向解码也要注意边界：有的处理会折叠大小写或规范化文本；有的Token单独解码不是完整字符。代码任务中要区分“意思相同”和“原始字节相同”。

课后自检

机制依据：[BPE][UNIGRAM][CHAT]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F04｜组批和补齐：为什么两句话变成[2,3]

从具体对象与小例子开始，理解计算过程与适用条件。

“组批”就是让若干条输入一起处理

一次只处理“我爱学习”，是单条输入。把“我爱学习”和“你爱”放在同一次计算中，叫一个批次（batch）。本批有2条，批大小B=2。

它们还是两条独立输入，不是把第二句话接到第一句话后面。批轴提供“一起调度”的组织方式，标准独立样本计算不让两条样本互相读取内容。尤其不能因为组批就把不同用户的上下文混起来。

上一课的两条编号是：

第0条：[1,2,3]      长度3
第1条：[4,2]        长度2

如果要放成规则的矩形表，每一行需一样长。我们把本批安排的长度设为T=3，给第二条补一个占位编号0：

input_ids = [[1,2,3],
             [4,2,0]]
shape     = [2,3]

Padding（补齐）是在短输入中增加占位项，不是在原话中补出有意义的新内容。编号0在本教材恰好是PAD；真实模型的PAD编号可能不同，也可能需要按模型配置处理。

真实长度与安排长度不是一回事

第二条真实长度仍是2，表里安排了3个位置。若生产系统把本批都补到128，形状就会是[2,128]；这不证明两条原话都含128个Token。

为了告诉后续计算哪些位置是真实内容，另配一张标记表：

is_real = [[1,1,1],
           [1,1,0]]

这里1表示真实位置，0表示填充位置。这是后面padding mask（填充掩码）的基础。“掩码”先理解成决定某项能不能参与运算的标记；完整的注意力掩码要到F12再把行列关系讲清。

补左边和补右边有什么区别

右补齐把第二行写成[4,2,0]；左补齐会写成[0,4,2]。两者都能表达“你爱”，但真实位置所在列不同。

如果程序总取“最后一列的预测”继续生成，右补齐行的最后一列是PAD，就可能取错位置。因此某些解码流程要求左补齐，或者必须按真实长度选取最后一个有效位置。哪种策略正确取决于生成代码和模型约定，不能只把一侧称为普适最佳方案。

本书基础算例用右补齐，因为对初读者直观；若用于生成，明确取每行最后一个有效位置，不能直接照抄[:, -1]。

补齐不等于截断，更不等于上下文压缩

补齐增加占位；截断删掉过长输入的部分内容；摘要压缩尝试用较短描述替代较长历史。删除真实内容可能让规则或证据消失，补齐本身没有这个目的。

组批也不总要把所有请求凑成同一个长方形。高性能推理可以采用长度分组或变长组织方式。本课用普通密集表解释形状，不把它包装成所有服务的真实内部存储。

为什么组批可能快，也可能让一个人等更久

同一套参数能够在多条输入上一起运算，可能更充分利用硬件。但为了凑够一批而等待，会增加某条请求的等待时间。还有一个浪费：把长度2和长度1000的两条都补到1000，会产生许多填充位置。

因此B、T不是越大越好。B说明并行组织了多少条，T影响每条安排多少位置；后续还要结合硬件、缓存和队列讨论。现在只需要能从实际输入写出编号表和有效位置表。

课后自检

机制依据：[F-PADDING][F-TENSOR]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F05｜Embedding查表：把一个编号换成一排数

从具体对象与小例子开始，理解计算过程与适用条件。

为什么不能直接拿“编号大小”理解文字

模型需要一种可以进行加权、组合、比较和更新的数字表示。编号1只是一个地址；它与编号4相差3没有语言意义。最常见的输入方式是准备一张可学习的数字表，让每个词表编号对应一排数。这张表叫Embedding矩阵（嵌入矩阵），记作E。

可学习的意思是训练时这些数会被调整；普通推理时通常从训练好的参数中读取，不是看到一句新话才临时生成一张表。Embedding查表本身就是模型的一个层，不是某个额外联网检索服务。

用6行4列的表，表示“我爱学习”和“你爱”

沿用6项教学词表，指定每个片段用4个数表示，写作d=4。下面的数字是人为构造的浮点数，有正数、负数和小数，只用来解释运算，并不代表“我”“你”的真实含义：

这张Embedding表记作E，形状为[6,4]：6行是词表中可以查找的6个编号；4列表示每个编号对应4个数。查表时，不是随机取三行，而是按两句话里各个文本片段的编号，依次取出对应的行。

第一句话：“我爱学习”怎样查表

先前的编号[1,2,3]不是无意义的三个孤立数字，而是依次对应“我”“爱”“学习”。查表过程逐项如下：

按照“我 → 爱 → 学习”的原有顺序，把三排数放在一起，就得到“我爱学习”的初始Embedding表示：

原文：“我”   “爱”   “学习”
编号：  1      2       3

“我”   → [0.2,-0.1,0.7,0.4]
“爱”   → [-0.3,0.8,0.1,0.5]
“学习” → [0.6,0.2,-0.4,0.9]

第一句话的结果：
[[0.2,-0.1,0.7,0.4],
 [-0.3,0.8,0.1,0.5],
 [0.6,0.2,-0.4,0.9]]       shape=[3,4]  （3个Token，每个4个数）

第二句话：“你爱”怎样查表

第二句话的真实文本只有“你／爱”两个Token，对应编号[4,2]。组批时加入的0代表PAD，因此要依次查E[4]、E[2]、E[0]：

同样按位置排列，得到的是“你爱”的两个Token表示，加上一个供组批使用的PAD占位表示：

原文：“你”   “爱”              （只有2个Token）
编号：  4      2       0(PAD)  （补齐后安排3个位置）

“你”   → [0.1,-0.5,0.9,0.3]
“爱”   → [-0.3,0.8,0.1,0.5]
PAD    → [0,0,0,0]  （只是占位，不属于“你爱”）

第二句话的结果：
[[0.1,-0.5,0.9,0.3],
 [-0.3,0.8,0.1,0.5],
 [0,0,0,0]]       shape=[3,4]  （2个Token + 1个PAD，每位置4个数）

把两句话的结果放在一起：第一张三行四列代表“我爱学习”的三个Token；第二张三行四列代表“你爱”的两个Token和一个PAD。现在有2张表，每张3行，每行4个数，所以结果H的形状是[2,3,4]。

这里要区分两步：文字 → Token编号是分词器的编码；Token编号 → Embedding向量是模型内的查表表示。到这一步，每个位置有一排数，但还没有把整句话算成一个能直接代表完整句意的向量，也没有生成回答。两个句子都包含“爱”（编号2），所以它们在同一张表里最初查到的都是[-0.3,0.8,0.1,0.5]；后续网络会根据位置和上下文更新各自的表示。

用一句可执行的定义表示：H中某条输入、某个位置的一排数，等于E中该位置Token编号所指向的那一行。PAD行虽然在这张教学表里恰好全为零，也仍然需要按照后续掩码规则处理。

为什么从两个轴变成三个轴

注意，原来的输入是两条句子，每条安排3个Token位置，所以它有两个轴：[2,3]。此时每个位置只存一个编号，例如第一句话的第2个位置是编号2（“爱”）。

查表后，这个位置不再只存编号2，而是存放E[2]=[-0.3,0.8,0.1,0.5]，即4个可用于计算的数。第一句话仍有3个位置，两句话仍有2条；改变的是每个位置存什么，所以增加“位置内部的第几个数”这个索引方向：

[B,T] --逐编号查E--> [B,T,d]

请按真实对象读这三个下标：H[第几句话, 第几个Token位置, 第几个特征]。例如H[0,1,0]=-0.3，是第一句话“我爱学习”中“爱”这个Token的初始向量的第1个数；H[1,1,0]=-0.3则是第二句话“你爱”里的“爱”。两者初始查同一行，后续结合上下文才可能不同。

“多一个轴”不是增加了一种新文本，也不是把一个整数复制4次。二进制位只描述数字的存储；One-hot的6个位置用来指定词表项；Embedding新增的4个特征来自所选表的4列。这三种“长度”不能混同。补齐改变位置数T；Embedding改变每个位置的表示宽度d。

再看一个更大规模的例子：B=2,T=128,d=4096：有2条输入，每条安排128个位置；每个位置的一个编号被换成4096个数，因此得到2张128行4096列的表。形状是[2,128,4096]，不是再生成了4096个Token。

隐藏维度到底“隐藏”了什么

隐藏表示指网络内部产生、不是直接提供给用户的中间数字表示；隐藏维度d是这种表示每个位置的宽度。隐藏不意味着神秘、加密或私人思考记录。

这一排数的各列通常没有人工指定的名称，不能擅自说第一维表示“动物”、第二维表示“快乐”。它们共同参与预测，可能以分布式方式表示多种信息。为了教学我们把列叫特征0到特征3，而不是捏造语义标签。

同一Token在标准固定查表中通常取同一行；经过位置处理和读取上下文的后续层，表示才会因句子不同而改变。输入Embedding、上下文化隐藏状态、整篇文档检索向量都可能是“一排数”，但来源、训练目标和用途不同。

PAD行是零，就能不用mask吗

不能由此保证。即使Value是零，若它参与概率归一化，仍可能分走注意力权重；位置处理、偏置等也可能让后续值不再为零。PAD是否参与，必须按掩码和损失约定处理。这里的零行是教学选择，不是完整隔离机制。

计算边界：不能说查完Embedding“才进入神经网络”。查表层已是模型运算的一部分；更准确的边界是：此前主要做请求组织和编号转换，从Embedding开始进入模型的数值表示与后续网络计算。

课后自检

机制依据：[F-EMBED][TR]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F06｜“放到设备”是什么：数据类型、内存、CPU与GPU

从具体对象与小例子开始，理解计算过程与适用条件。

同一个数有三种不同的问题

看一份形状[2,3,4]的数据，要分别问：它怎么排列（shape）、每个数怎样存（dtype）、存在哪里并由谁算（device）。这三项不能互相代替。

CPU是执行通用程序的处理器；GPU擅长在合适的运算上并行处理大量数字。设备device是计算框架用来标识执行或存储位置的概念，例如CPU或某块GPU。把数据放到GPU，不会自动使它变得更有语义，只是让相应硬件能够进行后续计算。

整数编号与浮点特征为何类型不同

Token ID用于找表中哪一行，通常采用框架支持的整数类型；Embedding权重和输出常用浮点类型。浮点数是一种用有限位数近似表示含小数数值的方式，它不是任意精度的实数。

int64表示每个整数用64位，即8字节；float32通常每个数用32位，即4字节；FP16和BF16各用16位，即2字节，但指数和有效数字的安排不同，表示范围和精细程度不能只看位数。实际算子支持什么类型，要看具体实现。

改变类型会改变内存与数值误差；改变shape是改变排列解释；改变device是改变执行位置。这些动作不是同一件事。

对较大规模的表示算一遍存储

[2,128]共有256个编号。按int64存储，仅编号数据为256×8=2048字节。

查表结果[2,128,4096]有1,048,576个数。若每个占2字节，仅这份结果为2,097,152字节，即2 MiB。MiB以1024为进制，1 MiB=1024×1024字节；十进制MB则是1,000,000字节。

这不是整个模型只需2 MiB。 E本身、所有层权重、中间结果、KV缓存及运行工作区都还没算。估内存必须列出对象，而不是看到一个张量大小就推断总显存。

一次常见执行的实际顺序

程序先准备模型参数和计算环境，再把本批ID与必要标记交给计算框架。对于独立显存的GPU，需要把参与运算的数据安排到兼容设备上；否则框架可能报设备不一致，而不是自动替你完成所有搬运。

随后调用Embedding操作：根据ID读取权重表对应行，生成本批表示。接着运行网络的矩阵运算。生成结束后，有些结果会被取回CPU用于文本处理或界面显示。

这只是常见逻辑次序，不是所有底层系统都真的进行同样的物理复制。统一内存、模型分片和卸载会改变细节；本课先建立“运算需要访问到数据”的概念。

为什么小任务放GPU有时不快

传输、调度和启动一次运算都有成本。若真正的计算只有几个数字，准备与搬运可能比计算本身还贵。GPU吞吐强，不等于每个小操作延迟都低。

还有一个常见计时陷阱：某些GPU调用是异步的，即CPU发出指令后即可继续，GPU还没做完。只量函数返回时间可能量到“排队指令”的时间，而非计算完成时间。测性能时需要按框架要求等待或使用设备计时机制。

现在把“组批、放设备、查表”连起来

组批解决“这次一起算哪些输入”；补齐和标记解决“不同长度怎么摆”；device解决“在哪里算”；dtype解决“每个数怎样存”；Embedding解决“编号对应哪排数”。每一步的职责都不同，因此每一种错误的排查也不同。

课后自检

机制依据：[F-TENSOR][F-EMBED]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

示例：从两句话到三维表示

本例衔接基础篇F01—F06，用两句话和一张小型参数表，串联编号、组批、形状与查表。先计算小规模表示，再解释[2,128,4096]。

1．文字如何转换为编号

我们用两条文字：“我爱学习”和“你爱”。分词器是一套把文字片段对应到整数编号的规则。本页人为规定它把第一句分成“我／爱／学习”，第二句分成“你／爱”。这只是为了算得清楚，不是任何商业模型的真实分词结果。

因此，第一句成为[1,2,3]，第二句成为[4,2]。一个编号只回答“是哪一项”，不回答“意思是什么”。4比1大，不表示“你”比“我”更重要。

现在还没有预测答案。我们只把文字换成了以后可以拿来找位置的编号。

2．“组批”到底组了什么

把两条输入交给同一次运算，一起处理，叫组批。这一组是一个批次（batch）；批里有2条输入，所以批大小B=2。

这里B只是“有几条”的缩写。没有引入神秘数学对象。两条输入依然各算各的，不能把第二条用户输入当成第一条用户的上下文。

但两条编号列表一条长3、一条长2。为了先用普通规则表格计算，我们给短的那条末尾放一个占位编号0：

第0条输入：1  2  3      真实有3个片段
第1条输入：4  2  0      真实有2个片段，末尾0只是填空

这个动作叫补齐（padding）。补齐后每行安排3个位置，写作T=3。T说的是安排了几个位置；第二句话真实长度仍是2。占位项不是模型突然理解出的一个新词。[F-PADDING]

3．为什么编号表写成[2,3]

两行，每行三个编号，所以表的大小写成[2,3]。这种描述大小的写法叫形状（shape）。

“里面存着[[1,2,3],[4,2,0]]”是在说内容；“形状是[2,3]”是在说大小。不要把两者混淆。编号表含2×3=6个整数。

在机器学习程序中，像这样规则排列的一组数字叫张量（tensor）。本页先把它理解成“数字容器”：一排数、表格、若干张同样大的表，都可以用张量来装。两行三列的编号表是一个有两个轴的张量：第一个轴选哪句话，第二个轴选那句话里的哪一个位置。[F-TENSOR]

4．为什么还要把编号换成一排数

编号可以找到某一项，但直接比较编号大小没有语义意义。模型为每个词表项准备一排可以被后续计算使用的数字，把这些行放成一张表，叫Embedding表（嵌入表）。

先不去猜每个数代表什么意思。本页每行只放4个数，完整表如下。它们是人为设置的小数和负数，不是真实语言模型训练得到的参数。采用小数而不是只有0和1，是为了避免把Embedding误认成二进制编码：

这张Embedding表有6行、4列，形状是[6,4]。6是词表项数：一共有多少种可以查找的编号。4是表示宽度d：每项用几个数表示。本页d=4。

编号、二进制、One-hot与Embedding不是一回事：“爱”的编号为2；如果只讨论它在电脑里如何以8位保存，可以写成00000010；如果用长度6的独热标识，可以写成[0,0,1,0,0,0]；但本例真正查出的Embedding是[-0.3,0.8,0.1,0.5]。第三个轴就是这一排4个浮点数的索引方向，不是二进制位数。实际查表只需要编号，不需要先构造One-hot。

6、3、4分别回答不同问题。 词表有6种可用项，不意味着一句话必须长6；一句话安排3个位置，不意味着每项只用3个数；每项用4个数，也不意味着一定有4个能人工命名的语义属性。

5．“查Embedding”真的只是先找到对应的行

先看第一句“我爱学习”：按本例的Token划分，它依次是“我／爱／学习”，所以编码后的编号才是[1,2,3]。这里不是拿三个随机数字找行，而是依次把原句的三个Token转换成Embedding向量：编号1对应“我”，编号2对应“爱”，编号3对应“学习”。

“我”   (编号1) → [0.2,-0.1,0.7,0.4]
“爱”   (编号2) → [-0.3,0.8,0.1,0.5]
“学习” (编号3) → [0.6,0.2,-0.4,0.9]

于是第一句成为：
[[0.2,-0.1,0.7,0.4],
 [-0.3,0.8,0.1,0.5],
 [0.6,0.2,-0.4,0.9]]

原来“我”这个位置只存编号1；现在这个位置对应一排[0.2,-0.1,0.7,0.4]。并没有把1转换成四位二进制码，而是按编号1读取参数矩阵的一整行。这样的每个Token向量以后还会参与注意力计算。[F-EMBED]

第二句则是“你爱”：它实际只包含“你／爱”两个Token，编码为[4,2]。为了和第一句放在同一批次里计算，才补成[4,2,0]。这表示“你”(4)、“爱”(2)，加上一个不属于原句的PAD占位(0)。因此依次查表取的是“你”的向量、“爱”的向量，以及PAD占位的向量：

第二句成为：
[[0.1,-0.5,0.9,0.3],
 [-0.3,0.8,0.1,0.5],
 [0,0,0,0]]

这不是把“你爱”编码成三个真实词：第三行只是为了补齐到长度3。查表得到的仍是逐Token的初始数值表示，而不是对完整句意的一次理解。注意“爱”在两句话里，初次查表得到同一排数。这不表示它永远不看上下文；后面的网络会把当前位置与允许读取的其他位置结合，产生新的表示。查表是起点，不是全部理解过程。

6．现在为什么多出一层[2,3,4]

把两句话的结果合在一起，是两张表，每张3行、每行4个数。于是整体形状为[2,3,4]。

总共2×3×4=24个数。原来6个编号，各自换成4个数，所以也可以算成6×4=24。

从下标理解第三个轴：第一个下标选择“我爱学习”还是“你爱”；第二个下标选择其中的哪个位置；第三个下标选择该Token向量的第几个数。例如H[0,1,0]=-0.3，是第一句话的第二个Token“爱”的初始表示第一个数。新增的是每个位置的数值特征轴，不是额外的词或二进制位。

“这是三维张量”说有三个轴；“每个位置是四维向量”说每排有四个数。这里维的两种说法要区分。向量就是此处有顺序的一排数，不需要先想象四维空间。

7．将表示扩展为[2,128,4096]

现在只换三个大小，不换计算道理。

• B=2：本批两条输入。
• T=128：每条输入补齐或安排到128个位置。
• d=4096：每个位置查表后用4096个数表示。

编号表有两行、每行128个整数，所以是[2,128]。每个整数再换成长度4096的一排数，整体就是[2,128,4096]。

它含2×128×4096=1,048,576个数。4096不是Token数，不是词表大小，也不是整个模型的参数总量。 它叫隐藏维度或隐藏表示宽度，意思是模型用这么宽的一排数来表示每个位置。更深的层通常还沿用这个宽度，但会改变数字内容。

若每个数用2字节保存，这一份输出约占2MiB。字节是存储大小的单位，MiB是1,048,576字节。这个估算只针对这一份数据，不包含模型全部参数、缓存或临时计算空间。F06会完整讲存储精度与设备。

8．“放到设备”没有改变这句话的意思

设备在这里指执行计算的处理器，例如CPU或GPU。CPU是通用处理器，GPU擅长并行执行大量合适的数值运算。为了让运算执行，程序要让输入数据与模型参数位于相容的设备和存储格式中。

可以把[1,2,3]存到内存，再复制到GPU显存中；它们仍然是相同编号，并没有因为移动就变得更“智能”。显存是GPU可直接使用的一类存储空间。移动数据可能花时间，空间也可能不够，所以这是实在的工程步骤。

在常见输入Embedding层中，查找地址使用整数编号，取出来的参数通常是浮点数；浮点数就是可以近似表示0.1、−0.7等数值的计算机数值格式。设备、格式和形状是三种不同属性。

9．还要带哪几份“辅助信息”

第一份是填充掩码：告诉后续计算哪些位置是真的。

第一句：[1,1,1]   都是真的
第二句：[1,1,0]   最后是补齐位置

这里的0/1不是Token编号，而是“能不能算作有效内容”的标记。即使PAD的Embedding恰好全0，也不代表后续计算自然会忽略它，因此仍需正确处理这些位置。

第二份是注意力掩码（attention mask）。注意力先理解为“为当前这个位置挑出可以参考的位置，再按不同份额结合它们的数字”。掩码决定“能参考谁”，不是决定“参考多少”。后者要到F09–12用加权平均算出来。

生成下一Token时，训练与运算通常要遵守不能偷看未来的规则。对三位置例子，可以读的位置是：

这是因果掩码。第二句话还必须把作为填充项的位置2排除。模型内部不同接口使用的掩码形状和真假含义不一定相同；本页表格只解释可见关系，不冒充某个API的入参。

第三份是位置编号（position IDs）。比如真实的三个位置记为0、1、2。Token ID回答“哪个片段”，位置ID回答“出现在哪里”，二者不是同一列。采用左补齐或缓存时，逻辑位置与表格列号可能不同，F13会分别举例。

最后可能有KV缓存（KV Cache）。缓存就是保存已经算过、后面还能复用的结果。第一次从头处理时通常没有历史缓存；继续生成时，可以带回之前各层算好的部分数字，避免从头重算。这不是长期记忆，也不是新知识进入模型参数。K和V的含义、为什么可以复用、哪些改动让它失效，会先在F11解释注意力，再在F16完整推演；此页不要求先背这两个字母。[F-CACHE]

10．完整过程小结

把两条独立输入一起计算，并把较短的编号列表补到本批安排的长度。由此得到一张两行、每行128个编号的表。模型根据每个编号，从自己的Embedding参数表中取出一排4096个数，所以结果是两张128行、4096列的表。程序同时准备有效位置、哪些位置能互相参考、各个真实片段的位置编号；若这是继续生成，还带入可复用的历史计算结果。随后开始各层的注意力与其他数值变换。Embedding查表本身已经属于模型数值表示的计算步骤，不是查完之后才第一次碰到神经网络。

你现在不需要先理解Attention的完整公式，便能解释这一步的每个对象。下一段若直接出现Q、K、V或softmax，先走F07→F09→F11；不是靠猜缩写读下去。

自检：请先口头回答，再看答案

问题一：词表1000项、三条输入、每条10个位置、每项用8个数表示，Embedding表和查表结果分别多大？

问题二：为何同样写0，有时表示PAD编号，有时表示掩码里的不能看？

问题三：Embedding的第2个数是不是永远表示情绪？

问题四：组批时第二个用户会读取第一个用户的内容吗？

F07｜模型最常做的算术：加权求和、点积与矩阵乘法

从具体对象与小例子开始，理解计算过程与适用条件。

从你已经会的平均数开始

2和6的普通平均是(2+6)/2=4，也能写成0.5×2+0.5×6。如果你认为第二个数应占更大比例，可以写成0.25×2+0.75×6=5，这叫加权平均。权重非负并且总和为1时，它表达“各占多少比例”。

对于两排数[2,0]和[0,4]，仍按对应位置计算：

0.25×[2,0] + 0.75×[0,4]
= [0.25×2+0.75×0, 0.25×0+0.75×4]
= [0.5,3]

得到的仍是一排数，没有选出一句文字。这会直接用在Attention中。

点积是怎样把两排数变成一个数

点积（dot product）要求两排数一样长：把对应位置相乘，再加起来。

[1,2,3] · [4,5,6]
= 1×4 + 2×5 + 3×6
= 32

公式Σ_i x_i y_i只是把上面三次乘法与加法写成通用规则。点积结果是一个标量，而不是三排数。它可以用于比较方向或产生分数，但原始点积也受向量长度影响，不能无条件说它就是纯粹的语义相似度。

矩阵乘法是“一次做很多个点积”

本段先给两个对象起名：X是当前输入数字表；W是决定如何组合这些数字的系数表。这里先手动指定W，F10再说明它在模型里怎样成为可训练参数。字母只标识对象，没有增加新的算术操作。

设两张表：

X = [[1,2,3],       W = [[1,0],
     [4,5,6]]           [0,1],
                         [1,1]]
X形状[2,3]         W形状[3,2]

计算Y=XW：Y的每个格子，用X的一行与W的一列做点积。

Y[0,0] = [1,2,3]·[1,0,1] = 4
Y[0,1] = [1,2,3]·[0,1,1] = 5
Y[1,0] = [4,5,6]·[1,0,1] = 10
Y[1,1] = [4,5,6]·[0,1,1] = 11
所以Y = [[4,5],[10,11]]，形状[2,2]

内侧尺寸必须匹配：[m,n]×[n,p]→[m,p]。m是第一张表的行数，n是每次点积配对的长度，p是输出列数。这里没有“把所有数字随便相乘”的自由。

一个Token从4096个数变成另外4096个数，究竟是什么动作

若输入一排数x长4096，乘一个[4096,4096]权重矩阵，每一输出列都对输入4096个数加权求和。输出还是4096个数，但数值和组合方式变了。这个过程常称线性投影；“投影”在这里不必等同三维物体投影到墙上，也不一定降低维度。

在多条输入的情况下，常把最后一个轴视为特征轴。同一W作用到每个位置，因此[B,T,d]×[d,k]→[B,T,k]。它改变每个位置的宽度，不直接混合两条样本或相邻Token。

转置怎样帮助“一排数分别与多行比较”

转置（transpose）是把一张表的行列交换。比如：

K = [[1,2],       Kᵀ = [[1,3,5],
     [3,4],             [2,4,6]]
     [5,6]]

K在这段只是给三行待比较数字起的表名，原来有3行，每行2个数。另有一排待比较数字q，长度也是2；想让q分别与K的3行做点积，可以将K转成2行3列，于是[1,2]×[2,3]→[1,3]，一次得到三个比较分数。到F11，才会把这种接收方表示和候选表示分别引入为Query和Key，并完整解释它们的参数来源。

注意上标ᵀ是转置，不是序列长度T；Kᵀ也不是K的T次方。

矩阵乘与逐元素乘不能混

在常见Python数值库里，@表示矩阵乘，*常表示对应格子逐元素相乘。对两个2×2矩阵，这两种操作都能运行且输出2×2，但结果完全不同。形状对了只是必要检查，不代表运算含义对了。

读公式时依次问：输入每个轴是什么、操作按哪条轴进行、输出每格怎么计算、得到的是分数还是特征。这个办法比只记“QKV都是矩阵”更可靠。

课后自检

机制依据：[F-LINALG][TR]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F08｜reshape、转轴、广播：形状变了，内容未必算过

从具体对象与小例子开始，理解计算过程与适用条件。

为什么深度学习代码里反复改变形状

有些操作需要“一张长表”，有些操作需要“多个头各一张表”。同一批数字可以用不同形状组织，但组织数据与学习新特征不是同一件事。若不分清，你会把一次reshape误读成模型又推理了一次。

reshape是重新分组，不是交换行列

把[[1,2,3],[4,5,6]]按行看成数字序列1、2、3、4、5、6，再改为3行2列，可以得到：

reshape为[3,2]：[[1,2],
                 [3,4],
                 [5,6]]

而同一原矩阵的转置是：

transpose后：  [[1,4],
                 [2,5],
                 [3,6]]

两个结果形状都为[3,2]，内容位置却不一样。前者重分组，后者交换“原行”和“原列”的身份。这是许多Attention实现错误的来源。

reshape前后元素数必须一致。12个数可以排成[3,4]或[2,2,3]，不能不丢不补地排成[5,5]。代码里的-1有时表示让库按总数推算这一轴，不是负数长度。

多头只是把特征轴分组吗

假设每个位置宽度d=4，有2个头，每头宽度2。投影后的[B,T,4]可以重排成[B,T,2,2]，再交换T轴与头轴，成为[B,2,T,2]，方便每个头独立计算。

这里“头”指一套Attention中的分组计算单元；具体内容来自已经学习好的投影权重。不是把原始文本分成两半，也不是头0天然负责中文、头1天然负责代码。

为了区分，记H=2为头数、d_h=2为每头宽度，d=H×d_h=4。代码经常用reshape后再transpose或permute（交换若干轴），两个步骤有各自作用。

广播：用一个小对象作用到许多位置

假设X有2行3列，每行都要加偏置[10,20,30]。不必手工复制两行偏置，库可以按广播（broadcasting）规则把这排数应用到每一行：

[[1,2,3],   + [10,20,30] = [[11,22,33],
 [4,5,6]]                    [14,25,36]]

常见广播规则从最右轴对齐：长度相同或某一方长度为1时可匹配。[2,3]与[3]可以；[2,3]与[2]通常不可以。若你要每行加不同的一个数，应把后者组织成[2,1]。

注意力分数可能是[B,H,T,T]，某些mask可以带长度为1的头轴来广播，表达“所有头共用这个限制”。但某种形状能广播，不代表语义正确，仍需检查轴身份。

内存布局与视图只需先懂一个原则

张量除了shape，还可用步长（stride）描述沿某轴前进一步在底层存储中跳多远。转轴有时只改变这份说明而不搬动全部数据，这样的结果可能是原数据的视图（view）。

因此某些操作要求内存连续排列，有时需要复制后才能执行；修改共享存储的视图还可能影响原对象。不要把“代码看起来只是换shape”当作一定免费，也不要无条件认为它一定复制。

squeeze通常移除长度为1的轴，unsqueeze增加长度为1的轴。若B恰好为1，随手squeeze可能把批轴也删掉，后续代码在B=1能跑、B=2却失败。显式指定轴比猜形状安全。

课后自检

机制依据：[F-TENSOR][F-LINALG]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F09｜概率、指数与softmax：把分数变成比例

从具体对象与小例子开始，理解计算过程与适用条件。

分数不是概率

本章从头到尾只使用同一组三个候选Token：候选A、B、C，模型分别给它们打分[2,1,0]。这些值叫logits（未归一化分数），不是概率：例如2不能读成200%，三个数相加也不等于1。实际logits也可能是负数，但为了方便核对，本章始终使用[2,1,0]。

概率在这里表示模型为候选分配的比例：每项不小于0，总和为1。0.2表示20%。它是模型在当前条件下的预测，不自动等于现实中答案正确的概率。

先学指数和对数需要的那一点

2³=8是指数；exp(x)是e^x，底数e约为2.71828。指数把任意实数转成正数：exp(0)=1，exp(1)约2.718，exp(-1)约0.368。

自然对数ln是反过来问“e的几次方等于这个正数”。所以ln(1)=0，ln(e)=1。ln(2)约0.693，ln(3)约1.099。后面的损失函数会用到对数，现在先认识它与指数互为反操作。

softmax一步不跳地算

Softmax把模型给三个候选的分数转成三项概率。从这里到本章的抽样示例，输入始终是[2,1,0]，并没有换另一组数据。逐步计算如下。计算机通常先减去最大值以避免指数过大，具体原因下一节会证明。

① 候选Token：       A          B          C
② 原始分数 z：     2          1          0
③ 减最大值2：      0         -1         -2
④ 分别取指数：     1      0.367879   0.135335
⑤ 指数求总和：     S = 1 + 0.367879 + 0.135335 ≈ 1.503215
⑥ 各自除以 S：  0.665241   0.244728   0.090031
⑦ 累计概率：    0.665241   0.909969   1.000000

抽样时取一个位于 [0,1) 的随机数，例如 u=0.70：
  A 区间：[0,       0.665241)
  B 区间：[0.665241,0.909969)   ← 0.70 落在这里
  C 区间：[0.909969,1)
所以本次抽中 B；但每次随机数可能不同。
表格只显示6位小数，程序使用更高精度的内部值。

通用写法是p_i = exp(z_i) / Σ_j exp(z_j)。i指当前候选，j遍历全部候选，Σ表示求和。分母相同，因此所有项会一起竞争比例。

若A的分数增大而B、C不变，Softmax归一化后B、C的概率就会下降，因为三者共享同一个分母。这也解释了注意力中的一个工程细节：仅把补齐位置（PAD）的Embedding设为零，不保证它不影响注意力。若它仍是可访问的Key位置，就可能参与注意力的Softmax分母；应通过合适的Attention Mask排除无效位置。这里说的是注意力Softmax，不是当前三个候选Token的生成概率。

为什么要减最大值

很大的指数可能超出有限精度能表示的范围。可以把所有分数减去同一个最大值m，再算softmax：

exp(z_i-m) / Σ exp(z_j-m)
= [exp(z_i)/exp(m)] / [Σexp(z_j)/exp(m)]
= exp(z_i) / Σexp(z_j)

分子分母的共同因子抵消，因此数学上结果不变，却能避免指数过大。用同一组分数[2,1,0]核对：不减最大值时，指数为[7.389056,2.718282,1]，总和约11.107338；逐项相除，仍是约[0.665241,0.244728,0.090031]。减最大值不是“删掉最大候选”，也不会改动原来的概率。

取最大与按概率抽样不是一回事

argmax选择分数或概率最大的候选；采样（sampling）按概率随机抽一个。概率为[0.665241,0.244728,0.090031]时，argmax总选第一项A；按上述概率采样时，也可能选B或C。例如随机数0.70选中B。这解释了为什么同一分布可以产生不同文字。

Temperature（温度）是在softmax前把分数除以正数τ。τ较小常使分布更集中，较大更分散。τ=0不能真的执行除零；接口若用0表示贪心，是另外的处理约定。

Top-k保留前k项；Top-p通常保留累计概率达到门槛的最小高概率候选集合，再在其中归一化采样。p是阈值而非Token数量。这些策略在生成时改变候选选择，不会让错误的矩阵计算变正确。

同一个softmax在两处出现

Attention中的softmax把“对输入各位置的分数”变为聚合权重；最后输出的softmax把“对词表各候选的分数”变为下一Token概率。算法可以相同，但归一化的轴、候选集合和用途不同，不能把注意力权重当作最终答案置信度。

课后自检

机制依据：[F-PROB][TR]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F10｜神经网络最小模型：参数、层、前向与隐藏状态

从具体对象与小例子开始，理解计算过程与适用条件。

从一条可调的规则认识“模型”

考虑y=w×x+b。x是每次变化的输入，w与b是决定计算规则的数。若w=2、b=1，输入3得到7。把w改为4，相同输入变成13。

参数是像w、b这样可以通过训练调整的数；超参数是训练或结构的设置，例如一层宽度、学习率、批大小，通常不通过同一梯度步骤自动学出；激活值或中间表示是某次前向算出来的临时数，如这次得到的7。

用户新输入改变的是x；正常推理并不因此自动改变w。

从一个系数w到一张参数表W

上面的w=2只有一个数；当输入和输出各有多个特征时，要存下许多个系数，把它们排成矩阵W。小写w常表示单个参数，大写W常表示整张参数表。 写W1、W2是在区分第1段和第2段变换，不是把W乘1或乘2。

偏置b也是一组参数，不过它在矩阵乘法后执行逐格相加。X和隐藏状态h是每次输入计算产生的数；W和b决定这些数怎样变换。正常推理从权重文件加载W、b后使用它们，不会因为某个用户输入变化就自动执行训练更新。

接下来先使用同一组给定参数算前向。等F17—F18建立“损失、梯度、优化器”的概念后，再解释参数如何被调整。理解参数是系数表，并不要求先把训练算法全部学完。

一个有两层的完整数值例子

输入x=[1,2]，第一层矩阵W1和偏置b1为：

W1 = [[1,-1],[1,1]]     b1 = [0,-2]
xW1 = [1×1+2×1, 1×(-1)+2×1] = [3,1]
xW1+b1 = [3,-1]

然后应用ReLU激活函数：每个数若小于0就换成0，否则保留。于是得到隐藏表示h=[3,0]。

第二层用W2=[[2],[1]]，结果hW2=3×2+0×1=6。这一次从输入到输出的计算叫前向传播（forward pass），也可简称前向。

所谓“层”，不是屏幕上一个抽象方框，而是一组按规则变换数据的运算。一个复杂模型将许多层串起来，上一步结果成为下一步输入。

为什么中间需要非线性函数

如果一直只乘矩阵、加偏置，多个线性或仿射变换可以合并成一个，层数增加并不自动带来不同类型的表达能力。ReLU这类不能用单一线性变换表示的操作提供非线性，让网络能表示更复杂的关系。

实际Transformer常用GELU、SiLU或带门的前馈结构。先懂“为什么要有非线性”，再去读具体函数，不必在第一次遇到名字时就背全部公式。

隐藏状态不是隐藏的中文草稿

上例h=[3,0]是一次计算结果，不是一句被藏起来的“我想到了答案”。语言模型里，一个Token通过某层后得到的一排数也叫隐藏状态。它会携带对后续计算有用的信息，但不能直接把每个坐标翻译成一句中文解释。

d表示每个位置的隐藏宽度；L常表示层数；参数总量与所有矩阵的尺寸和共享方式有关。d=4096不代表只有4096个参数。仅一个4096×4096矩阵就有16,777,216个格子。

权重共享和参数冻结

同一个W可以作用于同批每条输入、每个Token位置，叫共享权重。它不意味着共享各位置的计算结果。输入不同，中间状态仍不同。

“冻结参数”表示训练时不更新某些参数；“推理使用固定权重”表示本次计算不执行更新。某些模型服务会在别的时间训练新版本，但不能把普通对话中纠错等同在线训练。

为什么教材可以先给权重再讲训练

为了看懂内部运行，先拿已知权重走完前向。权重如何从大量例子中得到，放在F17—F19说明。好比先理解一个已有计算器怎样算结果，再理解它如何被设计出来。

小模型数值例子能证明你理解了运算，但它没有经过语言数据训练，不能生成有意义的回答。不要把手算网络称为“复现大模型智能”。

课后自检

机制依据：[F-LINALG][F-AUTOGRAD][TR]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F11｜Attention逐步计算：先算相关分数，再混合内容

从具体对象与小例子开始，理解计算过程与适用条件。

它想解决什么问题

一个Token先由Embedding表换成一排数，但这还不够。“苹果很好吃”和“苹果发布了电脑”需要结合不同上下文。注意力（Attention）是一段数值运算：为当前位置计算它应从哪些可读位置取得多少信息，再按这些份额混合信息。 它不是模型的眼睛，也不是另外三个会说话的智能体。

先抓住两件事：匹配时用什么来打分；打完分后实际拿什么来混合。 Query、Key、Value就是在这两件事里承担不同职责的数字。下面先给它们的来源，再算完整过程。来源：注意力原论文的机制说明。

进入注意力之前，X到底是什么

这里开始一个独立的两位置小模型，只处理“我／爱”两个教学Token。为了能逐格计算，把每个Token的表示宽度设为2，不沿用F05的四维Embedding表。从本节这张表直到输出，始终使用下面同一份输入与参数，不再切换数字。

把两行摆在一起，给整张表起名为大写 X：

X = [[1, 1],       第0行对应“我”
     [1,-1]]       第1行对应“爱”
形状：[2,2] = [Token位置数, 每个位置的特征数]

X不是整句中文，也不是Token编号表，而是本次注意力计算收到的数值表示。小写x₀只取X的第0行；x₁取第1行。方括号里的1和-1是人为指定的教学特征，没有“一定表示主语或动词”的含义，更不是二进制位。

本例省略归一化、位置旋转、偏置、多头与残差，只观察一个注意力头。真实网络中，注意力收到的X也可能是上一层输出或归一化后的表示；不能把每一层的X都当成最初的Embedding。那些额外步骤在F12—F16及系统篇逐步接入。

W是什么：先认识“乘法系数表”，再认识三个名字

F07里，[1,2] × [[3,4],[5,6]] = [13,16]：输出的第一个数是1×3+2×5，第二个是1×4+2×6。右边那张表里的3、4、5、6，决定了输入数字怎样被重新组合。它是一张权重矩阵，也就是乘法系数表，通常用字母W表示。

W是规则里的参数，X是这次送来的数据。 同一张W可以处理很多不同X；改X会改变本次结果，但正常推理不会因此改写W。神经网络里把“每行输入乘一张参数表，得到一排新特征”称为线性变换或线性投影。它不一定降低维度，也不是把三维东西投影到墙上。

Attention准备了三套这样的参数：

下标q、k、v只是说明“这张W负责哪一路”。Wq不是W乘q；W_Q中的下划线也不是一个计算动作。后面公式XWq才表示矩阵乘法，Python中通常写作X @ Wq。

这些系数从哪里来？ 训练前，程序按初始化方法设置它们；训练中根据预测误差调整；使用训练好的模型时，从模型权重文件加载已经得到的数值。它们不是对当前提问临时随机生成，也不是程序员给每个词手写的语法规则。这里的三张表是为演示手算而设定，不声称经过语言训练。来源：线性层的参数与计算约定。

Query、Key、Value各做哪一件事

现在把名字与对象连起来：

同一个位置可以同时当接收者和信息提供者。例如计算“爱”位置的新表示时，用“爱”的Query去比较“我”的Key和“爱”的Key，再混合“我”的Value与“爱”的Value。

小写q、k、v是一行；大写Q、K、V是把所有位置各自的行摆成的表。 在本节里每张表有2行，每行2个数。它们不是三份独立原文，而是同一份X经过不同参数变换得到的三份中间表示。

因此，三条计算是：

Q = X @ Wq     输入表示 × 查询参数表 → 所有位置的查询表示
K = X @ Wk     输入表示 × 键参数表   → 所有位置的匹配表示
V = X @ Wv     输入表示 × 值参数表   → 所有位置的内容表示

“分成三套参数”不意味着数学上不允许它们恰好相等。某些教学特例会设成相同矩阵；有些研究结构也会共享参数。但一般的分开设计允许三条路径学到不同变换。数值是否相同、是否共享，必须看该例子或模型的具体设定。

用同一份X，把三张参数表完整乘一次

本节始终使用下面三张2行2列的系数表，且不加偏置：

Wq = [[ 0.5, 0.5],    Wk = [[0.5, 0.5],    Wv = [[5, 10],
      [-0.5, 0.5]]          [0.5,-0.5]]          [5,-10]]

先取“我”的输入x₀=[1,1]。每个输出格子都是输入的一行与参数表的一列做点积：

q₀ = x₀Wq = [1×0.5+1×(-0.5), 1×0.5+1×0.5] = [0,1]
k₀ = x₀Wk = [1×0.5+1×0.5,    1×0.5+1×(-0.5)] = [1,0]
v₀ = x₀Wv = [1×5+1×5,        1×10+1×(-10)] = [10,0]

再取“爱”的输入x₁=[1,-1]，仍然使用相同的三张参数表，没有为“爱”换另一组W：

q₁ = x₁Wq = [1×0.5+(-1)×(-0.5), 1×0.5+(-1)×0.5] = [1,0]
k₁ = x₁Wk = [1×0.5+(-1)×0.5,    1×0.5+(-1)×(-0.5)] = [0,1]
v₁ = x₁Wv = [1×5+(-1)×5,        1×10+(-1)×(-10)] = [0,20]

于是，整个X变成三张结果表：

到这里还没有混合不同Token。 三个投影都是分别加工每一行；真正跨位置的比较和混合发生在下一步。Q/K/V各行的数字是由上面的X和W算出的，不是凭空给出的新输入。

对“爱”这个位置，从打分一直算到新表示

本节使用因果读取规则：当前位置能读自己和前面的位置。现在计算序列第1号位置“爱”，所以它能读第0号“我”和自己。取出的对象是：

当前接收者：爱，q₁=[1,0]
可读位置0：我，k₀=[1,0]，v₀=[10,0]
可读位置1：爱，k₁=[0,1]，v₁=[0,20]

第一步：Query和每一个Key打分。

对“我”的原始分数：q₁·k₀ = 1×1+0×0 = 1
对“爱”的原始分数：q₁·k₁ = 1×0+0×1 = 0
原始分数：[1,0]，顺序仍是[我,爱]

第二步：把分数除以Query/Key的宽度的平方根。 宽度记作d_k，这里是2；√2≈1.414214。这叫缩放，不是再修改W：

缩放分数：[1/√2, 0/√2] ≈ [0.7071067812,0]

第三步：沿可读位置做softmax，得到读取份额。 算法与F09相同，但这是当前Q/K得到的分数，不是F09词表候选的[2,1,0]。这里候选对象是两个输入位置，不是三个待生成Token。

减最大值： [0, -0.7071067812]
取指数：   [1, 0.4930686914]
指数之和： 1.4930686914
除以总和： [0.6697615493, 0.3302384507]
            来自“我”的份额   来自“爱”的份额

这些份额也是“权重”，但和Wq里的参数权重不是同一种东西。Wq等是已经加载的模型参数；这里的两个份额由本次输入计算而来，随输入改变。

第四步：用份额混合Value的对应格子。

输出第0格 = 0.6697615493×10 + 0.3302384507×0
          ≈ 6.6976154933
输出第1格 = 0.6697615493×0  + 0.3302384507×20
          ≈ 6.6047690135

“爱”位置的注意力输出 o₁ ≈ [6.6976154933,6.6047690135]

这排数是**“爱”位置的新中间表示**。它不是随机抽中“我”，不是选出一个Value，也不是生成了一句回答。Attention在这里做确定的加权求和，不执行F09演示的随机抽样。

把一行变成所有行，公式就出现了

现在仍然使用同一X和同一组三张参数表，同时看两个接收位置：

Q = [[0,1],        K = [[1,0],        V = [[10,0],
     [1,0]]             [0,1]]             [0,20]]

QKᵀ = [[0,1],     行：接收信息的位置（Query）
       [1,0]]     列：提供信息的位置（Key）

上标ᵀ表示转置：让K的原来每一行成为一列，以便一次计算所有“Query行与Key行”的点积。它不是序列长度T，也不是K的某次方。

第0号“我”不能读未来的“爱”。给禁止的分数位置加负无穷，记为−∞，它的指数按极限取0。给允许的位置加0。把这种加性掩码表命名为M：

M = [[0,−∞],      第0行只能读“我”
     [0, 0]]      第1行能读“我”和“爱”

S = QKᵀ/√2 + M = [[0,−∞],
                   [0.7071067812,0]]
A = 每行softmax(S) ≈ [[1,0],
                      [0.6697615493,0.3302384507]]
O = AV ≈ [[10,0],
          [6.6976154933,6.6047690135]]

S是分数表，A是读取份额表，O是混合后的输出表。它们都是本次计算结果，不是另外加载的模型参数。第0行只有一个合法位置，份额是1，输出自然就是自己的Value。

所有动作合起来，才写成这条简式：

Q=XWq，K=XWk，V=XWv
O=softmax(QKᵀ/√d_k + M)V

本例所有形状刚好相同，不能据此认定所有对象可互换。一般单头设有n个查询、m个Key，Q为[n,d_k]、K为[m,d_k]、V为[m,d_v]，则分数与份额为[n,m]、输出为[n,d_v]。d_v是每个Value有几个数，不必等于d_k；Query和Key的长度才需要配对做点积。

self并不是“只看自己”

本例Q、K、V都从同一条序列的X产生，所以叫Self-Attention，自注意力。每个位置仍可以读取规则允许的其他位置。“self”说来源，不说只能看自己。

Cross-Attention，交叉注意力则可以让Query来自一份序列、Key和Value来自另一份。例如翻译系统用正在生成的目标侧表示，读取源句编码器提供的表示。这里的两份输入是另一种结构，不能偷偷代入上面的同X公式。

Decoder是负责逐步生成后续Token的一类网络结构；Encoder是把给定输入转换成表示的一类结构。这里只认识它们的职责，具体网络结构在系统篇展开。因果读取规则来自生成任务的设计，不是英文字母Q/K/V自带的功能。

为什么需要三套表示，而不是直接拿X比较和混合

若只用原X匹配、也直接混合X，相当于限制匹配特征与被读取内容的变换方式。三套投影让模型可以分别学习“怎样接收”“怎样被匹配”“提供什么内容”。这是一种表达能力与参数量之间的设计选择，不是声称任何任务数学上都必须三张互不相同的表。

可以沿本例做两次明确分开的对照，每次都从本节基准恢复：

“份额不变”仅指当前这一次注意力分支；改变输出后，后面的层仍可能跟着变化。不能把局部对照扩大成整模型其他部分永远不受影响。

训练时，误差会沿“O→A与V→Q与K→各张W”的计算依赖传回，调整系数。到F17的梯度与F18的优化器，就会看到怎样算更新量。现在只要先区分：W保存可以学到的规则；Q/K/V保存这些规则作用在本次输入后的结果。

再进入多头、缩放和源码之前

一个头就是一套“Query/Key匹配，再混合Value”的计算路径。多头使用多组这样的路径，并把结果组合；不是模型同时开了多个聊天窗口。各头结果并排后，还可乘另一张参数表Wo，把混合结果转换回主网络需要的宽度。Wo是注意力输出投影，不是最后给词表候选打分的语言模型输出头。

除以√d_k是在控制点积分数的尺度。推导要用方差，F14会先解释这一统计量；它不是softmax的必要定义，也不是改变候选数量。为了逐步学习，本节先把它当作本例固定的缩放规则，再在Q007追问它的理由。

有些库的高级Attention接口把投影前的输入也命名为query/key/value，内部才乘W；另一些底层接口直接接收已经投影后的Q/K/V。同名不代表处于同一计算阶段。 读源码前要看接口是否负责投影，避免自己先乘一次W、库里又乘一次。PyTorch的线性层还把参数存成[输出宽度,输入宽度]并在计算时转置；本书手算采用[输入宽度,输出宽度]右乘约定，两者转置后可以表达同一变换。接口与形状依据。

以上数值使用未舍入结果继续计算；页面小数只作显示。可用本节的参数实验观察中间值，也可运行随包的concepts/verify_concepts.py复算。它验证教学算式与前提，不证明真实模型已学会中文。

课后自检

机制依据：[TR]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F12｜Mask不是黑箱：把“谁能看谁”写成一张表

从具体对象与小例子开始，理解计算过程与适用条件。

先给掩码一个不神秘的定义

Mask（掩码）是一份控制哪些元素允许参与某项运算的标记。在注意力里，一行是一个查询位置，一列是一个被读取位置。因此一个格子回答“这一行能不能读这一列”。

填充标记、注意力可读关系、训练损失计分位置都可能被称为mask，但用途不同。看见mask这个词，先问它控制什么，而不是只背一组0和1。

因果限制怎样防止读未来

三个位置0、1、2，在自回归训练和推理所用的因果注意力中，常见允许关系是：

叫“因果”是因为当前位置不能依赖尚未发生的后续Token，不是在声称模型学到了现实世界的因果关系。训练时整段答案可以一起送入；掩码限制每个位置只能利用前缀，目标通常是预测下一个Token。

填充限制与因果限制怎样合在一起

继续用第二条输入[4,2,0]。前两个位置是真实内容，第三个是PAD。对真实查询0、1，可读取列必须同时满足“不是PAD”和“不在未来”。它们的关系为：

query0 -> key0允许，key1禁止，key2禁止
query1 -> key0允许，key1允许，key2禁止

PAD查询行本身不是本次有意义的输出，不用它继续生成，也不让其预测计入正常损失。实际内核怎样避免全屏蔽行的数值问题，要遵守接口语义，不能盲目把整行都填负无穷。

批量输入还有样本边界；第0条不能因为同在一个batch就读到第1条。若将多个样本拼在一条序列中，需要另行处理跨样本可读关系，单独插一个结束Token不天然形成矩阵隔离。

“禁止”具体怎样改变softmax

一个常见数学表达是在禁止位置的分数加上负无穷，使其指数为0；允许位置加0，保留原分数，然后对一行归一化。

若先对所有位置softmax，再把禁止项清零而不重新归一化，剩余权重总和会小于1，通常不是原本要的注意力。

全行没有任何允许项时，softmax没有正常的有限候选可归一化，朴素计算可能出现NaN，即“不是有效数值”。工程实现要明确处理或避免这种行，而不是让NaN悄悄传下去。

不同API可能用布尔True表示允许，也可能表示屏蔽；也可能接受加性浮点mask。不要把本文1=允许直接当成任何库的通用布尔约定。

已有缓存时，表为什么不再是小正方形

先把缓存理解为“之前算好的中间结果”，详细内容在F16。假设已有3个历史位置，新算2个位置。这次只有2个Query，但可以读5个Key：

新位置3：[允许，允许，允许，允许，禁止]
新位置4：[允许，允许，允许，允许，允许]

因此表是[2,5]。第一行并不是只能读第一列，因为它的真实位置已经是3。规则是“Key逻辑位置不大于当前Query逻辑位置”，不是简单在一个2×5表左上角画小三角。

Loss mask又是什么

训练样本含问题与回答时，可能只给回答部分的下一Token预测计损失。loss mask决定哪些预测被评分；attention mask决定读取哪些条件。不给用户问题计损失，不意味着模型不能读用户问题。

这一差异以后用于解释训练：模型可以借助问题预测答案，即使问题本身不是本批直接评分的目标。

课后自检

机制依据：[TR][F-PADDING][F-CACHE]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F13｜位置编号与RoPE：先懂位置，再懂旋转

从具体对象与小例子开始，理解计算过程与适用条件。

Token是谁，和它出现在第几位，是两个问题

“我爱你”和“你爱我”使用类似的片段，但顺序不同。Token ID标识它是词表哪一项；position ID（位置编号）标识它在序列中的逻辑位置。

对本书的[1,2,3]，常用的位置编号是[0,1,2]。对左补齐[0,4,2]，数组列号为0、1、2，而两个真实Token的逻辑位置可以是0、1。PAD位置怎样填写由实现约定，不能用未经处理的列号替代全部位置逻辑。

位置编号不必是一段交给用户看的文本；它可能作为单独参数传入，也可能由模型代码根据输入长度和缓存推算。

为什么不能只靠查Embedding

相同Token按固定表查到同一排数。若一个没有任何位置机制的注意力系统只是对集合进行比较和聚合，它不能一般地编码所有顺序差异。因果mask提供部分先后约束，但并不能因此省掉模型设计中的位置机制。

一种方案给每个位置准备额外向量，并与Token表示相加；另一种常用机制RoPE将位置作用到Q/K上。不同模型使用不同设计，不能把两种操作拼成“所有模型先相加再旋转”。

只用平面上的点认识sin与cos

把向量[x,y]想作从原点到平面点的箭头。把箭头逆时针转90度，[1,0]变成[0,1]，[0,1]变成[-1,0]，长度不变。

角度也可用弧度表示：π弧度等于180度，π/2等于90度。cos与sin是描述旋转关系的函数；在单位圆上，旋转θ后的水平、竖直坐标分别是cosθ、sinθ。

任意二维向量的旋转公式为：

x' = x cosθ − y sinθ
y' = x sinθ + y cosθ

θ=0时cos=1、sin=0，所以不变；θ=π/2时cos=0、sin=1，所以变成[-y,x]。现在你已经能读懂RoPE最基本的二维操作，而不必先修完整三角函数课程。

RoPE怎样用位置改变匹配

RoPE可把一排特征按两个一组拆开，对不同组使用不同频率；位置越靠后，按对应频率旋转的角度就不同。例如某一组在位置m用角度mθ，在位置n用nθ。

这里新增的R不是模型的可学习投影W。 R(α)是由角度α直接构造的二维旋转矩阵：

R(α) = [[cosα, -sinα],
        [sinα,  cosα]]

本段把两个坐标写成一列，使用R乘该列；若把同一对坐标写成行向量，等价写法是右乘R(α)ᵀ。转置不能漏。α表示实际旋转角度，θ可表示每个位置增加的角度，mθ和nθ分别属于位置m、n；π在这里是圆周率，不是后训练中的策略概率符号。

旋转后的Q、K再做点积，包含与两者相对位置差有关的关系。用矩阵R表示旋转，可以写成R(mθ)ᵀ R(nθ)=R((n−m)θ)。左边是先比较两次旋转，右边说它等效包含角度差。

这不是说位置只剩距离、内容被丢掉了。原始Q和K仍在，旋转调制了内容匹配；实际公式包含它们的分量。

为什么缓存位置不能每次从0开始

前缀已经处理3个位置0、1、2，下一Token的逻辑位置应继续为3。如果把它误写为0，Q/K的旋转角会错，与缓存历史的相对关系也会错。

在典型RoPE缓存实现里，历史K可能已经按原位置旋转后保存。读取它不应再对同一份已旋转结果盲目旋转一次。缓存保存的是哪个阶段的表示，必须读具体接口约定。

位置编号、缓存槽和模型窗口不能混

缓存槽是数据存在容器中的位置；逻辑位置是Token在序列中的位置；允许上下文长度是模型或服务的限制。滑动窗口丢弃早期缓存后，逻辑位置也未必重置为0。

把上下文最大长度从32K改成128K不会自动保证模型在新长度上表现正确。位置缩放、训练长度分布、数值与任务评测都有关。这里的基础目标是读懂“位置参与哪一步”，而不是靠配置数字推断有效能力。

课后自检

机制依据：[ROPE][TR][F-CACHE]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F14｜把Attention装进一层：残差、归一化与前馈网络

从具体对象与小例子开始，理解计算过程与适用条件。

先把一层写成两段，而不是一大堆缩写

一种常见的pre-norm Decoder层可这样读：先归一化输入，再算Attention，把结果加回原输入；再归一化，经过前馈网络，再加回去。

原输入X
  -> 归一化 -> Attention -> 输出投影
  -> 与X相加，得到R
R -> 归一化 -> 前馈网络
  -> 与R相加，得到本层输出Y

pre-norm表示归一化在子层变换之前。其他架构可能使用不同位置或变体，本课给一个具体模型骨架，不声称全部网络顺序相同。

残差连接：保留一条直接通路

残差（residual）连接就是输出=输入+变换结果。输入[1,2]，本段变换结果[0.3,-0.1]，相加得到[1.3,1.9]。

这样子层可以学习在已有表示上如何调整，而不必每次从零重建一切。它也影响反向传播的通路；详细梯度在F17。相加要求维度兼容，因此Attention通常经输出投影回到原隐藏宽度d。

残差不是把“原话”保存一份中文副本，而是在数字表示上相加。

均值、方差和标准差从两个数算起

对一排数[1,3]：均值μ=(1+3)/2=2；每项偏离均值为[-1,1]；平方后[1,1]；平均得方差σ²=1；开平方得标准差σ=1。

平方是为了不让正负偏差互相抵消，方差描述波动大小。标准差与原数值有同样的量纲。这里按总体平均除以元素数，不能把其他统计场景的除以n−1不加区分地搬来。

LayerNorm实际规范化哪一排数

在典型Transformer中，对每个位置的隐藏特征独立计算均值与方差，再执行：

标准化值_i = (x_i − μ) / sqrt(σ² + ε)
输出_i = γ_i × 标准化值_i + β_i

ε是很小的正数，防止除以0等问题；γ、β是可学习的缩放与偏移参数。先忽略很小ε并设γ=1、β=0，上例[1,3]变成[-1,1]。

关键是按每个Token的特征轴计算，不是把本批所有句子所有Token一起求均值。若你改变归一化范围，模型行为和缓存可复用的前提都会改变。

RMSNorm常用均方根r=sqrt(mean(x_i²)+ε)缩放，不减均值。对[1,3]，忽略ε，r=√5，结果约[0.4472,1.3416]，与LayerNorm不同。名称都含Norm，不等于同一个操作。

FFN到底做了什么

前馈网络FFN通常对每个位置独立做“升维线性变换→非线性→降维线性变换”。例如d=4，中间宽度8，再回到4：[B,T,4]→[B,T,8]→[B,T,4]。

它不在这个步骤中直接对不同Token求和，但输入已经由Attention带入上下文，因此它能处理混合后的信息。它不是没有作用的装饰层，也不能简单认定是可按条目查询的事实数据库。

SiLU(x)=x×sigmoid(x)，其中sigmoid(x)=1/(1+exp(-x))。SwiGLU类门控结构用一个分支调节另一个分支，常含逐元素乘。这和矩阵乘不同，回看F07即可区分。

多层如何连起来

第0层输出作为第1层输入，各层通常有不同参数。每个Token位置的宽度d可以保持不变，但表示内容不断变换。深层的K/V来自深层输入，不是复制第一层缓存。

“32层、4096宽”分别描述深度与每位置宽度，不能读成32个独立聊天Agent。模型最后通常还有归一化和词表输出投影，下一课就从这里走到文字。

课后自检

机制依据：[TR]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F15｜从最后一排数到一个Token，再到一句回答

从具体对象与小例子开始，理解计算过程与适用条件。

最后一层还不是文字

网络处理完输入后，每个位置得到一排d个数。为了生成文字，要给词表每个候选打分。这一步叫输出投影或语言模型输出头。

假设最后一个有效位置的隐藏状态h=[1,2]，词表只有6项，使用一个2行6列的教学权重：

Wout = [[0,1,0,1,-1,0],
        [0,0,1,1, 0,-1]]
hWout = [0,1,2,3,-1,-2]

输入宽度2变成6个候选分数。取最大会得到编号3。这里的数字与前面字符映射都只是演示，不代表这个没有训练的网络真正理解了中文。

为什么看最后一个有效位置

自回归语言模型在一个位置上产生的是“接在此前缀之后的下一Token”分布。若输入Token为a、b、c，则c所在位置的最后表示用于预测接下来的d。

早先位置也可产生分布，但分别对应更短前缀后的预测。生成当前答案要用最后有效位置，不是任意平均所有位置。带右PAD的batch尤其要选对位置，不能无条件取数组最后一列。

Prefill和Decode只是两种运行阶段

Prefill（预填充）是处理已经给定的整段输入，生成各层所需表示及可保留的中间结果。Prefill结束时最后位置已有下一Token分数，所以可以选出第一个输出Token。

Decode（逐步解码）是把刚选出的新Token再送入模型，继续预测下一个。因为未来Token尚未选出来，后一个生成步骤依赖前一个结果。

已有输入：[a,b,c]
处理a,b,c -> 选出d
再处理d   -> 选出e
再处理e   -> 选出f

缓存可帮助“不重复处理全部历史”，但不消除生成之间的依赖。缓存内部在下一课解释。

选出来不等于已经处理过

第一步输出d时，模型刚处理过的是a、b、c；d只是从分数中选出的编号，还没有经过自己的Embedding和各层。因此如果缓存保存的是已计算Token的K/V，它此刻只覆盖3个位置，而非4个。

下一步将d作为新输入，才生成d在各层的K/V。这个一位之差决定你是否重复追加输入、是否用错位置和是否错误估计缓存长度。

生成Token与界面显示字符的关系

输出编号要通过对应分词器解回文本片段。某个Token可能对应几个字符，也可能只提供一个多字节字符的一部分。流式显示是让部分结果逐步到达界面，不代表每出现一个汉字就恰好完成一次模型计算。

网络传输也会将数据分成不固定大小的片段，F23会解释为什么半段JSON不能执行。这里先分清生成单位、文本编码单位、网络分片单位。

它怎样停止

模型可以生成特殊EOS（结束）Token；宿主也可以设置最大输出长度、停止字符串或接收取消请求。这些只是不同的停止原因，不能都读成“任务成功完成”。

例如达到输出长度上限可能截断JSON；得到工具调用意味着模型希望宿主做下一步，未必是最终回答；用户取消更不意味着工具一定没有完成副作用。

训练为什么能同时算多个位置

训练时完整样本a、b、c、d已给定，可以同时对a预测b、对ab预测c、对abc预测d，因果mask限制每个位置读取范围。这叫在已知前缀条件下并行计算训练目标，不是提前知道实际推理未来会生成什么。

读到“训练可并行、生成要顺序”时，用这个区别解释，不要以为两者使用了完全无关的语言能力。

课后自检

机制依据：[GENERATION][F-CACHE][TR]。本节数值与情景除另注外均为原创教学示例；来源不代替中文讲解。

F16｜KV Cache从零解释：为什么可以少算，又记住了什么

从具体对象与小例子开始，理解计算过程与适用条件。