词嵌入 (Word Embedding)

📌 核心定义 (What)

一句话定义：词嵌入 (Word Embedding) 是将离散的文字（如”猫”、“狗”）转换为连续的数字向量的技术。这些向量能够捕捉词语之间的语义关系。

计算机只认识数字，不认识文字。词嵌入就是文字到数字的翻译器。

🏠 生活类比 (Analogy)

🗺️ “语义地图”

想象一张巨大的城市地图：

北京在地图的某个位置 [116.4, 39.9]（经纬度）
上海在另一个位置 [121.5, 31.2]
纽约在 [-74.0, 40.7]

地理上接近的城市，坐标也接近。

词嵌入就是给词语分配”语义坐标”：

“猫” → [0.2, 0.8, -0.1, ...]（512 维向量）
“狗” → [0.3, 0.7, -0.2, ...]（和猫很接近！）
“汽车” → [-0.5, 0.1, 0.9, ...]（和猫狗很远）

神奇的是：向量运算能反映语义关系！

国王 - 男人 + 女人 ≈ 王后
北京 - 中国 + 日本 ≈ 东京

💻 JS 开发者类比

// ❌ One-Hot 编码（原始方法）
// 假设词汇表有 10000 个词
const cat = [1, 0, 0, 0, ..., 0];  // 第 1 位是 1，其余 9999 位是 0
const dog = [0, 1, 0, 0, ..., 0];  // 第 2 位是 1

// 问题：
// 1. 向量太长（10000 维）
// 2. 无法表示"猫和狗很像"（向量正交，点积为 0）

// ✅ Word Embedding（现代方法）
// 把 10000 维压缩成 512 维，且保留语义
const cat = [0.2, 0.8, -0.1, 0.5, ...];  // 512 维
const dog = [0.3, 0.7, -0.2, 0.4, ...];  // 和 cat 很接近

// 计算相似度
const similarity = dotProduct(cat, dog);  // 接近 1 = 很相似

🎬 视频详解 (Video)

🗺️ 交互演示：词嵌入空间 (Interactive)

探索词向量在语义空间的分布，体验 “国王 - 男人 + 女人 ≈ 王后” 的神奇运算。

🗺️ 词嵌入空间可视化

动物

食物

交通

地点

皇室

人物

🎯 与「猫」最相似的词:

鱼 (100%)狗 (100%)鸟 (99%)

💡 点击词语查看相似度 | 相同类别的词聚集在一起

🎯 为什么需要它 (Why)

问题：计算机无法理解文字

// 你写的代码
const sentence = "我爱北京天安门";

// 计算机看到的
[230, 136, 145, 231, 136, ...];  // 只是 UTF-8 字节码，毫无意义

解决方案：词嵌入

降维：从 one-hot 的 10000+ 维降到 256~1024 维
语义：相似的词向量接近，不同的词向量远离
可计算：可以做加减法、算相似度

📊 数学原理 (Math)

嵌入层 (Embedding Layer)

本质上是一个查找表 (Lookup Table)：

嵌入查找

\mathbf{e} = \mathbf{E}[i]

$\mathbf{E}$ : 嵌入矩阵，形状 $[\text{vocab\_size}, \text{embed\_dim}]$
$i$ : 词的索引（如 “猫” = 1234）
$\mathbf{e}$ : 该词的嵌入向量，形状 $[\text{embed\_dim}]$

词汇表大小 = 50000
嵌入维度 = 512

嵌入矩阵 E 的形状: [50000, 512]
查询 "猫"（索引 1234）→ E[1234] → 得到 512 维向量

相似度计算

余弦相似度

\text{similarity}(\mathbf{a}, \mathbf{b}) = \frac{\mathbf{a} \cdot \mathbf{b}}{|\mathbf{a}| |\mathbf{b}|} = \cos\theta

结果范围 $[-1, 1]$
$1$ = 完全相同方向（语义相同）
$0$ = 正交（无关）
$-1$ = 完全相反（语义相反）

import torch
import torch.nn as nn

# 1. 定义嵌入层
vocab_size = 10000  # 词汇表大小
embed_dim = 512     # 嵌入维度

embedding = nn.Embedding(vocab_size, embed_dim)

# 2. 查询词向量
# 假设 "猫"=0, "狗"=1, "汽车"=2
word_indices = torch.tensor([0, 1, 2])

# 获取嵌入向量
vectors = embedding(word_indices)
print(vectors.shape)  # [3, 512] → 3 个词，每个 512 维

# 3. 计算相似度
cat_vec = vectors[0]   # 猫的向量
dog_vec = vectors[1]   # 狗的向量
car_vec = vectors[2]   # 汽车的向量

# 余弦相似度
def cosine_similarity(a, b):
    return torch.dot(a, b) / (a.norm() * b.norm())

print(f"猫-狗 相似度: {cosine_similarity(cat_vec, dog_vec):.3f}")
print(f"猫-车 相似度: {cosine_similarity(cat_vec, car_vec):.3f}")
# 训练后，猫-狗 应该比 猫-车 更高

// 概念理解：嵌入层就是一个二维数组

// 嵌入矩阵 (假设词汇表 5 个词，嵌入维度 3)
const embeddingMatrix = [
  [0.2, 0.8, -0.1],  // 索引 0: "猫"
  [0.3, 0.7, -0.2],  // 索引 1: "狗"
  [-0.5, 0.1, 0.9],  // 索引 2: "汽车"
  [0.1, 0.9, 0.0],   // 索引 3: "老虎"
  [-0.4, 0.2, 0.8],  // 索引 4: "飞机"
];

// 查询词向量 = 查数组
function getEmbedding(wordIndex) {
  return embeddingMatrix[wordIndex];
}

const catVector = getEmbedding(0);  // [0.2, 0.8, -0.1]
const dogVector = getEmbedding(1);  // [0.3, 0.7, -0.2]

// 余弦相似度
function cosineSimilarity(a, b) {
  const dot = a.reduce((sum, val, i) => sum + val * b[i], 0);
  const normA = Math.sqrt(a.reduce((sum, val) => sum + val ** 2, 0));
  const normB = Math.sqrt(b.reduce((sum, val) => sum + val ** 2, 0));
  return dot / (normA * normB);
}

console.log(cosineSimilarity(catVector, dogVector));  // 接近 1

🔧 预训练嵌入

实际使用中，我们很少从零训练嵌入，而是使用预训练模型：

模型	特点	使用场景
Word2Vec	Google 2013，CBOW/Skip-gram	经典，快速
GloVe	Stanford，基于共现矩阵	学术常用
FastText	Facebook，支持子词	处理生僻词
BERT Embedding	上下文相关嵌入	现代 NLP 标配

# 使用 HuggingFace 加载预训练嵌入
from transformers import AutoTokenizer, AutoModel

tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese")
model = AutoModel.from_pretrained("bert-base-chinese")

# 获取 "猫" 的上下文嵌入
inputs = tokenizer("我家的猫很可爱", return_tensors="pt")
outputs = model(**inputs)

# outputs.last_hidden_state: [1, seq_len, 768]
# 每个 token 都有一个 768 维的向量

🌐 词嵌入 3D 空间 (Interactive)

探索词向量在 3D 空间中的分布，观察语义相似的词如何聚集在一起。

🌐 词嵌入 3D 空间

显示相似连线

animal

country

city

verb

adj

💡 观察: 相似语义的词在空间中更接近。如 "cat" 和 "dog" 都是动物，距离较近。