lstm使用示例

注意，本文代码来自于plm-nlp-code。

学习任何模型都需要一个简单可行的例子进行说明，我会基于plm-nlp-code的代码进行说明lstm在序列标注和句子极性二分类两个例子的应用。

序列标注

参考文件lstm_postag.py.

1. 加载数据

1 2	#加载数据 train_data, test_data, vocab, pos_vocab = load_treebank()

其中load_treebank代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

def load_treebank(): # 需要下载，可以自行设置代码 nltk.set_proxy('http://192.168.0.28:1080') # 如果没有的话那么则会下载，否则忽略 nltk.download('treebank') from nltk.corpus import treebank sents, postags = zip(*(zip(*sent) for sent in treebank.tagged_sents())) vocab = Vocab.build(sents, reserved_tokens=[""]) tag_vocab = Vocab.build(postags) train_data = [(vocab.convert_tokens_to_ids(sentence), tag_vocab.convert_tokens_to_ids(tags)) for sentence, tags in zip(sents[:3000], postags[:3000])] test_data = [(vocab.convert_tokens_to_ids(sentence), tag_vocab.convert_tokens_to_ids(tags)) for sentence, tags in zip(sents[3000:], postags[3000:])] return train_data, test_data, vocab, tag_vocab

加载后可以看到，train_data和test_data都是list，其中每一个sample都是tuple,分别是input和target。如下：

1 2 3 4

>>> train_data[0] >>> Out[1]: ([2, 3, 4, 5, 6, 7, 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], [1, 1, 2, 3, 4, 5, 2, 6, 7, 8, 9, 10, 8, 5, 9, 1, 3, 11])

2. 数据处理

1 2 3 4 5 6 7 8 9

# 这个函数就是将其变成等长，填充使用，至于是0还是1还是其他值并不重要，因为还有mask~ def collate_fn(examples): lengths = torch.tensor([len(ex[0]) for ex in examples]) inputs = [torch.tensor(ex[0]) for ex in examples] targets = [torch.tensor(ex[1]) for ex in examples] inputs = pad_sequence(inputs, batch_first=True, padding_value=vocab[""]) targets = pad_sequence(targets, batch_first=True, padding_value=vocab[""]) return inputs, lengths, targets, inputs != vocab[""]

3. 模型部分

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class LSTM(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, num_class): super(LSTM, self).__init__() self.embeddings = nn.Embedding(vocab_size, embedding_dim) self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True) self.output = nn.Linear(hidden_dim, num_class) init_weights(self) def forward(self, inputs, lengths): embeddings = self.embeddings(inputs) x_pack = pack_padded_sequence(embeddings, lengths, batch_first=True, enforce_sorted=False) hidden, (hn, cn) = self.lstm(x_pack) hidden, _ = pad_packed_sequence(hidden, batch_first=True) outputs = self.output(hidden) log_probs = F.log_softmax(outputs, dim=-1) return log_probs

其中有几个地方可能需要注意的：

• pack_padded_sequence和pad_packed_sequence
  因为lstm为rnn模型，样本输入不一定是等长的，那么torch提供了这两个函数进行统一处理，length告诉lstm，等超过length时这个样本后面pad进来的就不再计算了。

1 2 3 4 5 6 7 8 9 10 11 12 13 14

>>> from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence >>> seq = torch.tensor([[1,2,0], [3,0,0], [4,5,6]]) >>> lens = [2, 1, 3] >>> packed = pack_padded_sequence(seq, lens, batch_first=True, enforce_sorted=False) >>> packed PackedSequence(data=tensor([4, 1, 3, 5, 2, 6]), batch_sizes=tensor([3, 2, 1]), sorted_indices=tensor([2, 0, 1]), unsorted_indices=tensor([1, 2, 0])) >>> seq_unpacked, lens_unpacked = pad_packed_sequence(packed, batch_first=True) >>> seq_unpacked tensor([[1, 2, 0], [3, 0, 0], [4, 5, 6]]) >>> lens_unpacked tensor([2, 1, 3])

• lstm输出

hidden, (hn, cn)分别表示每个timestep的输出,最后一个时刻的每层输出,cn表示保存c的值。

所以可以看到，序列标注会用到每个timestep的输出来表示每个token。

• F.log_softmax和损失函数计算

如果看源码较多的情况下，你会发现log_softmax或者softmax会和CrossEntropyLoss出现在一起，这里很简单理解，因为CrossEntropyLoss由两个函数组成，log_softmax和NLLLoss，log_softmax或者softmax是做归一化，由分数转成概率，log_softmax是平滑。NLLLoss负责取target index对应的logits score，然后除以总分。目的使之最大。

3. 训练

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#训练过程 nll_loss = nn.NLLLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) #使用Adam优化器 model.train() for epoch in range(num_epoch): total_loss = 0 for batch in tqdm(train_data_loader, desc=f"Training Epoch {epoch}"): inputs, lengths, targets, mask = [x.to(device) for x in batch] lengths = lengths.cpu() log_probs = model(inputs, lengths) loss = nll_loss(log_probs[mask], targets[mask]) optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() print(f"Loss: {total_loss:.2f}")

这部分没啥好说的了，log_probs为三维矩阵，比如torch.Size([32, 58, 47]),表示batch_size=32,seq_length=58,一共47个tags。

推理部分就是argmax取其最大的tag index，可以看：

1 2 3 4 5 6 7 8

acc = 0 total = 0 for batch in tqdm(test_data_loader, desc=f"Testing"): inputs, lengths, targets, mask = [x.to(device) for x in batch] with torch.no_grad(): output = model(inputs, lengths) acc += (output.argmax(dim=-1) == targets)[mask].sum().item() total += mask.sum().item()

句子极性二分类

参考文件lstm_sent_polarity.py。

这个名字自己起的，任务目标具体就是对输入句子做二分类。

1. 加载数据

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

def load_sentence_polarity(): nltk.set_proxy('http://192.168.0.28:1080') nltk.download('sentence_polarity') from nltk.corpus import sentence_polarity vocab = Vocab.build(sentence_polarity.sents()) train_data = [(vocab.convert_tokens_to_ids(sentence), 0) for sentence in sentence_polarity.sents(categories='pos')[:4000]] \ + [(vocab.convert_tokens_to_ids(sentence), 1) for sentence in sentence_polarity.sents(categories='neg')[:4000]] test_data = [(vocab.convert_tokens_to_ids(sentence), 0) for sentence in sentence_polarity.sents(categories='pos')[4000:]] \ + [(vocab.convert_tokens_to_ids(sentence), 1) for sentence in sentence_polarity.sents(categories='neg')[4000:]] return train_data, test_data, vocab

关于数据格式:

1 2 3

train_data[321] Out[2]: ([6, 6, 6, 4489, 1337, 15065, 3252, 6], 0) # 前面部分表示句子的每个token，后面表示label。

label一共有两个，0和1,所以为二分类。

2. 有趣的点

整个训练过程貌似和上例没什么不同，但是可以举几个比较有意思的地方。

• 关于二分类使用CrossEntropyLoss还是BCELoss

这两者本质是一样的，BCELoss就是CrossEntropyLoss的特例。你可以看loss.py。

BCEWithLogitsLoss和BCELoss的区别就是一个需要用sigmoid一个不需要。

你可以尝试改动这个代码，将作者使用到的log_softmax和NLLLoss改成使用sigmoid和BCELoss。

• lstm中hn的输出

既然hn表示timestep的最后一个时刻的输出，那么我们也有理由相信，最后一个时刻的feature可以代表整个句子的feature。

那么就需要关注下hn的输出具体是什么样子了。

源码输出example比如:

1 2	hn.shape Out[2]: torch.Size([1, 32, 256])

其中1是因为num_layers为1，又不是双向lstm，所以为1。

而如果改成双向lstm，bidirectional=True，那么，

1 2	hn.shape Out[2]: torch.Size([2, 32, 256])

如果num_layers为3,那么：

1 2	hn.shape Out[2]: torch.Size([6, 32, 256])

到这里我们就要理解下他输出的含义了？

他表示一共有6个层，即3个双向lstm，而双向的实现，就是正向计算一次，反向再计算一次，即[::-1]，那么一共6层。

整个模型更改如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class LSTM(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, num_class): super(LSTM, self).__init__() self.embeddings = nn.Embedding(vocab_size, embedding_dim) self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True, bidirectional=True, num_layers=3) self.output = nn.Linear(hidden_dim * 6, num_class) def forward(self, inputs, lengths): embeddings = self.embeddings(inputs) x_pack = pack_padded_sequence(embeddings, lengths, batch_first=True, enforce_sorted=False) hidden, (hn, cn) = self.lstm(x_pack) outputs = self.output(hn.permute(1,0,2).reshape(-1, 6 * 256)) log_probs = F.log_softmax(outputs, dim=-1) return log_probs