问题

对词性进行标注（demo展示）

基本思路

  1. 编码词
  2. 得到编码的句子序列
  3. 输入LSTM
  4. LSTM输入Linear
  5. 经过log_softmax
  6. 取max为预测对象进行Loss计算
  7. loss_function = nn.NLLLoss()
  8. optimizer = optim.SGD(model.parameters(), lr=0.1)

代码

原理见另一个知识库笔记

  1. import torch
  2. import torch.autograd as autograd
  3. import torch.nn as nn
  4. import torch.nn.functional as F
  5. import torch.optim as optim
  6. import numpy
  7. torch.manual_seed(1)
  8. '''
  9. net = nn.LSTM(3, 4, bidirectional=True, batch_first=True)  # 隐层尺度为4
  10. net2 = nn.LSTM(3, 4, bidirectional=False, batch_first=True)
  11. x = torch.rand(1, 5, 3)  # 序列长度为5，输入尺度为3
  13. y=net(x)
  14. y2=net2(x)
  15. print(len(y))
  16. print(len(y2))
  17. print(y[0].shape)
  18. print(y2[0].shape)
  19. #print(y[1].shape)
  20. #print(y.shape)
  21. '''
  24. training_data = [
  25.     ("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
  26.     ("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
  27. ]
  29. word_to_ix = {} # 单词的索引字典
  30. for sent, tags in training_data:
  31.     for word in sent:
  32.         if word not in word_to_ix:
  33.             word_to_ix[word] = len(word_to_ix)
  34. print(word_to_ix)
  35. tag_to_ix = {"DET": 0, "NN": 1, "V": 2} # 手工设定词性标签数据字典
  36. index_to_tag={0:"DET", 1:"NN",2:"V"}
  38. class LSTMTagger(nn.Module):
  40.     def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):
  41.         super(LSTMTagger, self).__init__()
  42.         self.hidden_dim = hidden_dim
  44.         self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)
  46.         self.lstm = nn.LSTM(embedding_dim, hidden_dim)
  48.         self.hidden2tag = nn.Linear(hidden_dim, tagset_size)
  49.         self.hidden = self.init_hidden()
  52.     def init_hidden(self):
  53.         return (autograd.Variable(torch.zeros(1, 1, self.hidden_dim)),
  54.                 autograd.Variable(torch.zeros(1, 1, self.hidden_dim)))
  56.     def forward(self, sentence):
  57.         embeds = self.word_embeddings(sentence)
  58.         lstm_out, self.hidden = self.lstm(embeds.view(len(sentence), 1, -1), self.hidden)
  59.         tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))
  60.         tag_scores = F.log_softmax(tag_space,dim=1)
  61.         return tag_scores
  63. def prepare_sequence(seq, to_ix):
  64.     idxs = [to_ix[w] for w in seq]
  65.     tensor = torch.LongTensor(idxs)
  66.     return autograd.Variable(tensor)
  69. model = LSTMTagger(300, 100, len(word_to_ix), len(tag_to_ix))
  70. loss_function = nn.NLLLoss()
  71. optimizer = optim.SGD(model.parameters(), lr=0.1)
  73. inputs = prepare_sequence(training_data[0][0], word_to_ix)
  74. tag_scores = model(inputs)
  75. print(training_data[0][0])
  76. print(inputs)
  77. print(tag_scores)
  79. for epoch in range(300):
  80.     for sentence, tags in training_data:
  81.         model.zero_grad()
  82.         model.hidden = model.init_hidden()
  83.         sentence_in = prepare_sequence(sentence, word_to_ix)
  84.         #print(type(sentence_in))
  85.         #print((sentence_in.shape))
  86.         targets = prepare_sequence(tags, tag_to_ix)
  87.         tag_scores = model(sentence_in)
  88.         loss = loss_function(tag_scores, targets)
  89.         loss.backward()
  90.         optimizer.step()
  92. # 来检验下模型训练的结果
  93. inputs = prepare_sequence(training_data[0][0], word_to_ix)
  94. tag_scores = model(inputs)
  96. index=torch.max(tag_scores,1)[1].data.numpy()
  99. index=index.tolist()
  100. result=[index_to_tag[i] for i in index]
  101. print(result)

结果

利用第一句数据为预测对象进行预测，得到完全正确的结果
当然了数据这么少，还用数据测试不太妥，不过作为demo展示
image.png