RL4LMs
1.0.0
Fornecemos blocos de construção facilmente personalizáveis para modelos de idiomas de treinamento, incluindo implementações de algoritmos na política , funções de recompensa , métricas , conjuntos de dados e políticas de ator-crítico baseadas em LM
Link em papel: https://arxiv.org/abs/2210.01241
Link do site: https://rl4lms.apps.allenai.org/
Testado e comparado com mais de 2000 experimentos (Grue Benchmark?) Em um conjunto abrangente de:
Todos esses blocos de construção podem ser personalizáveis, permitindo que os usuários treinem o LMS baseado em transformadores para otimizar qualquer função de recompensa arbitrária em qualquer conjunto de dados de sua escolha.
git clone https://github.com/allenai/RL4LMs.git
cd RL4LMs
pip install -e . Fornecemos também um Dockerfile para o desenvolvimento usando recipientes do Docker contendo todas as dependências.
docker build . -t rl4lms Opcionalmente, as bibliotecas CORENLP são necessárias para determinados cálculos métricos (por exemplo, especiarias) que podem ser baixados através cd rl4lms/envs/text_generation/caption_metrics/spice && bash get_stanford_models.sh
Fornecemos uma API de treinamento simples que pode ser invocada via script de trem que permite treinar PPO, NLPO ou um modelo supervisionado usando um arquivo de configuração (YAML).
Por exemplo, para treinar T5-Base no resumo CNN/DM no PPO usando o Rouge-1 como função de recompensa, você pode executar:
python scripts/training/train_text_generation.py --config_path scripts/training/task_configs/summarization/t5_ppo.ymlOs arquivos de configuração para todas as tarefas podem ser encontrados aqui.
O arquivo de configuração contém detalhes sobre as configurações de hiper-parâmetro para blocos de construção que são descritos abaixo:
Conjunto de dados/tarefa : conjunto de dados contendo amostras com prompts de entrada e frases de referência. Os conjuntos de dados disponíveis são encontrados na classe DataPoolRegistry em registro. (Veja como criar seu próprio conjunto de dados aqui)
datapool :
id : cnn_daily_mail
args :
prompt_prefix : " Summarize: "Tokenizer - Um tokenizador pré -treinado que é usado para (DE) tokenize sequências de entrada e saída com configurações para preenchimento e truncamento
tokenizer :
model_name : t5-base
padding_side : left
truncation_side : left
pad_token_as_eos_token : False Função de recompensa : Função de recompensa que calcula as pontuações no nível do token a cada etapa do MDP. As funções de recompensa disponíveis podem ser encontradas na classe RewardFunctionRegistry . (Veja como criar sua própria função de recompensa aqui)
reward_fn :
id : rouge
args :
rouge_type : " rouge1 " Ambiente : configura um ambiente de geração de texto no estilo da academia que simula os episódios do MDP. Os lançamentos são gerados usando amostras de trem do conjunto de dados que consistem em textos de entrada e referência. Além disso, embrulhamos nosso ENV com SubProcVecEnv de linhas de base estável que processa episódios de n_envs em paralelo usando multiprocessamento para calcular recompensas em passo.
Outras configurações de configuração incluem:
max_episode_length : comprimento máximo do episódiomax_prompt_length - comprimento máximo do texto de entrada a considerarterminate_on_eos - se deve encerrar o episódio assim que a ação EOS for realizadaprompt_truncation_side - lado do truncamento para o texto rápidocontext_start_token - ID para token de contexto (corresponde ao token inicial dado ao decodificador em modelos de codificadores -decodificadores) env :
n_envs : 10
args :
max_prompt_length : 512
max_episode_length : 100
terminate_on_eos : True
prompt_truncation_side : " right "
context_start_token : 0ALG na política : Fornecemos implementações de 4 algoritmos na política: PPO, NLPO, A2C e TRPO adaptados de estábulos-Baselines3 adaptados para trabalhar com tarefas de PNL que podem ser usadas fora da caixa com uma política causal ou uma política de LM seqseq LM. (Veja como criar seu próprio algoritmo ou política na política)
Também fornecemos um treinador supervisionado para fins de benchmarking. Os modelos de partida quente supervisionada já foram enviados para o HUGGINGFACE HUB e especificados nos respectivos arquivos de configuração.
Os hiper-parâmetros do algoritmo podem ser especificados em alg/args .
Além disso, todos os algoritmos RL usam o controlador KL adaptativo para manter o LM próximo ao LM original, definindo coeficiente KL inicial ( alg/kl_div/coeff ) e KL Target ( alg/kl_div/target_kl ).
Apoiamos dois tipos de política de LM: política causal de LM (para modelos apenas para decodificadores) e política seq2seq lm (para modelos de codificadores-decodificadores). Além disso, para o NLPO, também fornecemos variantes mascaráveis destes. As implementações de políticas podem ser encontradas aqui e podem ser anexadas a algoritmos especificando alg/policy/id e alg/policy/args
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 Config : Fornecemos um treinador na política-um invólucro completo que instancia os blocos de construção de suas configurações correspondentes e fornece um loop de treinamento externo que consiste em trens e avaliações de train_evaluation/n_iters .
alg/args/n_steps X env/n_envs do algoritmo escolhido.eval_every , o LM é avaliado na divisão de validação usando métricas listadas em train_evaluation/metrics com geração kwargs fornecidos em train_evaluation/generation_kwargs (isso substitui alg/policy/generation_kwargs apenas para fins de inferência) # 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 : 100O RL4LMS fornece personalização completa-com relação à adição de novas tarefas/conjuntos de dados, funções de recompensa, algoritmos de avaliação, algoritmos na política e políticas críticas de ator.
Os usuários podem criar seus próprios conjuntos de dados subclassando textgenpool apenas substituindo prepare(cls, split: str, **args) -> 'TextGenPool': método para retornar uma instância do textgenpool. Um exemplo é mostrado abaixo:
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 As funções de recompensa personalizadas podem ser implementadas facilmente pela Sub-Classing Recompensafunction (um chamável) que leva a observação (
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 0Além das métricas tradicionais de NLG, para prototipagem rápida, fornecemos duas funções de recompensa sintética que treina o LMS para gerar números no aumento da ordem e gerar datas. Estes podem ser usados para testar rapidamente diferentes algoritmos e políticas. As configurações correspondentes podem ser encontradas aqui (números, datas)
Os usuários podem criar sua própria métrica de avaliação, que será usada para avaliar periodicamente o modelo na divisão de validação do conjunto de dados. Isso pode ser feito por subclassing basemétrico, que leva textos imediatos, textos gerados, textos de referência, meta_infos, modelo atual de LM, nome dividido como entrada e retorna um ditado com o nome da métrica como chave e valor que consistem em tuplo de pontuações no nível da sentença e pontuações de corpus. Um exemplo é o seguinte:
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 Além dos algoritmos de política suportados (PPO, NLPO, A2C, TRPO), os usuários podem implementar seus próprios algoritmos na política com facilidade, subclassando o OnPolicicyalGorithm da subclassificação. Como fornecemos invólucros para algoritmos na política que lida com lançamentos usando políticas de LM, ambiente, recompensas de computação etc., os usuários precisam apenas implementar o método train() com funções de perda personalizada.
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 Fornecemos implementações de políticas de ator-crítico baseadas em LM que envolvem LMs causais LM e SEQ2SEQ LMS. Eles também podem ser estendidos (para por exemplo: use uma arquitetura crítica diferente), substituindo os métodos apropriados (por exemplo, evaluate_actions() ))
Por fim, basta registrar seus componentes personalizados adicionando-os ao registro correspondente, após o que eles podem ser usados diretamente de configurações semelhantes aos componentes predefinidos
Fornecemos os modelos de crowdsourcing que usamos no turco mecânico, juntamente com insumos de exemplo em scripts/crowdworking_templates . Você pode achar isso um ponto de partida útil para avaliar as gerações do seu próprio modelo ou para reunir dados de treinamento para uma função de recompensa aprendida.
Além disso, apoiamos o registro do Wandb e o início do treinamento armazenando pontos de verificação e outros artefatos de treinamento em um caminho especificado pelo usuário. Isso é especialmente útil para administrar empregos preventíveis em aglomerados grandes e programados.
Artifacts include (1) jsonl file containing rollout infos at specified intervals (2) jsonl file containing training infos at specified intervals (3) jsonl file containing validation metrics at specified intervals (4) jsonl file containing test metrics before and after training (5) json file with validation predictions at specified intervals (6) json file with test predictions before and after training (7) trained LM model (8) Config JSON costumava executar o experimento
O uso completo é o seguinte:
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 }
}Para discussão, perguntas, troca de idéias, junte -se ao nosso canal Slack
