【LLM表示基础】Embedding Lookup：神经网络如何“理解“一个词

在 NLP 模型中，输入的第一步几乎都是同一个操作—把离散的词语变成连续的向量，这个操作就是 Embedding Lookup。它看起来简单，但理解它的本质，是读懂 Transformer、GPT、BERT 等一切语言模型的前提。

一、从一个最基本的问题出发

​ 神经网络只能处理数值，不能直接处理"apple"，"banana"这样的文本。那么，怎样把一个词交给神经网络？

​ 最直觉的方案是给每个词分配一个编号（索引），然后通过某种方式，把编号转换成一组浮点数向量——这组向量就是词的 embedding，而"通过索引取出向量"这个动作，就是 Embedding Lookup。

二、直观理解：Embedding Lookup 在做什么？

​ 假设我们有一个包含 4 个词的词表：

["apple", "banana", "orange", "fruit"]

​ 同时，我们维护一个 embedding 矩阵，每一行对应一个词的向量表示：

索引	词	embedding 向量 (示例)
0	apple	[0.1, 0.3, 0.5]
1	banana	[0.2, 0.4, 0.6]
2	orange	[0.3, 0.5, 0.7]
3	fruit	[0.0, 0.1, 0.2]

​ 当模型遇到 "banana" 时，它不关心这个字符串本身，只关心它的索引 $1$。Embedding Lookup 做的事情就是：拿着索引 1，去矩阵里取第 1 行，返回 $[0.2,0.4,0.6]$。

​ 简单说，embedding lookup 就是用词的索引去查 embedding 表，然后返回对应的向量。你可以把 embedding 矩阵想象成一本"词向量字典"—Embedding Lookup 就是翻到某一页，把对应的向量抄出来。

三、形式化定义

3.1 数学视角

​ 设词表大小为 $V$，embedding 维度为 $D$，则 embedding 矩阵定义为：
$$E\in {\mathbb{R}}^{V\times D}$$
​ 对于输入词 $w_i$（索引为 $i$），Embedding Lookup 的操作为：
$$\text{Embedding Lookup}(i)=E[i,:]\in {\mathbb{R}}^D$$
​ 以上面的例子为例：
$$E=\left[\begin{array}{ccc}0.1& 0.3& 0.5\\ 0.2& 0.4& 0.6\\ 0.3& 0.5& 0.7\\ 0.0& 0.1& 0.2\end{array}\right]\in {\mathbb{R}}^{4\times 3}$$
​ 查找 "banana"（索引 1）：
$$E[1,:]=[0.2,0.4,0.6]$$
​ 本质上，这就是一次矩阵的行索引操作，没有任何乘法或加法。

​ 虽然前向只是索引，但在反向传播时，梯度会精确回传到被查到的那一行 embedding 向量上，因此 embedding 矩阵可以被逐行高效地学习。

3.2 PyTorch实现

​ 在代码层面，这通常就是一次矩阵索引：

import torch

# 假设词表大小为 4，embedding 维度为 3
embedding_matrix = torch.tensor([
    [0.1, 0.3, 0.5],
    [0.2, 0.4, 0.6],
    [0.3, 0.5, 0.7],
    [0.0, 0.1, 0.2]
])

# 输入词索引
word_index = torch.tensor([1])  # banana
embedding_vector = embedding_matrix[word_index]  

​ 输出即为：

[0.2, 0.4, 0.6]

四、Embedding Lookup 与 One-Hot 编码的关系

4.1 从 One-Hot 到 Embedding

​ 在深度学习早期，更常见的做法是：

1. 先将词编码为 one-hot 向量

2. 再通过矩阵乘法映射到低维空间。

   以 "banana" 为例：

Step 1：构造 one-hot 列向量
$$\mathbf{x}=\left[\begin{array}{c}0\\ 1\\ 0\\ 0\end{array}\right]$$
Step 2：计算 $E^{\top }\mathbf{x}$
$$E^{\top }\mathbf{x}=\left[\begin{array}{cccc}0.1& 0.2& 0.3& 0.0\\ 0.3& 0.4& 0.5& 0.1\\ 0.5& 0.6& 0.7& 0.2\end{array}\right]\left[\begin{array}{c}0\\ 1\\ 0\\ 0\end{array}\right]=\left[\begin{array}{c}0.2\\ 0.4\\ 0.6\end{array}\right]$$
​ 结果和直接 lookup 完全一致——因为 one-hot 向量中只有一个 1，$E^{\top }\mathbf{x}$ 实际上就是从 $E^{\top }$ 中"选出"对应的一列（等价于 $E$ 的对应行）。

• 这是线性代数的基本性质：矩阵右乘一个 one-hot 列向量 $e_i$，结果就是取出该矩阵的第 $i$ 列。

$$A,e_i=A_{:,i}$$

所以 $E^\top e_i$ 取出的是 $E^\top$ 的第 $i$ 列，而 $E^\top$ 的第 $i$ 列就是 $E$ 的第$i$ 行——正好就是第 $i$ 个词的 embedding 向量。

4.2 为什么不用 One-Hot？

​ 既然结果等价，为什么要用 Embedding Lookup 替代 one-hot 乘法？看一组对比：

	One-Hot + 矩阵乘法	Embedding Lookup
空间	需构造 $V$ 维稀疏向量	仅需一个整数索引
计算量	$O(V\times D)$	$O(1)$
实际操作	大量"乘以 0"的无效计算	直接定位目标行

​ 特别地，当词表规模达到 5 万（GloVe）、3 万（BERT WordPiece）甚至 15 万（GPT-2 BPE）时，为每个 token 构造一个数万维的稀疏向量再做矩阵乘法，显然是不可接受的浪费。Embedding Lookup 是对这一过程的等价简化。

五、 PyTorch 中的 nn.Embedding

​ 理解了原理之后，来看实际代码。PyTorch 提供了 nn.Embedding 模块来封装整个 lookup 过程。

5.1 基本用法

import torch
import torch.nn as nn

# 创建 embedding 层：词表大小 10000，向量维度 256
embed = nn.Embedding(num_embeddings=10000, embedding_dim=256)

​ 这行代码在内部创建了一个 shape 为 (10000, 256) 的 embedding 矩阵，每一行对应词表中一个词的 256 维向量。

5.2 input_ids的含义

​ 在 NLP 中，文本需要先经过 分词 + 编码 才能输入模型。假设我们有两个句子：

句子 1: "I love deep learning"  →  分词后  →  ["I", "love", "deep", "learning"]
句子 2: "AI is fun <PAD>"       →  分词后  →  ["AI", "is", "fun", "<PAD>"]

​ 每个词在词表中有一个唯一索引（由 tokenizer 查表得到），于是两个句子变成两行整数：

# 每个数字是该词在词表中的索引，不是词本身
# 一行 = 一个句子，一列 = 一个位置
input_ids = torch.tensor([
    [12, 345, 6789, 0],     # "I"=12, "love"=345, "deep"=6789, "learning"=0
    [42, 7,   999,  3]      # "AI"=42, "is"=7, "fun"=999, "<PAD>"=3
])
# shape: (2, 4) — 2 个句子，每个句子 4 个词

5.3 批量Lookup 过程

​ 把 input_ids 传入 embedding 层，每个整数索引会被替换为对应的 256 维向量：

vectors = embed(input_ids)  # shape: (2, 4, 256)

​ shape 变化：(2, 4) → (2, 4, 256)，即 (batch_size, seq_len) → (batch_size, seq_len, embed_dim)。

​ 展开来看，这一步等价于：

# 对 input_ids 中的每个索引，分别去 embedding 矩阵查一行
vectors[0][0] = embed.weight[12]    # "I" 的向量
vectors[0][1] = embed.weight[345]   # "love" 的向量
vectors[0][2] = embed.weight[6789]  # "deep" 的向量
vectors[0][3] = embed.weight[0]     # "learning" 的向量
vectors[1][0] = embed.weight[42]    # "AI" 的向量
# ... 以此类推

​ 本质上就是对每个位置做了一次 Embedding Lookup，只不过 nn.Embedding 帮我们批量完成了。

5.4 其他实用功能

• 权重自动初始化：embed.weight 是一个 (V, D) 的 nn.Parameter，创建时随机初始化，训练过程中随模型一起更新。

• padding_idx：可以指定某个索引为填充符号，其向量始终为零向量且不参与梯度更新：

  embed = nn.Embedding(num_embeddings=10000, embedding_dim=256, padding_idx=0)
  # index 0 的向量永远是 [0, 0, ..., 0]，且不会被训练更新
  

• 加载预训练权重：可以用 Word2Vec、GloVe 等预训练向量初始化 embedding 矩阵：

  pretrained_vectors = ...  # shape: (V, D) 的 Tensor
  embed = nn.Embedding.from_pretrained(pretrained_vectors, freeze=False)
  # freeze=False 表示微调时继续更新，freeze=True 则冻结权重
  

六、Embedding Lookup 在哪里被使用？

​ Embedding Lookup 不仅仅用于 word embedding，它几乎出现在所有需要将离散 ID 映射为连续向量的场景中：

场景	输入	Embedding 矩阵
词嵌入（Word Embedding）	词/token 的索引	词向量矩阵
位置编码（Positional Embedding）	位置索引 0, 1, 2, …	位置向量矩阵
Token Type Embedding（BERT）	句子类型 0 或 1	类型向量矩阵
推荐系统	用户/物品 ID	用户/物品向量矩阵
图神经网络	节点 ID	节点特征矩阵

​ 在 BERT 中，一个 token 的输入表示就是三次 Embedding Lookup 的结果之和：
$${\mathbf{h}}_i=E_{\text{token}}[t_i]+E_{\text{position}}[i]+E_{\text{segment}}[s_i]$$

​ 可以理解为：“这个词是什么 + 它在第几个位置 + 它属于哪句话”

七、总结

• Embedding Lookup：用索引从 embedding 表中查找向量

• 是 NLP、推荐系统、GNN 中最基础也最关键的操作

• 本质是索引，但梯度可以精确回传

• 是 One-Hot + 矩阵乘法的高效等价形式

  理解 Embedding Lookup，等于真正迈进了深度学习处理离散符号的世界。