pytorch中的词性标注_seq2seq_比较naive的示例

一、各种用法_查漏补缺：

1.关于numpy中的argmax的用法：

numpy之argmax()函数 - 知乎 (zhihu.com)

具体看这篇文章够了

二、代码+注释：

参考：

Sequence Models and Long Short-Term Memory Networks — PyTorch Tutorials 2.0.1+cu117 documentation

01 序列模型和基于LSTM的循环神经网络 - 知乎 (zhihu.com)

#这么少的训练数据？
training_data = [
    ("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
    ("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
]

import torch
import torch.autograd as autograd # torch中自动计算梯度模块
import torch.nn as nn             # 神经网络模块
import torch.nn.functional as F   # 神经网络模块中的常用功能 
import torch.optim as optim       # 模型优化器模块
 
torch.manual_seed(1)  

#构建一个单词到 索引index1的 字典  word_to_ix 和 词性到所有的自带你tag_to_ix
word_to_ix = {} # 单词的索引字典
for sent, tags in training_data:
    for word in sent:
        if word not in word_to_ix:
            word_to_ix[word] = len(word_to_ix)
print(word_to_ix)
tag_to_ix = {"DET": 0, "NN": 1, "V": 2} # 手工设定词性标签数据字典

#设计这个RNN模型
class LSTMTagger(nn.Module):
 
    def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):#vocab_size：词的数量
        super(LSTMTagger, self).__init__() 
        self.hidden_dim = hidden_dim
 
        self.word_embeddings = nn.Embedding(vocab_size, embedding_dim) #词汇表-vocab*embedding_dim维度
 
        self.lstm = nn.LSTM(embedding_dim, hidden_dim) #从embedding_dim -> hidden_dim的lstm
 
        self.hidden2tag = nn.Linear(hidden_dim, tagset_size) #从hidden_dim维度 -> tagset_size维度的linear层
        self.hidden = self.init_hidden() #自动调用init_hidden()
 
    def init_hidden(self): #自动调用h_0的初始化内容
        return (autograd.Variable(torch.zeros(1, 1, self.hidden_dim)),
                autograd.Variable(torch.zeros(1, 1, self.hidden_dim)))
 
    def forward(self, sentence):                 #运行过程
        embeds = self.word_embeddings(sentence)  #sentence需要是一个 数字 组成的数组
        lstm_out, self.hidden = self.lstm(
            embeds.view(len(sentence), 1, -1), self.hidden) #将sentence数组转换为len*1*(自动)的3维空间 ->通过 lstm
        tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1)) #在将lstm_out转换为2维
        tag_scores = F.log_softmax(tag_space) #通过softmax
        return tag_scores #返回分数

#将句子转换为 对应的 数值数组：
def prepare_sequence(seq, to_ix):
    idxs = [to_ix[w] for w in seq] #将句子seq中的词汇转成数字index后 组成一个一维数组idxs
    tensor = torch.LongTensor(idxs)
    return autograd.Variable(tensor)

#生成model对象， loss_Function,optimizer对象实体
EMBEDDING_DIM = 6
HIDDEN_DIM = 6
model = LSTMTagger(EMBEDDING_DIM, HIDDEN_DIM, len(word_to_ix), len(tag_to_ix)) #模型对象
loss_function = nn.NLLLoss()  #loss_function
optimizer = optim.SGD(model.parameters(), lr=0.1) #optimizer

#一个小小的测试:
inputs = prepare_sequence(training_data[0][0], word_to_ix) #得到数值 数组inputs
tag_scores = model(inputs) #通过一个model得到的 tag_scores
print(training_data[0][0])
print(inputs)
print(tag_scores)
 
#用最大的数值对应的索引号去标签数据: “The dog ate the apple”
#所以，这里预测的结果是 1 1 1 1 1 也就是名词 名词 名词 名词 名词 ，这个纯粹随机结果

#正式的开始train
for epoch in range(300):  # 我们要训练300次，可以根据任务量的大小酌情修改次数。
    for sentence, tags in training_data:
        # 清除网络先前的梯度值，梯度值是Pytorch的变量才有的数据，Pytorch张量没有
        model.zero_grad()
        # 重新初始化隐藏层数据，避免受之前运行代码的干扰
        model.hidden = model.init_hidden()
        # 准备网络可以接受的的输入数据和真实标签数据，这是一个监督式学习
        sentence_in = prepare_sequence(sentence, word_to_ix)
        targets = prepare_sequence(tags, tag_to_ix) #targets数组也是转化为 数值 数组
        # 运行我们的模型，直接将模型名作为方法名看待即可
        tag_scores = model(sentence_in)
        # 计算损失，反向传递梯度及更新模型参数
        loss = loss_function(tag_scores, targets)
        loss.backward()
        optimizer.step()
 
# 来检验下模型训练的结果
inputs = prepare_sequence(training_data[0][0], word_to_ix)
tag_scores = model(inputs)
print(tag_scores)
#利用numpy中的argmax找到每一行最大值的 索引值
import numpy as np
numpy_array = tag_scores.detach().numpy()
np.argmax(numpy_array,axis=1)
 
#用最大的数值对应的索引号去标签数据: “The dog ate the apple”
#所以，这里预测的结果是 0 1 2 0 1 也就是冠词 名词 动词 冠词 名词 ，这个完全正确