pytorch之词嵌入(三)_pytorch词嵌入

2、pytorch中的词嵌入

在开始工作示例和练习之前，先简要介绍一下如何在Pytorch和深度学习编程中使用嵌入。类似于我们在制作单热向量时为每个单词定义唯一索引的方式，我们也需要在使用嵌入时为每个单词定义索引。这些将成为查找表的关键字。也就是说，嵌入存储为|V|×D矩阵，其中 D是嵌入的维数，因此单词分配索引 i将其嵌入存储在 i矩阵的第th行。在我的所有代码中，从单词到索引的映射都是一个名为word_to_ix的字典。

允许您使用嵌入的模块是torch.nn.Embedding，它带有两个参数：词汇量和嵌入的维数。

要在该表中建立索引，必须使用torch.LongTensor（因为索引是整数，而不是浮点数）。

3、N-Gram语言建模

回想一下，在n元语法模型中，给出了一系列单词 w，我们要计算

wi 是序列的第i个词

在此示例中，我们将在一些训练示例中计算损失函数，并使用反向传播更新参数。

#ngram语言模型
context_size=2    #上下文大小
embedding_dim=10  #词向量维度
test_sentence = """When forty winters shall besiege thy brow,
And dig deep trenches in thy beauty's field,
Thy youth's proud livery so gazed on now,
Will be a totter'd weed of small worth held:
Then being asked, where all thy beauty lies,
Where all the treasure of thy lusty days;
To say, within thine own deep sunken eyes,
Were an all-eating shame, and thriftless praise.
How much more praise deserv'd thy beauty's use,
If thou couldst answer 'This fair child of mine
Shall sum my count, and make my old excuse,'
Proving his beauty by succession thine!
This were to be new made when thou art old,
And see thy blood warm when thou feel'st it cold.""".split()
#构建三元组
trigrams=[([test_sentence[i],test_sentence[i+1]],test_sentence[i+2]) for i in range(len(test_sentence)-2)]
 
#构建词典
vocab=set(test_sentence)
word_to_ix={word :i for i ,word in enumerate(vocab)}
 
class Ngram(nn.Module):
    def __init__(self,vocab_size,embedding_dim,context_size):
        super(Ngram,self).__init__()
        self.embeddings=nn.Embedding(vocab_size,embedding_dim) #定义embedding
        self.lin1=nn.Linear(context_size*embedding_dim,128) #定义隐含层
        self.lin2=nn.Linear(128,vocab_size) #获取vocab_size个词向量
    
    def forward(self,inputs):
        embeds=self.embeddings(inputs).view(1,-1) #定义词向量 1*(context_size*embedding_dim)
        #print("embeds:",embeds.size())
        out=F.relu(self.lin1(embeds))  #vocab_size*embedding_dim
        out=self.lin2(out)             #embedding_dim*128
        prob=F.log_softmax(out,dim=1)  #每个词的概率
        return prob
 
losses=[]
loss_function=nn.NLLLoss()
model=Ngram(len(vocab),embedding_dim,context_size)
opt=optim.SGD(model.parameters(),lr=0.001)
 
for epoch in range(10):
    total_loss=0
    for ctx,target in trigrams:
        #1、准备输入模型的三元组  
        #print("ctx:",ctx)
        ctx_ids=[]
        for w in ctx:
            ctx_ids.append(word_to_ix[w])
        
        ctx_ids = torch.tensor(ctx_ids, dtype=torch.long)
        #2、梯度置0
        model.zero_grad()
        #3、获取log_probs
        log_probs=model(ctx_ids)
        #4、计算损失函数
        loss=loss_function(log_probs,torch.tensor([word_to_ix[target]], dtype=torch.long))
        #5、反向传播更新梯度
        loss.backward()
        opt.step()
        total_loss+=loss.item()
    losses.append(total_loss)
print(losses)

qw是单词的嵌入 w

#CBOW语言模型
#构建上下文窗口
cbows=[]
context_size=2
print(ctxs)
for i in range(context_size,len(ctxs)-context_size):
    ctx=ctxs[i-context_size:i+context_size+1]
    ctx.pop(context_size)
    target=ctxs[i]
    cbows.append((ctx,target))
print(cbows[:2])
    
class CBOW(nn.Module):
    def __init__(self,vocab_size,embedding_dim):
        super(CBOW,self).__init__()
        self.embeddings=nn.Embedding(vocab_size,embedding_dim) #定义embedding
        self.lin1=nn.Linear(embedding_dim,128) #定义隐含层
        self.lin2=nn.Linear(128,vocab_size) #获取vocab_size个词向量
    
    def forward(self,inputs):
        embeds=self.embeddings(inputs) #定义词向量 1*(context_size*embedding_dim)
        #print("embeds:",embeds.size())
        embeds=torch.sum(embeds,0).view(1,-1) #0：按照列求和；1：按照行求和
        #print("embeds:",embeds.size())
        out=F.relu(self.lin1(embeds))  #vocab_size*embedding_dim
        out=self.lin2(out)             #embedding_dim*128
        prob=F.log_softmax(out,dim=1)  #每个词的概率
        return prob
    
losses=[]
loss_function=nn.NLLLoss()
model=CBOW(len(vocab),embedding_dim)
opt=optim.SGD(model.parameters(),lr=0.001)
 
for epoch in range(10):
    total_loss=0
    for ctx,target in cbows:
        #1、准备输入模型的三元组  
        #print("ctx:",ctx)
        ctx_ids=[]
        for w in ctx:
            ctx_ids.append(word_to_ix[w])
        
        ctx_ids = torch.tensor(ctx_ids, dtype=torch.long)
        #2、梯度置0
        model.zero_grad()
        #3、获取log_probs
        log_probs=model(ctx_ids)
        #4、计算损失函数
        loss=loss_function(log_probs,torch.tensor([word_to_ix[target]], dtype=torch.long))
        #5、反向传播更新梯度
        loss.backward()
        opt.step()
        total_loss+=loss.item()
    losses.append(total_loss)
print(losses)