TRL documentation

Personalização do treinamento

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Personalização do treinamento

O TRL foi projetado com modularity em mente, para que os usuários possam personalizar eficientemente o loop de treinamento de acordo com suas necessidades. Abaixo estão exemplos de como você pode aplicar e testar diferentes técnicas.

Embora esses exemplos usem o DPOTrainer, esses métodos de personalização se aplicam à maioria (se não a todos) os treinadores no TRL.

Use diferentes otimizadores e agendadores

Por padrão, o DPOTrainer cria um otimizador torch.optim.AdamW. Você pode criar e definir um otimizador diferente e passá-lo para o DPOTrainer da seguinte forma:

from datasets import load_dataset
from torch import optim
from transformers import AutoModelForCausalLM
from trl import DPOTrainer

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
optimizer = optim.SGD(model.parameters(), lr=1e-6)

trainer = DPOTrainer(
    model=model,
    train_dataset=dataset,
    optimizers=(optimizer, None),
)
trainer.train()

Adicione um agendador de taxa de aprendizado

Você também pode adicionar agendadores de taxa de aprendizado passando tanto o otimizador quanto o agendador:

from torch import optim

optimizer = optim.AdamW(model.parameters(), lr=1e-6)
lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

trainer = DPOTrainer(..., optimizers=(optimizer, lr_scheduler))

Modelos de referência de 8 bits

Como o trl suporta todos os argumentos de palavra-chave ao carregar um modelo do transformers usando from_pretrained, você também pode aproveitar o load_in_8bit do transformers para um fine-tuning mais eficiente em termos de memória.

Saiba mais sobre o carregamento de modelos em 8 bits em transformers Carregamento em 8 bits ou 4 bits.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)
ref_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct", quantization_config=quantization_config)

trainer = DPOTrainer(..., ref_model=ref_model)

Adicionar callbacks personalizados

Você pode personalizar o loop de treinamento adicionando callbacks para registro de logs, monitoramento ou parada antecipada. Os callbacks permitem executar código personalizado em pontos específicos durante o treinamento.

from transformers import TrainerCallback


class CustomLoggingCallback(TrainerCallback):
    def on_log(self, args, state, control, logs=None, **kwargs):
        if logs is not None:
            print(f"Step {state.global_step}: {logs}")


trainer = DPOTrainer(..., callbacks=[CustomLoggingCallback()])

Adicionar métricas de avaliação personalizadas

Você pode definir métricas de avaliação personalizadas para acompanhar durante o treinamento. Isso é útil para monitorar o desempenho do modelo em tarefas específicas.

def compute_metrics(eval_preds):
    logits, labels = eval_preds
    # Add your metric computation here
    return {"custom_metric": 0.0}


training_args = DPOConfig(..., eval_strategy="steps", eval_steps=100)

trainer = DPOTrainer(..., eval_dataset=eval_dataset, compute_metrics=compute_metrics)

Use treinamento com precisão mista

O treinamento em precisão mista pode acelerar significativamente o treinamento e reduzir o uso de memória. Você pode ativá-lo definindo bf16=True ou fp16=True na configuração de treinamento.

# Use bfloat16 precision (recommended for modern GPUs)
training_args = DPOConfig(..., bf16=True)

Observação: Use bf16=True para GPUs Ampere (A100, RTX 30xx) ou mais novas, e fp16=True para GPUs mais antigas.

Use acúmulo de gradiente

Ao treinar com memória de GPU limitada, o acúmulo de gradientes permite simular tamanhos de lote maiores ao acumular gradientes em várias etapas antes de atualizar os pesos.

# Simulate a batch size of 32 with per_device_train_batch_size=4 and gradient_accumulation_steps=8
training_args = DPOConfig(
    ...,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
)

Alterar o objetivo de treinamento

Subclassar um trainer é a maneira mais simples de personalizar o treinamento. A perda é definida no método compute_loss, portanto, para treinar com um objetivo diferente, subclasse o trainer e sobrescreva esse método. A preparação de dados, a geração, o registro de logs e o checkpointing são herdados, de modo que a subclass contém apenas o que realmente muda.

import torch

from trl import DPOTrainer
from trl.trainer.utils import selective_log_softmax


class MyDPOTrainer(DPOTrainer):
    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
        # In this example: the hinge loss from https://huggingface.co/papers/2309.06657
        input_ids, attention_mask = inputs["input_ids"], inputs["attention_mask"]
        shift_labels, shift_completion_mask = input_ids[:, 1:], inputs["completion_mask"][:, 1:]
        logits = model(input_ids=input_ids, attention_mask=attention_mask).logits
        with torch.no_grad():
            ref_logits = self.ref_model(input_ids=input_ids, attention_mask=attention_mask).logits

        # Sum the log-probs over the completion tokens, for the policy and for the reference model
        logps = (selective_log_softmax(logits[:, :-1], shift_labels) * shift_completion_mask).sum(dim=1)
        ref_logps = (selective_log_softmax(ref_logits[:, :-1], shift_labels) * shift_completion_mask).sum(dim=1)

        chosen_logps, rejected_logps = logps.chunk(2, dim=0)  # batch is [chosen, rejected]
        ref_chosen_logps, ref_rejected_logps = ref_logps.chunk(2, dim=0)
        delta = (chosen_logps - ref_chosen_logps) - (rejected_logps - ref_rejected_logps)
        return torch.relu(1 - self.beta * delta).mean()

Adicione parâmetros à configuração

Subclasse a config para declarar os parâmetros que sua loss precisa:

from dataclasses import dataclass, field

from trl import DPOConfig


@dataclass
class MyDPOConfig(DPOConfig):
    my_coef: float = field(default=0.1, metadata={"help": "Coefficient of the custom term."})

Alterar o formato do lote

Quando a perda requer entradas que o collator padrão não produz, passe seu próprio collator e sobrescreva _prepare_dataset para deixar o dataset intacto quando ele já estiver no formato esperado:

class MyDPOTrainer(DPOTrainer):
    def _prepare_dataset(self, dataset, *args, **kwargs):
        return dataset


trainer = MyDPOTrainer(..., data_collator=my_collator)

Exemplo completo

O exemplo de SFT com difusão em blocos examples/sft_diffusion_gemma/sft_diffusion_gemma.py combina os três: DiffusionGemmaSFTConfig estende SFTConfig com os parâmetros de canvas e corrupção, e DiffusionGemmaSFTTrainer estende SFTTrainer e substitui a entropia cruzada autoregressiva por um objetivo de desruidificação de difusão em blocos. Nenhum deles requer uma alteração na biblioteca.

Antidoom, uma ferramenta de código aberto da Liquid AI, estende o DPOTrainer com Final Token Preference Optimization (Antislop), uma perda de preferência sobre uma única posição de token que reduz loops de repetição em modelos de raciocínio.

Update on GitHub