新建 Microsoft PowerPoint 演示文稿 (2).jpg

1. 前言

在了解了Transformer之后，这个模型是否可用呢？现在遇到的问题是，目前试了几个模型（LSTM、GRU、Transformer），但是还没有放入实践中，具体应该怎么操作？

有一篇帖子总结了一下学习处理NLP问题中间的坑。NLP数据预处理要比CV的麻烦很多。

• 去除停用词，建立词典，加载各种预训练词向量，Sentence -> Word ID -> Word Embedding的过程(Tobias Lee：文本预处理方法小记)，其中不仅需要学习pytorch，可能还要学习spacy，NLTK，numpy，pandas，tensorboardX等常用python包。
• 用到RNN时，还要经过pad,pack,pad的过程，像这样的很多函数在使用时需要有数学基础加上简单的实践，感觉对一个新人来说，高维数据的流动有点抽象，不容易理解。
• 数据集的读取，tensorboardX的使用。。。。各种东西要学习。在运行别人的代码后打印出信息，不仅看着上档次，而且可以看到很多实用的信息。。。

AllenNLP是在pytorch基础上的封装，它的目标是处理NLP任务，可以减少很多额外的学习。

• 分词，帮你用spacy，NLTK，或者简单的按空格分词处理。
• 数据集的读取，它内置了很多数据集的读取，你可以在通过学习它的读取方式，在它的基础上对自己需要的数据集进行读取。 、
• 在Sentence -> Word ID -> Word Embedding的过程中，Glove，ELMo，BERT等常用的都可以直接使用，需要word，char粒度的都可以。
• log打印输出，在内置的输出项之外，你可以很方便地加入想要输出的信息。模型的各个组件中的参数都可以存在一个json/jsonnet文件中，修改参数进行实验很方便。

2. 引入库

在getstarted中对每一行都做了注释

from typing import Iterator, List, Dict #AllenNLP使用类型注释来处理一切
import torch
import torch.optim as optim
import numpy as np

#在AllenNLP中，我们将每个训练示例表示为包含各种类型的字段的实例。这里每个例子都有一个包含句子的TextField，以及一个包含相应词性标签的SequenceLabelField。
from allennlp.data import Instance
from allennlp.data.fields import TextField, SequenceField

#通常使用AllenNLP来解决这样的问题，你将有两个类。第一个是DatasetReader，它包含数据文件和实例流的逻辑。
from allennlp.data.dataset_readers import DatasetReader
#我们经常要从URL加载数据集或模型。 cached_pa​​th帮助程序下载此类文件，在本地缓存它们，并返回本地路径。它还接受本地文件路径（它只是按原样返回）。
from allennlp.common.file_utils import cached_path

# 有多种方法可以将单词表示为一个或多个索引。
# 例如，可以维护唯一单词的词汇表，并为每个单词指定相应的ID。
# 或者可能在单词中每个字符有一个id，并将每个单词表示为一系列id。 AllenNLP使用具有TokenIndexer抽象的表示。
from allennlp.data.token_indexers import TokenIndexer, SingleIdTokenIndexer
from allennlp.data.tokenizers import Token
# TokenIndexer表示如何将标记转换为索引的规则，而词汇表包含从字符串到整数的相应映射。
# 例如，token indexer可能指定将令牌表示为字符ID序列，
# 在这种情况下，词汇表将包含映射{character  - > id}。
# 在这个特定的例子中，我们使用SingleIdTokenIndexer为每个标记分配一个唯一的id，因此Vocabulary只包含一个映射{token  - > id}（以及反向映射）。
from allennlp.data.vocabulary import Vocabulary

# 除了DatasetReader，另一个需要实现的类是模型Model，这是一个Pytorch组件，将张量输入和产出的词典作为张量输出
from allennlp.models import Model

# 如上所述，我们的模型将包含一个嵌入层，然后是LSTM，然后是前馈层。 AllenNLP包括所有这些智能处理填充和批处理的抽象，以及各种实用功能。
from allennlp.modules.text_field_embedders import TextFieldEmbedder, BasicTextFieldEmbedder
from allennlp.modules.token_embedders import Embedding
from allennlp.modules.seq2seq_encoders import Seq2SeqEncoder, PytorchSeq2SeqWrapper
from allennlp.nn.util import get_text_field_mask, sequence_cross_entropy_with_logits

from allennlp.training.metrics import CategoricalAccuracy

#在我们的训练中，我们需要一个可以智能地批量处理数据的DataIterators。
from allennlp.data.iterators import BucketIterator
#使用AllenNLP的全特征训练
from allennlp.training.trainer import Trainer
#希望对新输入作出预测。
from allennlp.predictors import SentenceTaggerPredictor

torch.manual_seed(1)

3.实现一个简单的LSTM词性标注

# 实现DatasetReader子类
# 教程中的两个数据集（训练集和验证集）是两个句子，每一个句子都进行了分词，并打上标签。使用###进行标识
class PosDatasetReader(DatasetReader):
    '''
    DatasetReader for PoS tagging data, one sentence per line, like
    The###DET dog###NN ate###V the###DET apple###NN
    '''

    # 我们的DatasetReader需要的唯一参数是TokenIndexers的dict，它指定如何将标记转换为索引。
    # 默认情况下，我们只为每个token（我们称之为“token”）生成一个索引，这只是每个不同令牌的唯一ID。 （这只是您在大多数NLP任务中使用的标准“单词索引”映射。）
    def __init__(self, token_indexers: Dict[str, TokenIndexer] = None) -> None:
        super().__init__(lazy=False)
        self.token_indexers = token_indexers or {"tokens": SingleIdTokenIndexer()}

    # DatasetReader.text_to_instance
    # 获取与训练示例相对应的输入（在这种情况下是句子的标记和相应的词性标记），
    # 实例化相应的Fields（在这种情况下是句子的TextField和其标签的SequenceLabelField） ），
    # 返回包含这些字段的实例。
    # 请注意，标记是可选的，因为我们希望能够从未标记的数据创建实例以对它们进行预测。
    def text_to_instance(self, tokens: List[Token], tags: List[str] = None) -> Instance:
        sentence_field = TextField(tokens, self.token_indexers)
        fields = {"sentence": sentence_field}

        if tags:
            label_field = SequenceLabelField(labels=tags, sequence_field=sentence_field)
            fields["labels"] = label_field

        return Instance(fields)

    # 我们必须实现的另一个部分是_read，它接受一个文件名并生成一个实例流。大部分工作已经在text_to_instance中完成。
    def _read(self, file_path: str) -> Iterator[Instance]:
        with open(file_path) as f:
            for line in f:
                pairs = line.strip().split()
                sentence, tags = zip(*(pair.split('###') for pair in pairs))
                yield self.text_to_instance([Token(word) for word in sentence], tags)


# 您将始终必须实现的另一个类是Model，它是torch.nn.Module的子类。
# 它的工作原理在很大程度上取决于你，它只需要一个前向方法，它接受张量输入并产生一个张量输出的字典，其中包括你用来训练模型的损失。
# 如上所述，我们的模型将包括嵌入层，定序器和前馈网络。
class LstmTagger(Model):
    def __init__(
            self,
            word_embeddings: TextFieldEmbedder,
            encoder: Seq2SeqEncoder,
            vocab: Vocabulary
    ) -> None:
        # 必须将词汇传递给基类构造函数
        super().__init__(vocab)
        self.word_embeddings = word_embeddings
        self.encoder = encoder

        # 前馈层不作为参数传入，而是由我们构造。
        # 请注意，它查看编码器以查找正确的输入维度并查看词汇表（特别是在标签 - >索引映射）以查找正确的输出维度。
        self.hidden2tag = torch.nn.Linear(in_features=encoder.get_output_dim(),
                                          out_features=vocab.get_vocab_size('labels'))
        self.accuracy = CategoricalAccuracy()

    def forward(self,
                sentence: Dict[str, torch.Tensor],
                labels: torch.Tensor = None
                ) -> Dict[str, torch.Tensor]:
        # 掩码处理，这里做了很好的封装，还记得之前实现Transformer的时候写的mask。
        # AllenNLP设计用于批量输入，但不同的输入序列具有不同的长度。在幕后，AllenNLP填充较短的输入，以便批处理具有统一的形状，这意味着我们的计算需要使用掩码来排除填充。这里我们只使用效用函数get_text_field_mask，它返回与填充和未填充位置相对应的0和1的张量。
        mask = get_text_field_mask(sentence)

        # 我们首先将句子张量（每个句子一系列token ID）传递给word_embeddings模块，该模块将每个句子转换为嵌入式张量序列。
        embeddings = self.word_embeddings(sentence)

        # 接下来，我们将嵌入的张量（和掩码）传递给LSTM，LSTM产生一系列编码输出。
        encoder_out = self.encoder(embeddings, mask)

        # 最后，我们将每个编码输出张量传递给前馈层，以生成对应于各种标签的logits。
        tag_logits = self.hidden2tag(encoder_out)
        output = {'tag_logits': tag_logits}

        # 标签是可选的，因为我们可能希望运行此模型来对未标记的数据进行预测。如果我们有标签，那么我们使用它们来更新我们的准确度指标并计算输出中的“损失”。
        if labels is not None:
            self.accuracy(tag_logits, labels, mask)
            output["loss"] = sequence_cross_entropy_with_logits(tag_logits, labels, mask)

        return output

    # 在前馈层更新正确率矩阵。这意味着我们需要覆盖从中提取数据的get_metrics方法。在幕后，CategoricalAccuracy指标存储预测数量和正确预测的数量，在每次前向更新这些计数。每次调用get_metric都会返回计算的精度，并（可选）重置计数，这使我们能够跟踪每个时期的新精度。
    def get_metrics(self, reset: bool = False) -> Dict[str, float]:
        return {"accuracy": self.accuracy.get_metric(reset)}


# 开始实现之前的DatasetReader和Model
# 首先实例化DatasetReader
reader = PosDatasetReader()

# 训练集和验证集数据下载
train_dataset = reader.read(
    cached_path(r'https://raw.githubusercontent.com/allenai/allennlp/master/tutorials/tagger/training.txt'))
validation_dataset = reader.read(
    cached_path(r'https://raw.githubusercontent.com/allenai/allennlp/master/tutorials/tagger/validation.txt'))

# 读入数据集后，使用数据集创建自己的词汇表
vocab = Vocabulary.from_instances(train_dataset + validation_dataset)

# 构建模型，选择嵌入层和隐藏层的大小
EMBEDDING_DIM = 6
HIDDEN_DIM = 6

# 为了嵌入标记，我们将使用BasicTextFieldEmbedder，它从索引名称到嵌入进行映射。
# 如果你回到我们定义DatasetReader的地方，默认参数包括一个名为“tokens”的索引，所以我们的映射只需要一个对应于该索引的嵌入。
# 我们使用词汇表来查找我们需要多少嵌入，并使用EMBEDDING_DIM参数来指定输出维度。
# 也可以从预先训练的嵌入开始（例如，GloVe向量），但是没有必要在这个小数据集上做到这一点。
token_embedding = Embedding(num_embeddings=vocab.get_vocab_size('tokens'), embedding_dim=EMBEDDING_DIM)
word_embeddings = BasicTextFieldEmbedder({"tokens": token_embedding})

# 接下来我们需要指定序列编码器。这里对PytorchSeq2SeqWrapper的需求有点不幸（如果你使用配置文件就不用担心了），但是这里需要为内置的PyTorch模块添加一些额外的功能（和更简洁的接口）。
# 在AllenNLP中，我们首先完成所有批处理，因此我们也指定了它。
lstm = PytorchSeq2SeqWrapper(torch.nn.LSTM(EMBEDDING_DIM, HIDDEN_DIM, batch_first=True))
model = LstmTagger(word_embeddings, lstm, vocab)

optimizer = optim.SGD(model.parameters(), lr=0.1)


iterator = BucketIterator(batch_size=2, sorting_keys=[("sentence", "num_tokens")])
iterator.index_with(vocab)

# 现在我们实例化我们的Trainer并运行它。在这里，我们告诉它运行1000次迭代并且如果它花费10个时期而没有验证度量改进则提前停止训练。
# 默认验证度量标准是损失（通过变小来改善），但也可以指定不同的度量和方向（例如，精度应该变大）。
trainer = Trainer(model=model,
                  optimizer=optimizer,
                  iterator=iterator,
                  train_dataset=train_dataset,
                  validation_dataset=validation_dataset,
                  patience=10,
                  num_epochs=1000)
trainer.train()
predictor = SentenceTaggerPredictor(model, dataset_reader=reader)
tag_logits = predictor.predict("The dog ate the apple")['tag_logits']
tag_ids = np.argmax(tag_logits, axis=-1)
print([model.vocab.get_token_from_index(i, 'labels') for i in tag_ids])

4. 如何保存训练好的模型

with open(r"C:/Users/01/Desktop/机器学习作业/AllenNLP/model/model.th", 'wb') as f:
    torch.save(model.state_dict(), f)
vocab.save_to_files(r"C:/Users/01/Desktop/机器学习作业/AllenNLP/model/vocabulary")
# And here's how to reload the model.
vocab2 = Vocabulary.from_files(r"C:/Users/01/Desktop/机器学习作业/AllenNLP/model/vocabulary")
model2 = LstmTagger(word_embeddings, lstm, vocab2)
with open(r"C:/Users/01/Desktop/机器学习作业/AllenNLP/model/model.th", 'rb') as f:
    model2.load_state_dict(torch.load(f))
predictor2 = SentenceTaggerPredictor(model2, dataset_reader=reader)
tag_logits2 = predictor2.predict("The dog ate the apple")['tag_logits']
assert tag_logits2 == tag_logits