【NLP】daydayup 词向量练习模子word2vec

词嵌入算法 word2vec

word2vec是一种高效练习词向量的模子，根本出发点是上下文相似的两个词。它们的词向量也应该相似。一样寻常分为CBOW（Continuous Bag-of-Words）与 Skip-Gram

• CBOW 词袋模子，使用中心词四周的词来推测中心词，中心词是目的，四周词是输入
  
• Skip-gram 根据中心词来推测四周词，中心词是输入，四周词是目的
  
• 左图为CBOW 右图是Skip-gram
  

CBOW模子

连续词袋模子，根据上下文来推测目的单词的模子。使用上下文各词的词向量的均值作为拼接起来的词向量。
对小型的数据比力符合

1. import numpy as np
2. import torch
3. import torch.nn as nn
4. import torch.optim as optim
5. import matplotlib.pyplot as plt
7. # 定义数据类型为浮点数
8. dtype = torch.FloatTensor
10. # 语料库，包含训练模型的句子
11. sentences = ["i like dog", "i like cat", "i like animal",
12.              "dog cat animal", "apple cat dog like", "cat like fish",
13.              "dog like meat", "i like apple", "i hate apple",
14.              "i like movie book music apple", "dog like bark", "dog friend cat"]
16. # 将所有句子拼接为一个字符串并按空格分词
17. word_sequence = ' '.join(sentences).split()
18. # 获取词汇表中的所有唯一词
19. word_list = list(set(word_sequence))
20. # 创建词典，词汇表中的每个词都分配一个唯一的索引
21. word_dict = {w: i for i, w in enumerate(word_list)}
23. # 创建跳字模型的训练数据
24. cow = []  # 训练数据
25. for i in range(1, len(word_sequence) - 1):
26.     # 获取两个上下文词对应的id
27.     context = [word_dict[word_sequence[i - 1]], word_dict[word_sequence[i + 1]]]
28.     # 当前词对应的id
29.     target = word_dict[word_sequence[i]]
31.     # 将目标词与上下文词配对，添加到训练数据中
32.     cow.append([context,target])
33. # print(cow)
34. # 定义嵌入维度（嵌入向量的大小）为2
35. embedding_size = 2
36. # 每次训练的批量大小
37. batch_size = 5
38. voc_size = len(word_list)
40. # 定义CBOW模型
41. class CBOW(nn.Module):
42.     def __init__(self):
43.         super(CBOW, self).__init__()
44.         # 定义词嵌入矩阵W，随机初始化，大小为(voc_size, embedding_size)
45.         self.embed = nn.Embedding(voc_size,embedding_size)
46.         self.l = nn.Linear(embedding_size,voc_size)
48.     # 前向传播
49.     def forward(self, x):
50.         x = self.embed(x)
51.         x = torch.mean(x,dim=1) # 自动降维
52.         x = self.l(x)
53.         return x
55. # 创建模型实例
56. model = CBOW()
58. # 定义损失函数为交叉熵损失
59. criterion = nn.CrossEntropyLoss()
60. # 使用Adam优化器
61. optimizer = optim.Adam(model.parameters(), lr=0.001)
63. # 定义随机批量生成函数
64. def random_batch(data, size):
65.     random_inputs = []  # 输入批次
66.     random_labels = []  # 标签批次
67.     # 从数据中随机选择size个索引
68.     random_index = np.random.choice(range(len(data)), size, replace=False)
70.     # 根据随机索引生成输入和标签批次
71.     for i in random_index:
72.         random_inputs.append(data[i][0])
73.         random_labels.append(data[i][1])
75.     return random_inputs, random_labels
77. # 训练模型
78. for epoch in range(10000):
79.     # 获取随机的输入和目标
80.     inputs, labels = random_batch(cow, batch_size)
82.     #转为张量
83.     input_batch = torch.LongTensor(inputs)
84.     label_batch = torch.LongTensor(labels)
86.     optimizer.zero_grad() # 梯度清零
87.     output = model(input_batch)
88.     # 计算损失函数
89.     loss = criterion(output, label_batch.view(-1))
91.     if (epoch + 1) % 1000 == 0:
92.         print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))
94.     loss.backward() # 反向传播
95.     optimizer.step() # 参数更新
97. #可视化词嵌入
98. for i, label in enumerate(word_list):
99.     W = model.embed.weight.data.numpy()
100.     x,y = float(W[i][0]),float(W[i][1])
101.     plt.scatter(x, y) #  绘制散点图
102.     plt.annotate(label, xy=(x, y), xytext=(5, 2), textcoords='offset points', ha='right', va='bottom')
104. plt.show()

复制代码

skip-grams

根据目的单词推测上下文单词的模子

1. import torch
2. import torch.nn as nn
3. import torch.optim as optim
4. import numpy as np
5. import matplotlib.pyplot as plt
7. # 语料库，包含训练模型的句子
8. sentences = ["i like dog", "i like cat", "i like animal",
9.              "dog cat animal", "apple cat dog like", "cat like fish",
10.              "dog like meat", "i like apple", "i hate apple",
11.              "i like movie book music apple", "dog like bark", "dog friend cat"]
13. # 构建词表
14. word_sentences = ' '.join(sentences).split()
15. word_list = list(set(word_sentences))
16. word_index = {w: i for i, w in enumerate(word_list)}
17. index_word = {i: w for i, w in enumerate(word_list)}
18. vocab_size = len(word_list)
20. # print(word_index)
22. # 创建词表
23. skip_grams = []
24. for i in range(1, len(word_sentences) - 1):
25.     # 当前词的id
26.     input_word = word_index[word_sentences[i]]
28.     # 获得上下文
29.     context = [word_index[word_sentences[i - 1]], word_index[word_sentences[i + 1]]]
30.     for w in context:
31.         # 当前词和上下文词组合形成的skip-gram数据集
32.         skip_grams.append([input_word, w])
34. # 定义超参数
35. # 词嵌入维度
36. emb_dim = 2
37. bach_size = 5
38. vocab_size = len(word_list)
40. # skip-gram 模型
41. class Word2Vec(nn.Module):
42.     def __init__(self):
43.         super().__init__()
44.         self.w1 = nn.Parameter(torch.rand(vocab_size, emb_dim).type(torch.FloatTensor))
45.         self.w2 = nn.Parameter(torch.rand(emb_dim, vocab_size).type(torch.FloatTensor))
47.     def forward(self, x):
48.         x = torch.matmul(x, self.w1)
49.         x = torch.matmul(x, self.w2)
50.         return x
52. # 模型训练
53. model = Word2Vec()
55. # 损失函数
56. criterion = nn.CrossEntropyLoss()
57. optimizer = optim.Adam(model.parameters(), lr=0.001)
59. def random_bath(data, size):
60.     label_list = []
61.     input_list = []
63.     random_index = np.random.choice(range(len(data)), size, replace=False)
65.     # 随机索引生成输入和标签批次
66.     for i in random_index:
67.         # 目标词one-hot 编码
68.         input_list.append((np.eye(vocab_size)[data[i][0]]))
70.         # 上下文
71.         label_list.append((data[i][1]))
72.     return input_list, label_list
74. for epoch in range(10000):
75.     # 获得数据
76.     inputs, labels = random_bath(skip_grams, bach_size)
78.     # 转换为张量
79.     input_bach = torch.Tensor(inputs)
80.     label_bach = torch.LongTensor(labels)
82.     optimizer.zero_grad()
83.     out = model(input_bach)
85.     loss = criterion(out, label_bach)
87.     if (epoch + 1) % 1000 == 0:
88.         print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))
90.     loss.backward()
91.     optimizer.step()
93. #可视化词嵌入
94. for i, label in enumerate(word_list):
95.     W, WT = model.parameters()  # 获取模型参数
96.     x, y = float(W[i][0]), float(W[i][1])
97.     plt.scatter(x, y)  # 绘制散点图
98.     plt.annotate(label, xy=(x, y), xytext=(5, 2), textcoords='offset points', ha='right', va='bottom')
100. plt.show()

复制代码

使用API调用

Gensim（generate similarity）是一个简单高效的自然语言处置惩罚Python库，用于抽取文档的语义主题（semantic topics）。Gensim的输入是原始的、无结构的数字文本（纯文本），内置的算法包罗Word2Vec，FastText，潜伏语义分析（Latent Semantic Analysis，LSA），潜伏狄利克雷分布（Latent Dirichlet Allocation，LDA）等，通过盘算练习语料中的统计共现模式自动发现文档的语义结构。这些算法都好坏监督的，这意味着不必要人工输入——仅仅必要一组纯文本语料。一旦发现这些统计模式后，任何纯文本（句子、短语、单词）就能接纳语义体现轻巧地表达。
model.wv: 这个对象包罗了全部单词的词嵌入向量。常用的方法有：

• model.wv[word]：返回某个特定单词的向量。
  
• model.wv.most_similar(word)：获取与某个单词最相似的词。
  
• model.wv.similarity(word1, word2)：盘算两个词之间的相似度。
  

1. import numpy as np
2. import matplotlib.pyplot as plt
3. from gensim.models import Word2Vec
5. sentences = "Word embedding is the collective name for a set of language modeling and feature learning techniques in natural language processing (NLP) where words or phrases from the vocabulary are mapped to vectors of real numbers."
7. # 每个句子分成单词表
8. token_list = [sentences.split()]  # 增加一个维度
9. print(token_list)
11. # 定义模型
12. model = Word2Vec(token_list, vector_size=2,window=1,min_count=0)
13. # 参数  语料库列表  size 词向量的维度  window窗口大小  最小出现次数、
15. # 获取词汇表   model.wv  映射矩阵 的对象
16. word_list = list(model.wv.index_to_key)
17. print(word_list)
19. # 可视化
20. # 设置matplotlib支持中文
21. plt.rcParams['font.sans-serif'] = ['SimHei']  # 设置中文字体
22. plt.rcParams['axes.unicode_minus'] = False  # 正确显示负号
23. #可视化词嵌入
24. for i, word in enumerate(word_list):
25.     W = model.wv[word]
26.     x,y = float(W[0]),float(W[1])
27.     plt.scatter(x, y) #  绘制散点图
28.     plt.annotate(word, xy=(x, y), xytext=(5, 2), textcoords='offset points', ha='right', va='bottom')
30. word_vector = [model.wv[word] for word in word_list]
31. sen_vector = np.mean(word_vector,axis=0)
32. print('句向量',sen_vector)
34. # 可视化
35. plt.scatter(sen_vector[0],sen_vector[1])
36. plt.annotate('句向量', xy=(sen_vector[0],sen_vector[1]), xytext=(5, 2), textcoords='offset points', ha='right', va='bottom')
38. plt.show()

复制代码

参考博客：
Gensim简介-CSDN博客