TF NNLM TK

TF-NNLM-TK: un conjunto de herramientas de modelo de lenguaje de red neural en TensorFlow

Acerca de

TF-NNLM-TK es un kit de herramientas escrito en Python3 para el modelado de lenguaje de red neuronal utilizando TensorFlow. Incluye modelos básicos como RNN y LSTM, así como modelos más avanzados. Proporciona funcionalidad para preprocesar los datos, entrenar los modelos y evaluarlos. El kit de herramientas es de código abierto bajo la licencia Apache 2.

Actualmente, los siguientes modelos son compatibles:

• Vainilla-rnn
• LSTM
• LSTM con proyección
• Gru
• RNN secuencial (dependiente de palabras, independiente de las palabras y con factor olvidado)
• Contexto de rango a largo plazo

Un primer ejemplo

Primero instale Python y TensorFlow. El código se prueba con Python 3 y TensorFlow 1.8.

Para este primer ejemplo, necesitamos descargar el kit de herramientas y algunos datos de capacitación. Usaremos el conjunto de datos PTB proporcionado en el tutorial de Tomas Mikolov. Para esto, puede ejecutar el siguiente código en su línea de comando:

git clone git clone https://github.com/uds-lsv/TF-NNLM-TK.git
cd TF-NNLM-TK
wget http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz
tar -xzf simple-examples.tgz

Luego, para entrenar y evaluar un primer modelo de lenguaje neuronal simple, simplemente ejecute el siguiente código

python train_basic_rnn_models.py --save_dir=small_lstm --model=lstm --train_file=simple-examples/data/ptb.train.txt --test_file=simple-examples/data/ptb.test.txt

python test.py --model_file=small_lstm/model.ckpt --test_file=simple-examples/data/ptb.test.txt

El entrenamiento dura unos 20 minutos en una GPU GTX 1050TI.

Los detalles

Preprocesamiento de datos:

Los scripts de capacitación ya llaman al código de procesamiento de datos. Si usa los datos predeterminados, probablemente pueda omitir esta sección.

El kit de herramientas incluye un procesador de datos, que lee un archivo de texto y crea a partir de dos matrices (numpy) que almacenan los lotes de las palabras de entrada (historial) y las palabras objetivo (predicción). El código también proporciona algunas herramientas útiles, como la funcionalidad, para crear y guardar el vocabulario, para crear recuentos o para asignar palabras OOV en archivos de prueba en un token desconocido dado.

Esta parte del código no tiene una función principal. En cambio, se llama directamente en el código Python de los scripts de entrenamiento. Por ejemplo, puedes llamar a Python

 DataProcessor ( train_file , batch_size , seq_length , True , '<unk>' , history_size = history_size )

Este fragmento de código tomará el Train_File, hará las transformaciones descritas anteriormente y creará lotes de él utilizando los parámetros dados.

Descripción del modelo

El TF-NNLM-TK proporciona el código de capacitación para los siguientes modelos de lenguaje neuronal:

Modelos básicos de RNN

Estos son comúnmente conocidos y usados. En particular, este kit de herramientas implementa Vanilla-RNN, LSTM, LSTM con proyección y Gru. Estos modelos se pueden entrenar utilizando el script Train_basic_rnn_models.py (ver el ejemplo a continuación).

Modelos secuenciales de RNN

Estos modelos usan más de n palabras de la historia en lugar del último. La implementación proporciona tres modelos: SRNN dependiente de palabras (WD-SRNN), SRNN independiente de las palabras (WI-SRNN) y el factor de olvido SRNN (FF-SRNN). Puede encontrar más información sobre estos modelos aquí. Estos modelos pueden ser entrenados utilizando el script Train_srnn.py

Modelo de contexto de rango a largo plazo (LSRC)

Estos modelos utilizan dos estados locales y globales separados para aprender dependencias de corto y largo alcance por separado. La implementación segmentaria de TF de la propagación posterior hace que este modelo sufra drásticamente del gradiente de fuga en el estado local, que utiliza un modelo de vainilla-RNN, por lo tanto, este último se reemplaza (temporalmente por un Gru). Puede encontrar más información sobre este modelo aquí. Este modelo puede ser entrenado utilizando el script Train_lsrc.py

Capacitación

Cada uno de estos scripts de entrenamiento (Train_Basic_RNN_Models.py, Train_Srnn.py y Train_LSRC.py) incluye una gran cantidad de parámetros, cada uno de ellos tiene una descripción adjunta. Para obtener esta descripción ejecutada, por ejemplo, en su línea de comando:

python train_basic_rnn_models.py --help

Los parámetros predeterminados de todos los modelos intentan que coincidan con la pequeña configuración reportada en la receta TensorFlow PTB-LM:

configuración	épocas	tren	válido	prueba
pequeño	13	37.99	121.39	115.91
medio	39	48.45	86.16	82.07
grande	55	37.87	82.62	78.29

Para reproducir estos números con el modelo LSTM (en realidad mejores números debido a la inicialización de Xavier), ejecute (ajustando la ruta a los datos a su configuración):

python train_basic_rnn_models.py --save_dir=small_lstm --model=lstm --train_file=path/to/data/train.txt --test_file=path/to/data/test.txt

Esta llamada entrenará el modelo LSTM en los datos de PTB utilizando exactamente la misma configuración utilizada en la receta TensorFlow. Si desea ejecutar el modelo con la configuración media, simplemente deberá establecer los parámetros en sus valores especificados en la configuración de medio:

python train_basic_rnn_models.py --init_scale=0.05 --seq_length=35 --embed_size=650 --hidden_size=650 --max_epoch=6 --num_epochs=39 --decay_rate=0.8 --batch_size=20 --input_keep_prob=0.5 --output_keep_prob=0.5 --model=lstm --save_dir=medium_lstm --train_file=path/to/data/train.txt --test_file=path/to/data/test.txt

La misma idea se aplica a los modelos más avanzados, excepto que necesita llamar a los scripts de capacitación correspondientes y que es posible que necesite ajustar ligeramente los parámetros. Prueba por ejemplo:

python train_srnn.py --model=wi-srnn --input_keep_prob=0.6 --save_dir=wisrnn_small_5gram --train_file=path/to/data/train.txt --test_file=path/to/data/test.txt 

Para entrenar el modelo WISRNN con la configuración predeterminada, excepto para el abandono de la incrustación de la palabra, que se establece en 0.4 (1-0.6). Esto debería conducir a un rendimiento de ~ 109.5 en el conjunto de datos de ejemplo desde arriba.

Del mismo modo, el modelo LSRC está entrenado utilizando el script correspondiente:

python train_lsrc.py --save_dir=lsrc_small --train_file=path/to/data/train.txt --test_file=path/to/data/test.txt 

El script también permite modificar la capacitación estableciendo los parámetros correspondientes. Use -Help para obtener más información sobre ellos.

Pruebas

El script de prueba es el mismo para todos los modelos. Solo necesita especificar la ruta al modelo que desea evaluar y la ruta a su archivo de prueba. Para evaluar el modelo LSTM pequeño que entrenamos anteriormente, solo necesitamos ejecutar el siguiente comando:

python test.py --model_file=small_lstm/model.ckpt --test_file=path/to/data/test.txt 

El script también ofrece algunos otros parámetros para controlar la velocidad en caso de que esté probando en un corpus muy grande.

Autores y licencia

Este kit de herramientas fue desarrollado originalmente por Youssef Ouealil, durante su tiempo en LSV, Universidad de Saarland. Actualmente está mantenido en el Grupo LSV por Michael A. Hedderich con contribuciones de Adam Kusmirek. Este trabajo fue financiado en parte por SFB 1102.

Este código tiene licencia bajo Apache 2.0. Las partes de este código se basan en la receta TensorFlow PTB-LM con licencia bajo la licencia Apache, versión 2.0 por los autores TensorFlow. Consulte el archivo de licencia para obtener más detalles.

Si usa este kit de herramientas como parte de una publicación, considere citarnos:

 @inproceedings{oualil-singh-greenberg-klakow:EMNLP2016,
  author = {Oualil, Youssef  and  Singh, Mittul  and  Greenberg, Clayton  and  Klakow, Dietrich},
  title = {Long-Short Range Context Neural Networks for Language Modeling},
  booktitle = {{EMNLP} 2016, Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing},
  day = {3},
  month = {November},
  year = {2016},
  address = {Austin, Texas},
  publisher = {Association for Computational Linguistics},
  pages = {1473--1481},
  url = {http://aclweb.org/anthology/D16-1154.pdf},
  poster = {http://coli.uni-saarland.de/~claytong/posters/EMNLP16_Poster.pdf}
}

o

 @inproceedings{oualil-greenberg-singh-klakow:2016:IS,
  author = {Youssef Oualil and Clayton Greenberg and Mittul Singh and Dietrich Klakow},
  title = {Sequential Recurrent Neural Networks for Language Modeling},
  day = {12},
  month = {September},
  year = 2016,
  address = {San Francisco, California, USA},
  booktitle = {{INTERSPEECH} 2016, Proceedings of the 17th Annual Conference of the International Speech Communication Association},
  doi = {10.21437/Interspeech.2016-422},
  url = {http://www.isca-speech.org/archive/Interspeech_2016/pdfs/0422.PDF},
  pages = {3509--3513},
  publisher = {{ISCA}}
}