1. 项目概述：从词袋到词向量，理解语言的新维度
几年前，当我第一次接触自然语言处理时，面对“苹果很好吃”和“苹果发布了新手机”这样的句子，计算机只能把它们看作一堆独立的词，完全无法理解“苹果”这个词在不同语境下的天壤之别。传统的词袋模型（Bag-of-Words）或TF-IDF方法，虽然能统计词频，但词与词之间是孤立的，语义信息几乎为零。直到word2vec的出现，才真正打开了用稠密向量（Dense Vector）表示词语语义的大门，让机器开始“理解”词语的相似性、类比关系甚至语法规则。而Skip-gram模型，作为word2vec的两种核心架构之一，以其简洁高效的设计，成为了将词语映射到向量空间这一过程的经典实现。
简单来说，Skip-gram模型要解决的核心问题是：给定一个中心词，如何让模型学会预测它周围可能出现的上下文词？比如，对于句子“The quick brown fox jumps over the lazy dog”，如果我们选定“fox”作为中心词，并设定一个大小为2的窗口，那么模型的目标就是学习到，当出现“fox”时，它周围较大概率会出现“quick”、“brown”、“jumps”、“over”这些词。通过在海量文本数据上反复进行这样的预测任务，模型最终会为每个词学习到一个固定维度的向量表示，而这个向量神奇地编码了该词的语义信息——语义相近的词，其向量在空间中的距离也更近。
这个项目笔记，就是一次对Skip-gram模型从理论到实践的深度拆解。它适合所有希望超越调包、真正理解词向量背后原理的NLP学习者、算法工程师以及对机器学习感兴趣的朋友。我们将不满足于仅仅调用gensim库的几行代码，而是要亲手推导梯度公式，用NumPy从零搭建一个可训练的Skip-gram模型，并深入探讨其背后的技巧、陷阱和优化之道。你会发现，理解了这个看似简单的模型，你就掌握了现代深度学习NLP的许多基础思想。
2. 模型核心思想与架构设计解析
2.1 从直觉到模型：分布式假说与神经网络实现
Skip-gram模型的灵感来源于语言学中的“分布式假说”（Distributional Hypothesis），即一个词的语义由其上下文决定。上下文相似的词，其语义也相似。Skip-gram用神经网络完美地建模了这一思想。
模型的输入输出极其简单：
- 输入：一个中心词（如“fox”），用其one-hot编码表示。假设我们的词汇表大小为V，那么这个输入就是一个长度为V、仅在对应词索引处为1，其余为0的稀疏向量。
- 输出：模型试图预测在中心词周围一个固定窗口大小（例如左右各2个词）内所有上下文词的概率分布。对于每个上下文位置，我们都要计算一个概率分布，表示词汇表中每个词作为该位置上下文词的可能性。
那么，模型是如何从one-hot输入得到概率分布的呢？这中间的核心就是两个权重矩阵：输入权重矩阵W（V×N维）和输出权重矩阵W‘（N×V维）。这里的N就是我们设定的词向量维度（例如300维）。这个过程可以分解为三步：
- 查找隐藏层：输入的中心词one-hot向量（1×V）与输入矩阵W（V×N）相乘。由于one-hot向量的特性，这个相乘操作等价于直接从W矩阵中“查找”出该中心词对应的那一行向量。因此，输入矩阵W的每一行，本质上就是该行对应词的词向量。我们得到了一个1×N维的隐藏层向量，它就是中心词的词向量表示。
- 计算得分：将得到的隐藏层向量（1×N）与输出矩阵W‘（N×V）相乘，得到一个1×V维的“得分”向量。这个得分向量中的每一个值，代表了词汇表中每一个词作为当前预测的上下文词的“原始分数”。
- 转化为概率：通过Softmax函数，将这个得分向量转化为一个概率分布。Softmax确保所有词汇的概率之和为1，并且得分高的词获得更高的概率。
注意：这里有一个关键点，也是初学者容易混淆的地方。在Skip-gram的原始论文和大多数实现中，输入矩阵W被称为词向量矩阵。也就是说，当我们训练完成后，我们直接取W矩阵的每一行作为对应词的最终词向量。输出矩阵W‘在某些优化技巧中会被用到，但最终我们通常只保留W。
2.2 目标函数：最大化上下文词的对数似然
模型有了，我们如何训练它？我们需要一个目标函数来告诉模型“好”与“坏”。Skip-gram的目标是最大化给定中心词时，其所有上下文词出现的条件概率的乘积。
对于一个中心词c和其上下文窗口内的一个上下文词o，我们希望最大化P(o|c)。对于整个训练语料，我们的目标就是最大化所有这样的(c, o)配对出现的概率。在数学上，我们通常采用更易于优化的对数形式，并转化为最小化负对数似然（Negative Log-Likelihood）。因此，对于单个(c, o)配对，其损失函数为：
Loss = -log(P(o|c))
其中，P(o|c)就是通过上述的神经网络（隐藏层 -> 输出层 -> Softmax）计算得到的，词汇表中第o个词的概率。
对于窗口内的所有上下文词，总损失是它们各自损失的和。模型训练的过程，就是通过反向传播算法，不断调整输入矩阵W和输出矩阵W‘中的参数，使得这个总损失越来越小。当损失足够小时，W矩阵中的每一行——即每个词的向量表示——就包含了丰富的语义信息。
2.3 为何有效？向量空间中的语义几何
训练完成后，为什么W矩阵中的向量就有语义了？我们可以从参数更新的角度来直观理解。
假设中心词是“猫”，一个正确的上下文词是“喵”。在训练中，模型会调整“猫”的向量（W中‘猫’对应的行）和“喵”的向量（W‘中‘喵’对应的列，注意W‘是N×V，其列向量也代表一种词表示）使得它们更“接近”（内积增大）。同时，对于大量不是“喵”的词（如“汽车”、“编程”），模型会轻微地使“猫”的向量与这些词的表示“远离”（内积减小）。
经过海量文本的训练，“猫”、“狗”、“兔子”等动物相关的词，因为它们拥有大量相似的上下文（如“跑”、“跳”、“宠物”、“毛”），所以它们的输入向量在调整过程中会朝着相似的方向移动，最终在向量空间中聚集在一起。而“猫”和“编程”由于上下文迥异，它们的向量就会渐行渐远。更神奇的是，像“国王 - 男人 + 女人 ≈ 女王”这样的向量类比关系也会自然涌现，这是因为这种关系模式在语料中反复出现，被模型捕捉并编码到了向量差值中。
3. 从零实现Skip-gram的关键步骤与代码剖析
理解了原理，我们动手实现一个最基础的Skip-gram模型。这里我们使用Python和NumPy，专注于理解核心流程，暂时不考虑效率问题。
3.1 数据预处理与词汇表构建
任何NLP任务的第一步都是处理文本数据。对于Skip-gram，我们需要将原始文本转化为一系列整数索引，并构建词汇表。
import numpy as np from collections import Counter import re def preprocess_text(text): """简单的文本预处理：小写化，去除标点符号。""" text = text.lower() text = re.sub(r'[^a-z\s]', '', text) # 移除非字母和空格的字符 words = text.split() return words def build_vocab(words, min_count=5): """构建词汇表，过滤低频词。""" word_counts = Counter(words) # 按词频排序，并过滤低频词 vocab = {word: idx for idx, (word, count) in enumerate(word_counts.items()) if count >= min_count} # 添加未知词和填充符（如果需要） vocab['<UNK>'] = len(vocab) # 创建反向索引：从ID到词 idx_to_word = {idx: word for word, idx in vocab.items()} return vocab, idx_to_word def text_to_indices(words, vocab): """将词列表转化为索引列表，未知词用<UNK>代替。""" return [vocab.get(word, vocab['<UNK>']) for word in words] # 示例 corpus = "The quick brown fox jumps over the lazy dog. The dog is lazy." words = preprocess_text(corpus) vocab, idx_to_word = build_vocab(words, min_count=1) indices = text_to_indices(words, vocab) print(f"词汇表: {vocab}") print(f"索引序列: {indices}")实操心得：
min_count参数至关重要。词汇表中包含大量只出现一两次的罕见词（如拼写错误、专有名词）会极大增加矩阵维度（V），导致模型参数暴涨、训练缓慢，且这些词的向量由于训练样本不足，质量会很差。通常根据语料库大小，将其设置为5、10或更高。对于特别大的语料，甚至可以考虑只保留前N个高频词。
3.2 生成训练样本（中心词-上下文词对）
Skip-gram的训练数据不是原始的句子，而是一个个(center_word_index, context_word_index)配对。
def generate_training_data(indices, window_size=2): """ 从索引序列生成训练数据。 参数: indices: 词索引列表。 window_size: 单侧上下文窗口大小。 返回: center_words: 中心词索引列表。 context_words: 对应的上下文词索引列表。 """ center_words = [] context_words = [] length = len(indices) for i, center_idx in enumerate(indices): # 确定当前中心词的上下文窗口边界 start = max(0, i - window_size) end = min(length, i + window_size + 1) # 遍历窗口内的所有词，排除中心词本身 for j in range(start, end): if j != i: center_words.append(center_idx) context_words.append(indices[j]) return np.array(center_words), np.array(context_words) # 示例 center_words, context_words = generate_training_data(indices, window_size=2) print(f"中心词样本: {center_words[:10]} -> {[idx_to_word[i] for i in center_words[:10]]}") print(f"上下文样本: {context_words[:10]} -> {[idx_to_word[i] for i in context_words[:10]]}") print(f"总样本数: {len(center_words)}")这个函数会为语料中的每一个词，生成其与窗口内每一个上下文词的配对。样本数量会远大于原始词数，这为模型提供了充足的训练数据。
3.3 模型初始化与前向传播
现在，我们初始化模型参数并实现前向传播。
class SkipGramModel: def __init__(self, vocab_size, embedding_dim): """ 初始化Skip-gram模型。 参数: vocab_size: 词汇表大小 V。 embedding_dim: 词向量维度 N。 """ self.V = vocab_size self.N = embedding_dim # 初始化权重矩阵。使用较小的随机值可以打破对称性，有助于训练。 # W_in 是输入到隐藏层的权重，形状为 (V, N)。它的行就是词向量。 self.W_in = np.random.randn(self.V, self.N) * 0.01 # W_out 是隐藏层到输出层的权重，形状为 (N, V)。 self.W_out = np.random.randn(self.N, self.V) * 0.01 def forward(self, center_word_idx): """ 前向传播。 参数: center_word_idx: 中心词的索引（整数）。 返回: hidden_layer: 隐藏层向量 (1, N)。 output_scores: 输出层得分 (1, V)。 probabilities: Softmax后的概率分布 (1, V)。 """ # 1. 输入层 -> 隐藏层：本质是查找词向量 # center_word_idx 的 one-hot 向量与 W_in 相乘，等价于取出 W_in 的第 center_word_idx 行。 hidden_layer = self.W_in[center_word_idx] # 形状 (N,) hidden_layer = hidden_layer.reshape(1, -1) # 变为 (1, N) 便于后续计算 # 2. 隐藏层 -> 输出层：计算得分 output_scores = np.dot(hidden_layer, self.W_out) # (1, N) * (N, V) = (1, V) # 3. 输出层 -> Softmax概率 # 减去最大值防止指数运算溢出 scores_shifted = output_scores - np.max(output_scores) exp_scores = np.exp(scores_shifted) probabilities = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # 缓存中间结果，用于反向传播 self.cache = { 'center_idx': center_word_idx, 'hidden_layer': hidden_layer, 'output_scores': output_scores, 'probabilities': probabilities } return hidden_layer, output_scores, probabilities def backward(self, context_word_idx, learning_rate=0.01): """ 反向传播，更新参数。 参数: context_word_idx: 目标上下文词的索引。 learning_rate: 学习率。 """ # 从缓存中取出前向传播的结果 center_idx = self.cache['center_idx'] hidden = self.cache['hidden_layer'] # (1, N) probs = self.cache['probabilities'] # (1, V) # 1. 计算输出层的梯度 # 对于Softmax + 负对数似然损失，输出层的误差信号非常简洁。 # dL/d(output_scores) = probs - y_true # y_true 是 context_word_idx 的 one-hot 向量。 doutput = probs.copy() # (1, V) doutput[0, context_word_idx] -= 1 # 在正确类别处减去1 # 2. 计算 W_out 和隐藏层的梯度 # dL/dW_out = hidden_layer.T * doutput dW_out = np.dot(hidden.T, doutput) # (N, 1) * (1, V) = (N, V) # dL/dhidden = doutput * W_out.T dhidden = np.dot(doutput, self.W_out.T) # (1, V) * (V, N) = (1, N) # 3. 计算 W_in 的梯度 # 由于输入是one-hot，W_in的梯度只会更新中心词对应的那一行。 dW_in = np.zeros_like(self.W_in) dW_in[center_idx, :] = dhidden.reshape(-1) # dhidden是(1,N)，需要展平 # 4. 更新参数（简单的SGD） self.W_in -= learning_rate * dW_in self.W_out -= learning_rate * dW_out def train_one_epoch(self, center_words, context_words, learning_rate=0.01): """ 用一个epoch的数据训练模型。 参数: center_words: 中心词索引数组。 context_words: 上下文词索引数组。 learning_rate: 学习率。 返回: total_loss: 本轮训练的总损失。 """ total_loss = 0 num_samples = len(center_words) for i in range(num_samples): c_idx = center_words[i] o_idx = context_words[i] # 前向传播 _, _, probs = self.forward(c_idx) # 计算损失：负对数似然 loss = -np.log(probs[0, o_idx] + 1e-8) # 加一个小数防止log(0) total_loss += loss # 反向传播，更新参数 self.backward(o_idx, learning_rate) return total_loss / num_samples # 返回平均损失这个实现是最原始、最直观的版本。它清晰地展示了：
- 前向传播：如何从中心词索引得到所有词的预测概率。
- 损失计算：使用负对数似然。
- 反向传播：梯度如何从损失函数传递回
W_in和W_out矩阵。注意dW_in的更新只发生在中心词对应的那一行，这印证了“查找表”的本质。
3.4 基础训练循环与向量获取
有了模型和数据，我们可以开始训练了。
# 超参数设置 VOCAB_SIZE = len(vocab) EMBEDDING_DIM = 10 # 为了演示，维度设小 LEARNING_RATE = 0.05 EPOCHS = 500 # 初始化模型 model = SkipGramModel(VOCAB_SIZE, EMBEDDING_DIM) # 训练循环 loss_history = [] for epoch in range(EPOCHS): avg_loss = model.train_one_epoch(center_words, context_words, LEARNING_RATE) loss_history.append(avg_loss) if (epoch + 1) % 50 == 0: print(f"Epoch {epoch+1}/{EPOCHS}, Average Loss: {avg_loss:.4f}") # 训练完成后，词向量就是 W_in 矩阵的每一行 word_vectors = model.W_in print(f"\n词向量矩阵形状: {word_vectors.shape}") # (V, N) # 查看某个词的向量 word = 'fox' if word in vocab: idx = vocab[word] vector = word_vectors[idx] print(f"单词 '{word}' 的词向量（前5维）: {vector[:5]}")运行这段代码，你会看到损失在逐渐下降。训练完成后，model.W_in就是一个(V, N)的矩阵，其中第i行就是词汇表中第i个词的词向量。
4. 效率瓶颈与核心优化技术详解
上面实现的基础版本在理论上是正确的，但在实践中完全不可行。问题出在Softmax计算上。我们的损失函数需要计算P(o|c) = exp(score_o) / sum(exp(score_i) for i in 1...V)。分母需要对词汇表V中的所有词计算指数和。当V很大时（现实任务中V通常在1万到百万级），这个计算成本是灾难性的。因此，原始的Skip-gram必须进行优化。主要有两种主流方法：层次Softmax（Hierarchical Softmax）和负采样（Negative Sampling）。负采样因其简单高效，成为了最流行的选择。
4.1 负采样（Negative Sampling）原理与实现
负采样的核心思想是：不再计算整个庞大词汇表的概率分布，而是将多分类问题转化为一系列二分类问题。
对于每个真实的(中心词c, 上下文词o)正样本，我们随机从词汇表中采样K个“噪声词”（即不太可能出现在c周围的词），构成K个负样本(c, noise)。模型的目标就变成了：最大化正样本的似然，同时最小化负样本的似然。
具体来说，我们使用一个sigmoid函数来代替Softmax。对于正样本(c, o)，我们希望sigmoid(u_o · v_c)接近1（其中v_c是c的输入向量，u_o是o的输出向量）。对于每个负样本(c, n)，我们希望sigmoid(u_n · v_c)接近0。
新的目标函数（负对数似然）为：Loss = -log(σ(u_o · v_c)) - Σ_{i=1 to K} log(σ(-u_{n_i} · v_c))其中σ是sigmoid函数。
这样，每次参数更新只需要计算K+1个词（1个正样本词 + K个负样本词）的得分和梯度，而不是整个V。通常K取值在5到20之间，计算量从O(V)降到了O(K)，实现了质的飞跃。
class SkipGramNegSampling: def __init__(self, vocab_size, embedding_dim, word_freqs): """ 使用负采样的Skip-gram模型。 参数: vocab_size: V。 embedding_dim: N。 word_freqs: 每个词的频率列表，用于负采样。 """ self.V = vocab_size self.N = embedding_dim # 初始化参数 self.W_in = np.random.randn(self.V, self.N) * 0.01 # 输入向量 self.W_out = np.random.randn(self.V, self.N) * 0.01 # 输出向量（注意这里形状是(V,N)，每个词也有输出向量） # 为负采样准备概率分布：使用3/4次幂来平滑频率，增加低频词被采样的机会 freqs = np.array(word_freqs) probs = freqs ** 0.75 probs /= np.sum(probs) self.neg_sample_probs = probs def get_negative_samples(self, target_idx, k=5): """ 根据词频分布采样负样本。 参数: target_idx: 正样本词的索引，避免采样到它自身。 k: 负采样数量。 返回: negative_indices: 负样本词索引列表。 """ # 创建一个候选池，排除目标词本身 candidate_indices = [i for i in range(self.V) if i != target_idx] candidate_probs = self.neg_sample_probs[candidate_indices] candidate_probs /= np.sum(candidate_probs) # 重新归一化 # 有放回地采样k次 neg_samples = np.random.choice(candidate_indices, size=k, p=candidate_probs, replace=True) return list(neg_samples) def forward_backward_neg(self, center_idx, target_idx, neg_indices, learning_rate=0.01): """ 针对一个中心词、一个正样本上下文词和一组负样本，执行前向和反向传播。 """ # 获取向量 v_c = self.W_in[center_idx] # 中心词输入向量 (N,) u_o = self.W_out[target_idx] # 正样本输出向量 (N,) # 计算正样本的损失和梯度 score_pos = np.dot(v_c, u_o) loss_pos = -np.log(self._sigmoid(score_pos)) # -log(σ(score)) # 正样本的梯度 g_pos = self._sigmoid(score_pos) - 1 # σ(score) - 1 grad_v_c_pos = g_pos * u_o grad_u_o = g_pos * v_c # 初始化中心词的总梯度 grad_v_c = grad_v_c_pos.copy() # 计算负样本的损失和梯度 loss_neg = 0 for neg_idx in neg_indices: u_n = self.W_out[neg_idx] score_neg = np.dot(v_c, u_n) loss_neg += -np.log(self._sigmoid(-score_neg)) # -log(σ(-score)) g_neg = self._sigmoid(score_neg) # σ(score) grad_v_c += g_neg * u_n # 负样本对中心词向量的梯度是正的 # 更新负样本的输出向量 self.W_out[neg_idx] -= learning_rate * (g_neg * v_c) # 更新中心词的输入向量和正样本的输出向量 self.W_in[center_idx] -= learning_rate * grad_v_c self.W_out[target_idx] -= learning_rate * grad_u_o total_loss = loss_pos + loss_neg return total_loss def _sigmoid(self, x): """数值稳定的sigmoid函数。""" if x >= 0: return 1.0 / (1.0 + np.exp(-x)) else: exp_x = np.exp(x) return exp_x / (1.0 + exp_x) def train_one_epoch_neg(self, center_words, context_words, k=5, learning_rate=0.01): """ 使用负采样训练一个epoch。 """ total_loss = 0 num_samples = len(center_words) for i in range(num_samples): c_idx = center_words[i] o_idx = context_words[i] # 采样负样本 neg_indices = self.get_negative_samples(o_idx, k=k) # 前向和反向传播 loss = self.forward_backward_neg(c_idx, o_idx, neg_indices, learning_rate) total_loss += loss return total_loss / num_samples这个实现是Skip-gram能够处理大规模语料的关键。word_freqs ** 0.75是一种经典技巧，它削弱了高频词的优势，让低频词有更多机会被选为负样本，从而学到更好的表示。
4.2 层次Softmax（Hierarchical Softmax）简介
层次Softmax是另一种优化方法。它不再使用扁平的Softmax，而是利用哈夫曼树（Huffman Tree）来组织词汇表。树的每个叶子节点代表一个词，从根节点到叶子节点的路径是唯一的。计算一个词的概率，变成了计算从根节点走到该叶子节点的路径上，一系列二分类决策（向左走还是向右走）的概率乘积。这样，计算一个词的概率复杂度从O(V)降到了O(log V)。
虽然层次Softmax也很高效，但其实现比负采样复杂，且负采样在大多数任务中表现更好，因此负采样成为了事实上的标准。了解层次Softmax有助于理解优化思路的多样性。
4.3 其他重要技巧与参数
- 动态窗口大小：在训练时，并不是对所有中心词都使用固定的窗口大小。一个常见技巧是随机采样窗口大小R，R的取值范围在1到设定的最大窗口大小之间。这样可以让模型既能学到较近的上下文（语法信息），也能学到较远的上下文（主题信息）。
- 高频词下采样（Subsampling）：像“the”、“a”、“in”这样的高频词，提供的信息量很少，但出现的次数极多。如果不对其处理，训练会被这些词主导。解决方案是以一定概率丢弃这些词。丢弃概率
P(w_i)与词频有关，公式通常为P(w_i) = 1 - sqrt(t / f(w_i))，其中t是一个阈值（如1e-5），f(w_i)是词的频率。频率越高，被丢弃的概率越大。 - 学习率调整：随着训练进行，逐渐降低学习率（如线性衰减）有助于模型收敛到更优的解。
5. 实战评估、可视化与常见问题排查
5.1 词向量质量评估：相似性与类比任务
训练出的词向量好不好，不能只看损失函数下降，需要有客观的评估方法。最常用的两种方式是：
1. 词语相似度任务：计算词向量之间的余弦相似度，与人工标注的词语相似度数据集（如WordSim-353, SimLex-999）进行相关性比较（如斯皮尔曼等级相关系数）。好的词向量，其相似度排名应与人类判断高度相关。
def cosine_similarity(vec_a, vec_b): """计算两个向量的余弦相似度。""" dot_product = np.dot(vec_a, vec_b) norm_a = np.linalg.norm(vec_a) norm_b = np.linalg.norm(vec_b) return dot_product / (norm_a * norm_b + 1e-8) # 防止除零 # 示例：查找与“fox”最相似的词 def find_most_similar(word, word_vectors, vocab, idx_to_word, top_k=5): if word not in vocab: return [] target_idx = vocab[word] target_vec = word_vectors[target_idx] similarities = [] for idx, vec in enumerate(word_vectors): if idx == target_idx: continue sim = cosine_similarity(target_vec, vec) similarities.append((idx_to_word[idx], sim)) # 按相似度降序排序 similarities.sort(key=lambda x: x[1], reverse=True) return similarities[:top_k] # 假设我们已经有了训练好的 word_vectors similar_words = find_most_similar('fox', model.W_in, vocab, idx_to_word, top_k=5) print(f"与 'fox' 最相似的词: {similar_words}")2. 词语类比任务：这是展示词向量“神奇”能力的经典任务。给定三个词A, B, C，寻找一个词D，使得关系“A之于B，如同C之于D”成立。即，向量vec(B) - vec(A) + vec(C)应该最接近vec(D)。
def word_analogy(a, b, c, word_vectors, vocab, idx_to_word, top_k=5): """ 解决类比问题：a is to b as c is to ?. """ if a not in vocab or b not in vocab or c not in vocab: return [] vec_a = word_vectors[vocab[a]] vec_b = word_vectors[vocab[b]] vec_c = word_vectors[vocab[c]] # 计算目标向量： king - man + woman = queen target_vec = vec_b - vec_a + vec_c # 寻找最相似的词（排除输入词本身） similarities = [] for idx, vec in enumerate(word_vectors): word = idx_to_word[idx] if word in [a, b, c]: continue sim = cosine_similarity(target_vec, vec) similarities.append((word, sim)) similarities.sort(key=lambda x: x[1], reverse=True) return similarities[:top_k] # 示例：在足够大的语料上训练后，期望得到类似结果 # analogy_result = word_analogy('man', 'king', 'woman', word_vectors, vocab, idx_to_word) # print(analogy_result) # 期望看到 ('queen', 高相似度)5.2 使用t-SNE进行词向量可视化
高维向量难以直观理解。t-SNE是一种降维技术，能将高维向量映射到2D或3D空间，同时尽可能保持点与点之间的相对距离（即相似关系）。
from sklearn.manifold import TSNE import matplotlib.pyplot as plt def visualize_vectors(word_vectors, words_of_interest, vocab, idx_to_word, perplexity=30): """ 使用t-SNE可视化指定词的词向量。 """ # 获取感兴趣词的索引和向量 indices = [vocab[word] for word in words_of_interest if word in vocab] vectors_to_plot = word_vectors[indices] labels = [idx_to_word[idx] for idx in indices] # 使用t-SNE降维 tsne = TSNE(n_components=2, perplexity=perplexity, random_state=42, init='pca') vectors_2d = tsne.fit_transform(vectors_to_plot) # 绘图 plt.figure(figsize=(10, 8)) plt.scatter(vectors_2d[:, 0], vectors_2d[:, 1], alpha=0.7) for i, label in enumerate(labels): plt.annotate(label, (vectors_2d[i, 0], vectors_2d[i, 1]), fontsize=9) plt.title('Word2Vec Embeddings Visualization (t-SNE)') plt.xlabel('t-SNE Component 1') plt.ylabel('t-SNE Component 2') plt.grid(True, alpha=0.3) plt.show() # 选择一些有语义关联的词进行可视化 words_to_viz = ['king', 'queen', 'man', 'woman', 'paris', 'france', 'london', 'england', 'cat', 'dog', 'animal', 'car', 'bus', 'vehicle', 'run', 'jump', 'walk'] # 注意：我们的示例语料太小，无法展示这种关系。这里仅为展示函数用法。 # visualize_vectors(word_vectors, words_to_viz, vocab, idx_to_word)注意事项：t-SNE的超参数
perplexity对结果影响很大，它大致表示每个点考虑多少近邻。对于词向量可视化，通常设置在5到50之间，需要根据数据量调整。另外，t-SNE每次运行结果可能略有不同。
5.3 常见问题、陷阱与排查指南
在实际实现和训练Skip-gram时，你会遇到各种各样的问题。下面是一个常见问题速查表：
| 问题现象 | 可能原因 | 排查与解决方案 |
|---|---|---|
| 损失不下降或下降极慢 | 1. 学习率太大或太小。 2. 词向量维度太高/太低，与数据量不匹配。 3. 未使用负采样或层次Softmax，计算的是完整Softmax（对于大V几乎不可能训练）。 4. 数据预处理有问题，样本质量差。 | 1. 尝试经典学习率如0.025，并加入衰减。 2. 常用维度是100-300。小语料用50-100，大语料用200-300。 3.务必使用负采样，K值设为5-20。 4. 检查词汇表大小、低频词过滤、标点处理是否正确。打印一些训练样本看看。 |
| 词向量质量差，相似词不相似 | 1. 训练轮数（epoch）不足。 2. 语料库太小或领域太偏。 3. 窗口大小设置不当。 4. 未进行高频词下采样。 | 1. 增加epoch，用验证集（类比任务）监控质量。 2. 使用更大、更通用的语料库（如维基百科、新闻语料）。 3. 尝试不同的窗口大小（如2, 5, 10）。小窗口偏向语法，大窗口偏向主题。 4. 引入高频词下采样，平衡数据分布。 |
| 训练速度非常慢 | 1. 使用纯Python/NumPy循环，未向量化。 2. 词汇表V太大。 3. 未使用负采样。 | 1. 对于真实项目，应使用TensorFlow/PyTorch等框架，利用GPU和向量化计算。 2. 增大 min_count，限制词汇表大小。3.负采样是速度的关键，确保已实现。 |
| 出现NaN或Inf损失 | 1. 学习率过高，导致梯度爆炸。 2. 数值计算不稳定（如exp过大）。 | 1. 大幅降低学习率。 2. 在Softmax或sigmoid计算中，确保做了数值稳定处理（如减去最大值）。 3. 对梯度进行裁剪（gradient clipping）。 |
| “国王-男人+女人≈女王”不成立 | 1. 语料不足或领域不匹配。 2. 向量维度太低，无法捕捉复杂关系。 3. 训练不充分。 | 1. 这是在大规模通用语料上表现出的特性。确保语料足够大且多样。 2. 尝试更高的维度（如300）。 3. 增加训练数据量和epoch。 |
我个人在实际操作中的体会是，Skip-gram的成功，30%在于模型理解，70%在于“炼丹”技巧和数据工程。负采样的K值是一个需要微调的超参数，太小可能学习不充分，太大则计算负担重且可能引入过多噪声，通常5-15是个安全范围。窗口大小的选择也很有讲究，如果你关心句法信息（如动词时态、介词搭配），小窗口（2-5）更好；如果关心文档主题或语义场（如“医院”和“医生”、“护士”的关系），大窗口（5-10甚至更大）更有效。最稳妥的方法是，用一份标准的词语类比或相似度数据集作为验证集，在训练过程中定期检查其表现，以此来指导超参数的选择。
最后，虽然我们从零实现了Skip-gram，但对于生产环境或严肃研究，强烈建议使用高度优化的库，如gensim。它的实现经过了极致优化，支持多线程、流式读取大文件、自动处理所有上述优化技巧。理解原理之后，使用gensim会让你事半功倍：
from gensim.models import Word2Vec sentences = [["the", "quick", "brown", "fox"], ["jumps", "over", "the", "lazy", "dog"]] # 需要分词后的句子列表 model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4, sg=1, negative=5) # sg=1 表示 Skip-gram print(model.wv['fox']) # 获取词向量 print(model.wv.most_similar('fox', topn=5)) # 查找相似词通过这个从理论推导、手工实现到优化实战的完整过程，希望你能真正穿透Skip-gram的黑箱，不仅知其然，更能知其所以然。这份理解，将是你在更复杂的NLP模型世界中前行的坚实基石。
