Word2Vec基本实践

2024-06-20 06:20
文章标签 word2vec 实践 基本

本文主要是介绍Word2Vec基本实践，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

系列文章目录

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

  • 系列文章目录
  • 前言
  • 一、使用SkipGram 模型
    • 1. 构建实验语料库
    • 2. 生成Skip-Gram训练数据
    • 3. 对Skip-Gram数据进行One-Hot编码
    • 4. 定义Skip-Gram模型
    • 5. 训练Skip-Gram模型
    • 6. 输出Skip-Gram词向量
  • 二、使用CBOW 模型
    • 1. 构建实验语料库
    • 2. 生成CBOW训练数据
    • 3. CBOW数据进行One-Hot编码
    • 4. 定义CBOW模型
    • 5. 训练CBOW模型
    • 6. 输出CBOW词向量

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考

一、使用SkipGram 模型

1. 构建实验语料库

# 定义一个句子列表，后面会用这些句子来训练CBOW和Skip-Gram模型
sentences = ["Kage is Teacher", "Mazong is Boss", "Niuzong is Boss","Xiaobing is Student", "Xiaoxue is Student",]
# 将所有句子连接在一起，然后用空格分隔成词汇
words = ' '.join(sentences).split()
# 构建词汇表，去除重复的词
word_list = list(set(words))
# 创建一个字典，将每个词汇映射到一个唯一的索引
word_to_idx = {word: idx for idx, word in enumerate(word_list)}
# 创建一个字典，将每个索引映射到对应的词汇
idx_to_word = {idx: word for idx, word in enumerate(word_list)}
voc_size = len(word_list) # 计算词汇表的大小
print("词汇表：", word_list) # 输出词汇表
print("词汇到索引的字典：", word_to_idx) # 输出词汇到索引的字典
print("索引到词汇的字典：", idx_to_word) # 输出索引到词汇的字典
print("词汇表大小：", voc_size) # 输出词汇表大小

2. 生成Skip-Gram训练数据

# 生成Skip-Gram训练数据
def create_skipgram_dataset(sentences, window_size=2):data = []for sentence in sentences:sentence = sentence.split()  # 将句子分割成单词列表for idx, word in enumerate(sentence):  # 遍历单词及其索引# 获取相邻的单词，将当前单词前后各N个单词作为相邻单词for neighbor in sentence[max(idx - window_size, 0): min(idx + window_size + 1, len(sentence))]:if neighbor != word:  # 排除当前单词本身# 将相邻单词与当前单词作为一组训练数据data.append((neighbor, word))return data
# 使用函数创建Skip-Gram训练数据
skipgram_data = create_skipgram_dataset(sentences)
# 打印未编码的Skip-Gram数据样例
print("Skip-Gram数据样例（未编码）：", skipgram_data)

3. 对Skip-Gram数据进行One-Hot编码

# 定义One-Hot编码函数
import torch # 导入torch库
def one_hot_encoding(word, word_to_idx):# 创建一个全为0的张量，长度与词汇表大小相同tensor = torch.zeros(len(word_to_idx))  tensor[word_to_idx[word]] = 1  # 将对应词汇的索引位置置为1return tensor  # 返回生成的One-Hot向量# 展示One-Hot编码前后的数据
word_example = "Teacher"
print("One-Hot编码前的单词：", word_example)
print("One-Hot编码后的向量：", one_hot_encoding(word_example, word_to_idx))# 展示编码后的Skip-Gram数据样例
print("Skip-Gram数据样例（已编码）：", [(one_hot_encoding(context, word_to_idx), word_to_idx[target]) for context, target in skipgram_data[:3]])

4. 定义Skip-Gram模型

# 定义Skip-Gram模型
import torch.nn as nn # 导入neural network
class SkipGram(nn.Module):def __init__(self, voc_size, embedding_size):super(SkipGram, self).__init__()# 从词汇表大小到嵌入大小的线性层（权重矩阵）self.input_to_hidden = nn.Linear(voc_size, embedding_size, bias=False)  # 从嵌入大小到词汇表大小的线性层（权重矩阵）self.hidden_to_output = nn.Linear(embedding_size, voc_size, bias=False)  def forward(self, X): # X : [batch_size, voc_size]        # 生成隐藏层：[batch_size, embedding_size]hidden_layer = self.input_to_hidden(X) # 生成输出层：[batch_size, voc_size]output_layer = self.hidden_to_output(hidden_layer)  return output_layerembedding_size = 2 # 设定嵌入层的大小，这里选择2是为了方便展示
skipgram_model = SkipGram(voc_size,embedding_size)  # 实例化SkipGram模型
print("Skip-Gram模型：", skipgram_model)##建立skipgram模型--使用nn.embedding层替代线性层import torch.nn as nn
class SkipGram(nn.Module):def __init__(self,voc_size,embeding_size):super(SkipGram,self).__init__()self.input_to_hidden=nn.Embedding(voc_size,embeding_size)self.hidden_to_output=nn.Linear(embeding_size,voc_size,bias=False)def forward(self,X):hidden_layer=self.input_to_hidden(X)output_layer=self.hidden_to_output(hidden_layer)return output_layervoc_size=len(words_list)
skipgram_model=SkipGram(voc_size,embeding_size=2)

5. 训练Skip-Gram模型

# 训练Skip-Gram模型
learning_rate = 0.001 # 设置学习速率
epochs = 1000 # 设置训练轮次
criterion = nn.CrossEntropyLoss()  # 定义交叉熵损失函数
import torch.optim as optim # 导入随机梯度下降优化器
optimizer = optim.SGD(skipgram_model.parameters(), lr=learning_rate)  # 开始训练循环
loss_values = []  # 用于存储每轮的平均损失值
for epoch in range(epochs):loss_sum = 0 # 初始化损失值for context, target in skipgram_data:        X = one_hot_encoding(target, word_to_idx).float().unsqueeze(0) # 将中心词转换为One-Hot向量   y_true = torch.tensor([word_to_idx[context]], dtype=torch.long) # 将周围词转换为索引值   y_pred = skipgram_model(X)  # 计算预测值loss = criterion(y_pred, y_true)  # 计算损失loss_sum += loss.item() # 累积损失optimizer.zero_grad()  # 清空梯度loss.backward()  # 反向传播optimizer.step()  # 更新参数if (epoch+1) % 100 == 0: # 输出每100轮的损失，并记录损失print(f"Epoch: {epoch+1}, Loss: {loss_sum/len(skipgram_data)}")  loss_values.append(loss_sum / len(skipgram_data))# 绘制训练损失曲线
import matplotlib.pyplot as plt # 导入matplotlib
plt.plot(range(1, epochs//100 + 1), loss_values) # 绘图
plt.title('Training Loss') # 图题
plt.xlabel('Epochs') # X轴Label
plt.ylabel('Loss') # Y轴Label
plt.show() # 显示图

6. 输出Skip-Gram词向量

# 输出Skip-Gram习得的词嵌入
print("\nSkip-Gram词嵌入:")
for word, idx in word_to_idx.items(): # 输出每个单词的嵌入向量print(f"{word}: \{skipgram_model.input_to_hidden.weight[:, idx].detach().numpy()}")  plt.rcParams["font.family"]=['SimHei'] # 用来设定字体样式
plt.rcParams['font.sans-serif']=['SimHei'] # 用来设定无衬线字体样式
plt.rcParams['axes.unicode_minus']=False # 用来正常显示负号
# 绘制二维词向量图
fig, ax = plt.subplots() 
for word, idx in word_to_idx.items():vec = skipgram_model.input_to_hidden.weight[:, \idx].detach().numpy() # 获取每个单词的嵌入向量ax.scatter(vec[0], vec[1]) # 在图中绘制嵌入向量的点ax.annotate(word, (vec[0], vec[1]), fontsize=12) # 点旁添加单词标签
plt.title('2维词嵌入') # 图题
plt.xlabel('向量维度1') # X轴Label
plt.ylabel('向量维度2') # Y轴Label
plt.show() # 显示图

二、使用CBOW 模型

1. 构建实验语料库

# 定义一个句子列表，后面会用这些句子来训练CBOW和CBOW模型
sentences = ["Kage is Teacher", "Mazong is Boss", "Niuzong is Boss","Xiaobing is Student", "Xiaoxue is Student",]
# 将所有句子连接在一起，然后用空格分隔成词汇
words = ' '.join(sentences).split()
# 构建词汇表，去除重复的词
word_list = list(set(words))
# 创建一个字典，将每个词汇映射到一个唯一的索引
word_to_idx = {word: idx for idx, word in enumerate(word_list)}
# 创建一个字典，将每个索引映射到对应的词汇
idx_to_word = {idx: word for idx, word in enumerate(word_list)}
voc_size = len(word_list) # 计算词汇表的大小
print("词汇表：", word_list) # 输出词汇表
print("词汇到索引的字典：", word_to_idx) # 输出词汇到索引的字典
print("索引到词汇的字典：", idx_to_word) # 输出索引到词汇的字典
print("词汇表大小：", voc_size) # 输出词汇表大小

2. 生成CBOW训练数据

# 生成CBOW训练数据
def create_cbow_dataset(sentences, window_size=2):data = []for sentence in sentences:sentence = sentence.split()  # 将句子分割成单词列表for idx, word in enumerate(sentence):  # 遍历单词及其索引# 获取上下文词汇，将当前单词前后各window_size个单词作为上下文词汇context_words = sentence[max(idx - window_size, 0):idx] \+ sentence[idx + 1:min(idx + window_size + 1, len(sentence))]# 将当前单词与上下文词汇作为一组训练数据data.append((word, context_words))return data# 使用函数创建CBOW训练数据
cbow_data = create_cbow_dataset(sentences)
# 打印未编码的CBOW数据样例（前三个）
print("CBOW数据样例（未编码）：", cbow_data[:3])

3. CBOW数据进行One-Hot编码

# 定义One-Hot编码函数
import torch # 导入torch库
def one_hot_encoding(word, word_to_idx):# 创建一个全为0的张量，长度与词汇表大小相同tensor = torch.zeros(len(word_to_idx))  tensor[word_to_idx[word]] = 1  # 将对应词汇的索引位置置为1return tensor  # 返回生成的One-Hot向量# 展示One-Hot编码前后的数据
word_example = "Teacher"
print("One-Hot编码前的单词：", word_example)
print("One-Hot编码后的向量：", one_hot_encoding(word_example, word_to_idx))# 展示编码后的CBOW数据样例
# 展示编码后的CBOW数据样例
print("CBOW数据样例（已编码）：", [(one_hot_encoding(target, word_to_idx), [one_hot_encoding(context, word_to_idx) for context in context_words]) for target, context_words in cbow_data[:3]])

4. 定义CBOW模型

# 定义CBOW模型
import torch.nn as nn # 导入neural network# 定义CBOW模型
class CBOW(nn.Module):def __init__(self, voc_size, embedding_size):super(CBOW, self).__init__()# 从词汇表大小到嵌入大小的线性层（权重矩阵）self.input_to_hidden = nn.Linear(voc_size, embedding_size, bias=False)  # 从嵌入大小到词汇表大小的线性层（权重矩阵）self.hidden_to_output = nn.Linear(embedding_size, voc_size, bias=False)  def forward(self, X): # X: [num_context_words, voc_size]# 生成嵌入：[num_context_words, embedding_size]embeddings = self.input_to_hidden(X)  # 计算隐藏层，求嵌入的均值：[embedding_size]hidden_layer = torch.mean(embeddings, dim=0)  # 生成输出层：[1, voc_size]output_layer = self.hidden_to_output(hidden_layer.unsqueeze(0)) return output_layerembedding_size = 2 # 设定嵌入层的大小，这里选择2是为了方便展示
cbow_model = CBOW(voc_size,embedding_size)  # 实例化cbow模型
print("CBOW模型：", cbow_model)

5. 训练CBOW模型

# 训练CBOW模型
learning_rate = 0.001 # 设置学习速率
epochs = 1000 # 设置训练轮次
criterion = nn.CrossEntropyLoss()  # 定义交叉熵损失函数
import torch.optim as optim # 导入随机梯度下降优化器
optimizer = optim.SGD(cbow_model.parameters(), lr=learning_rate)  # 开始训练循环
loss_values = []  # 用于存储每轮的平均损失值
for epoch in range(epochs):loss_sum = 0for target, context_words in cbow_data:# 将上下文词转换为One-hot向量并堆叠X = torch.stack([one_hot_encoding(word, word_to_idx) for word in context_words]).float() y_true = torch.tensor([word_to_idx[target]], dtype=torch.long)  # 将目标词转换为索引值y_pred = cbow_model(X)  # 计算预测值loss = criterion(y_pred, y_true)  # 计算损失loss_sum += loss.item()optimizer.zero_grad()  # 清空梯度loss.backward()  # 反向传播optimizer.step()  # 更新参数if (epoch+1) % 100 == 0: # 输出每100轮的损失，并记录损失print(f"Epoch: {epoch+1}, Loss: {loss_sum/len(cbow_data)}")  loss_values.append(loss_sum / len(cbow_data))
# 绘制训练损失曲线
import matplotlib.pyplot as plt # 导入matplotlib
plt.plot(range(1, epochs//100 + 1), loss_values) # 绘图
plt.title('Training Loss') # 图题
plt.xlabel('Epochs') # X轴Label
plt.ylabel('Loss') # Y轴Label
plt.show() # 显示图

6. 输出CBOW词向量

# 输出CBOW习得的词嵌入
print("\nCBOW词嵌入:")
for word, idx in word_to_idx.items(): # 输出每个单词的嵌入向量print(f"{word}: \{cbow_model.input_to_hidden.weight[:, idx].detach().numpy()}")  

plt.rcParams["font.family"]=['SimHei'] # 用来设定字体样式
plt.rcParams['font.sans-serif']=['SimHei'] # 用来设定无衬线字体样式
plt.rcParams['axes.unicode_minus']=False # 用来正常显示负号
# 绘制二维词向量图
fig, ax = plt.subplots() 
for word, idx in word_to_idx.items():vec = cbow_model.input_to_hidden.weight[:, \idx].detach().numpy() # 获取每个单词的嵌入向量ax.scatter(vec[0], vec[1]) # 在图中绘制嵌入向量的点ax.annotate(word, (vec[0], vec[1]), fontsize=12) # 点旁添加单词标签
plt.title('2维词嵌入') # 图题
plt.xlabel('向量维度1') # X轴Label
plt.ylabel('向量维度2') # Y轴Label
plt.show() # 显示图

这篇关于Word2Vec基本实践的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1077346。

相关文章

C++必修：模版的入门到实践

C++必修：模版的入门到实践

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：C++学习 贝蒂的主页：Betty’s blog 1. 泛型编程 首先让我们来思考一个问题，如何实现一个交换函数？ void swap(int& x, int& y){int tmp = x;x = y;y = tmp;} 相信大家很快就能写出上面这段代码，但是如果要求这个交换函数支持字符型
阅读更多...
亮相WOT全球技术创新大会，揭秘火山引擎边缘容器技术在泛CDN场景的应用与实践

亮相WOT全球技术创新大会，揭秘火山引擎边缘容器技术在泛CDN场景的应用与实践

2024年6月21日-22日，51CTO“WOT全球技术创新大会2024”在北京举办。火山引擎边缘计算架构师李志明受邀参与，以“边缘容器技术在泛CDN场景的应用和实践”为主题，与多位行业资深专家，共同探讨泛CDN行业技术架构以及云原生与边缘计算的发展和展望。 火山引擎边缘计算架构师李志明表示：为更好地解决传统泛CDN类业务运行中的问题，火山引擎边缘容器团队参考行业做法，结合实践经验，打造火山
阅读更多...
9 个 GraphQL 安全最佳实践

9 个 GraphQL 安全最佳实践

GraphQL 已被最大的平台采用 - Facebook、Twitter、Github、Pinterest、Walmart - 这些大公司不能在安全性上妥协。但是，尽管 GraphQL 可以成为您的 API 的非常安全的选项，但它并不是开箱即用的。事实恰恰相反：即使是最新手的黑客，所有大门都是敞开的。此外，GraphQL 有自己的一套注意事项，因此如果您来自 REST，您可能会错过一些重要步骤！
阅读更多...
微信小程序开发必知必会：文件结构和基本配置

微信小程序开发必知必会：文件结构和基本配置

一、微信小程序基本文件结构 1.  project.config.json：项目的基本配置文件，包括项目名称、appid、项目目录、页面文件夹等。     {"setting": {"urlCheck": false,"es6": true,"postcss": true,"nodeModulesPath": "D:\\\\node_modules"},"appid": "wxd678e
阅读更多...
PHP的基本语法有哪些？

PHP的基本语法有哪些？

PHP的基本语法包括以下几个方面： PHP标记：PHP脚本以<?php开始，以?>结束。这是PHP文件的默认文件扩展名是.php。 变量和常量：变量以$符号开头，其后是变量的名称。常量使用define()函数定义，例如define("常量名", 常量值);。 数据类型：PHP支持多种数据类型，如整型、浮点型、字符串型等。 注释：PHP支持单行注释（用//表示）和多行注释（用/* */表示
阅读更多...
SDAutoLayout/UIView+SDAutoLayout.h 的基本使用，记住这4个Api就足够了~

SDAutoLayout/UIView+SDAutoLayout.h 的基本使用，记住这4个Api就足够了~

1.1 > leftSpaceToView(self.view, 10) 方法名中带有“SpaceToView”的方法表示到某个参照view的间距，需要传递2个参数：（UIView）参照view 和 （CGFloat）间距数值 1.2 > widthRatioToView(self.view, 1) 方法名中带有“RatioToView”的方法表示view的宽度或者高度等属性相对于参
阅读更多...
Netty ByteBuf 释放详解：内存管理与最佳实践

Netty ByteBuf 释放详解：内存管理与最佳实践

Netty ByteBuf 释放详解：内存管理与最佳实践 在Netty中（学习netty请参考：🔗深入浅出Netty：高性能网络应用框架的原理与实践），管理ByteBuf的内存是至关重要的（学习ByteBuf请参考：🔗Netty ByteBuf 详解：高性能数据缓冲区的全面介绍）。未能正确释放ByteBuf可能会导致内存泄漏，进而影响应用的性能和稳定性。本文将详细介绍如何正确地释放ByteB
阅读更多...
Clickhouse 的性能优化实践总结

Clickhouse 的性能优化实践总结

文章目录 前言性能优化的原则数据结构优化内存优化磁盘优化网络优化CPU优化查询优化数据迁移优化 前言 ClickHouse是一个性能很强的OLAP数据库，性能强是建立在专业运维之上的，需要专业运维人员依据不同的业务需求对ClickHouse进行有针对性的优化。同一批数据，在不同的业务下，查询性能可能出现两极分化。 性能优化的原则 在进行ClickHouse性能优化时，有几条
阅读更多...
Eclipse使用git最基本流程

Eclipse使用git最基本流程

Eclipse使用git最基本流程，eclipsegit流程 git有诸多好处，网上都说的很清楚了，在这里我不再赘述。对于我来说，私下里想做一些项目，而又不能很好的保存自己的代码和进行版本控制，这时候，就用到了git。下面，就以我个人为例讲讲git从0开始如何安装使用。 Step1 准备工作 msysgit，下载地址为http://msysgit.github.io/
阅读更多...
RabbitMQ实践——临时队列

RabbitMQ实践——临时队列

临时队列是一种自动删除队列。当这个队列被创建后，如果没有消费者监听，则会一直存在，还可以不断向其发布消息。但是一旦的消费者开始监听，然后断开监听后，它就会被自动删除。 新建自动删除队列 我们创建一个名字叫queue.auto.delete的临时队列 绑定 我们直接使用默认交换器，所以不用创建新的交换器，也不用建立绑定关系。 实验 发布消息 我们在后台管理页面的默认交换器下向这个队列
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2