自然语言处理N天-AllenNLP学习(实现简单的词性标注)

新建 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

你可能感兴趣的:(自然语言处理N天-AllenNLP学习(实现简单的词性标注))