word language model

Modelado de idiomas a nivel de palabras RNN

Este ejemplo entrena un RNN de múltiples capas (Elman, Gru o LSTM) en una tarea de modelado de idiomas. Por defecto, el script de capacitación utiliza el conjunto de datos PTB, proporcionado. El modelo entrenado puede ser utilizado por el script Generar para generar texto nuevo. Este es un porte de pytorch/ejemplos/word_language_model haciendo que se use en floydhub.

Uso

El script main.py acepta los siguientes argumentos:

optional arguments:
  -h, --help         show this help message and exit
  --data DATA        location of the data corpus
  --model MODEL      type of recurrent net (RNN_TANH, RNN_RELU, LSTM, GRU)
  --emsize EMSIZE    size of word embeddings
  --nhid NHID        number of hidden units per layer
  --nlayers NLAYERS  number of layers
  --lr LR            initial learning rate
  --clip CLIP        gradient clipping
  --epochs EPOCHS    upper epoch limit
  --batch-size N     batch size
  --bptt BPTT        sequence length
  --dropout DROPOUT  dropout applied to layers (0 = no dropout)
  --decay DECAY      learning rate decay per epoch
  --tied             tie the word embedding and softmax weights
  --seed SEED        random seed
  --cuda             use CUDA
  --log-interval N   report interval
  --save SAVE        path to save the final model

Con estos argumentos, se puede probar una variedad de modelos. Como ejemplo, los siguientes argumentos producen modelos más lentos pero mejores:

python main.py --cuda --emsize 650 --nhid 650 --dropout 0.5 --epochs 40           # Test perplexity of 80.97
python main.py --cuda --emsize 650 --nhid 650 --dropout 0.5 --epochs 40 --tied    # Test perplexity of 75.96
python main.py --cuda --emsize 1500 --nhid 1500 --dropout 0.65 --epochs 40        # Test perplexity of 77.42
python main.py --cuda --emsize 1500 --nhid 1500 --dropout 0.65 --epochs 40 --tied # Test perplexity of 72.30

Estas perplejidades son iguales o mejores que la regularización de la red neuronal recurrente (Zaremba et al. 2014) y son similares a usar la incrustación de salida para mejorar los modelos de idiomas (Press & Wolf 2016 y vincular los vectores de palabras y los clasificadores de palabras: un marco de pérdidas para el modelado de idiomas (Inan et al. 2016), aunque ambos documentos han mejorado perplexities al usar una forma de forma de recurso recurrente (variamiento de lenguaje (inan et al. 2016).

Arquitectura

Pronto.

Corre en Floydhub

Aquí están los comandos para capacitar, evaluar y servir su tarea de modelado de idiomas en Floydhub.

Configuración del proyecto

Antes de comenzar, inicie sesión en Floydhub con el comando de inicio de sesión de Floyd, luego bifurca e inicie el proyecto:

$ git clone https://github.com/floydhub/word-language-model.git
$ cd word-language-model
$ floyd init word-language-model

Capacitación

Antes de comenzar, debe cargar el conjunto de datos Penn TreeBank-3 como un conjunto de datos Floydhub siguiendo esta guía: Crear y cargar un conjunto de datos. Entonces estarás listo para jugar con diferentes modelos de idiomas.

 # Train a LSTM on PTB with CUDA, reaching perplexity of 114.22
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input " python main.py --cuda --epochs 7 "

# Train a tied LSTM on PTB with CUDA, reaching perplexity of 110.44
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input " python main.py --cuda --epochs 7 --tied "

# Train a tied LSTM on PTB with CUDA for 40 epochs, reaching perplexity of 87.17
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input " python main.py --cuda --tied "

Nota:

• --gpu Ejecute su trabajo en una instancia de GPU de Floydhub.
• --env pytorch-0.2 prepara un entorno de Pytorch para Python 3.
• --data <USERNAME>/dataset/<PENN-TB3>/<VERSION>:input el conjunto de datos Penn Treebank-3 de PreSius cargado en la carpeta /input dentro del contenedor para nuestro trabajo.

El modelo utiliza el módulo nn.RNN (y sus módulos hermanos nn.GRU y nn.LSTM ) que usará automáticamente el backend de Cudnn si se ejecuta en CUDA con Cudnn instalado.

Durante el entrenamiento, si se recibe una interrupción del teclado (CTRL-C), se detiene la capacitación y el modelo actual se evalúa con el conjunto de datos de prueba.

Puede seguir el progreso utilizando el comando logs. Los primeros 2 ejemplos de capacitación deben completarse en aproximadamente 5 minutos en una instancia de GPU y 40 'en una CPU. El último ejemplo debe tomar alrededor de 30 'en una instancia de GPU y más de 3 horas en una instancia de CPU.

Evaluación

Es hora de evaluar nuestro modelo generando algún texto:

 # Generate samples from the trained LSTM model.
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input --data < REPLACE_WITH_JOB_OUTPUT_NAME > :model " python generate.py --cuda "

Prueba nuestro modelo previamente capacitado

Le hemos proporcionado un modelo previamente capacitado entrenado para 40 épocas que alcanzan la perplejidad de 87.17:

 # Generate samples from the trained LSTM model.
floyd run --gpu --env pytorch-0.2 --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input --data < REPLACE_WITH_JOB_OUTPUT_NAME > :model " python generate.py --cuda "

Servir el modelo a través de REST API

Floydhub admite el modo Seving para el propósito de demostración y prueba. Antes de servir a su modelo a través de REST API, debe crear un floyd_requirements.txt y declarar el requisito de matraz en él. Si ejecuta un trabajo con la bandera --mode serve , FloyDhub ejecutará el archivo app.py en su proyecto y lo adjuntará a un punto final de servicio dinámico:

floyd run --gpu --mode serve --env pytorch-0.2  --data < USERNAME > /dataset/ < PENN-TB 3> / < VERSION > :input --data < REPLACE_WITH_JOB_OUTPUT_NAME > :model

El comando anterior imprimirá un punto final de servicio para este trabajo en su consola terminal.

El punto final del servicio tardará un par de minutos en prepararse. Una vez que está arriba, puede interactuar con el modelo enviando una solicitud posterior con el número de palabras y la temperatura que el modelo usará para generar texto:

 # Template
# curl -X POST -o <NAME_&_PATH_DOWNLOADED_GENERATED_TEXT> -F "words=<NUMBER_OF_WORDS_TO_GENERATE>" -F "temperature=<TEMPERATURE>" <SERVICE_ENDPOINT>

curl -X POST -o generated.txt -F " words=100 " -F " temperature=3 " https://www.floydlabs.com/expose/vk47ixT8NeYBTFeMavbWta

Cualquier trabajo que se ejecute en modo de servicio permanecerá despierto hasta que alcance el tiempo de ejecución máximo. Entonces, una vez que haya terminado de probar, ¡recuerde cerrar el trabajo!

Tenga en cuenta que esta característica está en modo de vista previa y aún no está lista para la producción

Más recursos

Algunos recursos útiles en PNL para el aprendizaje profundo y la tarea de modelado de idiomas:

• La efectividad irrazonable de las redes neuronales recurrentes
• Procesamiento del lenguaje natural con aprendizaje profundo - Stanford
• Curso de Oxford Deep NLP 2017

Que contribuye

Para cualquier pregunta, el error (incluso los errores tipográficos) y/o las solicitudes de características, ¡no dude en contactarme ni abrir un problema!