使用 PyTorch 实现 Word2Vec 中Skip-gram 模型

最新推荐文章于 2024-04-30 11:24:34 发布
最新推荐文章于 2024-04-30 11:24:34 发布
阅读量583 收藏 1
点赞数
文章标签： pytorch word2vec 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/metal1/article/details/132886936
版权

首先创建了一个使用 Word2VecDataset 类自定义的数据集，用于生成训练数据。然后，定义了 Skip-gram 模型，并使用交叉熵损失函数和 Adam 优化器进行训练。

在每个训练周期中，遍历数据加载器，对每个批次进行前向传播、计算损失、反向传播和权重更新。最后，得到训练得到的词向量，并可以使用 word_vector 来获取特定单词的词向量表示。

确保在运行之前安装 PyTorch，可以使用 pip install torch 来安装它。请注意，如果可用的话，代码将在 GPU 上运行。如果没有 GPU，请将 .to(torch.device('cuda' if torch.cuda.is_available() else 'cpu')) 部分删除，并在 CPU 上运行。

以下是使用 PyTorch 实现 Skip-gram 模型的示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# Hyperparameters
embedding_dim = 100
window_size = 2
learning_rate = 0.001
epochs = 100
batch_size = 32

# Example corpus
corpus = [['I', 'enjoy', 'playing', 'football', 'with', 'my', 'friends'],
          ['We', 'like', 'to', 'play', 'tennis', 'on', 'weekends'],
          ['She', 'is', 'a', 'good', 'dancer']]

# Create vocabulary
vocab = list(set([word for sentence in corpus for word in sentence]))
vocab_size = len(vocab)
word2idx = {word: idx for idx, word in enumerate(vocab)}
idx2word = {idx: word for idx, word in enumerate(vocab)}

# Generate training data
class Word2VecDataset(Dataset):
    def __init__(self, corpus, word2idx):
        self.data = []
        for sentence in corpus:
            word_indices = [word2idx[word] for word in sentence]
            for center_word_idx, center_word in enumerate(word_indices):
                for context_word_idx in range(max(0, center_word_idx - window_size), min(center_word_idx + window_size + 1, len(word_indices))):
                    if context_word_idx != center_word_idx:
                        context_word = word_indices[context_word_idx]
                        self.data.append((center_word, context_word))
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx]

dataset = Word2VecDataset(corpus, word2idx)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# Define Skip-gram model
class SkipGramModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        super(SkipGramModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.linear = nn.Linear(embedding_dim, vocab_size)
        
    def forward(self, center_word):
        embedded = self.embedding(center_word)
        output = self.linear(embedded)
        return output

model = SkipGramModel(vocab_size, embedding_dim)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# Training
for epoch in range(epochs):
    running_loss = 0.0
    for i, (center_word, context_word) in enumerate(dataloader):
        optimizer.zero_grad()
        
        center_word = center_word.to(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))
        context_word = context_word.to(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))
        
        output = model(center_word)
        loss = criterion(output, context_word)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        
    average_loss = running_loss / len(dataloader)
    print(f'Epoch {epoch+1}/{epochs}, Loss: {average_loss:.4f}')

# Get trained word embeddings
trained_embeddings = model.embedding.weight.data.numpy()

# Example usage - Getting word vector for a word
word = 'football'
word_vector = trained_embeddings[word2idx[word]]
print(f"Word vector for '{word}': {word_vector}")

运行结果如下：

Epoch 1/100, Loss: 3.1324
Epoch 2/100, Loss: 3.0791
Epoch 3/100, Loss: 2.9902
Epoch 4/100, Loss: 2.9392
Epoch 5/100, Loss: 2.8870
Epoch 6/100, Loss: 2.8166
Epoch 7/100, Loss: 2.7615
Epoch 8/100, Loss: 2.7017
Epoch 9/100, Loss: 2.6500
Epoch 10/100, Loss: 2.5993
Epoch 11/100, Loss: 2.5496
Epoch 12/100, Loss: 2.5013
Epoch 13/100, Loss: 2.4621
Epoch 14/100, Loss: 2.4079
Epoch 15/100, Loss: 2.3660
Epoch 16/100, Loss: 2.3229
Epoch 17/100, Loss: 2.2795
Epoch 18/100, Loss: 2.2398
Epoch 19/100, Loss: 2.1998
Epoch 20/100, Loss: 2.1582
Epoch 21/100, Loss: 2.1278
Epoch 22/100, Loss: 2.1023
Epoch 23/100, Loss: 2.0569
Epoch 24/100, Loss: 2.0245
Epoch 25/100, Loss: 1.9936
Epoch 26/100, Loss: 1.9639
Epoch 27/100, Loss: 1.9344
Epoch 28/100, Loss: 1.9137
Epoch 29/100, Loss: 1.8888
Epoch 30/100, Loss: 1.8586
Epoch 31/100, Loss: 1.8352
Epoch 32/100, Loss: 1.8200
Epoch 33/100, Loss: 1.7815
Epoch 34/100, Loss: 1.7685
Epoch 35/100, Loss: 1.7531
Epoch 36/100, Loss: 1.7209
Epoch 37/100, Loss: 1.7049
Epoch 38/100, Loss: 1.6881
Epoch 39/100, Loss: 1.6775
Epoch 40/100, Loss: 1.6517
Epoch 41/100, Loss: 1.6390
Epoch 42/100, Loss: 1.6238
Epoch 43/100, Loss: 1.6077
Epoch 44/100, Loss: 1.5939
Epoch 45/100, Loss: 1.5745
Epoch 46/100, Loss: 1.5703
Epoch 47/100, Loss: 1.5574
Epoch 48/100, Loss: 1.5458
Epoch 49/100, Loss: 1.5308
Epoch 50/100, Loss: 1.5215
Epoch 51/100, Loss: 1.5122
Epoch 52/100, Loss: 1.4988
Epoch 53/100, Loss: 1.4958
Epoch 54/100, Loss: 1.4773
Epoch 55/100, Loss: 1.4746
Epoch 56/100, Loss: 1.4618
Epoch 57/100, Loss: 1.4560
Epoch 58/100, Loss: 1.4506
Epoch 59/100, Loss: 1.4380
Epoch 60/100, Loss: 1.4266
Epoch 61/100, Loss: 1.4257
Epoch 62/100, Loss: 1.4148
Epoch 63/100, Loss: 1.4090
Epoch 64/100, Loss: 1.4070
Epoch 65/100, Loss: 1.3940
Epoch 66/100, Loss: 1.3890
Epoch 67/100, Loss: 1.3846
Epoch 68/100, Loss: 1.3813
Epoch 69/100, Loss: 1.3738
Epoch 70/100, Loss: 1.3717
Epoch 71/100, Loss: 1.3681
Epoch 72/100, Loss: 1.3594
Epoch 73/100, Loss: 1.3593
Epoch 74/100, Loss: 1.3504
Epoch 75/100, Loss: 1.3447
Epoch 76/100, Loss: 1.3439
Epoch 77/100, Loss: 1.3397
Epoch 78/100, Loss: 1.3315
Epoch 79/100, Loss: 1.3260
Epoch 80/100, Loss: 1.3253
Epoch 81/100, Loss: 1.3229
Epoch 82/100, Loss: 1.3215
Epoch 83/100, Loss: 1.3148
Epoch 84/100, Loss: 1.3160
Epoch 85/100, Loss: 1.3072
Epoch 86/100, Loss: 1.3105
Epoch 87/100, Loss: 1.3104
Epoch 88/100, Loss: 1.3018
Epoch 89/100, Loss: 1.2912
Epoch 90/100, Loss: 1.2950
Epoch 91/100, Loss: 1.2938
Epoch 92/100, Loss: 1.2951
Epoch 93/100, Loss: 1.2859
Epoch 94/100, Loss: 1.2902
Epoch 95/100, Loss: 1.2840
Epoch 96/100, Loss: 1.2748
Epoch 97/100, Loss: 1.2840
Epoch 98/100, Loss: 1.2763
Epoch 99/100, Loss: 1.2772
Epoch 100/100, Loss: 1.2746


Word vector for 'football':

[-1.2727762   0.8401019  -0.5115612   2.0667355   1.1854529  -0.7444803
 -1.9658612  -1.0488677   0.98938674 -1.1675086   1.582392    1.7414839
 -0.4892138  -1.2149098   0.15343344 -1.8318586   0.41794038  0.25481498
  0.6008032  -0.23904797  0.80143225 -1.0495795  -1.0174142  -0.01827855
  2.7477944  -0.9574399   1.025569    2.4843202  -0.2796719  -0.4390253
 -1.4423424  -1.8073392   0.1897556   0.90259725  2.7565296  -0.28331178
 -1.8443514   0.77545553 -1.0289538   0.71483964  1.1801128  -0.22635305
  0.5960759   0.6690206  -1.9100318   1.2388043  -0.68522704  0.92120373
  1.0252377  -1.4376261  -0.6595934   0.31699112  0.6751458   0.99656415
  0.40565705 -1.0904227  -0.3513346  -0.66078615  1.1834346  -1.0899751
 -1.4925232  -0.30818892  1.4249563   0.06006899 -3.2386255   0.96192694
 -1.1045157   0.5540482  -1.5388466  -0.8721646   1.1221852   1.6488599
  0.44869688  1.1519432  -1.4588032  -0.04230021 -0.33113605  1.1316347
 -0.7425484  -0.11400439  0.37237874 -0.34573358  0.4140474  -0.04413145
  0.6157635  -1.0094129  -1.2208599  -0.7154122   0.9412035   0.9452426
 -0.0973389  -0.23566085  0.34300375 -0.95858365  0.8764276  -0.5669889
 -1.933235    0.22371146  1.6641699   1.3258857 ]

天一生水water
关注
一文弄懂Word2Vec之skip-gram（含详细代码）
Python，数据分析，机器学习，深度学习
12-06 1万+
目录 前言 一、什么是Skip-gram算法 二、目标是什么 三、定义表示法 3.1 one-hot向量 3.2 词向量（word vector） 3.3 单词矩阵 3.4 单词相似度 3.5 softmax函数 3.6算法过程 3.7 求softmax 四、skipgram代码实现 4.1 如何把词转换为向量 4.2 CBOW和Skip-gram的算法实现 Skip-gram的理想实现 Skip-gram的实际实现 4.3 使用Pytorch实现Skip-gram .
python-pytorch实现skip-gram 0.5.001
随笔
04-09 358
python-pytorch实现skip-gram 0.5.000
深度学总结：skip-gram pytorch实现
weixin_40759186的博客
02-21 5922
文章目录skip-gram pytorch 朴素实现网络结构训练过程:使用nn.NLLLoss()batch的准备，为unsupervised，准备数据获取（center,contex)的pair：采样时的优化：降低高频词的概率skip-gram 进阶的方法 skip-gram pytorch 朴素实现 网络结构 class SkipGram(nn.Module): def __init...
实现负频率_PyTorch 实现 Skip-gram
weixin_42299244的博客
01-09 313
代码实现：https://github.com/zhangxiann/Skip-gram这是我用于学习 Skip-gram 的笔记。文中会有一些公式，如果 github 出现公式乱码问题，请通过我的博客查看：https://zhuanlan.zhihu.com/p/275899732。下面废话不多说，教你手把手实现 Skip-gram。CBOW 和 Skip-gram 是两种训练得到词向量的方法...
python-pytorch实现skip-gram 0.5.000【直接可运行】
随笔
04-09 356
python-pytorch实现skip-gram 0.5.000【直接可运行】
Skip-gram负采样原理及代码实现（pytorch）
weixin_45837958的博客
05-12 2119
绝大多数的词向量学习模型本质都是建立在词和其上下文之间的联系。比如我们常见的CBOW模型，是根据上下窗口中的词的合集作为输入去预测目标词，即，其中其中的k为超参数文本窗口大小。而skip-gram模型在此基础上做了进一步的简化，使用中的每一个词作为独立的上下文对目标词进行预测。因此skip-gram模型可以用于建立词与词之间的共现关系，即，其中。
在PyTorch中处理文本数据时，如何进行词嵌入和文本向量化？
最新发布
coszhuang的博客
04-30 932
词嵌入和文本向量化是NLP中常用的技术，可以将文本数据转换为机器学习算法可以处理的数值向量，从而提取文本的语义信息和特征。词嵌入是一种将离散的词转换为连续的向量表示的方法，通常使用的是分布式假设。Skip-gram模型的目标是根据一个给定的中心词来预测与之相关的上下文词，而CBOW模型则是根据给定的上下文词来预测中心词。通过以上的详细介绍，包括了算法原理、公式推导、计算步骤和Python代码示例，我们可以在PyTorch中灵活处理文本数据，进行词嵌入和文本向量化的操作，并为后续的机器学习算法提供输入。
Pytorch学习笔记之训练词向量（三）
饲养员的小熊猫博客
04-11 1482
Pytorch学习笔记之Pytorch训练词向量（三） 学习目标 学习词向量的概念 用Skip-thought模型训练词向量 学习使用PyTorch dataset和dataloader 学习定义PyTorch模型 学习torch.nn中常见的Module Embedding 学习常见的PyTorch operations bmm logsigmoid 保存和读取PyTorch模型 ...
基于pytorch实现Word2Vec（skip-gram+Negative Sampling）
qq_24668285的博客
12-07 5834
目录 word2vec简介 语料处理 数据预处理 训练模型 近似训练法 参数设定 预测及可视化 word2vec简介 2013 年，Google 团队发表了 word2vec 工具。word2vec 工具主要包含两个模型：跳字模型（skip-gram）和连续词模型（continuous bag of words，简称 CBOW），以及两种高效训练的方法：负采样（negative sampling）和层序 softmax（hierarchical softmax）。 类似于f(x)->
word2vec在PyTorch中的实现代码及其数据
02-24
标题"word2vec在PyTorch中的实现代码及其数据"表明了这个压缩包包含的资源是关于使用Python深度学习框架PyTorch实现word2vec模型的源代码，以及可能用于训练或测试该模型的相关数据集。 描述中的"代码注释详细，...
pytorch-sgns:PyTorch中的Skipgram负采样
05-04
PyTorch SGNS Python中Word2Vec的SkipGramNegativeSampling 。 在实现了另一个但非常普遍的。 它可以与任何嵌入方案一起使用！ 我敢打赌。 vocab_size = 20000 word2vec = Word2Vec ( vocab_size = vocab_size , embedding_size = 300 ) sgns = SGNS ( embedding = word2vec , vocab_size = vocab_size , n_negs = 20 ) optim = Adam ( sgns . parameters ()) for batch , ( iword , owords ) in enumerate ( dataloader ): loss = sgns ( iword , owords )
word2vec-pytorch:PyTorch中word2vec的实现
04-29
总结来说，"word2vec-pytorch"项目为研究者和开发者提供了一个在PyTorch中实现word2vec模型的平台，结合CBOW和Skipgram模型，以及采样策略，可以有效地学习到单词的向量表示，进而应用于各种NLP任务，如文本分类、...
Python Skip-Gram代码实战，Skip-Gram代码超简单讲解和步骤拆解，Word2vec代码构建思路，Skip-Gram代码实例，模板套用
L_goodboy的博客
02-28 1777
Python Skip-Gram代码实战，Skip-Gram代码超简单讲解和步骤拆解，Word2vec代码构建思路，Skip-Gram代码实例，模板套用
pytorch笔记： 搭建Skip—gram
qq_40206371的博客
07-09 562
skip-gram 理论部分见：NLP 笔记：Skip-gram_刘文巾的博客-CSDN博客 1 导入库 import numpy as np import torch from torch import nn, optim import random from collections import Counter import matplotlib.pyplot as plt 2 数据集部分 2.1 训练数据 #训练数据 text ='I like dog i like cat i like
PyTorch 实现 Skip-gram
张贤的博客
11-06 2245
代码实现：https://github.com/zhangxiann/Skip-gram 这篇文章来说下如何使用 PyTorch 实现 Skip-gram，文中会出现一些数学公式。 CBOW 和 Skip-gram 是两种训练得到词向量的方法。其中 CBOW 是从上下文字词推测目标字词，而 Skip-gram 则是从目标字词推测上下文的字词。在大型数据集上，CBOW 比 Skip-gram 效果好；但是在小的数据集上，Skip-gram 比 CBOW 效果好。本文使用 PyTorch 来实现 Skip-.
深度学习框架-PyTorch实战
12-03
购买课程后，添加小助手微信（微信号：csdnxy68）回复【唐宇迪】进入学习群，获取唐宇迪老师答疑深度学习框架-PyTorch实战课程旨在帮助同学们快速掌握PyTorch框架核心模块使用方法与项目应用实例，让同学们熟练使用PyTorch框架进行项目开发。课程内容全部以实战为导向，基于当下计算机视觉与自然语言处理中经典项目进行实例讲解，通过Debug模式详解项目中每一行代码的作用与效果，整体风格通俗易懂，提供全部课程所属课件。
pytorch实现skip gram
weixin_40440610的博客
05-09 254
import torch import numpy as np import torch.nn as nn import torch.optim as optim import matplotlib.pyplot as plt import torch.utils.data as Data dtype = torch.FloatTensor device = torch.device("cuda" if torch.cuda.is_available() else "cpu") sentences =
pytorch动手实现skipgram模型
Learning from the mistakes
05-02 560
最近用pytorch实现了一下skipgram模型，代码参考了github哈，这里分享了我的实现： 下载数据集 import nltk nltk.download('twitter_samples') from nltk.corpus import twitter_samples 添加label label = "neg" neg_dataset = [(label, instance) for instance in twitter_samples.strings('negative_tweet
解决词相似度问题：深入理解Word2Vec与Skip-Gram模型
在实现过程中，L24word2vec着重于Skip-Gram模型，因为CBOW的实现方法相似。训练过程需要一个大型自然语言语料库，例如经典的PTB（Penn Treebank）数据集，它包含了《华尔街日报》文章的样本，被划分为训练、验证和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值