TRL documentation
Treinador DPO
Treinador DPO
Visão geral
O TRL oferece suporte ao Treinador de Otimização de Preferência Direta (DPO) para o treinamento de modelos de linguagem, conforme descrito no artigo Direct Preference Optimization: Your Language Model is Secretly a Reward Model de Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning e Chelsea Finn.
O resumo do artigo é o seguinte:
Embora os grandes modelos de linguagem (LMs) não supervisionados aprendam um amplo conhecimento do mundo e algumas habilidades de raciocínio, alcançar um controle preciso de seu comportamento é difícil devido à natureza completamente não supervisionada de seu treinamento. Os métodos existentes para obter essa capacidade de direcionamento coletam rótulos humanos da qualidade relativa das gerações do modelo e ajustam finamente o LM não supervisionado para alinhar-se a essas preferências, muitas vezes com aprendizado por reforço a partir de feedback humano (RLHF). No entanto, o RLHF é um procedimento complexo e frequentemente instável, que primeiro ajusta um modelo de recompensa que reflete as preferências humanas e, em seguida, ajusta finamente o grande LM não supervisionado usando aprendizado por reforço para maximizar essa recompensa estimada sem se afastar demais do modelo original. Neste artigo, introduzimos uma nova parametrização do modelo de recompensa no RLHF que permite a extração da política ótima correspondente em forma fechada, permitindo-nos resolver o problema padrão de RLHF com apenas uma simples perda de classificação. O algoritro resultante, que chamamos de Direct Preference Optimization (DPO), é estável, eficiente e computacionalmente leve, eliminando a necessidade de amostragem do LM durante o ajuste fino ou a realização de um ajuste significativo de hiperparâmetros. Nossos experimentos mostram que o DPO pode ajustar finamente LMs para alinhar-se às preferências humanas tão bem quanto ou melhor do que os métodos existentes. Notavelmente, o ajuste fino com DPO supera o RLHF baseado em PPO na capacidade de controlar o sentimento das gerações e iguala ou melhora a qualidade das respostas em sumarização e diálogo de turno único, sendo substancialmente mais simples de implementar e treinar.
Este método de pós-treinamento foi contribuído por Kashif Rasul e posteriormente refatorado por Quentin Gallouédec.
Início rápido
Este exemplo demonstra como treinar um modelo de linguagem usando o DPOTrainer do TRL. Treinamos um modelo Qwen 3 0.6B no conjunto de dados UltraFeedback.
from trl import DPOTrainer
from datasets import load_dataset
trainer = DPOTrainer(
model="Qwen/Qwen3-0.6B",
train_dataset=load_dataset("trl-lib/ultrafeedback_binarized", split="train"),
)
trainer.train()Tipo e formato de dataset esperados
O DPO requer um conjunto de dados de preferência. O DPOTrainer é compatível com os formatos de conjunto de dados padrão e conversacional. Quando fornecido com um conjunto de dados conversacional, o treinador aplicará automaticamente o modelo de chat ao conjunto de dados.
# Standard format
## Explicit prompt (recommended)
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Implicit prompt
preference_example = {"chosen": "The sky is blue.", "rejected": "The sky is green."}
# Conversational format
## Explicit prompt (recommended)
preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
"chosen": [{"role": "assistant", "content": "It is blue."}],
"rejected": [{"role": "assistant", "content": "It is green."}]}
## Implicit prompt
preference_example = {"chosen": [{"role": "user", "content": "What color is the sky?"},
{"role": "assistant", "content": "It is blue."}],
"rejected": [{"role": "user", "content": "What color is the sky?"},
{"role": "assistant", "content": "It is green."}]}Se o seu conjunto de dados não estiver em um desses formatos, você pode pré-processá-lo para convertê-lo no formato esperado. Aqui está um exemplo com o conjunto de dados Vezora/Code-Preference-Pairs:
from datasets import load_dataset
dataset = load_dataset("Vezora/Code-Preference-Pairs")
def preprocess_function(example):
return {
"prompt": [{"role": "user", "content": example["input"]}],
"chosen": [{"role": "assistant", "content": example["accepted"]}],
"rejected": [{"role": "assistant", "content": example["rejected"]}],
}
dataset = dataset.map(preprocess_function, remove_columns=["instruction", "input", "accepted", "ID"])
print(next(iter(dataset["train"]))){
"prompt": [{"role": "user", "content": "Create a nested loop to print every combination of numbers [...]"}],
"chosen": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
"rejected": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
}Olhando mais a fundo para o método DPO
A Otimização de Preferência Direta (DPO) é um método de treinamento projetado para alinhar um modelo de linguagem com dados de preferência. Em vez de pares de entrada-saída supervisionados, o modelo é treinado com pares de conclusões para o mesmo prompt, em que uma conclusão é preferida em relação à outra. O objetivo otimiza diretamente o modelo para ampliar a margem entre as log-verossimilhanças das conclusões preferidas e não preferidas, em relação a um modelo de referência, sem exigir um modelo de recompensa explícito. Na prática, isso é tipicamente alcançado suprimindo a verossimilhança das conclusões não preferidas, em vez de aumentar a verossimilhança das conclusões preferidas.
Esta seção detalha como o DPO funciona na prática, abordando as etapas principais: pré-processamento e cálculo da perda.
Pré-processamento e tokenização
Durante o treinamento, cada exemplo deve conter um prompt, além de uma conclusão preferida (chosen) e uma conclusão não preferida (rejected). Para mais detalhes sobre os formatos esperados, consulte Formatos de dataset.
O DPOTrainer tokeniza cada entrada usando o tokenizer do modelo.
Calculando a perda

A perda usada no DPO é definida da seguinte forma:
onde é o prompt, é a conclusão preferida e é a conclusão não preferida. é o modelo de política em treinamento, é o modelo de referência, é a função sigmoide, e é um hiperparâmetro que controla a intensidade do sinal de preferência.
Tipos de Perda
Várias formulações do objetivo foram propostas na literatura. Inicialmente, o objetivo do DPO foi definido conforme apresentado acima.
loss_type= | Descrição |
|---|---|
"sigmoid" (padrão) | Dado os dados de preferência, podemos ajustar um classificador binário de acordo com o modelo de Bradley-Terry e, de fato, os autores do DPO propõem a perda sigmoide sobre a verossimilhança normalizada por meio do logsigmoid para ajustar uma regressão logística. |
"hinge" | Os autores do RSO propõem usar uma perda de hinge sobre a verossimilhança normalizada do artigo SLiC. Nesse caso, o beta é o recíproco da margem. |
"ipo" | Os autores do IPO argumentam que a transformação de logit pode levar a overfitting e propõem a transformação identidade para otimizar preferências diretamente; o TRL expõe isso como loss_type="ipo". |
"exo_pair" | Os autores do EXO propõem a otimização de preferências com KL reversa. label_smoothing deve ser estritamente maior que 0.0; um valor recomendado é 1e-3 (veja a Eq. 16 para a variante pairwise simplificada). O método completo usa K>2 conclusões SFT e se aproxima do PPO à medida que K aumenta. |
"nca_pair" | Os autores do NCA mostram que o NCA otimiza a verossimilhança absoluta para cada resposta, em vez da verossimilhança relativa. |
"robust" | Os autores do Robust DPO propõem uma perda DPO não enviesada sob preferências ruidosas. Use label_smoothing em DPOConfig para modelar a probabilidade de inversão de rótulo; os valores válidos estão no intervalo [0.0, 0.5). |
"bco_pair" | Os autores do BCO treinam um classificador binário cujo logit serve como recompensa, de modo que o classificador mapeia pares {prompt, completion escolhido} para 1 e pares {prompt, completion rejeitado} para 0. |
"sppo_hard" | Os autores do SPPO afirmam que o SPPO é capaz de resolver o equilíbrio de Nash iterativamente, fazendo com que as recompensas escolhidas sejam o mais próximas possível de 1/2 e as recompensas rejeitadas sejam o mais próximas possível de -1/2, e que pode mitigar problemas de escassez de dados. A implementação aproxima esse algoritmo ao utilizar probabilidades de rótulos rígidos, atribuindo 1 ao vencedor e 0 ao perdedor. |
"aot" ou loss_type="aot_unpaired" | Os autores do AOT propõem o Alinhamento de Preferências Distribucional via Transporte Ótimo. loss_type="aot" é para dados pareados; loss_type="aot_unpaired" é para dados não pareados. Ambos impõem a dominância estocástica por meio de quantis ordenados; tamanhos de lote maiores por GPU ajudam. |
"apo_zero" ou loss_type="apo_down" | O método APO introduz um objetivo ancorado. apo_zero aumenta o peso dos vencedores e reduz o peso dos perdedores (útil quando o modelo tem desempenho inferior ao dos vencedores). apo_down reduz o peso de ambos, com pressão mais forte sobre os perdedores (útil quando o modelo já supera os vencedores). |
"discopop" | O artigo DiscoPOP utiliza LLMs para descobrir perdas de otimização de preferências offline mais eficientes. No artigo, a perda DiscoPOP proposta (que é uma perda modulada por log-ratio) superou outras perdas de otimização em diferentes tarefas (geração de texto positivo do IMDb, sumarização TLDR do Reddit e Alpaca Eval 2.0). |
"sft" | A perda de SFT (Supervised Fine-Tuning) é a perda de log-verossimilhança negativa, usada para treinar o modelo a gerar respostas preferidas. |
"sigmoid_norm" | Os autores do SimPO abordam o viés de comprimento na perda sigmoide original normalizando pelo número de tokens não mascarados; o TRL expõe isso como loss_type="sigmoid_norm". |
"udpo" | Os autores do UDPO propõem uma perda DPO não enviesada sob preferências ruidosas que, ao contrário de "robust", permanece não enviesada quando a probabilidade de inversão é superestimada. Use label_smoothing em DPOConfig para definir a probabilidade de inversão ε; os valores válidos estão no intervalo [0.0, 0.5). |
Métricas registradas
Durante o treinamento e a avaliação, registramos as seguintes métricas:
global_step: O número total de etapas do otimizador realizadas até o momento.epoch: O número do epoch atual, com base na iteração do conjunto de dados.num_tokens: O número total de tokens processados até o momento.loss: A perda média de DPO no intervalo de registro atual.entropy: A entropia média da distribuição de tokens prevista pelo modelo para tokens não mascarados.aux_loss: A perda auxiliar de balanceamento de carga de um modelo Mixture-of-Experts, antes de ser escalada porrouter_aux_loss_coefe adicionada à perda. Registrada apenas quando o modelo é um modelo MoE erouter_aux_loss_coefé diferente de zero.mean_token_accuracy: A proporção de tokens não mascarados para os quais a previsão top-1 do modelo corresponde ao token da conclusão escolhida.learning_rate: a taxa de aprendizado atual, que pode mudar dinamicamente se um agendador for usado.grad_norm: A norma L2 dos gradientes, calculada antes do recorte de gradientes.logits/chosen: Os valores médios de logit atribuídos pelo modelo aos tokens na conclusão escolhida.logits/rejected: Os valores médios de logit atribuídos pelo modelo aos tokens na conclusão rejeitada.logps/chosen: A média da log-probabilidade atribuída pelo modelo aos tokens na conclusão escolhida.logps/rejected: A média da log-probabilidade atribuída pelo modelo aos tokens na conclusão rejeitada.rewards/chosen: A recompensa implícita média calculada para a conclusão escolhida, calculada como .rewards/rejected: A recompensa implícita média calculada para a conclusão rejeitada, calculada como .rewards/margins: A margem média de recompensa implícita entre as conclusões escolhidas e rejeitadas.rewards/accuracies: A proporção de exemplos em que a recompensa implícita para a conclusão escolhida é maior do que a da conclusão rejeitada.
Personalização
Compatibilidade e restrições
Algumas combinações de argumentos são intencionalmente restritas na implementação atual do DPOTrainer:
use_weighting=Truenão é suportado comloss_type="aot"ouloss_type="aot_unpaired".- Adaptadores PEFT que visam
lm_headnão são suportados (usemodules_to_save=["lm_head"]em vez disso). sync_ref_model=Truenão é suportado ao treinar com modelos PEFT que não mantêm umref_modelindependente.sync_ref_model=Truenão pode ser combinado comprecompute_ref_log_probs=True.precompute_ref_log_probs=Truenão é suportado comIterableDataset(treino ou avaliação).
Combinações de múltiplas perdas
O treinador DPO suporta a combinação de múltiplas funções de perda com pesos diferentes, permitindo estratégias de otimização mais sofisticadas. Isso é particularmente útil para implementar algoritmos como MPO (Mixed Preference Optimization). O MPO é uma abordagem de treinamento que combina múltiplos objetivos de otimização, conforme descrito no artigo Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization.
Para combinar múltiplas perdas, especifique os tipos de perda e os pesos correspondentes como listas:
# MPO: Combines DPO (sigmoid) for preference and BCO (bco_pair) for quality
training_args = DPOConfig(
loss_type=["sigmoid", "bco_pair", "sft"], # loss types to combine
loss_weights=[0.8, 0.2, 1.0] # corresponding weights, as used in the MPO paper
)Inicialização do modelo
Você pode passar diretamente os kwargs do método from_pretrained() para o DPOConfig. Por exemplo, se você quiser carregar um modelo em uma precisão diferente, análogo a
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)você pode fazer isso passando o argumento model_init_kwargs={"dtype": torch.bfloat16} para o DPOConfig.
from trl import DPOConfig
training_args = DPOConfig(
model_init_kwargs={"dtype": torch.bfloat16},
)Observe que todos os argumentos de palavra-chave de from_pretrained() são suportados.
Treine adaptadores com PEFT
Suportamos integração estreita com a biblioteca 🤗 PEFT, permitindo que qualquer usuário treine adaptadores de forma conveniente e os compartilhe no Hub, em vez de treinar o modelo inteiro.
from datasets import load_dataset
from trl import DPOTrainer
from peft import LoraConfig
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
trainer = DPOTrainer(
"Qwen/Qwen3-0.6B",
train_dataset=dataset,
peft_config=LoraConfig(),
)
trainer.train()Você também pode continuar o treinamento do seu PeftModel. Para isso, primeiro carregue um PeftModel fora do DPOTrainer e passe-o diretamente para o trainer sem passar o argumento peft_config.
from datasets import load_dataset
from trl import DPOTrainer
from peft import AutoPeftModelForCausalLM
model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
trainer = DPOTrainer(
model=model,
train_dataset=dataset,
)
trainer.train()Ao treinar adaptadores, você geralmente usa uma taxa de aprendizado mais alta (≈1e‑5) do que no ajuste fino completo, pois apenas novos parâmetros estão sendo aprendidos.
DPOConfig(learning_rate=1e-5, ...)
Experimentação Rápida para DPO
RapidFire AI é um motor de experimentação de código aberto que se integra ao TRL e permite iniciar múltiplas configurações de DPO simultaneamente, mesmo em uma única GPU. Em vez de testar configurações sequencialmente, o RapidFire permite ver todas as suas curvas de aprendizado mais cedo, interromper execuções com baixo desempenho e clonar as promissoras com novas configurações em andamento sem reiniciar. Para mais informações, consulte RapidFire AI Integration.
Treinar com Unsloth
Unsloth é um framework de código aberto para ajuste fino e aprendizado por reforço que treina LLMs (como Llama, Mistral, Gemma, DeepSeek, entre outros) até 2× mais rápido, com até 70% menos VRAM, ao mesmo tempo em que oferece um fluxo de trabalho simplificado e compatível com o Hugging Face para treinamento, avaliação e implantação. Para mais informações, consulte Integração do Unsloth.
Tool Calling com DPO
O DPOTrainer oferece suporte completo ao ajuste fino de modelos com capacidades de tool calling. Nesse caso, cada exemplo do conjunto de dados deve incluir:
- As mensagens da conversa (prompt, chosen e rejected), incluindo qualquer chamada de ferramenta (
tool_calls) e respostas de ferramenta (mensagens com o papeltool) - A lista de ferramentas disponíveis na coluna
tools, geralmente fornecida como esquemas JSON
Para mais detalhes sobre a estrutura esperada do conjunto de dados, consulte a seção Formato do Conjunto de Dados — Chamada de Ferramenta.
Treinando Modelos de Visão e Linguagem
DPOTrainer oferece suporte completo ao treinamento de Vision-Language Models (VLMs). Para treinar um VLM, forneça um conjunto de dados com uma coluna image (uma única imagem por amostra) ou uma coluna images (lista de imagens por amostra). Para mais informações sobre a estrutura esperada do conjunto de dados, consulte a seção Dataset Format — Vision Dataset.
Um exemplo desse tipo de conjunto de dados é o RLAIF-V Dataset.
from trl import DPOConfig, DPOTrainer
from datasets import load_dataset
trainer = DPOTrainer(
model="Qwen/Qwen2.5-VL-3B-Instruct",
args=DPOConfig(max_length=None),
train_dataset=load_dataset("HuggingFaceH4/rlaif-v_formatted", split="train"),
)
trainer.train()Para VLMs, a truncagem pode remover tokens de imagem, levando a erros durante o treinamento. Para evitar isso, defina
max_length=Noneno DPOConfig. Isso permite que o modelo processe o comprimento total da sequência sem truncar tokens de imagem.DPOConfig(max_length=None, ...)Use
max_lengthapenas quando você tiver verificado que a truncagem não removerá os tokens de imagem para todo o conjunto de dados.
DPOTrainer
classe trl.DPOTrainer
< source >( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.dpo_config.DPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )
Parâmetros
- model (
strou PreTrainedModel ouPeftModel) — Modelo a ser treinado. Pode ser:- Uma string, sendo o model id de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co, ou um
caminho para um diretório contendo pesos de modelo salvos usando
save_pretrained, por exemplo,
'./my_model_directory/'. O modelo é carregado usando<ModelArchitecture>.from_pretrained(onde<ModelArchitecture>é derivado da configuração do modelo) com os argumentos de palavra-chave emargs.model_init_kwargs. Sedtypenão for especificado emargs.model_init_kwargs, o padrão éfloat32. Isso difere de from_pretrained, onde (desde a versão 5 do Transformers) o dtype é inferido a partir da configuração do modelo. - Um objeto PreTrainedModel. Somente modelos de linguagem causais são suportados.
- Um objeto
PeftModel. Somente modelos de linguagem causais são suportados.
- Uma string, sendo o model id de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co, ou um
caminho para um diretório contendo pesos de modelo salvos usando
save_pretrained, por exemplo,
- ref_model (PreTrainedModel, opcional) —
Modelo de referência usado para calcular as probabilidades log de referência. Se fornecido, este modelo é usado diretamente como a política de referência. Ele não pode ser um PeftModel. Se for None, o trainer usará automaticamente a política inicial correspondente a model, ou seja, o estado do modelo antes do início do treinamento DPO.
- Se fornecido, este modelo é usado diretamente como a política de referência. Ele não pode ser um
PeftModel. - Se
None, o trainer usará automaticamente a política inicial correspondente amodel, ou seja, o estado do modelo antes do início do treinamento DPO.
- Se fornecido, este modelo é usado diretamente como a política de referência. Ele não pode ser um
- args (DPOConfig, opcional) —
Configuração para este treinador. Se
None, uma configuração padrão é usada. - data_collator (
DataCollator, opcional) — Função a ser usada para formar um lote a partir de uma lista de elementos dotrain_datasetoueval_datasetprocessado. O padrão seráDataCollatorForPreferencese o modelo for um modelo de linguagem eDataCollatorForVisionPreferencese o modelo for um modelo de visão-linguagem. Collators personalizados devem truncar sequências antes do padding; o trainer não aplica truncamento pós-colagem. - train_dataset (Dataset ou IterableDataset) —
Dataset a ser usado para o treinamento. Este trainer suporta tanto o tipo modelagem de linguagem quanto o tipo
prompt-completion . O formato das amostras pode ser:
- Padrão: Cada amostra contém texto simples.
- Conversacional: cada amostra contém mensagens estruturadas (por exemplo, papel e conteúdo).
Quando
train_dataseté um IterableDataset (por exemplo, um dataset em streaming),max_stepsdeve ser definido nos argumentos de treinamento, pois seu comprimento não pode ser inferido e o número total de etapas de treinamento é necessário para limitar o loop de treinamento e configurar o agendador de taxa de aprendizado. - eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict ou
dict[str, Dataset | IterableDataset]) — Dataset a ser usado para avaliação. Ele deve atender aos mesmos requisitos quetrain_dataset. - processing_class (PreTrainedTokenizerBase ou ProcessorMixin, opcional) —
Classe de processamento usada para processar os dados. O lado do padding deve ser definido como “left”. Se
None, a classe de processamento é carregada a partir do nome do modelo com from_pretrained. Um token de padding,tokenizer.pad_token, deve ser definido. Se a classe de processamento não tiver definido um token de padding,tokenizer.eos_tokenserá usado como padrão. - compute_metrics (
Callable[[EvalPrediction], dict], opcional) — A função que será usada para calcular métricas na avaliação. Deve receber um EvalPrediction e retornar um dicionário de strings para valores de métricas. Ao passar SFTConfig combatch_eval_metricsdefinido comoTrue, sua funçãocompute_metricsdeve receber um argumento booleanocompute_result. Isso será acionado após o último lote de avaliação para sinalizar que a função precisa calcular e retornar as estatísticas de resumo globais, em vez de acumular as estatísticas do nível do lote. Os logits que ela recebe são recalculados com uma passagem de frente extra. Isso está obsoleto e será removido na v2.0.0. - callbacks (lista de TrainerCallback, opcional) —
Lista de callbacks para personalizar o loop de treinamento. Adicionará esses à lista de callbacks padrão detalhada aqui.
Se você deseja remover um dos callbacks padrão utilizados, use o método remove_callback.
- optimizers (
tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opcional, padrão(None, None)) — Uma tupla contendo o otimizador e o agendador a serem usados. Por padrão, será uma instância deAdamWno seu modelo e um agendador dado por get_linear_schedule_with_warmup controlado porargs. - quantization_config (BitsAndBytesConfig, opcional) —
Configuração de quantização usada ao carregar o modelo a partir de um identificador de modelo. Combine com
peft_configpara treinamento QLoRA. Ignorado se o modelo já estiver instanciado. - peft_config (
PeftConfig, opcional) — Configuração PEFT usada para envolver o modelo. SeNone, o modelo não é envolvido.
Trainer para o método de Direct Preference Optimization (DPO). Este algoritmo foi inicialmente proposto no artigo Direct Preference Optimization: Your Language Model is Secretly a Reward Model. Esta classe é um wrapper em torno da classe Trainer e herda todos os seus atributos e métodos.
Exemplo:
>>> from trl import DPOTrainer
>>> from datasets import load_dataset
>>> dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
>>> trainer = DPOTrainer(
... model="Qwen/Qwen2.5-0.5B-Instruct",
... train_dataset=dataset,
... )
>>> trainer.train()treino
< source >( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput
Parâmetros
- resume_from_checkpoint (
stroubool, opcional) — Se for umstr, caminho local para um checkpoint salvo por uma instância anterior deTrainer. Se for umboole for igual aTrue, carrega o último checkpoint em args.output_dir salvo por uma instância anterior deTrainer. Se presente, o treinamento será retomado a partir dos estados do modelo/otimizador/agendador carregados aqui. - trial (
optuna.Trialoudict[str, Any], opcional) — A execução do trial ou o dicionário de hiperparâmetros para a busca de hiperparâmetros. - ignore_keys_for_eval (
list[str], opcional) — Uma lista de chaves na saída do seu modelo (se for um dicionário) que devem ser ignoradas ao coletar previsões para avaliação durante o treinamento.
Retorna
~trainer_utils.TrainOutput
Objeto contendo a contagem de etapas globais, a perda de treinamento e as métricas.
Ponto de entrada principal do treinamento.
Salvará o modelo, para que você possa recarregá-lo usando from_pretrained().
Salvará apenas a partir do processo principal.
push_to_hub
< source >( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )
Parâmetros
- commit_message (
str, opcional, padrão"End of training") — Mensagem a ser commitada durante o push. - blocking (
bool, opcional, padrãoTrue) — Se a função deve retornar apenas quando ogit pushtiver terminado. - token (
str, opcional, padrãoNone) — Token com permissão de escrita para sobrescrever os argumentos originais do Trainer. - revision (
str, opcional) — A revisão git de onde o commit será feito. O padrão é o topo do ramo “main”. - private (
bool, opcional) — Se o repositório deve ser privado quando for criado. O padrão éargs.hub_private_repo. Não tem efeito se o repositório já existir. - kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados para~Trainer.create_model_card.
Envie self.model e self.processing_class para o hub de modelos do 🤗 no repositório self.args.hub_model_id.
DPOConfig
classe trl.DPOConfig
< source >( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: list[str] = <factory>loss_weights: list[float] | None = Noneld_alpha: float | None = Nonef_divergence_type: str = 'reverse_kl'f_alpha_divergence_coef: float = 0.5label_smoothing: float = 0.0beta: float = 0.1use_weighting: bool = Falsediscopop_tau: float = 0.05activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512pad_token: str | None = None )
Parâmetros que controlam o modelo
- model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave para from_pretrained, usados quando o argumentomodeldo DPOTrainer é fornecido como uma string. O valor derevisiontambém é usado ao carregar a classe de processamento. - trust_remote_code (
bool, opcional, padrãoFalse) — Se permite carregar modelos e tokenizers que incluem código Python personalizado do Hub. Encaminhado para from_pretrained e from_pretrained. - router_aux_loss_coef (
float, opcional) — Coeficiente da perda auxiliar de balanceamento de carga para modelos Mixture-of-Experts (MoE), adicionada à perda de treinamento com esse peso. Quando não definido, o valor declarado na configuração do modelo é utilizado. Defina como0.0para desativá-la. Falha quando usado com um modelo não-MoE. - disable_dropout (
bool, opcional, padrãoTrue) — Se deve desabilitar o dropout no modelo e no modelo de referência.
Parâmetros que controlam o pré-processamento dos dados
- dataset_num_proc (
int, opcional) — Número de processos a serem usados para processar o conjunto de dados. - max_length (
intouNone, opcional, padrão1024) — Comprimento máximo da sequência tokenizada. Sequências maiores quemax_lengthsão truncadas à esquerda ou à direita, dependendo dotruncation_mode. SeNone, nenhum truncamento é aplicado. - truncation_mode (
str, opcional, padrão"keep_start") — Modo de truncamento a ser usado quando a sequência excedemax_length. O único valor suportado é"keep_start". O valor"keep_end"está obsoleto e será removido na v2.0.0. - padding_free (
bool, opcional, padrãoFalse) — Se deve executar as passadas de forward sem padding, achatando todas as sequências do lote em uma única sequência contínua. Isso reduz o uso de memória ao eliminar o overhead de padding. Atualmente, isso é suportado apenas com o FlashAttention 2 ou 3, que podem lidar com a estrutura achatada do lote de forma eficiente. Temporariamente indisponível: desde o refatoramento do DPO, definir comoTrueemite um aviso e recorre ao padding padrão. Está planejado para retornar em uma atualização futura. - pad_to_multiple_of (
intoustr, opcional, padrão"auto") — Se definido, as sequências serão preenchidas até um múltiplo deste valor."auto"preenche até um múltiplo de 128 no Neuron (AWS Trainium), que compila uma vez por forma de entrada, e não preenche em outros ambientes. - precompute_ref_log_probs (
bool, opcional, padrãoFalse) — Se as probabilidades log do modelo de referência para todo o conjunto de dados de treinamento devem ser pré-computadas antes do treinamento. Isso permite economizar memória durante o treinamento, pois o modelo de referência não precisa ser mantido em memória. - precompute_ref_batch_size (
int, opcional) — Tamanho do lote a ser usado ao pré-computar as probabilidades log do modelo de referência. Isso pode ser definido com um valor maior que o tamanho do lote de treinamento para acelerar o pré-processamento. SeNone, o padrão éper_device_train_batch_sizepara treinamento eper_device_eval_batch_sizepara avaliação.
Parâmetros que controlam o treinamento
- loss_type (
list[str], opcional, padrão["sigmoid"]) — Tipo de perda a ser usado. Os valores possíveis são:'sigmoid','hinge','ipo','exo_pair','nca_pair','robust','bco_pair','sppo_hard','aot','aot_unpaired','apo_zero','apo_down','discopop','sft','sigmoid_norm','udpo'. Se vários tipos de perda forem fornecidos, eles serão combinados usando os pesos especificados emloss_weights. - loss_weights (
list[float], opcional) — Lista de pesos de perda para combinações de múltiplas perdas. Usado ao combinar vários tipos de perda. Exemplo:[0.8, 0.2, 1.0]para MPO. Se não for fornecido, o padrão é pesos iguais (1.0) para todos os tipos de perda. - ld_alpha (
float, opcional) — parâmetro α do paper LD-DPO, que controla o peso das log-probabilidades dos tokens verbosos nas respostas. SeNone, nenhum peso é aplicado à parte verbosa, e a perda é equivalente à perda padrão do DPO. Deve estar em [0.0, 1.0]:ld_alpha=1.0não aplica nenhum peso, eld_alpha=0.0mascara tokens além dos comprimentos compartilhados. - f_divergence_type (
str, opcional, padrão"reverse_kl") — regularizador de f-divergência entre a política e a referência (papel f-DPO). Os valores possíveis são:reverse_kl(padrão),forward_kl,js_divergence,alpha_divergence. Apenas os tipos de perda baseados na diferença de recompensa entre a escolha e a rejeição suportam um valor não padrão:'sigmoid','sigmoid_norm','hinge','ipo','exo_pair','robust','discopop','sft','udpo'. Os outros tipos de perda não possuem uma generalização válida de f-divergência e são rejeitados com um valor não padrão. - f_alpha_divergence_coef (
float, opcional, padrão0.5) — coeficiente α para o regularizador de α-divergência u^-α, usado apenas quandof_divergence_type='alpha_divergence'. - label_smoothing (
float, opcional, padrão0.0) — Parâmetro de label smoothing usado em Robust DPO, UDPO e EXO. Em Robust DPO e UDPO, é interpretado como a probabilidade ε de que um rótulo de preferência seja invertido e deve estar em [0.0, 0.5); um valor típico recomendado pelo paper de Robust DPO é 0.1. O UDPO usa isso para definir a = ε / (1 - ε), e o paper de UDPO recomenda a = 0.8, ou seja, ε = 4/9. Em EXO, corresponde ao parâmetro de label smoothing ε, para o qual o paper recomenda um valor típico de 1e-3. - beta (
float, opcional, padrão0.1) — Parâmetro que controla o desvio em relação ao modelo de referência. Valores maiores de β indicam menor desvio em relação ao modelo de referência. Para a perda IPO (loss_type='ipo'), esse valor é o parâmetro de regularização denotado por τ no artigo. - use_weighting (
bool, opcional, padrãoFalse) — Se deve aplicar ponderação no estilo WPO aos pares de preferências usando as probabilidades de sequência normalizadas pelo comprimento da política. - discopop_tau (
float, opcional, padrão0.05) — parâmetro τ/temperatura do paper DiscoPOP, que controla a forma da perda modulada por log-ratio ao usarloss_type='discopop'. O paper recomenda o valor padrãodiscopop_tau=0.05. - activation_offloading (
bool, opcional, padrãoFalse) — Se as ativações devem ser transferidas para a CPU. - sync_ref_model (
bool, opcional, padrãoFalse) — Se deve sincronizar o modelo de referência com o modelo ativo a cadaref_model_sync_stepspassos, usando o parâmetroref_model_mixup_alpha. Essa sincronização origina-se do artigo TR-DPO.sync_ref_model=Trueainda não é compatível com PEFT ouprecompute_ref_log_probs=True. - ref_model_mixup_alpha (
float, opcional, padrão0.6) — parâmetro α do paper TR-DPO, que controla a mistura entre a política atual e a política de referência anterior durante as atualizações. A política de referência é atualizada de acordo com a equação:π_ref = α * π_θ + (1 - α) * π_ref_prev. Para usar este parâmetro, você deve definirsync_ref_model=True. - ref_model_sync_steps (
int, opcional, padrão512) — parâmetro τ do paper TR-DPO, que determina a frequência com que a política atual é sincronizada com a política de referência. Para usar este parâmetro, você deve definirsync_ref_model=True.
Parâmetros obsoletos
Classe de configuração para o DPOTrainer.
Esta classe inclui apenas os parâmetros específicos para o treinamento DPO. Para a lista completa de argumentos de treinamento, consulte a documentação de TrainingArguments. Observe que os valores padrão nesta classe podem diferir dos presentes em TrainingArguments.
Usando HfArgumentParser, podemos transformar essa classe em argumentos argparse que podem ser especificados na linha de comando.
Esses parâmetros possuem valores padrão diferentes de TrainingArguments:
logging_steps: O valor padrão é10em vez de500.gradient_checkpointing: O padrão éTrueem vez deFalse.bf16: Padrão éTruesefp16não estiver definido, em vez deFalse.learning_rate: O valor padrão é1e-6em vez de5e-5.