从零实现CBOW词向量：中英文双语训练与PyTorch工程实践

1. 项目概述：从零开始跑通CBOW词向量训练，为什么这次作业值得你亲手敲一遍

“中英文语料训练CBOW模型获得词向量”——这行标题里藏着NLP入门路上最扎实的一块基石。我带过十几届某高校自然语言处理课程的助教，每年都有学生在作业二卡住：不是报错RuntimeError: expected scalar type Float but found Double，就是训练完的词向量聚类散得像撒了把米，或者中文分词后词表膨胀到5万+导致显存直接爆掉。但反过来看，只要把这一关真正打通，后续做文本分类、命名实体识别、甚至大模型微调，你对“词是怎么被机器理解的”这件事，就再也不会停留在“embedding是查表”这种模糊认知上。这个项目本质是一次微型工业级词向量生产流水线的完整复现：从原始语料清洗、子词切分与编码、上下文窗口构建、负采样策略实现，到PyTorch张量运算的每一处dtype对齐、梯度裁剪的临界值设定，再到最终用t-SNE可视化验证语义相似性——它不炫技，但每一步都踩在NLP工程实践的真实痛点上。尤其当你同时跑通中英文两套流程，会立刻意识到：英文靠空格天然分词，中文却必须直面字粒度vs词粒度的权衡；英文语料中“the”“a”这类停用词占比超30%，而中文的“的”“了”“在”同样需要定制化过滤；更关键的是，PyTorch的nn.Embedding层在中文场景下极易因词表索引越界触发静默错误，这种细节只有亲手调试过才会刻进肌肉记忆。所以别把它当普通作业——这是你第一次以工程师视角，亲手锻造一把理解语言的“小刀”，刀刃是否锋利，全看你在数据预处理时多抠了0.5%的标点清洗，在损失函数里多写了一行torch.clamp，在保存模型时是否坚持用了.cpu().state_dict()而非直接torch.save(model)。接下来的内容，我会把当年助教笔记里那些没写进PPT的实操陷阱、参数调试手记、以及中文语料特有的坑，全部摊开来讲。

2. 整体设计思路拆解：为什么CBOW仍是NLP入门不可绕过的“第一课”

2.1 选择CBOW而非Skip-gram的底层逻辑

很多初学者看到“词向量”第一反应是Word2Vec，再一搜发现有两个变体——CBOW和Skip-gram，于是纠结该选哪个。我的建议很明确：作业阶段必须从CBOW入手。这不是因为CBOW更“简单”，而是它的设计哲学天然适配教学场景。CBOW的核心思想是“用上下文预测中心词”，比如句子“我 爱 吃 苹 果”，给定窗口大小为2，模型会用[我,吃,苹,果]四个词的向量平均值，去预测中心词“爱”。这个过程在数学上可表达为：
$$ \hat{y} = \text{softmax}(W_2 \cdot \text{avg}(W_1 \cdot x_{-2}, W_1 \cdot x_{-1}, W_1 \cdot x_{+1}, W_1 \cdot x_{+2}) + b_2) $$
其中$W_1$是输入词向量矩阵（即我们要学习的词嵌入），$W_2$是输出投影矩阵。关键在于，CBOW的输入是多个词向量的平均值，这使得梯度更新更平滑、训练更稳定。我对比过同一语料下两种模型的loss曲线：CBOW通常在5个epoch内就能降到0.8以下，而Skip-gram前期震荡剧烈，常需15+ epoch才能收敛。对于作业环境——有限的GPU显存（可能只有单卡16G）、没有分布式训练框架、还要兼顾其他课程——CBOW的鲁棒性就是生产力。更实际的好处是，CBOW的预测目标是单个词，其输出层维度等于词表大小$V$，而Skip-gram要为每个上下文词单独预测中心词，输出层计算量是CBOW的$2C$倍（$C$为窗口大小）。当你的中文词表达到3万时，Skip-gram的softmax层计算开销会直接让训练速度降为CBOW的1/3。当然，Skip-gram在低频词表示上确实更强，但那是你跑通CBOW后才需要思考的进阶问题。

2.2 中英文双语并行设计的必要性

标题里强调“中英文语料”，这绝非为了凑字数。我在某实验室带过一个跨语言信息检索项目，团队初期只用英文维基语料训练词向量，结果在中文新闻摘要任务上F1值惨不忍睹。根本原因在于：词向量的质量高度依赖语料的语言特性与统计规律。英文语料中，形态变化丰富（run/running/ran），但分词边界清晰；中文则相反，形态几乎不变，但分词歧义严重（“结婚的和尚未结婚的”如何切分？）。因此，双语训练本质上是在强制你建立两套独立的认知框架：

• 英文处理链路：原始文本 → 小写转换 → 正则清洗（保留字母、数字、基础标点）→ 空格分词 → 停用词过滤（nltk.corpus.stopwords）→ 词频统计 → 低频词截断（<5次出现的词归为<UNK>）
• 中文处理链路：原始文本 → 繁体转简体 → 全角标点转半角 → 正则清洗（移除广告链接、HTML标签）→jieba精确模式分词→ 自定义停用词表（含“的”“了”“在”及网络新词如“yyds”“绝绝子”）→ 字符级回退机制（对未登录词按字切分）→ 词频统计 → 低频词处理（中文因分词误差，阈值需设为<3）
  两条链路最终都要生成统一格式的word2idx映射字典和idx2word逆映射，但预处理代码必须完全隔离。我见过太多学生把英文清洗脚本直接套用到中文上，结果中文文本被正则re.sub(r'[^a-zA-Z\s]', '', text)清成一片空白——因为中文字符全被过滤了。这种“看似一样、实则天差地别”的细节，只有双语并行才能暴露。

2.3 PyTorch实现而非Gensim的深层考量

标题明确要求“PyTorch实现”，而非调用Gensim的Word2Vec类。这背后是能力培养的代际差异。Gensim封装了所有细节，你只需传入分词后的列表，几行代码就能得到词向量。但当你需要：

• 在训练中动态调整学习率（如warmup+decay）
• 对特定词（如专业术语）施加额外约束损失
• 将词向量作为下游任务（如BERT）的初始化权重
• 调试梯度消失问题（查看model.embedding.weight.grad.norm()）
  Gensim就会变成黑箱。而PyTorch实现强迫你直面每一个张量操作：torch.nn.Embedding层的padding_idx参数为何必须设为0？nn.CrossEntropyLoss为何内部已包含softmax，所以前向传播中不能重复调用？torch.no_grad()在负采样时如何避免梯度污染？这些不是理论考题，而是你调试时真实会遇到的断点。我曾帮一位学生排查IndexError: index out of range in self，最终发现是中文分词后某个句子长度不足窗口要求，代码里没做max(0, start_idx)保护。这种错误在Gensim里会被自动忽略，但在PyTorch里就是硬性崩溃——而这恰恰是工程能力的分水岭。

3. 核心细节解析与实操要点：预处理、建模、训练的魔鬼细节

3.1 中文语料预处理：分词不是终点，而是起点

中文预处理的致命误区，是把“用jieba分词”当成终点。实际上，分词只是第一步，后续还有三道筛子必须过：

第一筛：分词粒度冲突的消解
jieba的默认模式对“苹果手机”会切分为["苹果", "手机"]，但若语料中大量出现“苹果公司”“苹果汁”，“苹果”作为水果义项的上下文就与科技义项混杂。解决方案是构建领域词典：

import jieba # 加载自定义词典（每行一个词，可带词性、权重） jieba.load_userdict("tech_dict.txt") # 内容示例：苹果公司 nz 1000 # tech_dict.txt中加入"苹果公司"后，"苹果手机"将更可能切分为["苹果公司", "手机"]

但注意，词典权重不宜过高（>5000会导致过度切分），我实测1000-3000是平衡点。

第二筛：未登录词（OOV）的字符级兜底
即使有词典，新词（如“奥密克戎”“元宇宙”）仍会出现。此时不能简单丢弃，而应启用字符级回退：

def word_to_tokens(word, word2idx, unk_id=0): if word in word2idx: return [word2idx[word]] else: # 回退到字粒度，但过滤掉单字停用词 chars = [c for c in word if c not in ['的', '了', '在']] return [word2idx.get(c, unk_id) for c in chars if c.strip()]

这个函数确保“奥密克戎”被拆为["奥","密","克","戎"]，每个字都有对应向量，而非整个词被置为<UNK>。

第三筛：标点与特殊符号的语义剥离
中文标点（，。！？）本身无语义，但若保留在词表中，会稀释有效词向量空间。我的做法是：

• 在分词后立即移除所有标点（re.sub(r'[^\w\s]', '', seg_text)）
• 但保留句末标点作为句子边界信号：在每句话末尾添加<EOS>标记，用于后续构建上下文窗口时识别句子边界，避免跨句取窗口。

提示：中文语料清洗后，务必检查词频分布。健康分布应呈长尾：前100词占总频次30%-40%，后10%低频词占总频次<5%。若出现“的”“了”等单字词频次超15%，说明标点过滤不彻底或停用词表缺失。

3.2 CBOW模型架构：从公式到PyTorch的逐层映射

CBOW模型在PyTorch中并非简单堆叠nn.Linear，其核心在于上下文聚合方式与负采样实现。以下是精简但完整的模型定义（省略__init__中的参数声明）：

class CBOWModel(nn.Module): def __init__(self, vocab_size, embedding_dim, context_size, num_negatives=5): super().__init__() self.vocab_size = vocab_size self.embedding_dim = embedding_dim self.context_size = context_size self.num_negatives = num_negatives # 输入词向量层：所有上下文词共享同一嵌入矩阵 self.embeddings = nn.Embedding(vocab_size, embedding_dim, padding_idx=0) # 输出投影层：将上下文向量映射到词表空间 self.output_layer = nn.Linear(embedding_dim, vocab_size) # 负采样用的噪声分布（按词频的3/4次方采样） self.noise_dist = None def forward(self, context_indices): # context_indices: [batch_size, 2*context_size]，每个元素是词索引 # Step 1: 获取上下文词向量 [batch_size, 2*context_size, embed_dim] context_vecs = self.embeddings(context_indices) # Step 2: 沿上下文维度平均 [batch_size, embed_dim] avg_context = torch.mean(context_vecs, dim=1) # Step 3: 投影到词表空间 [batch_size, vocab_size] output = self.output_layer(avg_context) return output def negative_sampling_loss(self, target_idx, context_indices): # target_idx: [batch_size]，真实中心词索引 # context_indices: [batch_size, 2*context_size] batch_size = target_idx.size(0) # 获取正样本得分（真实中心词） pos_scores = self.forward(context_indices).gather(1, target_idx.unsqueeze(1)) # 采样负样本（num_negatives个） neg_samples = torch.multinomial(self.noise_dist, batch_size * self.num_negatives, replacement=True) neg_samples = neg_samples.view(batch_size, self.num_negatives) # 计算负样本得分（重用forward，但输入为负样本索引） # 注意：此处需重构context_indices，使每个负样本与原上下文配对 # 实际代码中，我们用更高效的向量化实现（见后文） ...

关键细节解析：

• padding_idx=0：指定索引0为填充位，nn.Embedding会自动将该位置的梯度置零，避免填充词影响训练。
• torch.mean(..., dim=1)：这是CBOW区别于Skip-gram的核心——对上下文向量求均值而非拼接，大幅降低参数量。
• noise_dist：负采样噪声分布必须按词频的$z^{3/4}$构造（$z$为词频），而非均匀采样。这是因为高频词（如“的”）应被更多采样为负样本，以加速训练。构造代码：

# 假设word_freq为词频字典 {word: freq} freqs = np.array(list(word_freq.values())) noise_probs = freqs ** 0.75 noise_probs = noise_probs / noise_probs.sum() self.noise_dist = torch.from_numpy(noise_probs).float()

3.3 训练循环中的隐藏雷区：dtype、梯度、设备同步

PyTorch训练中最易被忽视的三个“静默杀手”：

雷区一：dtype不一致引发的隐式类型转换
nn.Embedding默认输出float32，但若你的target_idx是long类型（正确），而context_indices误设为float，PyTorch会自动将context_indices转为long，但若context_indices含小数，转换后索引错乱。强制规范：

# 所有索引张量必须显式声明为long context_indices = torch.tensor(context_batch, dtype=torch.long) target_idx = torch.tensor(target_batch, dtype=torch.long) # 模型输入前再校验 assert context_indices.dtype == torch.long, "Context indices must be long!"

雷区二：负采样中的梯度污染
标准负采样需计算正样本得分与负样本得分的log-sigmoid损失：
$$ \mathcal{L} = -\log \sigma(u_{w_O}^T \bar{v}{w_I}) - \sum{k=1}^K \log \sigma(-u_{w_k}^T \bar{v}_{w_I}) $$
其中$u$为输出向量，$\bar{v}$为上下文平均向量。但若直接用output.gather()获取正样本得分，再用output[neg_samples]获取负样本得分，output的梯度会同时流向正负样本，导致更新错误。正确做法是分离计算图：

# 使用torch.no_grad()禁用负样本梯度 with torch.no_grad(): neg_scores = self.output_layer(avg_context).gather(1, neg_samples) # 正样本得分正常计算梯度 pos_scores = self.output_layer(avg_context).gather(1, target_idx.unsqueeze(1)) # 合并损失 loss = -torch.log(torch.sigmoid(pos_scores)) - torch.log(torch.sigmoid(-neg_scores)).mean(dim=1)

雷区三：CPU-GPU数据搬运瓶颈
在DataLoader中，若collate_fn返回的张量未指定设备，model(input)会触发隐式搬运。实测显示，每次搬运增加15ms延迟。终极方案：在Dataset.__getitem__中直接返回GPU张量：

def __getitem__(self, idx): context, target = self.data[idx] # 直接移到GPU（假设device='cuda:0'） return (torch.tensor(context, device=self.device), torch.tensor(target, device=self.device))

但需注意：device必须在__init__中传入，且DataLoader的num_workers>0时此法失效（因子进程无法访问GPU），此时改用pin_memory=True+to(device)更稳妥。

4. 实操过程与核心环节实现：从数据加载到向量评估的全流程

4.1 数据加载与批处理：如何让DataLoader不拖慢训练

标准DataLoader在处理变长序列时效率低下，因为collate_fn需将所有样本pad到同长。CBOW的上下文窗口固定（如context_size=2），但句子长度不一，导致大量padding。优化方案是动态批处理（Dynamic Batching）：

from torch.utils.data import Dataset, DataLoader import numpy as np class CBOWDataset(Dataset): def __init__(self, sentences, word2idx, context_size=2): self.data = [] # 存储 (context_list, target_word_idx) 元组 self.context_size = context_size for sent in sentences: # 句子转索引，过滤掉未登录词 idx_sent = [word2idx.get(w, 0) for w in sent if w in word2idx] if len(idx_sent) < 2 * context_size + 1: continue # 滑动窗口提取样本 for i in range(context_size, len(idx_sent) - context_size): context = [] # 左侧上下文 for j in range(i - context_size, i): context.append(idx_sent[j]) # 右侧上下文 for j in range(i + 1, i + context_size + 1): context.append(idx_sent[j]) target = idx_sent[i] self.data.append((context, target)) def __len__(self): return len(self.data) def __getitem__(self, idx): context, target = self.data[idx] return torch.tensor(context, dtype=torch.long), torch.tensor(target, dtype=torch.long) # 动态批处理：按样本长度分组，减少padding def dynamic_collate_fn(batch): # batch是[(context1, target1), (context2, target2), ...] contexts, targets = zip(*batch) # 所有context长度相同（因CBOW窗口固定），无需pad contexts = torch.stack(contexts) targets = torch.stack(targets) return contexts, targets # 创建DataLoader dataset = CBOWDataset(sentences, word2idx, context_size=2) dataloader = DataLoader(dataset, batch_size=1024, shuffle=True, collate_fn=dynamic_collate_fn)

此方案下，contexts张量形状恒为[batch_size, 2*context_size]，零padding，显存占用降低40%。

4.2 训练主循环：带早停、学习率调度的工业级写法

一个健壮的训练循环需包含监控、容错、恢复机制。以下是精简版核心逻辑：

def train_epoch(model, dataloader, optimizer, criterion, device, epoch): model.train() total_loss = 0 for batch_idx, (context_batch, target_batch) in enumerate(dataloader): context_batch = context_batch.to(device) target_batch = target_batch.to(device) optimizer.zero_grad() # 前向传播 output = model(context_batch) # [batch_size, vocab_size] # 计算损失（使用CrossEntropyLoss，自动处理softmax+log+nll） loss = criterion(output, target_batch) loss.backward() # 梯度裁剪：防止RNN-like结构梯度爆炸 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) optimizer.step() total_loss += loss.item() # 每100 batch打印一次 if batch_idx % 100 == 0: print(f'Epoch {epoch} [{batch_idx}/{len(dataloader)}] Loss: {loss.item():.4f}') return total_loss / len(dataloader) # 主训练流程 model = CBOWModel(vocab_size=len(word2idx), embedding_dim=100, context_size=2).to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=2) best_loss = float('inf') patience_counter = 0 for epoch in range(1, 21): train_loss = train_epoch(model, dataloader, optimizer, criterion, device, epoch) scheduler.step(train_loss) # 根据loss调整lr if train_loss < best_loss - 1e-4: best_loss = train_loss patience_counter = 0 # 保存最佳模型（仅保存state_dict） torch.save(model.state_dict(), 'best_cbow_model.pth') else: patience_counter += 1 if patience_counter >= 5: print("Early stopping triggered!") break

关键点：

• ReduceLROnPlateau比固定学习率更适应loss波动，patience=2意味着连续2轮loss不降才衰减。
• clip_grad_norm_的max_norm=1.0经实测在CBOW中效果最佳，过大则失去裁剪意义，过小则抑制有效梯度。
• 保存state_dict()而非整个模型，避免序列化nn.Embedding的padding_idx等冗余属性。

4.3 词向量质量评估：不止于t-SNE可视化

训练完成的词向量，必须通过多维度验证，而非仅看t-SNE图“看起来聚得好”。以下是三种硬核评估法：

方法一：类比推理任务（Analogy Task）
测试“国王-男人+女人≈女王”这类关系。实现步骤：

1. 加载词向量矩阵W（shape:[vocab_size, embed_dim]）
2. 对查询词king,man,woman，计算vec = W[king] - W[man] + W[woman]
3. 计算vec与所有词向量的余弦相似度，取top-10最近邻
4. 若queen在top-10中，则计1分

def analogy_task(vec, W, idx2word, topk=10): # vec: [embed_dim] # W: [vocab_size, embed_dim] cos_sim = torch.nn.functional.cosine_similarity(W, vec.unsqueeze(0), dim=1) _, indices = torch.topk(cos_sim, topk) return [idx2word[i.item()] for i in indices] # 示例：测试“北京-中国+法国” beijing = W[word2idx['北京']] china = W[word2idx['中国']] france = W[word2idx['法国']] result = analogy_task(beijing - china + france, W, idx2word) print("北京-中国+法国 =", result) # 期望输出：巴黎

注意：中文类比需谨慎，因“北京-中国”可能指向“首都”概念，而“法国”的首都“巴黎”未必在top-10，此时应检查“首都”“城市”等抽象词是否在结果中。

方法二：相似度任务（Similarity Task）
用标准数据集（如WordSim-353）计算皮尔逊相关系数。但中文缺乏权威数据集，可自制：

• 构建100对高相似词（如["苹果","香蕉"]、["奔跑","疾驰"]）与100对低相似词（如["苹果","汽车"]）
• 人工打分（1-5分），计算模型余弦相似度与人工评分的相关系数
• 相关系数>0.65视为合格，>0.75为优秀

方法三：下游任务迁移（Downstream Transfer）
将词向量作为特征输入简单分类器，测试其泛化能力：

# 加载中文新闻标题数据集（如THUCNews） # 用训练好的CBOW向量替换原始词袋特征 # 训练一个LogisticRegression分类器 # 对比随机初始化词向量的baseline # 若准确率提升>3%，证明词向量捕获了有效语义

这才是检验词向量价值的黄金标准。

5. 常见问题与排查技巧实录：那些让我熬夜到凌晨三点的Bug

5.1 “IndexError: index out of range in self” —— 中文分词的幽灵错误

现象：训练刚开始就报错，指向self.embeddings(context_indices)。
排查路径：

1. 检查context_indices最大值：print(context_indices.max().item())
2. 若该值≥vocab_size，说明词表索引越界
3. 追溯源头：word2idx构建时是否漏掉了某些分词结果？
   根因与修复：

• 中文分词后，jieba.lcut("Python编程")可能返回["Python", "编程"]，但"Python"不在中文词表中，word2idx.get("Python", 0)返回0（<UNK>）
• 问题在于<UNK>索引0被padding_idx=0占用，导致embeddings[0]为零向量，但代码中未禁止其作为上下文
• 修复：在CBOWDataset.__init__中，对每个词w，先判断w in word2idx，否则跳过该词：

idx_sent = [] for w in sent: if w in word2idx and word2idx[w] != 0: # 确保不是<UNK> idx_sent.append(word2idx[w])

• 更彻底的方案：将<UNK>索引设为len(word2idx)-1，而非0，并在nn.Embedding中显式设置padding_idx=len(word2idx)-1。

5.2 “CUDA out of memory” —— 显存爆炸的七种死法

现象：训练到第3个epoch突然OOM，nvidia-smi显示显存100%。
七种常见死法与解法：

终极保命技巧：在train_epoch开头插入：

if torch.cuda.is_available(): torch.cuda.empty_cache() # 强制清空缓存 print(f"GPU memory: {torch.cuda.memory_allocated()/1024**3:.2f} GB")

5.3 “Loss不下降，始终在5.0左右” —— 学习率与初始化的玄学

现象：训练10个epoch，loss稳定在4.8-5.2，毫无下降趋势。
系统性排查清单：

• ✅ 检查nn.CrossEntropyLoss输入：output是否为[batch_size, vocab_size]，target是否为[batch_size]且值在[0, vocab_size-1]内？
• ✅ 检查output的数值范围：print(output.min().item(), output.max().item())，若全为nan，说明梯度爆炸，需减小lr或加大clip_grad_norm_
• ✅ 检查词向量初始化：nn.Embedding默认用uniform(-sqrt(1/embed_dim), sqrt(1/embed_dim))，但CBOW中embed_dim=100时，该范围过小，导致梯度太弱。修复：手动初始化

model.embeddings.weight.data.uniform_(-0.5, 0.5) # 扩大初始范围

• ✅ 检查学习率：lr=0.001对CBOW偏大，实测lr=0.0005更稳。若用Adam，可尝试lr=0.001但betas=(0.9, 0.999)保持默认。
• ✅ 检查负采样数：num_negatives=5是经验值，若语料小（<10MB），可降至3；若语料大（>100MB），可增至10。

最后的杀手锏：用torch.autograd.set_detect_anomaly(True)开启异常检测，它会在梯度计算出错时精准定位到哪一行代码。

5.4 中英文向量不可比？—— 词表对齐的工程真相

现象：分别训练中英文CBOW，想用余弦相似度找“apple”和“苹果”的匹配度，结果相似度仅0.12。
真相：不同语料训练的词向量空间是互不相通的坐标系，就像北京地图和上海地图，比例尺、方向、原点都不同。强行比较毫无意义。
正确解法：

• 方案A（推荐）：联合训练（Joint Training）
  将中英文语料混合，用统一词表（如<zh>、<en>前缀区分），让模型学习跨语言共性。但需解决分词差异，可先统一为字节对编码（BPE）。
• 方案B：后处理对齐（Post-hoc Alignment）
  用少量双语词典（如“apple-苹果”、“computer-计算机”）作为锚点，训练一个线性变换矩阵$W$，使$W \cdot v_{en} \approx v_{zh}$。最小化：
  $$ \mathcal{L} = \sum_{(w_{en}, w_{zh}) \in \mathcal{D}} | W \cdot v_{en} - v_{zh} |^2 $$
  其中$\mathcal{D}$为双语词典。用sklearn.linear_model.LinearRegression即可求解。
• 方案C：放弃直接比较，转向下游任务
  将中英文词向量分别作为特征，输入同一分类器，看其在跨语言任务（如情感分析）上的表现。这才是词向量价值的终极考场。

6. 项目收尾与延伸思考：当CBOW成为你工具箱里的“瑞士军刀”

跑通这个项目后，你手里握着的不再是一份作业答案，而是一套可复用的NLP基础设施。我在某公司的知识图谱项目中，就直接复用了这套CBOW训练脚本——把原始语料换成内部产品文档，将word2idx替换成entity2idx，几天内就生成了高质量的产品实体向量，支撑起后续的智能搜索推荐。这种迁移能力，正是扎实工程训练的馈赠。

但更要清醒的是：CBOW不是终点，而是理解更复杂模型的跳板。当你看着自己训练的“苹果”“香蕉”“梨”在t-SNE图中紧密相邻，不妨问自己：

• 如果把nn.Embedding换成nn.LSTM，让上下文向量不再是简单平均，而是时序建模，这就是ELMo的雏形；
• 如果把context_indices的输入，扩展为整个句子的token序列，并用Transformer编码，那就是BERT的起点；
• 如果把target_idx从单个词，改为整段文本的生成，再配上teacher forcing，你就站在了GPT的门前。

所以别急着追求大模型。真正的技术纵深，往往藏在最朴素的模型里——比如CBOW中那个torch.mean()操作，它背后是“语义组合性”的假设；比如负采样中z^{3/4}的指数，它源于Zipf定律对语言统计的深刻洞察。这些不是代码，而是语言学家、统计学家、工程师共同写就的