word language model

Modélisation de la langue au niveau des mots RNN

Cet exemple forme un RNN multicouche (Elman, GRU ou LSTM) sur une tâche de modélisation de la langue. Par défaut, le script d'entraînement utilise l'ensemble de données PTB, fourni. Le modèle formé peut ensuite être utilisé par le script Génération pour générer un nouveau texte. Ceci est un portage de pytorch / exemples / word_language_model, ce qui le rend utilisable sur floydhub.

Usage

Le script main.py accepte les arguments suivants:

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

Avec ces arguments, une variété de modèles peuvent être testés. Par exemple, les arguments suivants produisent des modèles plus lents mais meilleurs:

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

Ces perplexités sont égales ou meilleures que la régularisation du réseau neuronal récurrente (Zaremba et al. 2014) et sont similaires à l'utilisation de l'intégration de sortie pour améliorer les modèles de langage (Press & Wolf 2016 et les vecteurs de mots et les classificateurs de mots: un cadre de perte pour la modélisation du langage (Inan et al. 2016), bien que ces deux articles aient amélioré les perplexités en utilisant une forme de disposition récurrente (Dropout).

Architecture

Bientôt.

Courez sur Floydhub

Voici les commandes de formation, d'évaluation et de service de votre tâche de modélisation de la langue sur Floydhub.

Configuration du projet

Avant de commencer, connectez-vous sur Floydhub avec la commande Floyd Login, puis fourche et init le projet:

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

Entraînement

Avant de commencer, vous devez télécharger l'ensemble de données Penn TreeBank-3 en tant qu'ensemble de données FloydHub en suivant ce guide: Créez et téléchargez un ensemble de données. Ensuite, vous serez prêt à jouer avec différents modèles de langue.

 # 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 "

Note:

• --gpu exécutez votre travail sur une instance GPU Floydhub.
• --env pytorch-0.2 prépare un environnement pytorch pour Python 3.
• --data <USERNAME>/dataset/<PENN-TB3>/<VERSION>:input monte le jeu de données PENN TENBANK-3 Téléchargé PREVIUS dans le dossier /input à l'intérieur du conteneur de notre travail.

Le modèle utilise le module nn.RNN (et ses modules soeurs nn.GRU et nn.LSTM ) qui utiliseront automatiquement le backend CUDNN si l'exécution sur CUDA avec CUDNN installé.

Pendant la formation, si une interruption de clavier (CTRL-C) est reçue, la formation est arrêtée et le modèle actuel est évalué par rapport à l'ensemble de données de test.

Vous pouvez suivre les progrès en utilisant la commande Logs. Les 2 premiers exemples de formation doivent être achevés en environ 5 minutes sur une instance GPU et 40 'sur un processeur. Le dernier exemple devrait prendre environ 30 'sur une instance GPU et plus de 3 heures sur un CPU Instace.

Évaluation

Il est temps d'évaluer notre modèle générant du texte:

 # 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 "

Essayez notre modèle pré-formé

Nous vous avons fourni un modèle pré-formé formé pour 40 époques atteignant la perplexité 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 le modèle via l'API REST

Floydhub prend en charge le mode Seving à des fins de démo et de test. Avant de servir votre modèle via l'API REST, vous devez créer un floyd_requirements.txt et déclarer l'exigence de flacon. Si vous exécutez un travail avec --mode serve , floydhub exécutera le fichier app.py dans votre projet et le joignera à un point de terminaison de service dynamique:

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

La commande ci-dessus imprimera un point de terminaison de service pour ce travail dans votre console de terminal.

Le point de terminaison du service prendra quelques minutes pour se préparer. Une fois qu'il est en place, vous pouvez interagir avec le modèle en envoyant une demande de poste avec le nombre de mots et la température que le modèle utilisera pour générer du texte:

 # 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

Tout travail fonctionnant en mode de service restera jusqu'à ce qu'il atteigne le temps d'exécution maximal. Donc, une fois les tests terminés, n'oubliez pas de fermer le travail!

Notez que cette fonctionnalité est en mode prévisualisation et n'est pas encore prête à la production

Plus de ressources

Quelques ressources utiles sur la PNL pour l'apprentissage en profondeur et la tâche de modélisation des langues:

• L'efficacité déraisonnable des réseaux de neurones récurrents
• Traitement du langage naturel avec apprentissage en profondeur - Stanford
• Oxford Deep NLP 2017 Cours

Contributif

Pour toutes les questions, les demandes de bug (même de fautes de frappe) et / ou de fonctionnalités n'hésitent pas à me contacter ou à ouvrir un problème!