TF NNLM TK
1.0.0
TF-NNLM-TK est une boîte à outils écrite dans Python3 pour la modélisation du langage de réseau neuronal à l'aide de TensorFlow. Il comprend des modèles de base comme RNNS et LSTMS ainsi que des modèles plus avancés. Il fournit des fonctionnalités pour prétraiter les données, former les modèles et les évaluer. La boîte à outils est ouverte sous la licence Apache 2.
Actuellement, les modèles suivants sont pris en charge:
Installez d'abord Python et TensorFlow. Le code est testé avec Python 3 et TensorFlow 1.8.
Pour ce premier exemple, nous devons télécharger la boîte à outils et certaines données de formation. Nous utiliserons l'ensemble de données PTB fourni dans le tutoriel de Tomas Mikolov. Pour cela, vous pouvez exécuter le code suivant dans votre ligne de commande:
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.tgzEnsuite, pour entraîner et évaluer un premier modèle de langue neuronale simple, il suffit d'exécuter le code suivant
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.txtLa formation dure environ 20 minutes sur un GTX 1050ti GPU.
Les scripts de formation appellent déjà le code de traitement des données. Si vous utilisez les données par défaut, vous pouvez probablement ignorer cette section.
La boîte à outils comprend un processeur de données, qui lit un fichier texte et en crée deux tableaux (Numpy) qui stockent les lots des mots d'entrée (historique) et des mots cibles (prédiction). Le code fournit également quelques outils utiles tels que des fonctionnalités pour créer et enregistrer le vocabulaire, pour créer des comptes ou pour cartographier les mots OOV dans des fichiers de test dans un jeton inconnu donné.
Cette partie du code n'a pas de fonction principale. Au lieu de cela, il est directement appelé dans le code Python des scripts de formation. Par exemple, vous pouvez appeler Python
DataProcessor ( train_file , batch_size , seq_length , True , '<unk>' , history_size = history_size )Cet extrait de code prendra le train_file, effectuera les transformations décrites ci-dessus et créera des lots à partir des paramètres donnés.
Le TF-NNLM-TK fournit le code de formation des modèles de langage neuronal suivant:
Ceux-ci sont communément connus et utilisés. En particulier, cette boîte à outils implémente Vanilla-RNN, LSTM, LSTM avec projection et GRU. Ces modèles peuvent être formés à l'aide du script Train_basic_rnn_models.py (voir l'exemple ci-dessous).
Ces modèles utilisent plus de n mots de l'histoire au lieu du dernier. L'implémentation fournit trois modèles: SRNN dépendant du mot (WD-SRNN), SRNN indépendant du mot (WI-SRNN) et Srnn-Factor Factor (FF-SRNN). Plus d'informations sur ces modèles peuvent être trouvées ici. Ces modèles peuvent être formés à l'aide du script train_srnn.py
Ces modèles utilisent deux états locaux et mondiaux distincts pour apprendre séparément les dépendances courtes et à longue portée. La mise en œuvre de la TF segmentaire de la rétro-propagation fait que ce modèle souffre radicalement du gradient de fuite à l'état local, qui utilise un modèle de vanille-RNN, ainsi ce dernier est remplacé (temporairement par un GRU). Plus d'informations sur ce modèle peuvent être trouvées ici. Ce modèle peut être formé à l'aide du script train_lsrc.py
Chacun de ces scripts de formation (Train_Basic_Rnn_Models.py, Train_Srnn.py et Train_lsrc.py) comprend un grand nombre de paramètres, chacun d'eux a une description qui y est attachée. Pour obtenir cette description, par exemple, par exemple, sur votre ligne de commande:
python train_basic_rnn_models.py --helpLes paramètres par défaut de tous les modèles essaient de correspondre à la petite configuration rapportée dans la recette de TensorFlow PTB-LM:
| configurer | époques | former | valide | test |
|---|---|---|---|---|
| petit | 13 | 37,99 | 121.39 | 115.91 |
| moyen | 39 | 48.45 | 86.16 | 82.07 |
| grand | 55 | 37.87 | 82.62 | 78.29 |
Pour reproduire ces nombres avec le modèle LSTM (en fait de meilleurs nombres en raison de l'initialisation de Xavier), exécutez (ajustant le chemin d'accès aux données de votre paramètre):
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.txtCet appel entraînera le modèle LSTM sur les données PTB en utilisant exactement la même configuration utilisée dans la recette TensorFlow. Si vous souhaitez exécuter le modèle avec la configuration moyenne, vous devrez simplement définir les paramètres sur leurs valeurs spécifiées dans la configuration moyenne:
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.txtLa même idée s'applique aux modèles les plus avancés, sauf que vous devez appeler les scripts de formation correspondants et que vous devrez peut-être ajuster légèrement les paramètres. Essayez par exemple:
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 Pour former le modèle WISRNN avec la configuration par défaut, à l'exception du mot d'incorporation de mots, qui est défini sur 0,4 (1-0,6). Cela devrait conduire à une performance de ~ 109,5 sur l'exemple d'ensemble de données d'en haut.
De même, le modèle LSRC est formé à l'aide du script correspondant:
python train_lsrc.py --save_dir=lsrc_small --train_file=path/to/data/train.txt --test_file=path/to/data/test.txt Le script permet également de modifier la formation en définissant les paramètres correspondants. Utilisez --help pour obtenir plus d'informations à leur sujet.
Le script de test est le même pour tous les modèles. Vous n'avez qu'à spécifier le chemin du modèle que vous souhaitez évaluer et le chemin d'accès à votre fichier de test. Pour évaluer le petit modèle LSTM que nous avons formé au-dessus, nous avons juste besoin d'exécuter la commande suivante:
python test.py --model_file=small_lstm/model.ckpt --test_file=path/to/data/test.txt Le script propose également quelques autres paramètres pour contrôler la vitesse au cas où vous testez sur un très grand corpus.
Cette boîte à outils a été initialement développée par Youssef Oualil, pendant son séjour à l'Université de LSV, Saarland. Il est actuellement entretenu au groupe LSV par Michael A. Hedderich avec des contributions d'Adam Kusmirek. Ce travail a été financé en partie par SFB 1102.
Ce code est sous licence sous Apache 2.0. Les parties de ce code sont basées sur la recette TensorFlow PTB-LM sous licence Apache, version 2.0 par les auteurs TensorFlow. Veuillez consulter le fichier de licence pour plus de détails.
Si vous utilisez cette boîte à outils dans le cadre d'une publication, veuillez envisager de nous citer:
@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}
}
ou
@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}}
}
