RLSeq2Seq
1.0.0
Remarque: Ce code n'est plus activement maintenu.
Ce référentiel contient le code développé dans TensorFlow pour l'article suivant:
Si vous avez utilisé ce code, veuillez envisager de citer l'article suivant:
@article{keneshloo2018deep,
title={Deep Reinforcement Learning For Sequence to Sequence Models},
author={Keneshloo, Yaser and Shi, Tian and Ramakrishnan, Naren and Reddy, Chandan K.},
journal={arXiv preprint arXiv:1805.09461},
year={2018}
}
Ces dernières années, les modèles de séquence à la séquence (SEQ2SEQ) sont utilisés dans une variété de tâches, de la traduction automatique, de la génération de titres, de la résumé de texte, de la parole au texte, de la génération d'image. Le cadre sous-jacent de tous ces modèles est généralement un réseau neuronal profond qui contient un encodeur et un décodeur. L'encodeur traite les données d'entrée et un décodeur reçoit la sortie de l'encodeur et génère la sortie finale. Bien que l'utilisation d'un modèle d'encodeur / de décodeur produise, la plupart du temps, de meilleurs résultats que les méthodes traditionnelles sur les tâches mentionnées ci-dessus, les chercheurs ont proposé des améliorations supplémentaires par rapport à ces modèles de séquence, comme l'utilisation d'un modèle basé sur l'attention sur l'entrée, les modèles de génération de pointeurs et les modèles d'auto-attention. Cependant, tous ces modèles SEQ2SEQ souffrent de deux problèmes communs: 1) le biais d'exposition et 2) l'incohérence entre la mesure du train / test. Récemment, un point de vue complètement frais a émergé pour résoudre ces deux problèmes dans les modèles SEQ2SEQ en utilisant des méthodes dans l'apprentissage par renforcement (RL). Dans ces nouvelles recherches, nous essayons d'examiner les problèmes SEQ2SEQ du point de vue RL et nous essayons de proposer une formulation qui pourrait combiner la puissance des méthodes RL dans la prise de décision et la séquence pour séquencer les modèles dans la mémorisation de longues souvenirs. Dans cet article, nous résumerons certains des cadres les plus récents qui combinent des concepts du monde RL à la zone de réseau neuronal profond et expliquer comment ces deux domaines pourraient bénéficier de l'autre pour résoudre les tâches complexes SEQ2SEQ. En fin de compte, nous fournirons des informations sur certains des problèmes des modèles existants actuels et comment nous pouvons les améliorer avec de meilleurs modèles RL. Nous fournissons également le code source de mise en œuvre de la plupart des modèles qui seront discutés dans cet article sur la tâche complexe de la résumé de texte abstractif.
- Utilisez Python 2.7
Les exigences Python peuvent être installées comme suit:
pip install -r python_requirements.txt
- TensorFlow 1.10.1
- Cuda 9
- Cudnn 7.1
https://github.com/abisee/cnn-dailymail
https://summari.es/
Nous avons fourni des codes d'assistance pour télécharger l'ensemble de données CNN-DailyMail et prétraiter cet ensemble de données de données et de salle de rédaction. Veuillez vous référer à ce lien pour y accéder.
Nous avons vu une grande amélioration par rapport à la mesure Rouge en utilisant notre version traitée de ces ensembles de données dans les résultats de résumé, par conséquent, nous suggérons fortement d'utiliser ces fichiers prétraités pour toute la formation.
Ce code est un cadre général pour une variété de modes différents qui prend en charge les fonctionnalités suivantes:
Bengio et al. a proposé l'idée d'échantillonnage programmé pour éviter le problème du biais d'exposition. Récemment, Goyal et al. a proposé une relaxtion différenciable de cette méthode, en utilisant un argmax souple plutôt du dur-argmax, qui résout l'erreur de rétro-propagation qui existe dans ce modèle. De plus, Ranzato et al. a proposé un autre modèle simple appelé end2endbackprop pour éviter le problème du biais d'exposition. Pour former un modèle basé sur chacun de ces articles, nous fournissons différents drapeaux comme suit:
Paramètre Défaut Description Scheduled_sampling FAUX Que ce soit pour faire un échantillonnage programmé ou non Sampling_probability 0 Valeur d'Epsilon pour le choix du sol ou la sortie du modèle fixe_sampling_probabilité FAUX Que ce soit pour utiliser une probabilité d'échantillonnage fixe ou adaptative hard_argmax Vrai Que ce soit pour utiliser Soft Argmax ou Hard Argmax greedy_scheduled_sampling FAUX Que ce soit pour utiliser gourmand ou échantillon pour la sortie, vrai signifie gourmand E2ebackprop FAUX L'avoir d'utiliser l'algorithme E2EeBackprop pour résoudre les biais d'exposition alpha 1 Argument doux Argmax
CUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=scheduled-sampling-hardargmax-greedy --batch_size=80 --max_iter=40000 --scheduled_sampling=True --sampling_probability=2.5E-05 --hard_argmax=True --greedy_scheduled_sampling=TrueCUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=scheduled-sampling-softargmax-sampling --batch_size=80 --max_iter=40000 --scheduled_sampling=True --sampling_probability=2.5E-05 --hard_argmax=False --greedy_scheduled_sampling=False --alpha=10CUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=scheduled-sampling-end2endbackprop --batch_size=80 --max_iter=40000 --scheduled_sampling=True --sampling_probability=2.5E-05 --hard_argmax=True --E2EBackProp=True --k=4
Paramètre Défaut Description RL_TRAINT FAUX Démarrer la formation de gradient de politique convert_to_reinforce_model FAUX Convertissez un modèle de pointeur en un modèle de renforcement. Allumez cela et exécutez en mode train. Votre modèle de formation actuel sera copié sur une nouvelle version (même nom avec _cov_init annexé) qui sera prêt à s'exécuter avec un drapeau de couverture activé, pour l'étape de formation de la couverture. intradécodeur FAUX Utiliser l'attention intradecodeuse ou non use_temporal_attention Vrai Que ce soit pour utiliser l'attention temporelle ou non matrix_attention FAUX Utilisez l'attention de la matrice, Eq. 2 à https://arxiv.org/pdf/1705.04304.pdf ETA 0 Facteur de mise à l'échelle RL / MLE, 1 Moyens Utiliser la perte de RL, 0 Moyens Utiliser la perte de MLE fixe_eta FAUX Utiliser la valeur fixe pour ETA ou adaptative en fonction de l'étape globale gamma 0,99 Facteur de réduction RL REWARD reward_function rouge_l / f_score Soit Bleu ou l'une des mesures rouges (Rouge_1 / F_Score, Rouge_2 / F_Score, Rouge_l / F_Score)
Paulus et al. a proposé un modèle d'autocritique de politique de politique pour la résumé de texte abstrait. La figure suivante représente le fonctionnement de cette méthode et comment nous avons implémenté cette méthode:
Pour reproduire leur expérience, nous pouvons utiliser l'ensemble de processus suivants:
CUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=intradecoder-temporalattention-withpretraining --batch_size=80 --max_iter=20000 --use_temporal_attention=True --intradecoder=True --rl_training=FalseIci, nous utilisons un GPU différent pour l'évaluation, mais nous pouvons utiliser le même GPU si nous diminuons le nombre de lots. Dans notre mise en œuvre, nous utilisons une taille de lot de 8 pour l'évaluation, mais pour chaque étape d'évaluation, nous allions 100 fois sur l'ensemble de données de validation. Ceci est similaire à la recherche de l'erreur d'évaluation sur une taille de lot de 800.
CUDA_VISIBLE_DEVICES=1 python src/run_summarization.py --mode=eval --data_path= $HOME /data/cnn_dm/finished_files/chunked/val_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=intradecoder-temporalattention-withpretraining --batch_size=8 --use_temporal_attention=True --intradecoder=True --rl_training=FalseComme suggéré par Paulus et al, nous utilisons une transition linéaire de la perte de l'entropie croisée à la perte de RL afin qu'à la fin, nous comptons complètement sur la perte de RL pour entraîner le modèle. Le paramètre ETA contrôle cette transition. Nous définissons ETA pour être ETA = 1 / (itération max RL).
Tout d'abord, ajoutez le paramètre de formation requis au modèle:
CUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=intradecoder-temporalattention-withpretraining --batch_size=80 --max_iter=40000 --intradecoder=True --use_temporal_attention=True --eta=2.5E-05 --rl_training=True --convert_to_reinforce_model=TrueEnsuite, commencez à exécuter le modèle avec la perte de formation MLE + RL:
CUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=intradecoder-temporalattention-withpretraining --batch_size=80 --max_iter=40000 --intradecoder=True --use_temporal_attention=True --eta=2.5E-05 --rl_training=TrueCUDA_VISIBLE_DEVICES=1 python src/run_summarization.py --mode=eval --data_path= $HOME /data/cnn_dm/finished_files/chunked/val_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=intradecoder-temporalattention-withpretraining --batch_size=8 --use_temporal_attention=True --intradecoder=True --rl_training=TrueNous utilisons Rouge comme mesures d'évaluation.
CUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=decode --data_path= $HOME /data/cnn_dm/finished_files/chunked/test_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=intradecoder-temporalattention-withpretraining --rl_training=True --intradecoder=True --use_temporal_attention=True --single_pass=1 --beam_size=4 --decode_after=0
Paramètre Défaut Description AC_TRAINT FAUX Utilisez l'apprentissage acteur-critique par DDQN. dqn_scheduled_sampling FAUX L'avoir utilisé d'échantillonnage planifié pour utiliser les estimations du modèle DDQN par rapport aux valeurs réelles des Q-estimations dqn_layers 512,256 128 Taille de couche cachée dense DDQN. Il créera trois couches denses avec 512, 256 et 128 taille dqn_replay_buffer_size 100000 Taille du tampon de relecture dqn_batch_size 100 Taille du lot pour la formation du modèle DDQN dqn_target_update 10000 Mettre à jour le réseau cible Q toutes les 10000 étapes dqn_sleep_time 2 Train DDQN Modèle toutes les 2 secondes dqn_gpu_num 1 Numéro de GPU pour former le DDQN dueling_net Vrai S'il faut utiliser du réseau de duel pour former le modèle https://arxiv.org/pdf/1511.06581.pdf dqn_polyak_averaging Vrai Que ce soit à utiliser la moyenne de Polyak pour mettre à jour les paramètres du réseau cible Q: psi ^ {prime} = (tau * psi ^ {prime}) + (1-tau) * psi calculer_true_q FAUX Que ce soit pour utiliser de vraies valeurs Q pour former DDQN ou utiliser les estimations de DDQN pour le former dqn_pretrain FAUX Prenez la rétraction du réseau DDQN avec un modèle d'acteur fixe DQN_PRETRAIN_STEPS 10000 Nombre d'étapes pour pré-entraîner le DDQN
Le cadre général du modèle acteur-critique est le suivant:
Dans notre implémentation, l'acteur est le modèle de générateur de pointeur et le critique est un modèle de régression qui minimise l'estimation de la valeur Q à l'aide du réseau DIBEED Q (DDQN). Le code est implémenté de telle sorte que la formation DDQN se trouve sur un fil différent du thread principal et nous collectons des expériences pour ce réseau de manière asynchrone du modèle d'acteur. Par conséquent, pour chaque lot, nous collectons (Batch_Size * MAX_DEC_STEPS) pour la formation DDQN. Nous avons implémenté le tampon de relecture prioritaire. Et pendant la formation DDQN, nous sélectionnons toujours nos mini lots de telle sorte qu'ils contiennent des expériences qui ont la meilleure récompense partielle selon le résumé de la touche au sol. Nous avons ajouté une option de formation DDQN sur la base de la véritable estimation Q et avons proposé un processus d'échantillonnage planifié pour la formation de ce réseau. Veuillez noter que la formation DDQN en utilisant la véritable estimation Q réduira considérablement la vitesse de l'entraînement, en raison de la collection de vraies valeurs Q. Par conséquent, nous suggérons d'activer cela uniquement pour quelques itérations. Comme suggéré par Bahdanau et al. Il est également bon d'utiliser un acteur pré-formé fixe pour pré-entraîner d'abord le modèle de critique, puis de commencer à entraîner les deux modèles, simultanément. Par exemple, nous pouvons utiliser l'ensemble de codes suivant pour exécuter une expérience similaire à Bahdanau et al .:
CUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=actor-critic-ddqn --batch_size=80 --max_iter=20000 Nous pouvons utiliser Duel Network pour former le DDQN en activant le drapeau dueling_net . De plus, nous pouvons choisir de mettre à jour le réseau cible en utilisant la moyenne de Polyak par le drapeau dqn_polyak_averaging .
CUDA_VISIBLE_DEVICES=0,1 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=actor-critic-ddqn --batch_size=80 --max_iter=21000 --ac_training=True --dueling_net=True --dqn_polyak_averaging=True --convert_to_reinforce_model=True --dqn_gpu_num=1 Utilisez le drapeau dqn_pretrain_steps pour définir le nombre d'itération que vous souhaitez pré-entraîner le critique.
CUDA_VISIBLE_DEVICES=0,1 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=actor-critic-ddqn --batch_size=80 --ac_training=True --dqn_pretrain=True --dueling_net=True --dqn_polyak_averaging=True --dqn_gpu_num=1 Nous pouvons exécuter l'acteur dans un GPU et un critique dans un autre GPU simplement en utilisant un numéro de GPU différent pour le critique à l'aide de l'option dqn_gpu_num . De plus, comme mentionné précédemment, nous devons éviter d'utiliser une véritable estimation Q pendant longtemps, nous utilisons donc une véritable estimation pour entraîner le DDQN pour seulement 1000 itérations.
CUDA_VISIBLE_DEVICES=0,1 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=actor-critic-ddqn --batch_size=80 --max_iter=22000 --ac_training=True --dueling_net=True --dqn_polyak_averaging=True --calculate_true_q=True --dqn_gpu_num=1 Veuillez noter que nous n'utilisons plus l'indicateur calculate_true_q .
CUDA_VISIBLE_DEVICES=0,1 python src/run_summarization.py --mode=train --data_path= $HOME /data/cnn_dm/finished_files/chunked/train_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=actor-critic-ddqn --batch_size=80 --max_iter=40000 --ac_training=True --dueling_net=True --dqn_polyak_averaging=True --dqn_gpu_num=1CUDA_VISIBLE_DEVICES=0 python src/run_summarization.py --mode=decode --data_path= $HOME /data/cnn_dm/finished_files/chunked/test_ * --vocab_path= $HOME /data/cnn_dm/finished_files/vocab --log_root= $HOME /working_dir/cnn_dm/RLSeq2Seq/ --exp_name=actor-critic-ddqn --ac_training=True --dueling_net=True --dqn_polyak_averaging=True --dqn_gpu_num=1 --single_pass=1 --beam_size=4 Veuillez noter que nous pouvons utiliser des options telles que intradecoder , temporal_attention , E2EBackProp , scheduled_sampling , etc. dans des modèles acteurs-critiques. L'utilisation de ces options aidera à avoir un modèle d'acteur mieux performant.
Merci @astorfi pour son aide sur la préparation de cette documentation.
