1. Various usages_checking and filling in gaps:
1. Regarding the usage of argmax in numpy:
numpy's argmax() function - Zhihu (zhihu.com)
It’s enough to read this article specifically
2. Code + comments:
reference:
Sequence Models and Long Short-Term Memory Networks — PyTorch Tutorials 2.0.1+cu117 documentation
01 Sequence model and LSTM-based recurrent neural network - Zhihu (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 也就是冠词 名词 动词 冠词 名词 ，这个完全正确