# Treinador DPO Online

[![model badge](https://img.shields.io/badge/All_models-Online_DPO-blue)](https://huggingface.co/models?other=online-dpo,trl)

## Visão geral

O DPO online foi proposto em [Direct Language Model Alignment from Online AI Feedback](https://huggingface.co/papers/2402.04792) por Shangmin Guo, Biao Zhang, Tianlin Liu, Tianqi Liu, Misha Khalman, Felipe Llinares, Alexandre Rame, Thomas Mesnard, Yao Zhao, Bilal Piot, Johan Ferret e Mathieu Blondel.

O resumo do artigo é o seguinte:

> Métodos de alinhamento direto a partir de preferências (DAP), como o DPO, surgiram recentemente como alternativas eficientes ao aprendizado por reforço com feedback humano (RLHF), que não exigem um modelo de recompensa separado. No entanto, os conjuntos de dados de preferências usados em métodos DAP são geralmente coletados antes do treinamento e nunca atualizados, de modo que o feedback é puramente offline. Além disso, as respostas nesses conjuntos de dados são frequentemente amostradas de um modelo de linguagem distinto daquele que está sendo alinhado, e, como o modelo evolui ao longo do treinamento, a fase de alinhamento é inevitavelmente off-policy. Neste estudo, postulamos que o feedback online é fundamental e melhora os métodos DAP. Nosso método, feedback de IA online (OAIF), usa um LLM como anotador: em cada iteração de treinamento, amostramos duas respostas do modelo atual e solicitamos ao anotador LLM que escolha qual delas é preferida, fornecendo assim feedback online. Apesar de sua simplicidade, demonstramos, por meio de avaliação humana em várias tarefas, que o OAIF supera tanto os métodos DAP offline quanto os métodos RLHF. Mostramos ainda que o feedback utilizado no OAIF é facilmente controlável, por meio de prompts de instrução ao anotador LLM.

Este método de pós-treinamento foi contribuído por [Michael Noukhovitch](https://huggingface.co/mnoukhov), [Shengyi Costa Huang](https://huggingface.co/vwxyzjn), [Quentin Gallouédec](https://huggingface.co/qgallouedec) e [Edward Beeching](https://huggingface.co/edbeeching).

## Início rápido

Este exemplo demonstra como treinar um modelo usando o método DPO online. Usamos o modelo [Qwen 0.5B](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct) como modelo base e o modelo de recompensa [trl-lib/Qwen2-0.5B-Reward](https://huggingface.co/trl-lib/Qwen2-0.5B-Reward). Usamos os prompts do [conjunto de dados UltraFeedback](https://huggingface.co/datasets/openbmb/UltraFeedback). Você pode visualizar os prompts no conjunto de dados aqui:

<iframe src="https://huggingface.co/datasets/trl-lib/ultrafeedback-prompt/embed/viewer/default/train?row=0" frameborder="0" width="100%" height="560px"
>

Abaixo está o script para treinar o modelo:

```python
# train_online_dpo.py
from datasets import load_dataset
from trl.experimental.online_dpo import OnlineDPOConfig, OnlineDPOTrainer
from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
reward_model = AutoModelForSequenceClassification.from_pretrained("trl-lib/Qwen2-0.5B-Reward", num_labels=1)
train_dataset = load_dataset("trl-lib/ultrafeedback-prompt", split="train")

training_args = OnlineDPOConfig(output_dir="Qwen2-0.5B-OnlineDPO")
trainer = OnlineDPOTrainer(
    model=model, reward_funcs=reward_model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset
)
trainer.train()
```

Execute o script usando o seguinte comando:

```bash
torchrun --nproc_per_node 8 train_online_dpo.py
```

Distribuído em 8 GPUs, o treinamento leva aproximadamente 1 hora. Você pode verificar o progresso do treinamento analisando o gráfico de recompensa. Uma tendência de aumento tanto na recompensa para as conclusões rejeitadas quanto para as escolhidas indica que o modelo está melhorando e gerando respostas melhores ao longo do tempo.

![](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/online-dpo-qwen2.png)

Para ver como o [modelo treinado](https://huggingface.co/trl-lib/Qwen2-0.5B-OnlineDPO) se comporta, você pode usar o [Transformers Chat CLI](https://huggingface.co/docs/transformers/quicktour#chat-with-text-generation-models).

$ transformers chat trl-lib/Qwen2-0.5B-OnlineDPO &lt;quentin_gallouedec&gt;: Qual é a melhor linguagem de programação?

&lt;trl-lib/Qwen2-0.5B-OnlineDPO&gt;: A melhor linguagem de programação depende das suas necessidades e prioridades específicas. Algumas pessoas preferem linguagens de programação imperativas (como Haskell ou Lisp), enquanto outras preferem linguagens de programação funcionais (como Scala ou Python). É importante considerar seu estilo de trabalho, ambiente de programação e requisitos do projeto ao escolher uma linguagem de programação.

## Tipo de dataset esperado

O DPO online requer apenas um [conjunto de dados somente com prompts](dataset_formats#prompt-only) (diferentemente do DPO offline, que espera um [conjunto de dados de preferências](dataset_formats#preference)). O [experimental.online_dpo.OnlineDPOTrainer](/docs/trl/v1.18.2/pt/online_dpo_trainer#trl.experimental.online_dpo.OnlineDPOTrainer) suporta tanto o formato [conversacional](dataset_formats#conversational) quanto o formato [padrão](dataset_formats#standard) de conjuntos de dados. Quando fornecido com um conjunto de dados conversacional, o treinador aplicará automaticamente o modelo de chat ao conjunto de dados.

## Dicas de uso

### Incentivar a geração do token EOS

Ao usar um modelo de recompensa, podemos querer que o modelo gere conclusões dentro de um comprimento específico. Durante o treinamento, o modelo gerará conclusões até o comprimento máximo especificado no argumento `max_new_tokens` de [experimental.online_dpo.OnlineDPOConfig](/docs/trl/v1.18.2/pt/online_dpo_trainer#trl.experimental.online_dpo.OnlineDPOConfig). Se você quiser penalizar o modelo por não gerar um token EOS antes de atingir o comprimento máximo, pode usar o argumento `missing_eos_penalty` de [experimental.online_dpo.OnlineDPOConfig](/docs/trl/v1.18.2/pt/online_dpo_trainer#trl.experimental.online_dpo.OnlineDPOConfig):

```python
training_args = OnlineDPOConfig(..., max_new_tokens=128, missing_eos_penalty=1.0)
```

### Registro de Completions

Para entender melhor o comportamento do seu modelo durante o treinamento, você pode registrar periodicamente as conclusões de amostras usando o [LogCompletionsCallback](/docs/trl/v1.18.2/pt/callbacks#trl.LogCompletionsCallback).

```python
trainer = OnlineDPOTrainer(..., eval_dataset=eval_dataset)
completions_callback = LogCompletionsCallback(trainer, num_prompts=8)
trainer.add_callback(completions_callback)
```

Este callback registra as conclusões geradas pelo modelo diretamente no Weights & Biases.

![Logged Completions](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/wandb_completions.png)

## Métricas registradas

Durante o treinamento e a avaliação, registramos as seguintes métricas. Aqui está um exemplo de [execução rastreada no Weights and Biases](https://wandb.ai/huggingface/trl/runs/w4apmsi9)

* `objective/kl`: A divergência média de Kullback-Leibler (KL) entre o modelo atual e o modelo de referência.
* `objective/entropy`: A entropia média do modelo, indicando o grau de aleatoriedade das ações escolhidas pelo modelo.
* `objective/non_score_reward`: A recompensa média de fontes não relacionadas à pontuação, basicamente `beta * kl.sum(1)`, onde `beta` é o coeficiente de penalidade de KL e `kl` é a divergência de KL por token.
* `objective/rlhf_reward`: A recompensa média de RLHF, que é `scores - non_score_reward`. O `rlhf_reward` é o objetivo final do treinamento de DPO online. Se o treinamento estiver funcionando como previsto, essa métrica deve continuar aumentando.
* `objective/scores`: As pontuações médias retornadas pelo modelo de recompensa.
* `objective/scores_margin`: A margem média de pontuação (de acordo com o modelo de recompensa externo) entre as conclusões escolhidas e rejeitadas.
* `rewards/chosen`: A recompensa média (de acordo com o modelo de recompensa implícito do DPO online) das conclusões escolhidas.
* `rewards/rejected`: A recompensa média (de acordo com o modelo de recompensa implícito do DPO online) das conclusões rejeitadas.
* `rewards/accuracies`: As acurácias do modelo de recompensa implícito do DPO online.
* `rewards/margins`: A margem média de recompensa (de acordo com o modelo de recompensa implícito do DPO online) entre as conclusões escolhidas e rejeitadas.
* `logps/chosen`: As probabilidades logarítmicas médias das conclusões escolhidas.
* `logps/rejected`: As probabilidades logarítmicas médias das conclusões rejeitadas.
* `val/contain_eos_token`: A fração de conclusões que contêm um token EOS.
* `beta`: O parâmetro que controla o peso do termo de perda que representa o desvio em relação ao modelo de referência. Geralmente fixo, mas pode ser dinâmico ao passar uma lista para [experimental.online_dpo.OnlineDPOConfig](/docs/trl/v1.18.2/pt/online_dpo_trainer#trl.experimental.online_dpo.OnlineDPOConfig).

## Experimentos de benchmark

Para validar que a implementação do DPO online funciona, executamos experimentos com os modelos Pythia 1B, 2.8B e 6.9B em um único nó com 8 x H100s. Seguem os comandos que usamos para executar os experimentos, com o script de exemplo do DPO online como ele existia na época ([`examples/scripts/online_dpo.py`](https://github.com/huggingface/trl/blob/v1.10.0/examples/scripts/online_dpo.py), removido posteriormente) — para reproduzi-los, execute a partir de um checkout da v1.10.0 (`git checkout v1.10.0`). Utilizamos os modelos SFT / RM diretamente de [The N+ Implementation Details of RLHF with PPO: A Case Study on TL;DR Summarization](https://huggingface.co/papers/2403.17031).

```shell
# 1B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/multi_gpu.yaml \
    examples/scripts/online_dpo.py \
    --model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft  \
    --reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
    --dataset_name trl-lib/tldr \
    --learning_rate 5.0e-7 \
    --output_dir pythia-1b-deduped-tldr-online-dpo \
    --beta 0.1 \
    --per_device_train_batch_size 8 \
    --gradient_accumulation_steps 2 \
    --num_train_epochs 3 \
    --max_new_tokens 53 \
    --warmup_steps 0.1 \
    --missing_eos_penalty 1.0 \
    --save_steps 0.1 \
    --push_to_hub

# 2.8B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
    examples/scripts/online_dpo.py \
    --model_name_or_path trl-lib/pythia-2.8b-deduped-tldr-sft  \
    --reward_model_path trl-lib/pythia-2.8b-deduped-tldr-rm \
    --dataset_name trl-lib/tldr \
    --learning_rate 5.0e-7 \
    --output_dir pythia-2.8b-deduped-tldr-online-dpo \
    --beta 0.1 \
    --per_device_train_batch_size 8 \
    --gradient_accumulation_steps 2 \
    --num_train_epochs 3 \
    --max_new_tokens 53 \
    --warmup_steps 0.1 \
    --missing_eos_penalty 1.0 \
    --save_steps 0.1 \
    --push_to_hub

# 6.9B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
    examples/scripts/online_dpo.py \
    --model_name_or_path trl-lib/pythia-6.9b-deduped-tldr-sft  \
    --reward_model_path trl-lib/pythia-6.9b-deduped-tldr-rm \
    --dataset_name trl-lib/tldr \
    --learning_rate 5.0e-7 \
    --output_dir pythia-6.9b-deduped-tldr-online-dpo \
    --beta 0.1 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --num_train_epochs 3 \
    --max_new_tokens 53 \
    --warmup_steps 0.1 \
    --missing_eos_penalty 1.0 \
    --save_steps 0.1 \
    --push_to_hub
```

O experimento é rastreado neste [🐝 relatório do W&B](https://wandb.ai/huggingface/trl/reports/Online-DPO-experiments-for-TL-DR-summarisation--Vmlldzo5MTczMDU0).

O checkpoint do DPO online apresenta uma taxa de vitória cada vez maior à medida que aumentamos o tamanho dos modelos. Esse é um bom sinal de que a implementação do DPO online está funcionando conforme o esperado.

## OnlineDPOTrainer[[trl.experimental.online_dpo.OnlineDPOTrainer]]

#### trl.experimental.online_dpo.OnlineDPOTrainer[[trl.experimental.online_dpo.OnlineDPOTrainer]]

```python
trl.experimental.online_dpo.OnlineDPOTrainer(model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str], ref_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, NoneType] = None, reward_funcs: str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]] | list[str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]]] | None = None, args: trl.experimental.online_dpo.online_dpo_config.OnlineDPOConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: typing.Union[datasets.arrow_dataset.Dataset, torch.utils.data.IterableDataset, NoneType] = None, eval_dataset: typing.Union[datasets.arrow_dataset.Dataset, torch.utils.data.IterableDataset, dict[str, typing.Union[datasets.arrow_dataset.Dataset, torch.utils.data.IterableDataset]], NoneType] = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, reward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = None, peft_config: PeftConfig | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None), preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None)
```

[Fonte](https://github.com/huggingface/trl/blob/v1.18.2/trl/experimental/online_dpo/online_dpo_trainer.py#L94)

**Parâmetros:**

model (`str | nn.Module | PreTrainedModel`) : 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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained), por exemplo, `'./my_model_directory/'`. O modelo é carregado usando [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) com os argumentos de palavra-chave em `args.model_init_kwargs`. - Um objeto [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel). Apenas modelos de linguagem causais são suportados.

ref_model ([PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) ou `torch.nn.Module` ou `None`) : O modelo de referência a ser usado para o treinamento. Se None for especificado, o modelo de referência será criado a partir do modelo.

reward_funcs (`RewardFunc | list[RewardFunc]`) : Funções de recompensa a serem usadas para calcular as recompensas. Para calcular as recompensas, chamamos todas as funções de recompensa com os prompts e as conclusões e somamos as recompensas. Pode ser: - Uma única função de recompensa: Pode ser uma string (caminho para o modelo), um [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) ou uma função chamável personalizada. - Uma lista de funções de recompensa: Todas devem ser de tipos compatíveis.

args ([experimental.online_dpo.OnlineDPOConfig](/docs/trl/v1.18.2/pt/online_dpo_trainer#trl.experimental.online_dpo.OnlineDPOConfig)) : Os argumentos de configuração do DPO online a serem usados para o treinamento.

data_collator (`DataCollator`) : O data collator a ser usado para o treinamento. Se None for especificado, o data collator padrão (`experimental.utils.DPODataCollatorWithPadding`) será utilizado, que irá aplicar padding nas sequências até o comprimento máximo das sequências no lote, dado um conjunto de dados de sequências em pares.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : O conjunto de dados a ser usado para o treinamento.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset) ou `dict[str, Dataset | IterableDataset]`) : O conjunto de dados a ser usado para avaliação.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) ou [ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.ProcessorMixin), *opcional*) : Classe de processamento usada para processar os dados. Se fornecida, será usada para processar automaticamente as entradas para o modelo e será salva junto com o modelo para facilitar a reexecução de um treinamento interrompido ou a reutilização do modelo ajustado.

reward_processing_classes ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) ou `list[PreTrainedTokenizerBase]`, *opcional*) : Classes de processamento correspondentes às funções de recompensa especificadas em `reward_funcs`. Pode ser:  - Uma única classe de processamento: Usada quando `reward_funcs` contém apenas uma função de recompensa. - Uma lista de classes de processamento: Deve corresponder à ordem e ao comprimento das funções de recompensa em `reward_funcs`.  Se definido como `None`, o tokenizer para cada função de recompensa baseada em modelo é carregado automaticamente usando [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained).

peft_config ([PeftConfig](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/config#peft.PeftConfig), *opcional*) : configuração PEFT usada para envolver o modelo. Se `None`, o modelo não é envolvido.

compute_metrics (`Callable[[EvalPrediction], dict]`, *opcional*) : A função a ser usada para calcular as métricas. Deve receber um `EvalPrediction` e retornar um dicionário de strings para valores de métricas.

callbacks (`list[transformers.TrainerCallback]`) : Os callbacks a serem usados para o treinamento.

optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`) : O otimizador e o agendador a serem usados para o treinamento.

preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`) : A função a ser usada para pré-processar os logits antes de calcular as métricas.

Inicialize o OnlineDPOTrainer.

#### treinar[[trl.experimental.online_dpo.OnlineDPOTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Fonte](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L1450)

**Parâmetros:**

resume_from_checkpoint (`str` ou `bool`, *opcional*) : Se for um `str`, caminho local para um checkpoint salvo por uma instância anterior de `Trainer`. Se for um `bool` e for igual a `True`, carrega o último checkpoint em *args.output_dir* salvo por uma instância anterior de `Trainer`. Se presente, o treinamento será retomado a partir dos estados do modelo/otimizador/agendador carregados aqui.

trial (`optuna.Trial` ou `dict[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 reunir as 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.

#### save_model[[trl.experimental.online_dpo.OnlineDPOTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Fonte](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L4077)

Salvará o modelo, para que você possa recarregá-lo usando `from_pretrained()`.

Salvará apenas a partir do processo principal.

#### push_to_hub[[trl.experimental.online_dpo.OnlineDPOTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Fonte](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L4337)

**Parâmetros:**

commit_message (`str`, *opcional*, padrão `"End of training"`) : Mensagem a ser commitada durante o push.

blocking (`bool`, *opcional*, padrão `True`) : Se a função deve retornar apenas quando o `git push` tiver terminado.

token (`str`, *opcional*, padrão `None`) : Token com permissão de escrita para sobrescrever os argumentos originais do Trainer.

revision (`str`, *opcional*) : A revisão do git a partir da qual o commit será feito. O padrão é o topo da branch "main".

private (`bool`, *opcional*) : Se deve tornar o repositório privado quando ele 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`.

**Retorna:**

A URL do repositório para onde o modelo foi enviado se `blocking=False`, ou um objeto `Future` que acompanha o progresso do commit se `blocking=True`.

Envie `self.model` e `self.processing_class` para o hub de modelos do 🤗 no repositório `self.args.hub_model_id`.

## OnlineDPOConfig[[trl.experimental.online_dpo.OnlineDPOConfig]]

#### trl.experimental.online_dpo.OnlineDPOConfig[[trl.experimental.online_dpo.OnlineDPOConfig]]

```python
trl.experimental.online_dpo.OnlineDPOConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 5e-07, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = False, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, reward_model_path: str | None = None, max_new_tokens: int = 64, max_length: int = 512, temperature: float = 0.9, top_p: float = 1.0, top_k: int = 0, min_p: float | None = None, repetition_penalty: float = 1.0, generation_kwargs: dict | None = None, cache_implementation: str | None = None, missing_eos_penalty: float | None = None, beta: list[float] = <factory>, loss_type: str = 'sigmoid', disable_dropout: bool = True, use_vllm: bool = False, vllm_model_impl: str = 'vllm', vllm_structured_outputs_regex: str | None = None, vllm_gpu_memory_utilization: float | None = 0.55, vllm_mode: str = 'colocate', vllm_server_base_url: str | None = None, vllm_server_host: str = '0.0.0.0', vllm_server_port: int = 8000, vllm_server_timeout: float = 240.0, vllm_group_port: int = 51216, vllm_tensor_parallel_size: int = 1, vllm_enable_sleep_mode: bool = False, ds3_gather_for_generation: bool = True, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, reward_weights: list[float] | None = None)
```

[Fonte](https://github.com/huggingface/trl/blob/v1.18.2/trl/experimental/online_dpo/online_dpo_config.py#L23)

**Parâmetros:**

reward_model_path (`str`, *opcional*) : Caminho para o modelo de recompensa.

max_new_tokens (`int`, *opcional*, padrão `64`) : Número máximo de tokens a serem gerados por conclusão.

max_length (`int`, *opcional*, padrão `512`) : Comprimento total máximo da sequência (prompt + completion) usado para calcular as probabilidades logarítmicas. Se a sequência exceder esse limite, os tokens mais à esquerda serão truncados para preservar o máximo possível da completion. Não é aplicado quando as entradas contêm imagens, pois o truncamento removeria os tokens de imagem.

temperature (`float`, *opcional*, padrão `0.9`) : Temperatura para amostragem. Quanto maior a temperatura, mais aleatórias são as conclusões.

missing_eos_penalty (`float`, *opcional*) : Penalidade aplicada à pontuação quando o modelo não gera um token EOS. Isso é útil para incentivar a geração de complementos mais curtos que o comprimento máximo (`max_new_tokens`). A penalidade deve ser um valor positivo.

beta (`float` ou `list[float]`, *opcional*, padrão `0.1`) : Parâmetro que controla o desvio em relação ao modelo de referência. Um β maior significa menos desvio em relação ao modelo de referência. Para a perda IPO (`loss_type="ipo"`), β é o parâmetro de regularização denotado por τ no [artigo](https://huggingface.co/papers/2310.12036). Se uma lista de floats for fornecida, o β será selecionado para cada novo epoch e o último β será usado para o restante dos epochs.

loss_type (`str`, *opcional*, padrão `"sigmoid"`) : Tipo de perda a ser usado. Os valores possíveis são:  - `"sigmoid"`: perda sigmoid do artigo original de [DPO](https://huggingface.co/papers/2305.18290). - `"ipo"`: perda IPO do artigo [IPO](https://huggingface.co/papers/2310.12036).

disable_dropout (`bool`, *opcional*, padrão `True`) : Se deve desabilitar o dropout no modelo e no modelo de referência.

**Parâmetros que controlam a geração:**

top_p (`float`, *opcional*, padrão `1.0`) : Flutuante que controla a probabilidade cumulativa dos tokens principais a serem considerados. Deve estar em (0, 1]. Defina como `1.0` para considerar todos os tokens.

top_k (`int`, *opcional*, padrão `0`) : Número de tokens de vocabulário com maior probabilidade a serem mantidos para o filtro top-k. Se `0`, o filtro top-k é desativado e todos os tokens são considerados.

min_p (`float`, *opcional*) : Probabilidade mínima do token, que será escalada pela probabilidade do token mais provável. Deve ser um valor entre `0.0` e `1.0`. Valores típicos estão na faixa de `0.01-0.2`.

repetition_penalty (`float`, *opcional*, padrão `1.0`) : Flutuante que penaliza novos tokens com base em sua presença no prompt e no texto gerado até o momento. Valores > `1.0` incentivam o modelo a usar tokens novos, enquanto valores < `1.0` incentivam o modelo a repetir tokens.

cache_implementation (`str`, *opcional*) : Implementação do método de cache para uma geração mais rápida quando `use_vllm` está definido como `False`.

generation_kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais para passar ao [GenerationConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/text_generation#transformers.GenerationConfig) (se estiver usando transformers) ou ao `SamplingParams` (se estiver usando vLLM) ao amostrar as conclusões. Isso pode ser usado para personalizar ainda mais o comportamento da geração, como definir `suppress_tokens`, `num_beams`, etc. Se contiver chaves que conflitem com os outros parâmetros de geração (como `min_p`, `top_p`, etc.), eles os sobrescreverão.

**Parâmetros que controlam a aceleração da geração impulsionada pelo vLLM:**

use_vllm (`bool`, *opcional*, padrão `False`) : Se deve usar o vLLM para gerar complementos. Se definido como `True`, o trainer usará o vLLM para geração em vez do padrão model.generate(). Requer que `vllm` esteja instalado.

vllm_model_impl (`str`, *opcional*, padrão `"vllm"`) : Implementação do modelo a ser usada para vLLM. Deve ser uma das opções `"transformers"` ou `"vllm"`. `"transformers"`: Use o backend `transformers` para a implementação do modelo. `"vllm"`: Use a biblioteca `vllm` para a implementação do modelo.

vllm_mode (`str`, *opcional*, padrão `"colocate"`) : Modo a ser usado para a integração com o vLLM quando `use_vllm` está definido como `True`. Deve ser um dos valores `"server"` ou `"colocate"`.  - `"server"`: O trainer enviará solicitações de geração para um servidor vLLM separado. Certifique-se de que um servidor vLLM está em execução (inicie com `vllm serve`). - `"colocate"`: O vLLM será executado no mesmo processo e compartilhará as GPUs de treinamento. Isso evita a necessidade de um servidor separado, mas pode causar disputa de recursos com o treinamento.

vllm_structured_outputs_regex (`str`, *opcional*) : Regex para saídas estruturadas do vLLM. Se `None` (padrão), as saídas estruturadas ficam desativadas.

**Parâmetros que controlam o servidor vLLM (usados apenas quando `vllm_mode` é `"server"`):**

vllm_server_base_url (`str`, *opcional*) : URL base para o servidor vLLM (por exemplo, `"http://localhost:8000"`). Se fornecida, `vllm_server_host` e `vllm_server_port` são ignorados.

vllm_server_host (`str`, *opcional*, padrão `"0.0.0.0"`) : Host do servidor vLLM para conexão. Ignorado se `vllm_server_base_url` for fornecido.

vllm_server_port (`int`, *opcional*, padrão `8000`) : Porta do servidor vLLM para conexão. Ignorado se `vllm_server_base_url` for fornecido.

vllm_server_timeout (`float`, *opcional*, padrão `240.0`) : Duração total do tempo limite, em segundos, para aguardar que o servidor vLLM esteja ativo. Se o servidor não estiver ativo após o tempo limite, um `ConnectionError` é lançado.

vllm_group_port (`int`, *opcional*, padrão `51216`) : Número da porta para o grupo de atualização de pesos. Isso é usado para se comunicar com o servidor vLLM. A menos que a porta esteja ocupada, não é necessário alterá-la.

**Parâmetros que controlam a execução do vLLM colocalizado (usados apenas quando `vllm_mode` é `"colocate"`):**

vllm_gpu_memory_utilization (`float`, *opcional*, padrão `0.55`) : Controla a utilização de memória de GPU para o vLLM. Essa configuração só se aplica quando `vllm_mode` está definido como `"colocate"`. Se você estiver usando `vllm_mode="server"`, este parâmetro deve ser passado separadamente ao iniciar o servidor vLLM por meio da flag `--vllm_gpu_memory_utilization`.

vllm_tensor_parallel_size (`int`, *opcional*, padrão `1`) : Controla o tamanho do paralelismo de tensor para o vLLM. Essa configuração só se aplica quando `vllm_mode` está definido como `"colocate"`. Se você estiver usando `vllm_mode="server"`, este parâmetro deve ser passado separadamente ao iniciar o servidor vLLM por meio da flag `--vllm_tensor_parallel_size`.

vllm_enable_sleep_mode (`bool`, *opcional*, padrão `False`) : Ativa o modo de suspensão do vLLM para descarregar pesos/cache durante o passo do otimizador. Mantém o uso de memória da GPU baixo, mas a reativação do mecanismo adiciona latência de transferência entre host e dispositivo.

**Outros parâmetros:**

ds3_gather_for_generation (`bool`, *opcional*, padrão `True`) : Esta configuração se aplica ao DeepSpeed ZeRO-3. Se habilitado, os pesos do modelo de política são reunidos para a geração, melhorando a velocidade de geração. No entanto, desabilitar esta opção permite treinar modelos que excedem a capacidade de VRAM de uma única GPU, embora com o custo de uma geração mais lenta. Desabilitar esta opção não é compatível com a geração via vLLM.

model_init_kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave para passar a `AutoModelForCausalLM.from_pretrained` ao instanciar o modelo a partir de uma string. O valor de `revision` também é usado ao carregar as classes de processamento de recompensa.

trust_remote_code (`bool`, *opcional*, padrão `False`) : Se permite carregar modelos que incluem código Python personalizado do Hub. Encaminhado para [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained). Também aplicado aos carregamentos de reward-model e reward-tokenizer.

reward_weights (`list[float]`, *opcional*) : Pesos para combinar múltiplas funções de recompensa. Deve corresponder ao número de funções de recompensa. Se `None`, todas as funções de recompensa têm pesos iguais.

Classe de configuração para o [experimental.online_dpo.OnlineDPOTrainer](/docs/trl/v1.18.2/pt/online_dpo_trainer#trl.experimental.online_dpo.OnlineDPOTrainer).

Esta classe inclui apenas os parâmetros específicos para o treinamento de Online DPO. Para a lista completa de argumentos de treinamento, consulte a documentação de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments). Observe que os valores padrão nesta classe podem diferir daqueles em [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments).

Usando [HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser), podemos transformar essa classe em argumentos [argparse](https://docs.python.org/3/library/argparse#module-argparse) que podem ser especificados na linha de comando.

> [!NOTE]
> Esses parâmetros possuem valores padrão diferentes de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments): - `logging_steps`: Padrão é `10` em vez de `500`. - `gradient_checkpointing`: Padrão é `True` em vez de `False`. - `bf16`: Padrão é `True` se `fp16` não estiver definido, em vez de `False`. - `learning_rate`: Padrão é `5e-7` em vez de `5e-5`. - `remove_unused_columns`: Padrão é `False` em vez de `True`.

