---
tags: [AI, llm, 嵌入]
阶段: 05-Transformer与LLM原理
难度: ★☆☆
created: 2026-10-18
related: "[[Tokenizer与BPE]], [[位置编码-正弦与RoPE]], [[Embedding与向量检索]]"
---

# 预备知识-token与嵌入

## 定义

**词元**（token，记作 $t$）是语言模型处理的最小离散单位，取自有限集合 $\mathcal{V}$；$\mathcal{V}$ 称为**词表**（vocabulary），$V=|\mathcal{V}|$ 为词表大小；一段文本经分词器映射为 token 序列 $(t_1,\dots,t_T)$，$T$ 为序列长度；**嵌入矩阵** $\mathbf{E}\in\mathbb{R}^{V\times d}$ 是可训练参数矩阵，其第 $i$ 行 $\mathbf{e}_i=\mathbf{E}_{i,:}$ 称为第 $i$ 个 token 的**嵌入向量**（embedding），即该 token 的连续表示。

本篇符号约定如下。

| 符号 | 含义 |
|---|---|
| $t_p$ | 序列第 $p$ 个位置的 token，取值为词表中的某个下标 |
| $\mathcal{V}$、$V$ | 词表集合、词表大小 $V=\lvert\mathcal{V}\rvert$ |
| $T$ | 序列长度，即 token 个数 |
| $d$ | 嵌入维度，在 Transformer 中即 $d_{\text{model}}$ |
| $\mathbf{E}\in\mathbb{R}^{V\times d}$ | 嵌入矩阵，形状为 $V$ 行 $d$ 列 |
| $\mathbf{e}_i\in\mathbb{R}^{d}$ | $\mathbf{E}$ 的第 $i$ 行，token $i$ 的嵌入向量 |
| $\mathbf{o}_i\in\{0,1\}^{V}$ | token $i$ 的 one-hot 向量，仅第 $i$ 个分量为 1 |
| $\mathbf{X}\in\mathbb{R}^{T\times d}$ | 一条序列的嵌入输出，$\mathbf{X}_{p,:}=\mathbf{e}_{t_p}$ |
| $\mathbf{O}\in\mathbb{R}^{T\times V}$ | one-hot 堆叠矩阵，$\mathbf{O}_{p,:}=\mathbf{o}_{t_p}^{\top}$ |
| $\mathbf{h}\in\mathbb{R}^{d}$ | 某位置经若干层后的隐藏状态 |
| $\mathbf{W}_{\text{out}}\in\mathbb{R}^{d\times V}$ | 输出投影矩阵，把隐藏状态映射为词表上的 logits |
| $\mathbf{z}\in\mathbb{R}^{V}$ | logits，$\mathbf{z}=\mathbf{h}^{\top}\mathbf{W}_{\text{out}}$ |
| $L$ | Transformer 层数 |
| $d_{ff}$ | 前馈网络中间维度，通常取 $4d$ |
| $r$ | 嵌入参数占总参数的比例 |

其余术语在正文首次出现处定义：**分词器**（tokenizer）是文本到 token 序列的可逆或近似可逆映射，见 [[Tokenizer与BPE]]；**上下文窗口**是模型单次前向可处理的最大 $T$；**权重绑定**（weight tying）指输入嵌入矩阵与输出投影共享同一组参数；**位置编码**是注入位置信息的向量或变换，见 [[位置编码-正弦与RoPE]]。

## 为什么重要

神经网络的可训练部分只能处理实数张量与实数梯度。token 是离散符号，既没有定义加法，也没有定义距离，因此必须先经过一个参数化映射才能进入后续计算，嵌入层就是这个映射。去掉嵌入层会得到三种具体后果。第一种是若用 token 序号作为输入，模型被迫接受一个与语义无关的全序关系与等距假设，例如把相邻编号的两个 token 视为距离 1，这种假设没有任何数据依据，且输入尺度随 $V$ 增长。第二种是若用 one-hot 直接送入后续线性层，参数量与嵌入层相同，但前向需要 $T V d$ 次乘加并构造 $T\times V$ 的中间矩阵，计算与瞬时显存约为查表的 $V$ 倍。第三种是若用固定随机向量且不训练，表示与预测目标无关，模型无法利用 token 之间的可替换性。

嵌入层同时决定三个可量化指标。参数量上，输入嵌入占 $Vd$ 个参数，GPT-2 small 的 $50257\times 768=3.86\times10^{7}$ 占总参数 $1.24\times10^{8}$ 的 31%。计算量上，输出投影把隐藏状态映射回 $V$ 维 logits，每个 token 需 $dV$ 次乘加，在 $V=50257$、$d=768$、$L=12$、$T=1024$ 时为注意力两项 $2LTd$ 的 2.05 倍。表示能力上，嵌入维度 $d$ 与层数 $L$ 共同决定模型容量，$d$ 过小时不同 token 的行向量在训练中难以分离，$d$ 过大时稀有 token 的行只被访问少数几次，估计方差大。

在本库中的位置：本篇是 05 阶段的入口，[[Tokenizer与BPE]] 决定行索引的语义与 $V$ 的取值，[[注意力机制与QKV]] 在嵌入序列上做线性投影，[[位置编码-正弦与RoPE]] 修补嵌入缺失的位置信息，[[GPT系列架构]] 与 [[从零实现小型GPT指南]] 复用本篇的权重绑定与形状约定。对应学习目标中的「懂原理」与「能复现」：能写出查表与矩阵乘法的等价式，能在 NumPy 与 PyTorch 中实现并验证。

## 原理与推导

### 1 离散符号与连续表示的形式化要求

设文本是有限字母表上的字符串，分词后得到 token 序列。模型需要构造映射 $f:\mathcal{V}\to\mathbb{R}^{d}$，并使 $f$ 满足三条要求。

- 可微性：$f$ 由参数决定，损失对参数的梯度存在且非零，否则无法用梯度下降训练。
- 可共享性：在相似上下文中出现的 token 应获得相近的向量，使模型能用少量样本泛化到稀有 token。
- 成本可控：存储与计算随 $V$、$d$ 的增长应为线性或更低，不能出现 $V^{2}$ 级别的开销。

序号编码 $f(i)=i$ 满足可微性，但它把词表下标当作数值，隐含两条假设：$|i-j|$ 具有语义，且相邻下标语义相近。在按频率排序构造的词表中，这两条均不成立。

one-hot 编码 $\mathbf{o}_i\in\{0,1\}^{V}$ 满足可微性（作为常数输入），但违反可共享性：任意两个不同 token 的内积为 $\mathbf{o}_i^{\top}\mathbf{o}_j=\delta_{ij}$，欧氏距离恒为 $\sqrt{2}$，全部 token 彼此等距，没有任何相似结构。此外 one-hot 的维度为 $V$，若其后接一个 $d$ 维线性层，权重矩阵为 $V\times d$，与嵌入矩阵同规模，但前向必须显式构造 $T\times V$ 的中间矩阵，无法利用按行索引的稀疏访问。

嵌入矩阵把"给每个 token 分配一个可训练向量"写成矩阵形式：$\mathbf{E}$ 的第 $i$ 行即 $f(i)$。这里的参数总量为 $Vd$，与 one-hot 加线性层的第一层参数量相同，但计算与存储方式不同，下一小节给出严格等价关系。

### 2 one-hot 乘法与查表的严格等价

取 one-hot 向量 $\mathbf{o}_i\in\mathbb{R}^{V}$，其分量 $(\mathbf{o}_i)_k=1$ 当且仅当 $k=i$，否则为 0。对嵌入矩阵 $\mathbf{E}\in\mathbb{R}^{V\times d}$ 计算 $\mathbf{E}^{\top}\mathbf{o}_i$：

$$
(\mathbf{E}^{\top}\mathbf{o}_i)_{a}=\sum_{k=1}^{V}E_{k,a}(\mathbf{o}_i)_{k}=E_{i,a},\qquad a=1,\dots,d .
$$

右端正是 $\mathbf{E}$ 第 $i$ 行的第 $a$ 个分量，故

$$
\mathbf{E}^{\top}\mathbf{o}_i=\mathbf{e}_i=\mathbf{E}_{i,:}.
$$

对整条序列，把 one-hot 按行堆叠为 $\mathbf{O}\in\mathbb{R}^{T\times V}$，则

$$
\mathbf{X}=\mathbf{O}\mathbf{E}\in\mathbb{R}^{T\times d},\qquad \mathbf{X}_{p,:}=\mathbf{e}_{t_{p}} .
$$

形状链为 $(T\times V)(V\times d)\to(T\times d)$，与查表 $\mathbf{X}=\mathbf{E}[\mathbf{t}]$ 的输出形状一致，且逐元素相等。批量情形把 $T$ 换成 $(B,T)$，得到 $(B,T,V)(V,d)\to(B,T,d)$。

两个实现的计算量差异由上式直接读出。矩阵乘法需要 $T\cdot V\cdot d$ 次乘加；查表只需 $T\cdot d$ 次按行复制，不需要浮点运算。取 $T=1024$、$V=50257$、$d=768$，前者约 $3.95\times10^{10}$ 次乘加，后者约 $7.9\times10^{5}$ 次读取，相差五个数量级。存储上，one-hot 矩阵 $\mathbf{O}$ 在 fp32 下占 $1024\times50257\times4\approx206$ MB，查表不产生中间矩阵。因此工程实现一律使用查表，但推导与梯度分析使用矩阵形式更清晰。

反向传播同样等价。设 $\mathbf{G}=\partial\mathcal{L}/\partial\mathbf{X}\in\mathbb{R}^{T\times d}$，由 $\mathbf{X}=\mathbf{O}\mathbf{E}$ 得

$$
\frac{\partial\mathcal{L}}{\partial\mathbf{E}}=\mathbf{O}^{\top}\mathbf{G}
=\sum_{p=1}^{T}\mathbf{o}_{t_{p}}\mathbf{G}_{p,:},
$$

其第 $k$ 行为

$$
\frac{\partial\mathcal{L}}{\partial\mathbf{E}_{k,:}}=\sum_{p:\,t_{p}=k}\mathbf{G}_{p,:}.
$$

该式说明两件事。第一，梯度只累加到本批次出现过的行上，其余行梯度为零，反向是稀疏的；NumPy 中对应 `np.add.at(dE, ids, dout)`，PyTorch 中对应嵌入层的稀疏梯度语义。第二，同一个 token 在一批中出现多次时，其梯度是各次贡献之和，因此高频 token 的有效学习率高于低频 token。

参数量与显存可一并算出。$V=50257$、$d=768$ 时 $Vd=3.86\times10^{7}$。fp32 权重占 154 MB，梯度再占 154 MB，Adam 的一阶与二阶矩各占 154 MB，合计约 617 MB，仅嵌入层一项。这是小显存设备上词表大小成为硬约束的直接原因。

### 3 嵌入维度的选择

在 Transformer 中嵌入维度等于模型维度 $d=d_{\text{model}}$，并与注意力头数 $n_{\text{head}}$、每头维度 $d_{\text{head}}$ 满足

$$
d=n_{\text{head}}\cdot d_{\text{head}},\qquad d_{\text{head}}\in[64,128].
$$

$d$ 不能独立于层数与词表任意选取，因为它同时进入参数量、计算量与残差流的数值范围。先给出参数量的分解。忽略偏置与归一化参数，单个 Transformer 层包含四个 $d\times d$ 的注意力投影 $\mathbf{W}_{Q},\mathbf{W}_{K},\mathbf{W}_{V},\mathbf{W}_{O}$ 与两层前馈 $\mathbf{W}_{1}\in\mathbb{R}^{d\times d_{ff}}$、$\mathbf{W}_{2}\in\mathbb{R}^{d_{ff}\times d}$，取 $d_{ff}=4d$ 时

$$
P_{\text{layer}}=4d^{2}+2\cdot d\cdot 4d=12d^{2}.
$$

总参数量为

$$
N\approx 12Ld^{2}+Vd\quad(\text{权重绑定}),\qquad N\approx 12Ld^{2}+2Vd\quad(\text{不绑定}).
$$

嵌入占比 $r=Vd/N$ 可化为

$$
r=\frac{Vd}{12Ld^{2}+Vd}=\frac{V}{12Ld+V}.
$$

该式关于 $L$ 与 $d$ 单调递减，说明权重绑定与小维度模型关系最大，在大模型上几乎不影响参数总量。下表用该式核对三个公开配置，误差在 3% 以内。

| 模型 | $V$ | $d$ | $L$ | $12Ld^{2}$ | $Vd$ | 合计 | $r$ |
|---|---|---|---|---|---|---|---|
| GPT-2 small | 50257 | 768 | 12 | $8.49\times10^{7}$ | $3.86\times10^{7}$ | $1.24\times10^{8}$ | 31.2% |
| GPT-2 medium | 50257 | 1024 | 24 | $3.02\times10^{8}$ | $5.15\times10^{7}$ | $3.54\times10^{8}$ | 14.5% |
| Llama-2 7B | 32000 | 4096 | 32 | $6.44\times10^{9}$ | $1.31\times10^{8}$ | $6.57\times10^{9}$ | 2.0% |

Llama-2 行的合计与论文报告的 6.7B 相差约 2%，来源是 SwiGLU 前馈使用三个矩阵且 $d_{ff}=11008$ 而非 $4d$，以及归一化层参数；这不影响 $r$ 的量级结论。

维度选择的经验约束有三条。第一，$d_{\text{head}}$ 取 64 至 128，低于 64 时每个头的投影维度过小，注意力分数估计方差偏大；高于 128 时单头参数增多而头数减少，损失多头提供的子空间多样性。第二，$d/L$ 的比值在常见配置中落在 64 至 128：GPT-2 small 为 $768/12=64$，GPT-3 为 $12288/96=128$，Llama-2 7B 为 $4096/32=128$；该比值过小意味着层数相对宽度过多，残差流容量不足。第三，$Vd$ 不应在小模型上超过总参数的约三分之一，否则嵌入层吸收了本应分配给注意力的容量。

$d$ 过小的具体后果是不同 token 的行向量在 $d$ 维空间中夹角分辨率不足，余弦相似度的估计方差随 $d$ 减小而增大，稀有 token 与高频 token 的表示难以分离。$d$ 过大的具体后果是每个嵌入行在训练中获得的更新次数相对减少，$Vd$ 参数中大部分行的梯度累积步数不足，验证集上表现为稀有 token 的损失下降缓慢。

### 4 嵌入向量的语义结构

嵌入矩阵的训练信号来自下一 token 预测，没有任何项直接约束余弦相似度，但余弦相似度仍呈现稳定结构，原因是可替换性：两个 token 若出现在相似上下文中，将它们互换对损失的改变相近，梯度方向也相近，因而行向量趋同。

余弦相似度定义为

$$
\cos(\mathbf{e}_i,\mathbf{e}_j)=\frac{\mathbf{e}_i^{\top}\mathbf{e}_j}{\lVert\mathbf{e}_i\rVert_{2}\lVert\mathbf{e}_j\rVert_{2}}\in[-1,1].
$$

它对向量长度不敏感，只度量方向。若先做 $L_{2}$ 归一化 $\hat{\mathbf{e}}_i=\mathbf{e}_i/\lVert\mathbf{e}_i\rVert_{2}$，则 $\cos=\hat{\mathbf{e}}_i^{\top}\hat{\mathbf{e}}_j$，内积与余弦等价，这是检索系统统一归一化的原因，见 [[Embedding与向量检索]]。余弦与欧氏距离的关系为

$$
\lVert\hat{\mathbf{e}}_i-\hat{\mathbf{e}}_j\rVert_{2}^{2}=2-2\cos(\mathbf{e}_i,\mathbf{e}_j),
$$

故单位化后最小化欧氏距离与最大化余弦相似度是同一优化问题。

需要区分的三种结构。其一，各向异性：训练后的嵌入常集中在一个窄锥内，随机取两个 token 的余弦均值显著大于 0，因此不能把余弦 0.5 解释为"中等相似"，跨模型比较余弦值没有意义；常用处理是减去均值向量后再度量。其二，线性类比：静态词向量上存在 $\mathbf{e}_{\text{king}}-\mathbf{e}_{\text{man}}+\mathbf{e}_{\text{woman}}\approx\mathbf{e}_{\text{queen}}$ 的近似关系，该性质来自共现统计的低秩结构，在 LLM 的输入嵌入上弱于 word2vec，且对归一化方式敏感。其三，上下文无关：$\mathbf{E}$ 每个 token 类型只有一行，同一个词在不同句子中得到完全相同的输入向量，消歧发生在上层注意力与前馈中，见 [[Transformer架构详解]]。

因此准确的说法是：输入嵌入编码 token 类型的身份与可替换性，隐藏状态编码该次出现的语境含义。把输入嵌入直接当作词义表示，会在多义词与长距离依赖上产生系统性误差。

### 5 输入嵌入与输出投影的权重绑定

未绑定时，输出层把隐藏状态映射为词表上的 logits：

$$
\mathbf{z}=\mathbf{W}_{\text{out}}^{\top}\mathbf{h}+\mathbf{b},\qquad \mathbf{W}_{\text{out}}\in\mathbb{R}^{d\times V},
$$

其中 $\mathbf{h}\in\mathbb{R}^{d}$ 为最后一层隐藏状态，$\mathbf{b}\in\mathbb{R}^{V}$ 为偏置。softmax 后得到下一个 token 的分布。输入侧参数为 $Vd$，输出侧参数为 $Vd$，合计 $2Vd$。

权重绑定取 $\mathbf{W}_{\text{out}}=\mathbf{E}^{\top}$，两侧共享同一组 $Vd$ 个参数。此时第 $i$ 个 token 的 logit 为

$$
z_{i}=\mathbf{h}^{\top}\mathbf{e}_i+b_{i},
$$

即"用输出侧隐藏状态与候选 token 的输入嵌入做内积"。这一形式给出两条可检验的性质。对称性：写入与读出使用同一方向，token 的表示在输入端与输出端一致。低秩约束：绑定时 $\mathbf{z}=\mathbf{E}\mathbf{h}+\mathbf{b}$，全部 logits 落在 $\mathbf{E}$ 的列空间内，维数不超过 $d$；当 $d<V$ 时这是实质性限制。

梯度上，绑定的参数接收两条路径的贡献。输入路径由第 2 节给出，只覆盖本批次出现的 token；输出路径为

$$
\frac{\partial\mathcal{L}}{\partial\mathbf{E}}\bigg|_{\text{out}}
=\left(\frac{\partial\mathcal{L}}{\partial\mathbf{W}_{\text{out}}}\right)^{\top}
=\mathbf{g}\mathbf{h}^{\top},\qquad \mathbf{g}=\frac{\partial\mathcal{L}}{\partial\mathbf{z}}\in\mathbb{R}^{V},
$$

其中 $\mathbf{g}\mathbf{h}^{\top}$ 是 $V\times d$ 的外积。softmax 与交叉熵使 $\mathbf{g}$ 的每个分量一般非零，因此输出路径对全部 $V$ 行都是稠密更新，恰好补偿输入路径的稀疏性。这是绑定在优化上的作用，与省参数是两件独立的事。

参数节省量为 $Vd$。由第 3 节的 $r$ 可知其相对意义随规模下降：GPT-2 small 省下 31% 的参数，Llama-2 7B 只省下 2%。因此绑定主要影响中小模型与词表很大的模型；部分大模型选择解绑，用额外的 $Vd$ 参数换取输出侧独立的投影方向。

### 6 位置信息的缺失

设 $\mathbf{P}\in\{0,1\}^{T\times T}$ 为置换矩阵，满足 $\mathbf{P}^{\top}\mathbf{P}=\mathbf{I}$，对输入 $\mathbf{X}$ 左乘即重排序列顺序。无掩码自注意力的打分为

$$
\mathbf{S}=\mathbf{X}\mathbf{W}_{Q}\mathbf{W}_{K}^{\top}\mathbf{X}^{\top}\in\mathbb{R}^{T\times T}.
$$

代入 $\mathbf{P}\mathbf{X}$ 得

$$
\mathbf{S}'=\mathbf{P}\mathbf{X}\mathbf{W}_{Q}\mathbf{W}_{K}^{\top}\mathbf{X}^{\top}\mathbf{P}^{\top}=\mathbf{P}\mathbf{S}\mathbf{P}^{\top}.
$$

softmax 按行归一化。$\mathbf{P}\mathbf{S}\mathbf{P}^{\top}$ 的第 $p$ 行是 $\mathbf{S}$ 第 $\pi(p)$ 行的相应列置换，行内归一化的分母随之置换，故

$$
\mathrm{softmax}(\mathbf{P}\mathbf{S}\mathbf{P}^{\top})=\mathbf{P}\,\mathrm{softmax}(\mathbf{S})\,\mathbf{P}^{\top}.
$$

输出为

$$
\mathbf{P}\,\mathrm{softmax}(\mathbf{S})\,\mathbf{P}^{\top}\cdot\mathbf{P}\mathbf{X}\mathbf{W}_{V}
=\mathbf{P}\,\mathrm{softmax}(\mathbf{S})\,\mathbf{X}\mathbf{W}_{V},
$$

即输出等于原输出左乘 $\mathbf{P}$。前馈网络与 LayerNorm 均逐位置作用，残差连接保持该性质，故整个无掩码 Transformer 块对输入序列**置换等变**：重排输入只导致输出同样重排，模型无法区分 $(a,b,c)$ 与 $(c,a,b)$。

因果掩码破坏严格的置换等变，因为掩码固定了"每个位置可见的前缀长度"，顺序通过可见集合间接进入。但掩码不提供绝对位置索引，也不提供位置之间的可学习距离，模型无法表达"相距 3 个 token"这类关系。位置信息必须由外部注入：正弦或可学习位置嵌入加到 $\mathbf{X}$ 上，或 RoPE 直接作用于注意力中的 $\mathbf{Q}$ 与 $\mathbf{K}$，见 [[位置编码-正弦与RoPE]]。原始 Transformer 在加位置编码前把 token 嵌入乘以 $\sqrt{d}$，使嵌入与位置向量的尺度匹配；这一细节在 Pre-LN 结构中影响减弱，但在 Post-LN 结构中影响残差流的方差。

## 关键直觉

> [!tip] 嵌入层是可训练的查找表：前向等价于 one-hot 矩阵乘法，反向等价于按索引把梯度累加到被访问的行。它用行索引编码 token 的同一性，用行向量的内积编码 token 之间的可替换性；语义结构不是设计目标，而是下一 token 预测在训练中塑造的副产品。该表述与第 2 节的等价式、第 5 节的双路径梯度严格对应：查表给出前向的精确等价，按索引累加给出反向的精确等价。

## 例子与代码

以下代码在 NumPy 2.3.5 与 Python 3.13 下运行，输出为实际打印结果。

### 例 1：验证 one-hot 乘法与查表逐元素相等

构造 $V=5$、$d=3$ 的小矩阵，取三个 token 编号，分别用查表与矩阵乘法计算同一条序列的嵌入。

```python
import numpy as np

V, d = 5, 3                       # 词表大小 5，嵌入维度 3
E = np.array([[1., 2., 2.],       # 第 0 行
              [2., 4., 4.],       # 第 1 行：与第 0 行同向，长度为其两倍
              [1., 0., 0.],
              [0., 1., 0.],
              [1., 1., 0.]])
ids = np.array([2, 0, 4])         # 三个 token 的编号，即 E 的行索引

O = np.zeros((len(ids), V))       # one-hot 堆叠矩阵，形状 (3, 5)
O[np.arange(len(ids)), ids] = 1.0
lookup = E[ids]                   # 查表，形状 (3, 3)
matmul = O @ E                    # 矩阵乘法，形状 (3, 3)
print(O.shape, lookup.shape, matmul.shape)
print(np.array_equal(lookup, matmul), np.abs(lookup - matmul).max())
```

```text
(3, 5) (3, 3) (3, 3)
True 0.0
```

这段代码做三件事：构造 one-hot 矩阵、用两种方式取嵌入、比较结果。`O @ E` 的形状链是 $(3\times5)(5\times3)\to(3\times3)$，与 `E[ids]` 一致；`np.array_equal` 判断逐元素相等，`max` 报告最大绝对误差为 0。去掉 one-hot 矩阵改用查表，结果不变但不再构造 $T\times V$ 的稠密中间量；保留矩阵形式的意义在于它把梯度推导化为普通矩阵乘法，便于验证第 2 节的公式。

### 例 2：反向传播的稀疏性

把上游梯度设为 $3\times3$ 的等差矩阵，比较按索引累加与 one-hot 转置乘法的结果。

```python
import numpy as np

E = np.array([[1., 2., 2.], [2., 4., 4.], [1., 0., 0.], [0., 1., 0.], [1., 1., 0.]])
ids = np.array([2, 0, 4])
O = np.eye(5)[ids]                        # one-hot 堆叠矩阵，与例 1 的构造相同
dout = np.arange(1., 10.).reshape(3, 3)   # 上游传回的梯度，形状同 X
dE_lookup = np.zeros_like(E)
np.add.at(dE_lookup, ids, dout)           # 按索引把整行梯度累加
dE_matmul = O.T @ dout                    # one-hot 转置乘法
print(dE_lookup)
print(np.allclose(dE_lookup, dE_matmul))
print((np.abs(dE_lookup).sum(axis=1) > 0).sum())   # 非零行的数量
```

```text
[[4. 5. 6.]
 [0. 0. 0.]
 [1. 2. 3.]
 [0. 0. 0.]
 [7. 8. 9.]]
True
3
```

`ids=[2,0,4]` 决定了只有第 0、2、4 行被写入，第 1、3 行保持为零。第 0 行的值来自 `dout` 的第 2 行，因为 token 0 位于序列第 2 个位置，这正是 $\partial\mathcal{L}/\partial\mathbf{E}_{k,:}=\sum_{p:t_{p}=k}\mathbf{G}_{p,:}$ 的逐元素体现。若把 `np.add.at` 换成 `dE_lookup[ids] = dout`，当同一 token 在序列中重复出现时后写覆盖前写，梯度会丢失，这是实现嵌入反向时最常见的错误。

### 例 3：余弦相似度矩阵

对同一个嵌入矩阵逐行归一化后计算 $5\times5$ 余弦矩阵。

```python
import numpy as np

E = np.array([[1., 2., 2.], [2., 4., 4.], [1., 0., 0.], [0., 1., 0.], [1., 1., 0.]])
S = E / np.linalg.norm(E, axis=1, keepdims=True)   # 逐行 L2 归一化
C = S @ S.T                                       # 余弦相似度矩阵
print(np.round(C, 3))
```

```text
[[1.    1.    0.333 0.667 0.707]
 [1.    1.    0.333 0.667 0.707]
 [0.333 0.333 1.    0.    0.707]
 [0.667 0.667 0.    1.    0.707]
 [0.707 0.707 0.707 0.707 1.   ]]
```

第 0 行与第 1 行的余弦为 1，尽管长度分别为 3 与 6，说明余弦只反映方向；第 2 行与第 3 行正交，余弦为 0；第 0 行与第 4 行为 $3/(3\sqrt{2})\approx0.707$，等于夹角 $45^{\circ}$ 的余弦。去掉逐行归一化直接算 $\mathbf{E}\mathbf{E}^{\top}$，得到的是内积而非余弦，第 0 行与第 1 行的值会变成 18，不再是可比尺度。

### 例 4：PyTorch 的形状与权重绑定

以下代码需 PyTorch 2.0 及以上，未在本机安装，输出为按定义可预期的形状。

```python
import torch
import torch.nn as nn

emb = nn.Embedding(50257, 768, padding_idx=0)     # 内部权重形状 (V, d)
ids = torch.tensor([[1, 42, 999], [7, 8, 0]])     # (B, T) 的 int64
x = emb(ids)
print(x.shape)           # torch.Size([2, 3, 768])
print(emb.weight.shape)  # torch.Size([50257, 768])

class TinyLM(nn.Module):
    def __init__(self, vocab_size=50257, d_model=768):
        super().__init__()
        self.token_emb = nn.Embedding(vocab_size, d_model)
        self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
        self.lm_head.weight = self.token_emb.weight   # 绑定：共享同一个 Parameter

m = TinyLM()
logits = m.lm_head(m.token_emb(ids))
print(logits.shape)                              # torch.Size([2, 3, 50257])
print(sum(p.numel() for p in m.parameters()))    # 38597376 = 50257 * 768
```

`nn.Embedding` 的前向就是 `weight[input]`，参数形状为 $(V,d)$，输入 $(B,T)$ 的 int64 张量输出 $(B,T,d)$。`padding_idx=0` 使第 0 行初始化为零且梯度为零，但它不会自动阻止注意力关注 padding 位置，掩码需在注意力中单独处理。`lm_head.weight = token_emb.weight` 把两个模块指向同一个 `Parameter` 对象，`parameters()` 会去重，因此参数量正好是 $50257\times768=38597376$ 而不是两倍；若改为赋值 `lm_head.weight.data = token_emb.weight.data`，两个张量数值相同但仍是不同参数，优化器会分别更新，绑定失效。`logits` 的形状为 $(B,T,V)$，与词表大小同阶，这是大词表模型显存峰值常出现在输出层的原因。

## 易错点

> [!warning] 以下六条均可在代码或形状推导中直接检验。
> 1. 把 $\mathbf{E}$ 的形状写成 $(d,V)$：取出一个 token 会得到 $V$ 维向量，后续所有形状推导错误。正确形状为 $(V,d)$，行索引是 token id。
> 2. 认为 `nn.Embedding` 有独立的前向语义：它就是 `weight[input]`，等价于 one-hot 乘法；`padding_idx` 只把该行置零并屏蔽其梯度，不产生注意力掩码。
> 3. 用 token 序号整数作为输入特征：引入与语义无关的序关系与等距假设，且输入尺度随词表大小变化，不同模型间不可比。
> 4. 认为权重绑定只省参数：绑定同时改变函数形式（logit 为隐藏状态与输入嵌入的内积）与梯度路径（输出路径对全部 $V$ 行稠密更新），会改变优化动态。
> 5. 把输入嵌入当作上下文相关的语义表示：同一 token 在任何位置得到相同输入向量，语境信息在隐藏层产生；跨模型比较余弦值也无效，因为各向异性程度不同。
> 6. 认为未被访问的嵌入行在 AdamW 下保持初始值：梯度张量为稠密、零梯度行的自适应步长为零，但解耦权重衰减仍按 $p\leftarrow p(1-\eta\lambda)$ 作用于这些行，长时间训练后它们会向零收缩。

## 关联笔记

- 前置 [[Tokenizer与BPE]]：嵌入矩阵的行索引由分词器定义，词表大小 $V$ 与切分粒度直接决定本篇的参数量与序列长度。
- 后续 [[位置编码-正弦与RoPE]]：第 6 节证明无掩码注意力对置换等变，位置信息必须外部注入，该篇给出正弦编码与 RoPE 的推导。
- 后续 [[注意力机制与QKV]]：注意力在嵌入序列 $\mathbf{X}\in\mathbb{R}^{T\times d}$ 上做三次线性投影，本篇的形状约定是该篇推导的起点。
- 对照 [[Embedding与向量检索]]：第 4 节的余弦相似度与归一化在检索系统中被直接使用，但检索向量通常来自上下文化编码器而非输入嵌入。
- 复现 [[从零实现小型GPT指南]]：`nn.Embedding` 与 `lm_head` 共享参数是该项目的必要实现细节，参数量核对以本篇第 3 节公式为准。

## 达标检测

- [ ] 写出 $\mathbf{E}$、$\mathbf{O}$、$\mathbf{X}$ 的形状，并给出批量情形 $(B,T,V)(V,d)\to(B,T,d)$ 的完整形状链。
- [ ] 不查资料推出 $\partial\mathcal{L}/\partial\mathbf{E}=\mathbf{O}^{\top}\mathbf{G}$，说明为什么只有部分行非零，并写出等价的 `np.add.at` 调用。
- [ ] 取 $V=50257$、$d=768$、$L=12$，计算 $12Ld^{2}$、$Vd$ 与 $r$，与 31.2% 的误差不超过 1 个百分点。
- [ ] 写出权重绑定的输入路径与输出路径梯度，说明输出路径为何对全部 $V$ 行稠密，并解释它与省参数是两件独立的事。
- [ ] 证明无掩码自注意力满足 $\mathrm{Attn}(\mathbf{P}\mathbf{X})=\mathbf{P}\,\mathrm{Attn}(\mathbf{X})$，并说明因果掩码破坏了哪一步。
- [ ] 用 NumPy 验证 one-hot 乘法与查表逐元素相等，报告最大绝对误差，并解释两者计算量相差的数量级。
- [ ] 指出用 token 序号作为输入的三条具体后果，并给出对应的替代方案。

## 参考来源

- d2l.ai《动手学深度学习》第 14 章「自然语言处理：预训练」中的词嵌入部分 —— 对应本篇第 4 节分布假设、余弦相似度与词类比。
- Raschka, *Build a Large Language Model (From Scratch)*, 2024, 第 2 章 —— 对应 token 到 id 的映射、`nn.Embedding` 的输入输出形状与嵌入层参数量的核对方法。
- Mikolov et al., "Efficient Estimation of Word Representations in Vector Space", arXiv:1301.3781 —— 对应本篇第 4 节嵌入向量的线性结构与相似度性质。
- Radford et al., "Language Models are Unsupervised Multitask Learners", 2019 —— 对应 50257 词表规模与输入输出嵌入绑定的工程选择。
- Vaswani et al., "Attention Is All You Need", arXiv:1706.03762 —— 对应本篇第 6 节嵌入缩放 $\sqrt{d}$ 与位置编码引入的动机。
- PyTorch 官方文档 `torch.nn.Embedding` —— 对应 `padding_idx` 语义、权重形状与前向等价于索引操作。
