04-词向量到嵌入：让机器理解语言的奥秘

词向量到嵌入：让机器理解语言的奥秘

探索自然语言处理的核心技术，理解如何让计算机读懂人类语言。

前言

语言是人类智慧的结晶，但计算机只能理解数字。如何把"语言"变成"数字"？这就是**词嵌入（Word Embedding）**技术要解决的核心问题。

今天，我们从词向量的发展历程出发，深入理解这项让机器"读懂"语言的关键技术。

---

一、语言表示的演进

从符号到向量

计算机处理语言的第一步，是将语言转化为数值表示：

语言表示的三个阶段：

1. 独热编码（One-Hot）
   "苹果" → [0, 0, 0, 1, 0, 0, ...]（词汇表长度）

2. 词向量（Word Vector）
   "苹果" → [0.23, -0.45, 0.67, ...]（固定维度，如300维）

3. 上下文嵌入（Contextual Embedding）
   "苹果" → 根据上下文动态生成向量

为什么需要更好的表示？

独热编码的问题：

# 假设词汇表有10000个词
vocab = {"我": 0, "喜欢": 1, "苹果": 2, "香蕉": 3, ...}

# One-Hot编码
def one_hot(word, vocab_size=10000):
    vec = [0] * vocab_size
    vec[vocab[word]] = 1
    return vec

print(one_hot("苹果"))
# [0, 0, 1, 0, 0, ..., 0]  共10000个数字，只有一个1

问题：

1. 维度灾难：词汇表有多大，向量就有多长
2. 稀疏性：只有一个位置是1，其余都是0
3. 语义缺失：无法表达词与词之间的相似性

"苹果" → [0, 0, 1, 0, 0, ...]
"香蕉" → [0, 0, 0, 1, 0, ...]

两者距离相等，无法体现它们都是"水果"

---

二、Word2Vec：词向量的里程碑

核心思想

词的语义由它的上下文决定------这是Word2Vec的理论基础。

"你可以通过一个人交往的朋友来了解这个人。" ------ 同样适用于词

句子：我喜欢吃 苹果 和香蕉

苹果的上下文：我、喜欢、吃、和、香蕉
苹果的语义 ≈ 上下文词的语义

香蕉的上下文：我、喜欢、吃、苹果、和
苹果和香蕉有相似的上下文 → 它们语义相近

两种训练架构

1. CBOW（连续词袋模型）

目标：用上下文预测中心词

输入：上下文词 ["我", "喜欢", "吃", "香蕉"]
输出：中心词 "苹果"

        上下文词
           ↓
        取平均
           ↓
    ┌─────────────┐
    │   隐藏层    │  ← 词向量在这里学习
    └─────────────┘
           ↓
        Softmax
           ↓
        预测词

2. Skip-gram

目标：用中心词预测上下文

输入：中心词 "苹果"
输出：上下文词 ["我", "喜欢", "吃", "香蕉"]

        中心词
           ↓
    ┌─────────────┐
    │   隐藏层    │
    └─────────────┘
           ↓
        Softmax
           ↓
      多个上下文预测

代码实现

import torch
import torch.nn as nn
import torch.optim as optim

class SkipGram(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        super().__init__()
        # 中心词嵌入
        self.center_embedding = nn.Embedding(vocab_size, embedding_dim)
        # 上下文词嵌入
        self.context_embedding = nn.Embedding(vocab_size, embedding_dim)

        # 初始化
        nn.init.xavier_uniform_(self.center_embedding.weight)
        nn.init.xavier_uniform_(self.context_embedding.weight)

    def forward(self, center_word, context_word):
        # 获取嵌入向量
        center_vec = self.center_embedding(center_word)  # (batch, embed_dim)
        context_vec = self.context_embedding(context_word)  # (batch, embed_dim)

        # 计算点积
        score = torch.sum(center_vec * context_vec, dim=1)  # (batch,)

        return score

    def get_embedding(self, word_idx):
        """获取词向量"""
        return self.center_embedding.weight[word_idx]

# 训练示例
def train_skipgram():
    # 模拟数据
    corpus = ["我 喜欢 吃 苹果", "我 喜欢 吃 香蕉", "他 不 喜欢 苹果"]
    vocab = {"我": 0, "喜欢": 1, "吃": 2, "苹果": 3, "香蕉": 4, "他": 5, "不": 6}

    vocab_size = len(vocab)
    embedding_dim = 10

    model = SkipGram(vocab_size, embedding_dim)
    optimizer = optim.Adam(model.parameters(), lr=0.01)

    # 生成训练数据（中心词-上下文对）
    def get_training_data(corpus, window_size=2):
        data = []
        for sentence in corpus:
            words = sentence.split()
            for i, center in enumerate(words):
                for j in range(max(0, i - window_size), min(len(words), i + window_size + 1)):
                    if i != j:
                        data.append((vocab[words[i]], vocab[words[j]]))
        return data

    training_data = get_training_data(corpus)

    # 训练
    for epoch in range(100):
        total_loss = 0
        for center, context in training_data:
            center_tensor = torch.tensor([center])
            context_tensor = torch.tensor([context])

            # 正样本
            pos_score = model(center_tensor, context_tensor)
            pos_loss = -torch.log(torch.sigmoid(pos_score))

            # 负采样（简化：随机选负样本）
            neg_context = torch.randint(0, vocab_size, (1,))
            neg_score = model(center_tensor, neg_context)
            neg_loss = -torch.log(1 - torch.sigmoid(neg_score))

            loss = pos_loss + neg_loss
            total_loss += loss.item()

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        if epoch % 20 == 0:
            print(f"Epoch {epoch}, Loss: {total_loss:.4f}")

    # 查看词向量
    print("\n词向量示例：")
    for word, idx in vocab.items():
        vec = model.get_embedding(idx).detach().numpy()
        print(f"{word}: {vec[:3]}...")  # 只显示前3维

train_skipgram()

词向量的神奇特性

训练完成后，词向量会呈现出令人惊叹的语义关系：

# 经典例子：King - Man + Woman ≈ Queen

# 使用预训练的GloVe向量
import numpy as np

def load_glove_vectors(glove_file):
    """加载GloVe预训练向量"""
    word_vectors = {}
    with open(glove_file, 'r', encoding='utf-8') as f:
        for line in f:
            values = line.split()
            word = values[0]
            vector = np.array(values[1:], dtype='float32')
            word_vectors[word] = vector
    return word_vectors

def analogy(word_vectors, a, b, c):
    """
    类比推理：a is to b as c is to ?
    计算: result = b - a + c
    """
    result = word_vectors[b] - word_vectors[a] + word_vectors[c]

    # 找最相似的词
    best_word = None
    best_similarity = -1

    for word, vector in word_vectors.items():
        if word in [a, b, c]:
            continue
        similarity = np.dot(result, vector) / (np.linalg.norm(result) * np.linalg.norm(vector))
        if similarity > best_similarity:
            best_similarity = similarity
            best_word = word

    return best_word

# 示例结果
print("King - Man + Woman =", analogy("king", "man", "woman"))  # queen
print("Paris - France + Italy =", analogy("paris", "france", "italy"))  # rome

词向量空间的几何意义：

        王后(Queen)
            ●
           /│
          / │
         /  │
    女人 ●   │
        │   │
        │   │
    男人 ●───┼───● 国王(King)
        │
        │
        ●

性别关系：Man → Woman 的向量 ≈ King → Queen 的向量
国家-首都：France → Paris 的向量 ≈ Italy → Rome 的向量

---

三、GloVe：全局向量表示

核心思想

Word2Vec基于局部上下文，GloVe则结合了全局统计信息：

共现矩阵（Co-occurrence Matrix）：

         我  喜欢  吃  苹果  香蕉
我       0    3    2    2     2
喜欢     3    0    3    2     2
吃       2    3    0    1     1
苹果     2    2    1    0     1
香蕉     2    2    1    1     0

GloVe利用这种全局共现统计来学习词向量

目标函数

J = Σᵢⱼ f(Xᵢⱼ) (wᵢᵀw̃ⱼ + bᵢ + b̃ⱼ - log Xᵢⱼ)²

其中：
- Xᵢⱼ：词i和词j的共现次数
- wᵢ, w̃ⱼ：词向量
- f(X)：权重函数

---

四、FastText：字符级嵌入

核心创新

FastText将词分解为字符n-gram，能处理未登录词（OOV）：

单词："苹果"

字符n-gram（n=3）：
<苹, 苹果, 果>, <苹果>

最终向量 = n-gram向量之和

def get_ngrams(word, n=3):
    """获取字符n-gram"""
    # 添加边界符号
    word = '<' + word + '>'
    ngrams = []

    for i in range(len(word) - n + 1):
        ngrams.append(word[i:i+n])

    return ngrams

print(get_ngrams("apple"))
# ['<ap', 'app', 'ppl', 'ple', 'le>']

优势：

• 能处理拼写错误
• 能处理新词
• 对形态丰富的语言效果更好

---

五、上下文嵌入：BERT时代的革命

静态嵌入的局限

Word2Vec/GloVe为每个词学习固定的向量：

"我 喜欢 吃 苹果"
"苹果 公司 发布 新款 iPhone"

两处的"苹果"向量相同，但语义不同！

上下文嵌入

BERT等模型根据上下文动态生成向量：

from transformers import BertModel, BertTokenizer
import torch

# 加载预训练模型
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
model = BertModel.from_pretrained('bert-base-chinese')

def get_contextual_embedding(text, word_idx):
    """获取上下文嵌入"""
    inputs = tokenizer(text, return_tensors='pt')
    outputs = model(**inputs)

    # 获取指定位置的嵌入
    embedding = outputs.last_hidden_state[0, word_idx, :]

    return embedding.detach().numpy()

# 同一个词，不同上下文
text1 = "我喜欢吃苹果"
text2 = "苹果公司发布新品"

emb1 = get_contextual_embedding(text1, 4)  # "苹果"
emb2 = get_contextual_embedding(text2, 0)  # "苹果"

# 两个嵌入不同！
similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print(f"相似度: {similarity:.4f}")  # 低于1，因为语义不同

主流嵌入模型对比

模型	类型	特点
Word2Vec	静态	开创性工作，简单高效
GloVe	静态	利用全局统计信息
FastText	静态	支持子词，处理OOV
ELMo	动态	双向LSTM，上下文相关
BERT	动态	双向Transformer，强大
GPT	动态	单向Transformer，生成能力强
Word2Vec	静态	开创性工作，简单高效

---

六、嵌入的实际应用

1. 文本相似度计算

def cosine_similarity(vec1, vec2):
    """余弦相似度"""
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

# 句子向量 = 词向量的平均
def sentence_embedding(sentence, word_vectors):
    words = sentence.split()
    vectors = [word_vectors[w] for w in words if w in word_vectors]
    if not vectors:
        return None
    return np.mean(vectors, axis=0)

# 相似度计算
sentence1 = "我喜欢吃苹果"
sentence2 = "我爱吃香蕉"
sentence3 = "今天天气很好"

emb1 = sentence_embedding(sentence1, word_vectors)
emb2 = sentence_embedding(sentence2, word_vectors)
emb3 = sentence_embedding(sentence3, word_vectors)

print(f"句子1和句子2相似度: {cosine_similarity(emb1, emb2):.4f}")
print(f"句子1和句子3相似度: {cosine_similarity(emb1, emb3):.4f}")

2. 词义可视化

from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

def visualize_words(word_vectors, words):
    """词向量可视化"""
    # 获取词向量矩阵
    vectors = np.array([word_vectors[w] for w in words])

    # PCA降维到2维
    pca = PCA(n_components=2)
    result = pca.fit_transform(vectors)

    # 绘图
    plt.figure(figsize=(10, 8))
    plt.scatter(result[:, 0], result[:, 1])

    for i, word in enumerate(words):
        plt.annotate(word, xy=(result[i, 0], result[i, 1]))

    plt.title("词向量可视化")
    plt.show()

# 可视化示例
words = ["国王", "王后", "男人", "女人", "苹果", "香蕉", "水果"]
visualize_words(word_vectors, words)

---

七、嵌入技术的未来发展

趋势与挑战

方向	说明
多语言嵌入	跨语言的统一表示空间
多模态嵌入	文本、图像、音频统一表示
领域自适应	针对特定领域优化嵌入
高效压缩	降低嵌入维度，减少存储

---

小结

技术	核心思想	优势	局限
One-Hot	简单编码	直观	维度灾难、无语义
Word2Vec	上下文预测	语义关系	静态向量
GloVe	全局共现	统计信息	静态向量
FastText	字符n-gram	处理OOV	计算量大
BERT	上下文感知	动态语义	需要预训练

---

思考与练习

1. 思考题：

   • 为什么词向量能捕捉语义关系？
   • 静态嵌入和动态嵌入各适合什么场景？

2. 动手练习：

   • 使用Gensim训练一个中文Word2Vec模型
   • 用t-SNE可视化词向量空间

3. 延伸阅读：

   • Word2Vec原论文
   • GloVe原论文
   • Gensim文档

---

下期预告

下一篇文章，我们将深入探讨：GPT系列全解析：从GPT-1到GPT-4的进化

会解答这些问题：

• GPT系列的技术演进路径是什么？
• 每一代GPT的关键创新是什么？
• ChatGPT是如何炼成的？

关注专栏，不错过后续更新！

---

作者：ECH00O00 本文首发于掘金专栏《AI科普实验室》 欢迎评论区交流讨论，点赞收藏就是最大的鼓励 ❤️