RLSeq2Seq
1.0.0
Hinweis: Dieser Code wird nicht mehr aktiv gepflegt.
Dieses Repository enthält den in TensorFlow entwickelten Code für das folgende Papier:
Wenn Sie diesen Code verwendet haben, sollten Sie bitte das folgende Papier zitieren:
@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}
}
In den letzten Jahren werden Sequence-to-Sequence (SEQ2SEQ) -Modelle in einer Vielzahl von Aufgaben verwendet, von maschineller Übersetzung, Schlagzeilengenerierung, Textübersicht, Sprache zu Text, bis zur Bildunterschriftengenerierung. Der zugrunde liegende Rahmen all dieser Modelle ist normalerweise ein tiefes neuronales Netzwerk, das einen Encoder und Decoder enthält. Der Encoder verarbeitet die Eingabedaten und ein Decoder empfängt die Ausgabe des Encoders und generiert die endgültige Ausgabe. Obwohl die ledigliche Verwendung eines Encoder-/Decoder-Modells die meiste Zeit bessere Ergebnisse als herkömmliche Methoden bei den oben genannten Aufgaben erzielen würde, schlugen die Forscher zusätzliche Verbesserungen gegenüber diesen Sequenzmodellen vor, z. Alle diese SEQ2SEQ -Modelle leiden jedoch unter zwei häufigen Problemen: 1) Expositionsverzerrung und 2) Inkonsistenz zwischen Zug-/Testmessung. In jüngster Zeit entstand eine völlig neue Sichtweise bei der Lösung dieser beiden Probleme in SEQ2SQ -Modellen, indem Methoden im Verstärkungslernen (RL) verwendet wurden. In diesen neuen Forschungen versuchen wir, die SEQ2SEQ-Probleme aus der Sicht der RL zu betrachten, und wir versuchen, eine Formulierung zu erstellen, die die Kraft von RL-Methoden in der Entscheidungsfindung und der Sequenzmodelle in Erinnerung an lange Erinnerungen kombinieren könnte. In diesem Artikel werden wir einige der neuesten Frameworks zusammenfassen, die Konzepte von RL World bis zum tiefen Bereich Neuronales Netzwerk kombinieren und erklären, wie diese beiden Bereiche bei der Lösung komplexer SEQ2SEQ -Aufgaben voneinander profitieren können. Am Ende werden wir Einblicke in einige der Probleme der aktuellen vorhandenen Modelle geben und wie wir sie mit besseren RL -Modellen verbessern können. Wir bieten auch den Quellcode für die Implementierung der meisten Modelle, die in diesem Artikel über die komplexe Aufgabe der abstrakten Textübersicht diskutiert werden.
- Verwenden Sie Python 2.7
Python -Anforderungen können wie folgt installiert werden:
pip install -r python_requirements.txt
- Tensorflow 1.10.1
- CUDA 9
- Cudnn 7.1
https://github.com/abisee/cnn-dailymail
https://summari.es/
Wir haben Helfercodes bereitgestellt, um den CNN-DailyMail-Datensatz herunterzuladen und diesen Datensatz- und Newsroom-Datensatz vorzubereiten. Bitte beachten Sie diesen Link, um darauf zuzugreifen.
Wir haben eine große Verbesserung des Rouge-Maßes durch die Verwendung unserer verarbeiteten Version dieser Datensätze in den Zusammenfassungsergebnissen gesehen. Daher empfehlen wir dringend, diese vorverarbeiteten Dateien für das gesamte Training zu verwenden.
Dieser Code ist ein allgemeiner Rahmen für eine Vielzahl verschiedener Modi, die die folgenden Funktionen unterstützen:
Bengio et al. schlug die Idee einer geplanten Stichprobe vor, um das Problem der Expositionsverzerrung zu vermeiden. Vor kurzem haben Goyal et al. schlug eine differenzierbare Entspannung dieser Methode vor, indem man Soft-Argmax eher harte Argmax verwendete, der den in diesem Modell vorhandenen Back-Propagations-Fehler löst. Auch Ranzato et al. schlug ein weiteres einfaches Modell namens end2endbackProp vor, um das Problem der Expositionsverzerrung zu vermeiden. Um ein Modell zu trainieren, das auf jeder dieser Arbeiten basiert, bieten wir verschiedene Flaggen wie folgt:
Parameter Standard Beschreibung planed_sampling FALSCH ob geplante Stichprobe oder nicht Sample_Probability 0 Epsilon-Wert für die Auswahl der Bodenwahrheit oder der Modellausgabe fixed_sampling_probability FALSCH Ob Sie die Wahrscheinlichkeit der festen Abtastung oder adaptiv verwenden sollen Hard_argmax WAHR Ob Sie Soft Argmax oder Hard Argmax verwenden möchten Greedy_Scheduled_sampling FALSCH Unabhängig davon E2eBackProp FALSCH Ob Sie den E2EbackProp -Algorithmus verwenden, um die Expositionsverzerrung zu lösen Alpha 1 weiches Argmax -Argument
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
Parameter Standard Beschreibung rl_training FALSCH Starten Sie die Richtlinien-Gradient-Schulungen convert_to_reinforce_model FALSCH Konvertieren Sie ein Zeigermodell in ein Verstärkungsmodell. Schalten Sie dies ein und laufen Sie im Zugmodus. Ihr aktuelles Trainingsmodell wird in eine neue Version kopiert (gleicher Name mit _COV_init angehängt), das für die Berichterstattungstrainingstufe mit der Abdeckflagge ausgeführt wird. IntradeKoder FALSCH Verwenden Sie die Aufmerksamkeit der Intradekodierer oder nicht use_temporal_attention WAHR Ob Sie zeitliche Aufmerksamkeit verwenden oder nicht matrix_attention FALSCH Verwenden Sie die Aufmerksamkeit der Matrix, Gl. 2 In https://arxiv.org/pdf/1705.04304.pdf ETA 0 RL/MLE -Skalierungsfaktor, 1 Mittel verwenden RL -Verlust, 0 bedeutet, MLE -Verlust zu verwenden Fixed_eta FALSCH Verwenden Sie den festen Wert für ETA oder Adaptive basierend auf dem globalen Schritt Gamma 0,99 RL Belohnungsrabattfaktor Belohnung_Funktion rouge_l/f_score Entweder Bleu oder eines der Rouge -Messungen (Rouge_1/F_SCORE, Rouge_2/F_Score, Rouge_L/F_SCORE)
Paulus et al. schlug ein selbstkritisches politisches Gradientenmodell für die summende Textübersicht vor. Die folgende Abbildung zeigt, wie diese Methode funktioniert und wie wir diese Methode implementiert haben:
Um ihr Experiment zu replizieren, können wir die folgenden Prozesse verwenden:
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=FalseHier verwenden wir eine andere GPU zur Bewertung, können jedoch dieselbe GPU verwenden, wenn wir die Anzahl der Chargen verringern. In unserer Implementierung verwenden wir eine Stapelgröße von 8 für die Bewertung, aber für jeden Eval -Schritt iterieren wir den Validierungsdatensatz 100 Mal. Dies ähnelt dem Finden des Bewertungsfehlers bei einer Stapelgröße von 800. Dies hilft dabei, den vom Bewertungsprozess erforderlichen Speicher zu verringern und Optionen für das Ausführen von Schulungen und Bewertungen auf einer GPU zu liefern.
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=FalseWie von Paulus et al. Vorgeschlagen, verwenden wir einen linearen Übergang vom Verlust von Cross-Entropy bis zum RL-Verlust, so dass wir uns am Ende vollständig auf den RL-Verlust verlassen, um das Modell zu trainieren. Der Parameter ETA steuert diesen Übergang. Wir setzen ETA auf ETA = 1/(maximale RL -Iteration).
Fügen Sie zunächst dem Modell den erforderlichen Trainingsparameter hinzu:
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=TrueLeiten Sie dann das Modell mit MLE+RL -Trainingsverlust aus:
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=TrueWir verwenden Rouge als Bewertungsmetriken.
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
Parameter Standard Beschreibung AC_TRINING FALSCH Verwenden Sie das lernende Lernen von Schauspielern von DDQN. DQN_Scheduled_sampling FALSCH Ob Sie geplante Stichproben verwenden, um Schätzungen des DDQN-Modells im Vergleich zu den tatsächlichen Q-Schätzungswerten zu verwenden DQN_Layers 512,256,128 Ddqn dichte versteckte Schichtgröße. Es werden drei dichte Schichten mit 512, 256 und 128 Größe erzeugen DQN_REPLAY_BUFFER_SIZE 100000 Größe des Wiederholungspuffers DQN_BATCH_SIZE 100 Chargengröße für das Training des DDQN -Modells dqn_target_update 10000 Aktualisieren Sie das Ziel -Q -Netzwerk alle 10000 Schritte dqn_sleep_time 2 Trainieren Sie das DDQN -Modell alle 2 Sekunden DQN_GPU_NUM 1 GPU -Nummer zum Training des DDQN Duelling_net WAHR Ob Sie das Duell -Netzwerk verwenden, um das Modell https://arxiv.org/pdf/1511.06581.pdf zu trainieren dqn_polyak_averaging WAHR Ob Sie die Mittelung von Polyak verwenden, um die Ziel-Q-Netzwerkparameter zu aktualisieren: PSI^{prime} = (Tau * psi^{prime})+ (1-tau) * psi calculate_true_q FALSCH Ob Sie echte Q-Werte zum Training von DDQN verwenden oder die Schätzungen von DDQN verwenden, um es zu trainieren DQN_PRETRAIN FALSCH Vorbereitet das DDQN -Netzwerk mit festem Akteurmodell DQN_PRETRAIN_STEPS 10000 Anzahl der Schritte, um den DDQN vorzuverüben
Der allgemeine Rahmen für das handelsübliche Modell lautet wie folgt:
In unserer Implementierung ist der Akteur das Zeigergeneratormodell und der Kritiker ist ein Regressionsmodell, das die Q-Wert-Schätzung unter Verwendung des Doppel-Deep-Q-Netzwerks (DDQN) minimiert. Der Code wird so implementiert, dass sich das DDQN -Training auf einem anderen Thread als der Hauptfache befindet und wir Erfahrungen für dieses Netzwerk asynchron aus dem Schauspielermodell sammeln. Daher sammeln wir für jede Charge (batch_size * max_dec_steps) für das DDQN -Training. Wir haben den priorisierten Wiederholungspuffer implementiert. Und während des DDQN-Trainings wählen wir immer unsere Mini-Stapel so aus, dass sie Erfahrungen enthalten, die die beste teilweise Belohnung entsprechend der Zusammenfassung der Bodenwahrheit haben. Wir haben eine Option für die Schulung von DDQN hinzugefügt, die auf der echten Q-Bewertung basieren, und einen geplanten Sampling-Prozess für die Schulung dieses Netzwerks angeboten. Bitte beachten Sie, dass das Training DDQN mit echtem Q-Schätzungen die Schulungsgeschwindigkeit aufgrund der Sammlung echter Q-Werte erheblich verringert. Daher schlagen wir vor, dies nur für einige Iterationen zu aktivieren. Wie von Bahdanau et al. Es ist auch gut, einen festen vorgeschriebenen Schauspieler zu verwenden, um das Kritikermodell zuerst vorzubinden und dann gleichzeitig beide Modelle zu trainieren. Zum Beispiel können wir die folgenden Codes verwenden, um ein ähnliches Experiment wie 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 Wir können das Duelling -Netzwerk verwenden, um das DDQN durch Aktivieren von dueling_net -Flag zu trainieren. Darüber hinaus können wir das Zielnetzwerk mithilfe von Polyak -Mittelung durch dqn_polyak_averaging -Flag aktualisieren.
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 Verwenden Sie dqn_pretrain_steps -Flag, um festzulegen, wie viele Iteration Sie den Kritiker vorentwickeln möchten.
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 Wir können den Schauspieler in einer GPU und in einem anderen Kritiker in einer anderen GPU einfach mit einer anderen GPU -Nummer für Kritiker verwenden, die die Option dqn_gpu_num verwendet. Wie bereits erwähnt, sollten wir es vermeiden, eine echte q-Bewertung für lange zu verwenden. Daher verwenden wir echte Schätzungen, um DDQN für nur 1000 Iterationen zu trainieren.
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 Bitte beachten Sie, dass wir nicht mehr calculate_true_q -Flag verwenden.
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 Bitte beachten Sie, dass wir Optionen wie intradecoder , temporal_attention , E2EBackProp , scheduled_sampling usw. in Schauspieler-Kritik-Modellen verwenden können. Die Verwendung dieser Optionen hilft dabei, ein besser leistungsstarkes Schauspielermodell zu erzielen.
Danke @astorfi für seine Hilfe bei der Vorbereitung dieser Dokumentation.
