RL4LMs
1.0.0
Wir bieten leicht anpassbare Bausteine für Schulungssprachmodelle, einschließlich Implementierungen von On-Policy-Algorithmen , Belohnungsfunktionen , Metriken , Datensätzen und LM-basierten Schauspieler-Kritischen Richtlinien
Papierlink: https://arxiv.org/abs/2210.01241
Website Link: https://rl4lms.apps.allenai.org/
Gründlich getestet und mit über 2000 Experimenten (Grue Benchmark ?) Auf einem umfassenden Satz von:
Alle diese Bausteine können anpassbar sein, damit Benutzer transformatorbasierte LMS schulen können, um eine beliebige Belohnungsfunktion auf jedem Datensatz ihrer Wahl zu optimieren.
git clone https://github.com/allenai/RL4LMs.git
cd RL4LMs
pip install -e . Wir bieten auch eine Dockerfile für die Entwicklung anhand von Docker -Containern, die alle Abhängigkeiten enthalten.
docker build . -t rl4lms Optional sind Corenlp -Bibliotheken für bestimmte metrische Berechnungen (z. B. Gewürz) erforderlich, die über cd rl4lms/envs/text_generation/caption_metrics/spice && bash get_stanford_models.sh heruntergeladen werden können.
Wir bieten eine einfache Trainings -API, die über das Zugskript aufgerufen werden kann, mit dem PPO, NLPO oder ein überwachtes Modell mithilfe einer Konfigurationsdatei (YAML) trainieren können.
Zum Beispiel können Sie ausführen:
python scripts/training/train_text_generation.py --config_path scripts/training/task_configs/summarization/t5_ppo.ymlKonfigurationsdateien für alle Aufgaben finden Sie hier.
Die Konfigurationsdatei enthält Details zu Hyper-Parameter-Einstellungen für Bausteine, die unten beschrieben werden:
Datensatz/Aufgabe : Datensatz mit Beispiele mit Eingabeaufforderungen und Referenzsätzen. Verfügbare Datensätze finden Sie in der DataPoolRegistry in der Registrierung. (Sehen Sie, wie Sie hier Ihren eigenen Datensatz erstellen.)
datapool :
id : cnn_daily_mail
args :
prompt_prefix : " Summarize: "Tokenizer - ein vorgebildeter Tokenizer, mit dem (DE) Eingangs- und Ausgangssequenzen mit Einstellungen für Polsterung und Kürzung verwendet werden
tokenizer :
model_name : t5-base
padding_side : left
truncation_side : left
pad_token_as_eos_token : False Belohnungsfunktion : Belohnungsfunktion, die bei jedem Zeitschritt von MDP Token-Ebene berechnet. Verfügbare Belohnungsfunktionen finden Sie in der RewardFunctionRegistry . (Sehen Sie, wie Sie hier Ihre eigene Belohnungsfunktion erstellen.)
reward_fn :
id : rouge
args :
rouge_type : " rouge1 " Umgebung : Konfiguriert eine Textgenerierungsumgebung im Fitnessstudio, die MDP-Episoden simuliert. Rollouts werden mit Zugproben aus Datensatz erzeugt, die aus Eingabe- und Referenztexten bestehen. Darüber hinaus wickeln wir unsere Env mit SubProcVecEnv aus stabilen Baselines, die n_envs -Episoden parallel unter Verwendung von Multi-Processing verarbeitet, um schrittweise Belohnungen zu berechnen.
Weitere Konfigurationseinstellungen umfassen:
max_episode_length : MAX -Länge der Episodemax_prompt_length - maximale Länge des zu berücksichtigenden Eingabentextesterminate_on_eos - ob die Episode beendet werden soll, sobald die EOS -Aktion durchgeführt wirdprompt_truncation_side - Kürzungsseite für den Eingabeaufforderungstextcontext_start_token - id für context token (entspricht dem anfänglichen token, der decodierer in codiererdekodermodellen gegeben wurde) env :
n_envs : 10
args :
max_prompt_length : 512
max_episode_length : 100
terminate_on_eos : True
prompt_truncation_side : " right "
context_start_token : 0On-Policy-ALG : Wir bieten Implementierungen von 4 On-Policy-Algorithmen an: PPO, NLPO, A2C und TRPO, angepasst von stabilen Baselines3, die auf die Arbeit mit NLP-Aufgaben zugeschnitten sind, die außerhalb des Boxs mit einer kausalen Richtlinie oder einer SEQ2SEQ-LM-Richtlinie verwendet werden können. (Sehen Sie, wie Sie einen eigenen On-Policy-Algorithmus oder Ihre eigene Richtlinie erstellen.)
Wir bieten auch einen betrieblichen Trainer für Benchmarking -Zwecke an. Überlebte Warmstartmodelle werden bereits auf HuggingFace -Hub hochgeladen und in den jeweiligen Konfigurationsdateien angegeben.
Hyperparameter für den Algorithmus können unter alg/args angegeben werden.
Darüber hinaus verwenden alle RL-Algorithmen den adaptiven KL-Controller, um das LM in der Nähe des ursprünglichen LM zu halten, indem der anfängliche KL-Koeffizient ( alg/kl_div/coeff ) und Ziel KL ( alg/kl_div/target_kl ) festgelegt wird.
Wir unterstützen zwei Arten von LM-Richtlinien: Kausal-LM-Richtlinie (nur für Decoder-Modelle) und SEQ2SEQ LM-Richtlinie (für Encoder-Decoder-Modelle). Für NLPO liefern wir auch maskierbare Varianten davon. Richtlinienimplementierungen finden Sie hier in und können Algorithmen durch Angeben von alg/policy/id und alg/policy/args beigefügt werden
alg :
id : ppo
args :
n_steps : 512
batch_size : 64
verbose : 1
learning_rate : 0.000002
n_epochs : 5
ent_coef : 0.0
kl_div :
coeff : 0.001
target_kl : 0.2
policy :
id : seq2seq_lm_actor_critic_policy
args :
model_name : t5-base
apply_model_parallel : True
prompt_truncation_side : " right "
generation_kwargs :
do_sample : True
top_k : 50
min_length : 50
max_new_tokens : 100 Trainerkonfiguration : Wir bieten einen On-Policy-Trainer an-einen Funktionsumschlag mit Features, der Bausteine aus ihren entsprechenden Konfigurationen instanziiert und eine äußere Trainingsschleife bietet, die aus Zug- und Bewertungs -Iterationen besteht, train_evaluation/n_iters .
alg/args/n_steps x env/n_envs des ausgewählten Algorithmus.eval_every -ITERS wird LM nach Validierungs geteilt unter Verwendung von Metriken, die in train_evaluation/metrics aufgeführt sind, mit den in train_evaluation/generation_kwargs bereitgestellten Generationskwargs (dies überschreitet nur Rollout alg/policy/generation_kwargs für Inferenz -Zwecke) # train and evaluation
train_evaluation :
eval_batch_size : 100
n_iters : 100
eval_every : 10
save_every : 1
metrics :
- id : meteor
args : {}
- id : rouge
- id : bleu
args : {}
- id : bert_score
args :
language : en
- id : diversity
args : {}
generation_kwargs :
do_sample : True
top_k : 0
temperature : 0.7
min_length : 50
max_new_tokens : 100RL4LMs bieten vollständige Anpassbarkeit-in Bezug auf das Hinzufügen neuer Aufgaben/Datensätze, Belohnungsfunktionen, Bewertungsmetrik, On-Policy-Algorithmen und Akteur-Kritischen Richtlinien.
Benutzer können ihre eigenen Datensätze erstellen, indem sie Textgenpool subklassigen, indem Sie nur prepare(cls, split: str, **args) -> 'TextGenPool': Methode zur Rückgabe einer Instanz von TextgenPool. Ein Beispiel ist unten gezeigt:
from rl4lms . data_pools . text_generation_pool import Sample , TextGenPool
class MyDataPool ( TextGenPool ):
@ classmethod
def prepare ( cls , split : str ):
..
samples = []
for ix , item in enumerate (..):
sample = Sample ( id = f" { split } _ { ix } " ,
prompt_or_input_text = item [ "document" ],
references = [ item [ "target" ]]
)
samples . append ( sample )
pool_instance = cls ( samples )
return pool_instance Benutzerdefinierte Belohnungsfunktionen können leicht implementiert werden, indem die Belohnung (ein Callable) subklassifiziert wird (ein Callable), der Beobachtung annimmt (
from rl4lms . envs . text_generation . observation import Observation
from rl4lms . envs . text_generation . reward import RewardFunction
class MyRewardFunction ( RewardFunction ):
def __init__ ( self , * args ) -> None :
super (). __init__ ()
def __call__ ( self , prev_observation : Observation ,
action : int ,
current_observation : Observation ,
done : bool ,
meta_info : Dict [ str , Any ] = None ) -> float :
if done :
reward = ..
return reward
return 0Zusätzlich zu herkömmlichen NLG -Metriken bieten wir zum schnellen Prototyping zwei synthetische Belohnungsfunktionen, die LMS trainieren, um Zahlen in zunehmender Reihenfolge zu erzeugen und Daten zu erzeugen. Diese können verwendet werden, um verschiedene Algorithmen und Richtlinien schnell zu testen. Entsprechende Konfigurationen finden Sie hier (Zahlen, Daten)
Benutzer können ihre eigene Bewertungsmetrik erstellen, mit der dann das Modell auf die Validierungsaufteilung des Datensatzes regelmäßig bewertet wird. Dies kann durch subklassifizierende Basemetrie erfolgen, die Eingabedelatexte, generierte Texte, Referenztexte, meta_infos, aktuelles LM-Modell, geteiltem Namen als Eingänge und zurückgibt und einen Diktat mit metrischen Namen als Schlüssel und Wert aus Tupel der Scores auf Satzebene und Corpus-Ebene zurückgibt. Ein Beispiel ist wie folgt:
from rl4lms . envs . text_generation . metric import BaseMetric
class MyMetric ( BaseMetric ):
def __init__ ( self ) -> None :
super (). __init__ ()
def compute ( self ,
prompt_texts : List [ str ],
generated_texts : List [ str ],
reference_texts : List [ List [ str ]],
meta_infos : List [ Dict [ str , Any ]] = None ,
model : PreTrainedModel = None ,
split_name : str = None ):
metric_dict = {
"custom_metrics/my_metric" : ([ 0.4 , 0.7 , 0.9 ], 0.7 )
}
return metric_dict Zusätzlich zu unterstützten On-Policy-Algorithmen (PPO, NLPO, A2C, TRPO) können Benutzer ihre eigenen Onpolicy-Algorithmen mit Subklassen von Stable-Baselines3-Onpolicyalgorithmus implementieren. Da wir Wrapper für On-Policy-Algorithmen zur Verfügung stellen, die Rollouts mithilfe von LM-Richtlinien, Umgebungen, Berechnung von Belohnungen usw. übernimmt, müssen Benutzer nur die train() -Methode mit benutzerdefinierten Verlustfunktionen implementieren.
from stable_baselines3 . common . on_policy_algorithm import OnPolicyAlgorithm
class MyOnPolicyAlgorithm ( OnPolicyAlgorithm ):
def __init__ ( ** args ):
super (). __init__ ( ** args )
def train ( self ) -> None :
# train for n_epochs epochs
for epoch in range ( self . n_epochs ):
# Do a complete pass on the rollout buffer
for rollout_data in self . rollout_buffer . get ( self . batch_size ):
# compute loss Wir bieten LM-basierte Akteur-kritische Richtlinienimplementierungen an, die kausale LM- und SEQ2SEQ-LMS einbringen. Diese können auch erweitert werden (für z.: Verwenden Sie eine andere Kritikerarchitektur), indem geeignete Methoden überschrieben werden (z. B. evaluate_actions() ).
Registrieren Sie schließlich Ihre benutzerdefinierten Komponenten, indem Sie sie in die entsprechende Registrierung hinzufügen. Danach können sie direkt aus Konfigurationen verwendet werden, die den vordefinierten Komponenten ähneln
Wir haben die Crowdsourcing -Vorlagen zur Verfügung gestellt, die wir auf mechanischen Türken verwendet haben, zusammen mit Beispieleingaben in scripts/crowdworking_templates . Sie finden dies möglicherweise einen hilfreichen Ausgangspunkt, um die Generationen Ihres eigenen Modells zu bewerten, oder um Trainingsdaten für eine gelernte Belohnungsfunktion zu sammeln.
Darüber hinaus unterstützen wir die Holzprotokollierung und warme Ausbildung durch die Speicherung von Kontrollpunkten und anderen Trainingsartefakten auf einem benutzerdefinierten Weg. Dies ist besonders nützlich, um präventive Jobs in großen, geplanten Clustern zu leiten.
Artefakte umfassen (1) JSONL -Datei mit Rollout -Infos in bestimmten Intervallen (2) JSONL -Datei, die Trainingsinfos in bestimmten Intervallen (3) JSONL -Datei enthält, die Validierungsmetriken in bestimmten Intervallen (4) JSONL -Datei enthalten, die Testmetriken vor und nach dem Training (5) -Tile mit den Voraussetzungen mit den Testen (5). (8) Konfiguration JSON wurde zum Ausführen des Experiments verwendet
Die vollständige Nutzung ist wie folgt:
WANDB_API_KEY= < YOUR-WANDB-API-KEY-HERE > python scripts/training/train_text_generation.py
--config_path < PATH-TO-CONFIG-FILE >
--experiment_name < EXPERIMENT-NAME >
--base_path_to_store_results < PATH-TO-STORE-RESULTS >
--log_to_wandb @inproceedings { Ramamurthy2022IsRL ,
title = { Is Reinforcement Learning (Not) for Natural Language Processing?: Benchmarks, Baselines, and Building Blocks for Natural Language Policy Optimization } ,
author = { Rajkumar Ramamurthy and Prithviraj Ammanabrolu and Kiant{'e} Brantley and Jack Hessel and Rafet Sifa and Christian Bauckhage and Hannaneh Hajishirzi and Yejin Choi } ,
journal = { arXiv preprint arXiv:2210.01241 } ,
url = { https://arxiv.org/abs/2210.01241 } ,
year = { 2022 }
}Für Diskussion, Fragen, Ideenaustausch, schließen Sie sich unserem Slack -Kanal an
