torchnlp

Torchnlp

Torchnlp é uma biblioteca de aprendizado profundo para tarefas de PNL. Construído em Pytorch e Torchtext, é uma tentativa de fornecer componentes reutilizáveis ​​que funcionam entre as tarefas. Atualmente, ele pode ser usado para reconhecimento de entidade nomeado (NER) e tarefas de Chunking com um modelo bidirecional de CRF LSTM e um modelo de rede de transformadores. Ele pode suportar qualquer conjunto de dados que use o formato Conll 2003. Mais tarefas serão adicionadas em breve

Fluxo de trabalho de alto nível

1. Defina a tarefa de PNL
2. Estender a classe Model e implementar os métodos forward() e loss() para retornar previsões e perdas, respectivamente
3. Use a classe HParams para definir facilmente os hiperparâmetros para o modelo
4. Defina uma função de dados para retornar iteradores de dados, vocabulários etc. usando a API da Torchtext. Verifique Conll.py para um exemplo
5. Configure as classes de Evaluator e Trainer para usar o modelo, iteradores de dados e métricas. Verifique o NER.PY para obter detalhes
6. Execute o treinador pelo número desejado de épocas junto com um critério de parada precoce
7. Use o avaliador para avaliar o modelo treinado em uma divisão específica de conjunto de dados
8. Execute a inferência no modelo treinado usando os processadores de entrada disponíveis

Componentes de caldeira

• Model : lida com carregamento e economia de modelos, bem como os hiperparâmetros associados
• HParams : classe genérica para definir hiperparâmetros. Pode ser persistido
• Trainer : Treine um determinado modelo em um conjunto de dados. Suporta recursos como cronogramas de decaimento da taxa de aprendizado predefinidos e parada precoce
• Evaluator : avalia o modelo em um conjunto de dados e várias métricas predefinidas ou personalizadas.
• get_input_processor_words : Use durante a inferência para converter rapidamente strings de entrada em um formato que pode ser processado por um modelo

Modelos disponíveis

• transformer.Encoder , transformer.Decoder : Implementação de rede de transfômeros da atenção é tudo o que você precisa
• CRF : camada de campo aleatório condicional que pode ser usado como saída final
• TransformerTagger : modelo de marcação de sequência implementado usando a rede de transformadores e CRF
• BiLSTMTagger : modelo de marcação de sequência implementado usando LSTMS e CRF bidirecionais

Instalação

A Torchnlp requer um mínimo de Python 3.5 e Pytorch 0.4.0 para executar. Verifique o Pytorch para as etapas de instalação. Clone este repositório e instale outras dependências, como a TorchText:

 pip install -r requirements.txt

Vá para a raiz do projeto e verifique se há integridade com o Pytest:

 pytest

Instale este projeto:

 python setup.py

Uso

A Torchnlp foi projetada para ser usada dentro do intérprete Python para facilitar a experiência sem digitar argumentos complicados da linha de comando.

Tarefa ner

A tarefa NER pode ser executada em qualquer conjunto de dados que confirme no formato Conll 2003. Para usar o conjunto de dados NER do Conll 2003, coloque os arquivos do conjunto de dados na seguinte estrutura de diretório em sua raiz do espaço de trabalho:

 .data
  |
  |---conll2003
          |
          |---eng.train.txt
          |---eng.testa.txt
          |---eng.testb.txt

eng.testa.txt é usado o conjunto de dados de validação e eng.testb.txt é usado como conjunto de dados de teste.

Inicie o módulo NER no shell python que configura as importações:

 python -i -m torchnlp.ner

 Task: Named Entity Recognition

Available models:
-------------------
TransformerTagger

    Sequence tagger using the Transformer network (https://arxiv.org/pdf/1706.03762.pdf)
    Specifically it uses the Encoder module. For character embeddings (per word) it uses
    the same Encoder module above which an additive (Bahdanau) self-attention layer is added

BiLSTMTagger

    Sequence tagger using bidirectional LSTM. For character embeddings per word
    uses (unidirectional) LSTM


Available datasets:
-------------------
    conll2003: Conll 2003 (Parser only. You must place the files)

>>>

Treine o modelo de transformador no conjunto de dados Conll 2003:

 >>> train('ner-conll2003', TransformerTagger, conll2003)

O primeiro argumento é o nome da tarefa. Você precisa usar o mesmo nome de tarefa durante a avaliação e inferência. Por padrão, a função do trem usará a métrica F1 com uma janela de 5 épocas para executar a parada precoce. Para alterar os critérios de parada antecipados, defina a variável Global PREFS da seguinte maneira:

 >>> PREFS.early_stopping='lowest_3_loss'

Isso agora usará a perda de validação como critério de parada com uma janela de 3 épocas. Os arquivos do modelo são salvos no diretório do nome do nome da tarefa . Nesse caso, é NER-CONLL2003-TRANSFORMERTAGGER

Avalie o modelo treinado na divisão do conjunto de dados Testb :

 >>> evaluate('ner-conll2003', TransformerTagger, conll2003, 'test')

Ele exibirá métricas como precisão, precisão da sequência, F1 etc

Execute o modelo treinado interativamente para a tarefa NER:

 >>> interactive('ner-conll2003', TransformerTagger)
...
Ctrl+C to quit
> Tom went to New York
I-PER O O I-LOC I-LOC

Da mesma forma, você pode treinar o modelo bidirecional de CRF LSTM usando a classe BiLSTMTagger . A personalização do hyperparameter é bastante direta. Vejamos os hiperparâmetros para TransformerTagger :

 >>> h2 = hparams_transformer_ner()
>>> h2

Hyperparameters:
 filter_size=128
 optimizer_adam_beta2=0.98
 learning_rate=0.2
 learning_rate_warmup_steps=500
 input_dropout=0.2
 embedding_size_char=16
 dropout=0.2
 hidden_size=128
 optimizer_adam_beta1=0.9
 embedding_size_word=300
 max_length=256
 attention_dropout=0.2
 relu_dropout=0.2
 batch_size=100
 num_hidden_layers=1
 attention_value_channels=0
 attention_key_channels=0
 use_crf=True
 embedding_size_tags=100
 learning_rate_decay=noam_step
 embedding_size_char_per_word=100
 num_heads=4
 filter_size_char=64

Agora vamos desativar a camada CRF:

 >>> h2.update(use_crf=False)

Hyperparameters:
filter_size=128
optimizer_adam_beta2=0.98
learning_rate=0.2
learning_rate_warmup_steps=500
input_dropout=0.2
embedding_size_char=16
dropout=0.2
hidden_size=128
optimizer_adam_beta1=0.9
embedding_size_word=300
max_length=256
attention_dropout=0.2
relu_dropout=0.2
batch_size=100
num_hidden_layers=1
attention_value_channels=0
attention_key_channels=0
use_crf=False
embedding_size_tags=100
learning_rate_decay=noam_step
embedding_size_char_per_word=100
num_heads=4
filter_size_char=64

Use-o para re-treinar o modelo:

 >>> train('ner-conll2003-nocrf', TransformerTagger, conll2003, hparams=h2)

Juntamente com o modelo, os hiperparâmetros também são salvos, para que não haja necessidade de passar no objeto HParams durante a avaliação. Observe também que, por padrão, não substituirá nenhum diretório de modelos existentes (renomeará). Para alterar esse comportamento, defina a variável prefs:

 >>> PREFS.overwrite_model_dir = True

A variável PREFS é automaticamente persistida em prefs.json

Tarefa de Chunking

O conjunto de dados Conll 2000 está disponível para a tarefa de Chunking. O conjunto de dados é baixado automaticamente do repositório público para que você não precise baixá -lo manualmente.

Comece a tarefa de Chunking:

 python -i -m torchnlp.chunk

Treine o modelo de transformador:

 >>> train('chunk-conll2000', TransformerTagger, conll2000)

Não há partição de validação fornecida no repositório, portanto, 10% do conjunto de treinamento é usado para validação.

Avalie o modelo no conjunto de testes:

 >>> evaluate('chunk-conll2000', TransformerTagger, conll2000, 'test')

Uso independente

Os módulos transformer.Encoder , transformer.Decoder e CRF podem ser importados independentemente, pois dependem apenas do Pytorch:

 from torchnlp.modules.transformer import Encoder
from torchnlp.modules.transformer import Decoder
from torchnlp.modules.crf import CRF

Consulte os comentários no código -fonte para obter mais detalhes sobre o uso