一、Word2Vec
1.1简介
Word2Vec：一种基于神经网络的词嵌入技术，它的目标是将单词映射到实数向量空间中，使得语义相似的单词在向量空间中的距离较近。这种映射是通过在大规模文本语料库上训练神经网络模型来实现的。Word2Vec通过学习单词的共现信息，能够在向量空间中模拟出有意义的语义关系，如同义词、反义词等。
本质是一个神经网络模型，目的是通过模型训练学习得到一个矩阵（Matrix C），一个表示词与词之间关联关系的矩阵。
二、CBOW
2.1简介
CBOW（连续词袋模型）：
CBOW（Continuous Bag of Words，连续词袋模型）与Skip-Gram相反，CBOW模型通过给定的上下文单词来预测中心词。具体来说，对于文本中的每一个中心词，CBOW模型会将其周围一定窗口大小内的其他单词（即上下文单词）作为输入，并尝试预测该中心词。
CBOW模型类似于一个高级的完型填空游戏，其中上下文中的词汇（已知选项）被用来"填空"预测出缺失的中心词（答案），从而揭示词汇间的语义联系和模式。
2.2结构
输入层：输入上下文单词的one-hot编码。
嵌入层：将上下文单词的one-hot编码转换为词向量，并将这些词向量进行平均或求和，得到上下文向量。
输出层：输出层同样使用softmax函数输出中心词的概率分布。
2.3 one-hot编码
one-hot 编码是一种常用于将类别数据（如单词）转换为机器学习模型可以处理的数值形式的方法。one-hot 编码会为每个类别分配一个全为零的向量，除了该类别的索引位置为1之外。因为单词通常被视为离散的类别，所以这种方法在处理文本数据时特别有用。
2.4词嵌入
假设现在统计词料库中的所有词的个数围殴4960个，按顺序依次给每个词进行one-hot编码，例如第1个词为：1,0,0,0,0,0,0,....,0，最后1个词为： 0,0,0,0,0,0,0,....,1
此时出现了一个问题：矩阵为非常稀疏，出现维度灾难
例如有一句话为"我爱北京天安门"，传入神经网络输入层的数据为：
1,0,0,0,0,0,0,....,0
0,1,0,0,0,0,0,....,0
0,0,1,0,0,0,0,....,0
0,0,0,1,0,0,0,....,0（4 * 4960）
那么该怎么解决这个问题呢？
方案：通过神经网络训练，将每个词都映射到一个较短的词向量上来。
这个较短的词向量维度是多大呢？ 一般需要在训练时自己来指定。现在很常见的例如300维。
例如有一句话为"我爱北京天安门"，通过神经网络训练后的数据为：
0.62,0.12,0.01,0,0,0,0,....,0
0.1,0.12,0.001,0,0,0,0,....,0
0,0,0.01,0.392,0.39, 0,....,0
0,0,0,1,0,0.01,0.123,....,0.11（4 * 300）
这种将高维度的词表示转换为低维度的词表示的方法，我们称之为词嵌入（word embedding）
2.5 CBOW原理
BOW模型的核心思想是通过上下文中的词来预测目标词。具体而言，CBOW模型通过将上下文中的词的词向量相加，得到一个上下文向量，然后通过一个隐藏层将上下文向量映射到目标词的概率分布。在训练过程中，CBOW模型通过最大化预测目标词的概率来学习到每个词的词向量表示。
2.6 模型训练步骤
1、当前词的上下文词语的one-hot编码输入到输入层。
2、这些词分别乘以同一个矩阵WV*N后分别得到各自的1*N 向量。
3、将多个这些1*N 向量取平均为一个1*N 向量。
4、将这个1*N 向量乘矩阵 W'V*N ,变成一个1*V 向量。
5、将1*V 向量softmax归一化后输出取每个词的概率向量1*V
6、将概率值最大的数对应的词作为预测词。
7、将预测的结果1*V 向量和真实标签1*V 向量（真实标签中的V个值中有一个是1，其他是0）计算误差
8、在每次前向传播之后反向传播误差，不断调整 WV*N和 W'V*N矩阵的值。
示例：
假定语料库中一共有4960个词，则词编码为4960个01组合 现在压缩为300维
依据下图
即4960 * 300
2.7 代码示例
python
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from tqdm import tqdm
import numpy as np
#任务：已经有了语料库，1、构造训练数据集（单词，词库）
context_size = 2 #设置词左边和右边选择的个数
raw_text = """
"We are about to study the idea of a computational process. Computational processes are abstract beings that inhabit computers.As they evolve, processes manipulate other abstract things called data.The evolution of a process is directed by a pattern of rules
called a program. People create programs to direct processes. In effecte,we conjure the spirits of the computer with our spells.""".split()
vocab = set(raw_text)# 集合，词库内容独一无二
vocab_size = len(vocab)
word_to_idx = {word:i for i, word in enumerate(vocab)} #for循环的复合写法，第一次循环，i得到索引号，word得到第一个单词
idx_to_word = {i:word for i, word in enumerate(vocab)}
data = []
for i in range(context_size , len(raw_text) - context_size):
context = (
[raw_text[i - (2-j)] for j in range(context_size)]
+[raw_text[i + j +1] for j in range(context_size)])
target = raw_text[i] #获取目标词
data.append((context, target))
def make_context_vector(context,word_to_ix):
idxs = [word_to_ix[w] for w in context]
return torch.tensor(idxs,dtype=torch.long)
print(make_context_vector(data[0][0],word_to_idx))
#在cuda中训练
device= "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
class CBOW(nn.Module):
def __init__(self, vocab_size, embedding_dim):
super(CBOW, self).__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.proj = nn.Linear(embedding_dim, 128)
self.output = nn.Linear(128, vocab_size)
def forward(self,inputs):
embeds = sum(self.embedding(inputs)).view(1,-1)
out = F.relu(self.proj(embeds))
out = self.output(out)
nll_prob = F.log_softmax(out, dim=-1)
return nll_prob
model = CBOW(vocab_size, 10).to(device)
optimizer = optim.Adam(model.parameters(), lr=0.001)
losses = []
loss_function = nn.NLLLoss()
for epoch in tqdm(range(200)):
total_loss = 0
for context, target in data:
context_vector = make_context_vector(context,word_to_idx).to(device)
target = torch.tensor([word_to_idx[target]]).to(device)
#开始前向传播
train_predict = model(context_vector) # 可以不写forward,torch的内置功能,
loss = loss_function(train_predict, target) #计算真实值和预测值之间的差距
#反向传播
optimizer.zero_grad() # 梯度值清零
loss.backward() # 反向传播计算得到每个参数的梯度值
optimizer.step() #根据梯度更新网络参数
total_loss += loss.item()
losses.append(total_loss)
print(losses)
#测试
context = ['People', 'create', 'to', 'direct']
context_vector = make_context_vector(context,word_to_idx).to(device)
#预测的值
model.eval()
predict = model(context_vector)
max_idx = predict.argmax(1) #dim=1表示每一行中的最大值对应的索引号，dim=0表示每一列中的最大值对应的索引号
# 获取词向量，这个Embedding就是我们需要的词向量，他只是一个模型的一个中间过程
print('CBOW embedding weights:',model.embedding.weight)
w = model.embedding.weight.cpu().detach().numpy() #.detach(:这个法会创建一个新Tensor,原来的Tensor共享数#这意味着这个新的Tensor不会参与梯度的反向传播，这对于防止在计算梯度时意外修改某些参数很有用。
print(w)
#生成词嵌入字典，即{单词1:词向量1，单词2:词向量2...}的格式
word_2_vec = {}
for word in word_to_idx.keys():
# 词向量矩阵中某个词的索引所对应的那一列即为所该词的词向量
word_2_vec[word] = w[word_to_idx[word],:]
print('over')
##1保存训练后的词向量为npz文件''numpy w 处理矩阵的速度非常快，方便后期其他人项目，要继续使用
np.savez('word2vec.npz',file_1 = w)
data = np.load('word2vec.npz')
print(data.files)对于这段代码：实现了一个简单的CBOW模型，用于学习词向量表示。代码首先准备数据，构建词汇表并生成训练数据集。然后定义了CBOW模型类，包括Embedding层、线性映射层和输出层。接着使用Adam优化器 和负对数似然损失函数进行模型训练，迭代多个epoch。最后，给定上下文词列表，模型预测目标词的词向量表示，并将训练得到的词向量保存为npz文件。整体而言，这段代码展示了如何使用PyTorch实现CBOW模型进行词向量表示学习。