torchnlp
Initial Release
TORCHNLP es una biblioteca de aprendizaje profundo para tareas de PNL. Construido en Pytorch y TorchText, es un intento de proporcionar componentes reutilizables que funcionan en todas las tareas. Actualmente se puede utilizar para el reconocimiento de entidad nombrado (NER) y las tareas de fragmentación con un modelo LSTM CRF bidireccional y un modelo de red de transformadores. Puede admitir cualquier conjunto de datos que use el formato Conll 2003. Más tareas se agregarán en breve
Model e implementa los métodos forward() y loss() para devolver las predicciones y la pérdida respectivamenteHParams para definir fácilmente los hiperparámetros para el modeloEvaluator y Trainer para usar el modelo, los iteradores y métricas del conjunto de datos. Consulte ner.py para más detallesModel : Maneja la carga y el ahorro de modelos, así como los hiperparámetros asociadosHParams : clase genérica para definir hiperparametros. Se puede persistirTrainer : capacite a un modelo dado en un conjunto de datos. Admite características como horarios de descomposición de tasa de aprendizaje predefinidas y paradas tempranasEvaluator : evalúa el modelo en un conjunto de datos y múltiples métricas predefinidas o personalizadas.get_input_processor_words : use durante la inferencia para convertir rápidamente las cadenas de entrada en un formato que puede ser procesado por un modelo transformer.Encoder , transformer.Decoder : la implementación de la red de transfomer desde la atención es todo lo que necesitaCRF : capa de campo aleatorio condicional que se puede usar como salida finalTransformerTagger : modelo de etiquetado de secuencia implementado utilizando la red Transformer y CRFBiLSTMTagger : modelo de etiquetado de secuencia implementado utilizando LSTMS bidireccionales y CRF TorchNLP requiere un mínimo de Python 3.5 y Pytorch 0.4.0 para funcionar. Consulte Pytorch para ver los pasos de instalación. Clon este repositorio e instale otras dependencias como TorchText:
pip install -r requirements.txt
Vaya a la raíz del proyecto y verifique la integridad con Pytest:
pytest
Instale este proyecto:
python setup.py
TORCHNLP está diseñado para usarse dentro del intérprete de Python para que sea más fácil experimentar sin escribir argumentos de línea de comandos engorrosos.
Tarea ner
La tarea NER se puede ejecutar en cualquier conjunto de datos que confirme al formato Conll 2003. Para usar el conjunto de datos NER de Conll 2003, coloque los archivos del conjunto de datos en la siguiente estructura de directorio dentro de su espacio de trabajo Root:
.data
|
|---conll2003
|
|---eng.train.txt
|---eng.testa.txt
|---eng.testb.txt
eng.testa.txt se utiliza el conjunto de datos de validación y eng.testb.txt se usa como el conjunto de datos de prueba.
Inicie el módulo NER en el shell de Python que configura las importaciones:
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)
>>>
Entrena el modelo de transformador en el conjunto de datos Conll 2003:
>>> train('ner-conll2003', TransformerTagger, conll2003)
El primer argumento es el nombre de la tarea. Debe usar el mismo nombre de la tarea durante la evaluación y la inferencia. Por defecto, la función del tren utilizará la métrica F1 con una ventana de 5 épocas para realizar una parada temprana. Para cambiar los criterios de detención temprana, establece la variable global PREFS de la siguiente manera:
>>> PREFS.early_stopping='lowest_3_loss'
Esto ahora usará la pérdida de validación como criterios de detención con una ventana de 3 épocas. Los archivos del modelo se guardan en TaskName-ModelName Directory. En este caso es NER-CONLL2003-TRANSFORMERTGERGER
Evalúe el modelo capacitado en la división del conjunto de datos Testb :
>>> evaluate('ner-conll2003', TransformerTagger, conll2003, 'test')
Mostrará métricas como precisión, precisión de secuencia, F1, etc.
Ejecute el modelo entrenado de manera interactiva para la tarea NER:
>>> interactive('ner-conll2003', TransformerTagger)
...
Ctrl+C to quit
> Tom went to New York
I-PER O O I-LOC I-LOC
Puede entrenar de manera similar el modelo LSTM CRF bidireccional utilizando la clase BiLSTMTagger . Personalizar los hiperparámetros es bastante sencillo. Veamos los 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
Ahora desactivemos la capa 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
Úselo para volver a entrenar el modelo:
>>> train('ner-conll2003-nocrf', TransformerTagger, conll2003, hparams=h2)
Junto con el modelo, los hiperparámetros también se guardan, por lo que no es necesario pasar el objeto HParams durante la evaluación. También tenga en cuenta que, de forma predeterminada, no sobrescribirá ningún director de modelos existente (se cambiará el nombre). Para cambiar ese comportamiento establece la variable prefs:
>>> PREFS.overwrite_model_dir = True
La variable PREFS se persiste automáticamente en prefs.json
Tarea de fragmentación
El conjunto de datos Conll 2000 está disponible para la tarea de fragmentación. El conjunto de datos se descarga automáticamente del repositorio público para que no necesite descargarlo manualmente.
Comience la tarea de fragmentación:
python -i -m torchnlp.chunk
Entrena el modelo de transformador:
>>> train('chunk-conll2000', TransformerTagger, conll2000)
No se proporciona una partición de validación en el repositorio, por lo tanto, el 10% del conjunto de capacitación se utiliza para la validación.
Evaluar el modelo en el conjunto de pruebas:
>>> evaluate('chunk-conll2000', TransformerTagger, conll2000, 'test')
Los módulos transformer.Encoder , transformer.Decoder y CRF pueden importarse de forma independiente, ya que solo dependen de Pytorch:
from torchnlp.modules.transformer import Encoder
from torchnlp.modules.transformer import Decoder
from torchnlp.modules.crf import CRF
Consulte los comentarios dentro del código fuente para obtener más detalles sobre el uso.
