torchnlp
Initial Release
Torchnlp est une bibliothèque d'apprentissage en profondeur pour les tâches NLP. Construit sur Pytorch et TorchText, il s'agit d'une tentative de fournir des composants réutilisables qui fonctionnent entre les tâches. Actuellement, il peut être utilisé pour la reconnaissance des entités nommés (NER) et les tâches de section avec un modèle LSTM CRF bidirectionnel et un modèle de réseau de transformateur. Il peut prendre en charge n'importe quel ensemble de données qui utilise le format Conll 2003. Plus de tâches seront ajoutées sous peu
Model et mettre en œuvre les méthodes forward() et loss() pour renvoyer les prédictions et les pertes respectivementHParams pour définir facilement les hyperparamètres du modèleEvaluator et les classes Trainer pour utiliser le modèle, les itérateurs de données et les mesures. Vérifiez Ner.py pour plus de détailsModel : gère le chargement et la sauvegarde des modèles ainsi que les hyperparamètres associésHParams : classe générique pour définir des hyperparamètres. Peut être persistéTrainer : former un modèle donné sur un ensemble de données. Prend en charge des fonctionnalités telles que les horaires de désintégration du taux d'apprentissage prédéfinis et l'arrêt anticipéEvaluator : évalue le modèle sur un ensemble de données et plusieurs mesures prédéfinies ou personnalisées.get_input_processor_words : utilisez pendant l'inférence pour convertir rapidement les chaînes d'entrée en un format qui peut être traité par un modèle transformer.Encoder , transformer.Decoder : la mise en œuvre du réseau transfomer de l'attention est tout ce dont vous avez besoinCRF : couche de champ aléatoire conditionnelle qui peut être utilisée comme sortie finaleTransformerTagger : Modèle de marquage de séquence implémenté à l'aide du réseau de transformateur et du CRFBiLSTMTagger : modèle de balise de séquence implémenté à l'aide de LSTM et CRF bidirectionnels Torchnlp nécessite un minimum de Python 3.5 et Pytorch 0.4.0 pour fonctionner. Vérifiez Pytorch pour les étapes d'installation. Clone ce référentiel et installer d'autres dépendances comme TorchText:
pip install -r requirements.txt
Allez à la racine du projet et vérifiez l'intégrité avec Pytest:
pytest
Installez ce projet:
python setup.py
Torchnlp est conçu pour être utilisé à l'intérieur de l'interprète Python pour faciliter l'expérimentation sans taper arguments de ligne de commande encombrants.
Tâche NER
La tâche NER peut être exécutée sur n'importe quel ensemble de données qui confirme au format Conll 2003. Pour utiliser le jeu de données CONLL 2003, placez les fichiers de données dans la structure du répertoire suivant dans votre root d'espace de travail:
.data
|
|---conll2003
|
|---eng.train.txt
|---eng.testa.txt
|---eng.testb.txt
eng.testa.txt est utilisé l'ensemble de données de validation et eng.testb.txt est utilisé comme ensemble de données de test.
Démarrez le module NER dans le shell Python qui configure les importations:
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)
>>>
Former le modèle Transformer sur l'ensemble de données Conll 2003:
>>> train('ner-conll2003', TransformerTagger, conll2003)
Le premier argument est le nom de la tâche. Vous devez utiliser le même nom de tâche lors de l'évaluation et de l'inférence. Par défaut, la fonction de train utilisera la métrique F1 avec une fenêtre de 5 époques pour effectuer un arrêt anticipé. Pour modifier les critères d'arrêt anticipés, définissez la variable globale PREFS comme suit:
>>> PREFS.early_stopping='lowest_3_loss'
Cela utilisera désormais la perte de validation comme critère d'arrêt avec une fenêtre de 3 époques. Les fichiers du modèle sont enregistrés dans le répertoire TaskName-ModelName . Dans ce cas, c'est NER-CONLL2003-transformèreur
Évaluez le modèle formé sur la division de l'ensemble de données TestB :
>>> evaluate('ner-conll2003', TransformerTagger, conll2003, 'test')
Il affichera des mesures comme la précision, la précision des séquences, F1, etc.
Exécutez le modèle formé de manière interactive pour la tâche NER:
>>> interactive('ner-conll2003', TransformerTagger)
...
Ctrl+C to quit
> Tom went to New York
I-PER O O I-LOC I-LOC
Vous pouvez également former le modèle LSTM CRF bidirectionnel en utilisant la classe BiLSTMTagger . La personnalisation des hyperparamètres est tout à fait simple. Regardons les hyperparamètres pour 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
Maintenant, désactivons la couche 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
Utilisez-le pour reconstituer le modèle:
>>> train('ner-conll2003-nocrf', TransformerTagger, conll2003, hparams=h2)
Parallèlement au modèle, les hyperparamètres sont également enregistrés, il n'est donc pas nécessaire de passer l'objet HParams pendant l'évaluation. Notez également que par défaut, il n'écrasera aucun répertoire de modèle existant (renommera à la place). Pour modifier ce comportement, définissez la variable préfes:
>>> PREFS.overwrite_model_dir = True
La variable PREFS est automatiquement persistée dans prefs.json
Tâche
L'ensemble de données CONLL 2000 est disponible pour la tâche de section. L'ensemble de données est automatiquement téléchargé à partir du référentiel public afin que vous n'ayez pas besoin de le télécharger manuellement.
Démarrez la tâche de section:
python -i -m torchnlp.chunk
Former le modèle du transformateur:
>>> train('chunk-conll2000', TransformerTagger, conll2000)
Aucune partition de validation n'est fournie dans le référentiel, donc 10% de l'ensemble de formation est utilisé pour la validation.
Évaluez le modèle sur l'ensemble de tests:
>>> evaluate('chunk-conll2000', TransformerTagger, conll2000, 'test')
Les modules transformer.Encoder , transformer.Decoder et CRF peuvent être importés indépendamment car ils ne dépendent que de Pytorch:
from torchnlp.modules.transformer import Encoder
from torchnlp.modules.transformer import Decoder
from torchnlp.modules.crf import CRF
Veuillez vous référer aux commentaires dans le code source pour plus de détails sur l'utilisation
