TRL documentation
Personalização do treinamento
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