TRL documentation
SDPO
SDPO
A Otimização de Política por Auto-Destilação (SDPO) foi introduzida em Reinforcement Learning via Self-Distillation por Jonas Hübotter, Frederike Lübeck, Lejs Behric, Anton Baumann, Marco Bagatella, Daniel Marta, Ido Hakimi, Idan Shenfeld, Thomas Kleine Buening, Carlos Guestrin e Andreas Krause.
Modelos de linguagem de grande porte são cada vez mais pós-treinados com aprendizado por reforço em domínios verificáveis, como código e matemática. No entanto, os métodos atuais para aprendizado por reforço com recompensas verificáveis (RLVR) aprendem apenas a partir de uma recompensa de resultado escalar por tentativa, criando um gargalo severo de atribuição de crédito. Muitos ambientes verificáveis fornecem, na verdade, feedback textual rico, como erros de tempo de execução ou avaliações de um juiz, que explicam por que uma tentativa falhou. Formalizamos esse cenário como aprendizado por reforço com feedback rico e introduzimos a Otimização de Política por Auto-Destilação (SDPO), que converte feedback tokenizado em um sinal de aprendizado denso, sem nenhum professor externo ou modelo de recompensa explícito. A SDPO trata o modelo atual, condicionado ao feedback, como um auto-professor e destila suas previsões de próximo token informadas pelo feedback de volta para a política. Dessa forma, a SDPO aproveita a capacidade do modelo de identificar retrospectivamente seus próprios erros no contexto. Em raciocínio científico, uso de ferramentas e programação competitiva no LiveCodeBench v6, a SDPO melhora a eficiência de amostragem e a precisão final em relação a baselines fortes de RLVR. Notavelmente, a SDPO também supera os baselines em ambientes padrão de RLVR que retornam apenas feedback escalar, usando rollouts bem-sucedidos como feedback implícito para tentativas falhas. Por fim, aplicar a SDPO a perguntas individuais no momento do teste acelera a descoberta em tarefas de recompensa binária difíceis, alcançando a mesma probabilidade de descoberta que a amostragem best-of-k ou conversas de múltiplas rodadas, com 3x menos tentativas.
Como funciona
O SDPO visa o aprendizado por reforço com recompensas verificáveis (RLVR), em que cada tentativa gera apenas uma recompensa escalar esparsa. Ele converte isso em um sinal denso, no nível de tokens: para cada prompt, a política amostra num_generations conclusões pontuadas por reward_funcs, um rollout bem-sucedido (mais o feedback opcional de privileged_context) se torna um reprompt do professor, e a distribuição informada por feedback do professor sobre uma conclusão é destilada de volta para a política. Professor e aluno são a mesma rede, portanto, nenhum professor externo ou modelo de recompensa é necessário além do verificador.
Modos de perda e o professor
distillation_weight controla como os dois sinais se combinam como uma combinação convexa: a perda é (1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss. 1.0 (o padrão) treina puramente na perda de auto-destilação, 0.0 recorre ao gradiente de política padrão no estilo GRPO, e valores intermediários misturam ambos. O objetivo de destilação em si é definido por distillation_mode — "sampled_token" (o padrão) usa um KL reverso em nível de token e requer distillation_alpha=1.0, enquanto "full_logits" e "topk_logits" destilam sobre o vocabulário completo ou os top-distillation_topk.
teacher_model_kind define os pesos do modelo professor: "ema" (o padrão) acompanha o modelo aluno com uma média móvel exponencial sincronizada a cada teacher_sync_steps passos, com taxa teacher_update_rate; "live" reutiliza diretamente o modelo aluno atual; e "base" congela os pesos iniciais. O reprompting é controlado por use_successful_as_teacher, success_reward_threshold, dont_reprompt_on_self_success e pelas strings reprompt_template / solution_template / feedback_template. A geração é executada por meio do Transformers por padrão, ou pelo vLLM (modo colocation ou servidor) quando use_vllm=True.
Colunas esperadas do conjunto de dados
Cada exemplo deve fornecer:
prompt: o prompt voltado para o alunoprivileged_context: texto privilegiado opcional, como feedback do ambiente, usado quandoinclude_environment_feedback=True
Uso
from datasets import Dataset
from trl.experimental.sdpo import SDPOConfig, SDPOTrainer
dataset = Dataset.from_dict(
{
"prompt": [[{"role": "user", "content": "Solve 2+2."}]],
"privileged_context": ["Your earlier answer used the wrong format."],
}
)
training_args = SDPOConfig(
output_dir="sdpo-model",
distillation_mode="topk_logits", # Explicitly select top-K logit distillation
distillation_topk=100, # Required when using top-K logit distillation
include_environment_feedback=True, # Use dataset privileged_context for teacher reprompts
)
trainer = SDPOTrainer(
model="Qwen/Qwen2.5-1.5B-Instruct",
reward_funcs=reward_func,
args=training_args,
train_dataset=dataset,
)
trainer.train()O SDPO sempre requer uma coluna prompt. Para usar o feedback do ambiente, inclua também uma coluna privileged_context e defina include_environment_feedback=True. O SDPO usará os rollouts bem-sucedidos e, quando habilitado, esse texto para construir reprompts do professor para autodestilação.
Servindo o modelo teacher a partir do servidor vLLM
Com teacher_model_kind="live", o teacher é o próprio student atual, cujos pesos o servidor vLLM já possui (eles são sincronizados para geração a cada passo). Defina use_teacher_server=True para pontuar as log-probabilidades do teacher naquele mesmo servidor, em vez de executar um forward local separado do teacher, removendo o teacher completamente do passo de treinamento:
training_args = SDPOConfig(
output_dir="sdpo-model",
use_vllm=True,
vllm_mode="server",
teacher_model_kind="live",
use_teacher_server=True,
distillation_weight=1.0,
distillation_mode="sampled_token",
)Ao usar o servidor de professor:
use_vllm=Trueevllm_mode="server"são obrigatóriosteacher_model_kinddeve ser"live"(o servidor mantém os pesos atuais do aluno)distillation_weightdeve ser1.0(destilação pura; uma mistura convexa com a perda da política requer os logits de vocabulário completo)distillation_modedeve ser"sampled_token"(KL reversa no token realizado) ou"topk_logits". O servidor retorna os próprios log-probs top-k do teacher, portantotopk_logitsdestila sobre o suporte top-k do teacher (não pode usar o do student, ao contrário do objetivo local); com um teacher"live", os dois suportes quase coincidem.full_logitsnão está disponível.
Callbacks
O trainer emite um pequeno conjunto de hooks de callback que são úteis para depuração, observabilidade e testes. Esses hooks são destinados a servir como pontos de integração práticos para fluxos de trabalho experimentais de auto-destilação.
Ganchos de auto-destilação compartilhados:
on_self_distillation_batch_prepared: disparado quando um lote de auto-destilação está pronto. O payload incluiprompt_ids,completion_idseold_per_token_logpsquando as entradas para o recorte de amostragem por importância estão disponíveis.on_generation_batch_built: disparado quando um novo lote de geração em buffer é criado. O payload incluigenerate_everyesteps_per_generation.
Hook específico do SDPO:
on_teacher_context_built: disparado após o SDPO construir as entradas condicionadas ao teacher. O payload incluiteacher_input_ids,teacher_attention_mask,completion_maskeself_distillation_mask.
Script de exemplo
Use examples/sdpo_math/sdpo_math.py para iniciar o treinamento do SDPO pela linha de comando. O script suporta recompensas matemáticas verificáveis, feedback do ambiente via --feedback_column e PEFT/LoRA por meio das flags padrão de ModelConfig.
python examples/sdpo_math/sdpo_math.py \
--model_name_or_path Qwen/Qwen2.5-Math-1.5B-Instruct \
--dataset_name openai/gsm8k \
--dataset_config main \
--output_dir outputs/sdpo-qwen35-2b-gsm8k \
--learning_rate 5e-5 \
--dtype bfloat16 \
--bf16 true \
--max_completion_length 128 \
--use_peft \
--lora_target_modules q_proj k_proj v_proj o_proj gate_proj up_proj down_proj \
--per_device_train_batch_size 1 \
--gradient_accumulation_steps 2 \
--num_generations 8 \
--generation_batch_size 32 \
--distillation_alpha 1.0 \
--distillation_mode sampled_token \
--distillation_weight 0.5 \
--report_to none \
--eval_strategy steps \
--eval_steps 1000 \
--save_strategy noSDPOConfig
classe trl.experimental.sdpo.SDPOConfig
< source >( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 5e-05lr_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 | None = Nonegradient_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 = Falselabel_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] | None = Nonetrust_remote_code: bool = Falsedisable_dropout: bool = Truemax_prompt_length: int | None = 512num_generations: int = 8num_generations_eval: int | None = Nonemax_completion_length: int | None = 256ds3_gather_for_generation: bool = Trueshuffle_dataset: bool = Truegeneration_batch_size: int | None = Nonesteps_per_generation: int | None = Nonetemperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonegeneration_kwargs: dict[str, typing.Any] | None = Nonechat_template_kwargs: dict[str, typing.Any] | None = Nonerepetition_penalty: float = 1.0cache_implementation: str | None = Noneuse_vllm: bool = Falseuse_teacher_server: bool = Falsevllm_mode: str = 'colocate'vllm_model_impl: str = 'vllm'vllm_enable_sleep_mode: bool = Falsevllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_group_port: int = 51216vllm_server_timeout: float = 240.0vllm_tensor_parallel_size: int = 1vllm_gpu_memory_utilization: float = 0.3vllm_max_model_length: int | None = Nonenum_iterations: int = 1loss_type: str = 'dapo'mask_truncated_completions: bool = Falsedont_reprompt_on_self_success: bool = Truebeta: float = 0.0epsilon: float = 0.2epsilon_high: float | None = Noneimportance_sampling_level: str = 'token'reward_weights: list[float] | None = Nonescale_rewards: str = 'group'distillation_alpha: float = 1.0distillation_mode: typing.Literal['sampled_token', 'full_logits', 'topk_logits'] = 'sampled_token'distillation_topk: int | None = Nonedistillation_is_clip: float | None = 2.0distillation_add_tail: bool = Falsedistillation_weight: float = 1.0teacher_model_kind: str = 'ema'teacher_update_rate: float = 0.05teacher_sync_steps: int = 1max_reprompt_len: int = 10240use_successful_as_teacher: bool = Truesuccess_reward_threshold: float = 1.0reprompt_template: str = '{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n'solution_template: str = '\nCorrect solution:\n\n{successful_previous_attempt}\n\n'feedback_template: str = '\nThe following is feedback from your unsuccessful earlier attempt:\n\n{feedback_raw}\n\n'include_environment_feedback: bool = Falseenvironment_feedback_only_without_solution: bool = Falseremove_thinking_from_demonstration: bool = Falsediagnostics_warning_interval: int = 10diagnostics_flat_tolerance: float = 1e-08 )
Parâmetros que controlam o objetivo da política online
- beta (
float, opcional, padrão0.0) — Coeficiente KL. Se0.0(padrão), o modelo de referência não é carregado, reduzindo o uso de memória e melhorando a velocidade de treinamento. DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning usa um valor de0.001. - epsilon (
float, opcional, padrão0.2) — Valor para o recorte (clipping). - epsilon_high (
float, opcional) — Valor superior de epsilon para o recorte. Se não for especificado, o valor padrão será o mesmo do limite inferior especificado no argumentoepsilon. O paper DAPO recomenda0.28. - importance_sampling_level (
str, opcional, padrão"token") — Controla se as razões de amostragem de importância são calculadas no nível'token'ou'sequence'.'token'mantém as razões brutas de log-probabilidade por token (um peso por token).'sequence'faz a média das razões de log-probabilidade entre os tokens válidos para produzir uma única razão por sequência. O paper do GSPO mostra que a amostragem no nível de sequência frequentemente resulta em treinamento mais estável e melhor alinhamento com recompensas no nível de sequência. - reward_weights (
list[float], opcional) — Pesos para cada função de recompensa. Deve corresponder ao número de funções de recompensa. SeNone, todas as recompensas são ponderadas igualmente com peso1.0. - scale_rewards (
stroubool, opcional, padrão"group") — Especifica a estratégia de escalonamento para as recompensas. Os valores suportados são:Trueou'group'(padrão): as recompensas são escalonadas pelo desvio padrão dentro de cada grupo, garantindo variância unitária dentro de um grupo.'batch': as recompensas são escalonadas pelo desvio padrão em todo o lote, conforme recomendado no paper PPO Lite.Falseou'none': nenhum escalonamento é aplicado. O paper Dr. GRPO recomenda não escalar as recompensas, pois o escalonamento pelo desvio padrão introduz um viés de dificuldade por pergunta.
Parâmetros que controlam a perda SDPO
- distillation_weight (
float, opcional, padrão1.0) — Peso da combinação convexa entre os objetivos de política e autodestilação. A perda é(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss. Deve estar em[0, 1].1.0(padrão) treina puramente com autodestilação,0.0retorna ao gradiente de política padrão no estilo GRPO, e valores intermediários misturam ambos. - distillation_alpha (
float, opcional, padrão1.0) — Coeficiente de interpolação de divergência. O SDPO de tokens amostrados requer a configuração oficial de reverse-KLdistillation_alpha=1.0. - distillation_mode (
Literal["sampled_token", "full_logits", "topk_logits"], opcional, padrão"sampled_token") — Modo do objetivo de destilação.sampled_tokené o modo padrão do SDPO e requerdistillation_alpha=1.0. - distillation_topk (
int, opcional) — Aproximação top-k para SDPO em nível de logits. Deve ser definido quandodistillation_mode=topk_logitse deixado indefinido caso contrário. - distillation_is_clip (
float, opcional, padrão2.0) — Coeficiente de clipping para amostragem de importância na auto-destilação.Nonedesativa o clipping. - distillation_add_tail (
bool, opcional, padrãoFalse) — Se deve adicionar um bucket de cauda para a massa de probabilidade não top-k.
Parâmetros que controlam o teacher
- teacher_model_kind (
str, opcional, padrão"ema") — Escolha do professor semântico.baseusa o aluno inicial,liveusa o aluno atual eemausa um professor com média exponencial. - teacher_update_rate (
float, opcional, padrão0.05) — Taxa de atualização do teacher usada para a sincronização do teacher EMA. - teacher_sync_steps (
int, opcional, padrão1) — Com que frequência sincronizar o modelo teacher EMA.
Parâmetros que controlam o reprompting
- use_successful_as_teacher (
bool, opcional, padrãoTrue) — Usa rollouts bem-sucedidos como feedback implícito para autodestilação. - success_reward_threshold (
float, opcional, padrão1.0) — Recompensa mínima para que um rollout seja considerado uma demonstração bem-sucedida. - dont_reprompt_on_self_success (
bool, opcional, padrãoTrue) — Pula a reavaliação quando o modelo gera a resposta correta. - max_reprompt_len (
int, opcional, padrão10240) — Comprimento máximo para reprompting em auto-destilação. - reprompt_template (
str, opcional, padrão"{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n") — Modelo para reenviar o prompt ao professor com uma demonstração bem-sucedida. - solution_template (
str, opcional, padrão"\nCorrect solution -- \n\n{successful_previous_attempt}\n\n"): Modelo para formatar o texto da demonstração bem-sucedida. - feedback_template (
str, opcional, padrão"\nThe following is feedback from your unsuccessful earlier attempt -- \n\n{feedback_raw}\n\n"): Modelo para formatar o feedback do ambiente para reenvio de prompt. - include_environment_feedback (
bool, opcional, padrãoFalse) — Se deve incluir feedback do ambiente nos reprompts do professor quando disponível. - environment_feedback_only_without_solution (
bool, opcional, padrãoFalse) — Se deve usar apenas o feedback quando não há uma solução bem-sucedida disponível. - remove_thinking_from_demonstration (
bool, opcional, padrãoFalse) — Se deve remover blocos <think>…</think> do texto da demonstração.
Parâmetros que controlam os diagnósticos
- diagnostics_warning_interval (
int, opcional, padrão10) — Emite diagnósticos repetidos do trainer a cada N passos degenerados consecutivos. Defina como 0 para desativar. - diagnostics_flat_tolerance (
float, opcional, padrão1e-8) — Tolerância usada para decidir se a variância da recompensa ou a atividade de reprompt é efetivamente zero.
Parâmetros que controlam o modelo
- model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave paratransformers.AutoModelForCausalLM.from_pretrained, usados quando o argumentomodeldoSDPOTraineré fornecido como uma string. O valor derevisiontambém é usado ao carregar as classes 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. Também aplicado a cargas de reward-model e reward-tokenizer. - disable_dropout (
bool, opcional, padrãoTrue) — Se deve desabilitar o dropout no modelo. Isso é útil para treinar com um modelo de referência, pois impede que o modelo gere logprobs diferentes para a mesma entrada.
Parâmetros que controlam o pré-processamento de dados
- remove_unused_columns (
bool, opcional, padrãoFalse) — Se deve manter apenas a coluna ‘prompt’ no conjunto de dados. Se você usar uma função de recompensa personalizada que requer qualquer coluna além de ‘prompts’ e ‘completions’, deve manter isso comoFalse. - max_prompt_length (
int, opcional, padrão512) — Comprimento máximo do prompt. Prompts mais longos são truncados pela esquerda. - shuffle_dataset (
bool, opcional, padrãoTrue) — Se deve embaralhar o conjunto de dados de treinamento.
Parâmetros que controlam a geração
- num_generations (
int, opcional, padrão8) — Número de gerações a amostrar. O tamanho efetivo do lote (num_processes per_device_batch_size gradient_accumulation_steps) deve ser divisível por este valor. - num_generations_eval (
int, opcional) — Número de gerações a amostrar durante a avaliação. Isso permite usar menos gerações durante a avaliação para economizar computação. SeNone, usa o valor denum_generations. - max_completion_length (
int, opcional, padrão256) — Comprimento máximo da conclusão gerada. - temperature (
float, opcional, padrão1.0) — Temperatura para amostragem. Quanto maior a temperatura, mais aleatórias são as conclusões. - top_p (
float, opcional, padrão1.0) — Float 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ão0) — Número de tokens do vocabulário com maior probabilidade a serem mantidos para o filtro top-k. Se0, 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 a 0.2. - repetition_penalty (
float, opcional, padrão1.0) — Float 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 novos tokens, 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 aoGenerationConfig(se estiver usando transformers) ou aoSamplingParams(se estiver usando vLLM) ao amostrar as conclusões. Isso pode ser usado para personalizar ainda mais o comportamento da geração, como definirsuppress_tokens,num_beams, etc. Se contiver chaves que conflitam com os outros parâmetros de geração (comomin_p,top_p, etc.), eles os sobrescreverão. - chat_template_kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave adicionais para passar à funçãoapply_chat_templateao gerar completions. - ds3_gather_for_generation (
bool, opcional, padrãoTrue) — 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 do vLLM.
Parâmetros que controlam a aceleração da geração com vLLM
- use_vllm (
bool, opcional, padrãoFalse) — Se deve usar o vLLM para gerar completions. Se definido comoTrue, o trainer usará o vLLM para geração em vez do padrão model.generate(). Requer quevllmesteja instalado. - use_teacher_server (
bool, opcional, padrãoFalse) — Calcula os logprobs do teacher a partir do servidor de geração vLLM em execução, em vez de um forward local do teacher. Suportado apenas parateacher_model_kind='live'comuse_vllm=True,vllm_mode='server',distillation_weight=1.0(destilação pura) edistillation_modeem {‘sampled_token’, ‘topk_logits’} (o servidor retorna os top-k logprobs do teacher, não o vocabulário completo;topk_logitsdestila sobre o suporte top-k do próprio teacher). - vllm_mode (
str, opcional, padrão"colocate") — Modo a ser usado para a integração com o vLLM quandouse_vllmestá definido comoTrue. 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 comvllm 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_model_impl (
str, opcional, padrão"vllm") — Implementação do modelo a ser usada para o vLLM. Deve ser uma detransformersouvllm.transformers: Use o backendtransformerspara a implementação do modelo.vllm: Use a bibliotecavllmpara a implementação do modelo. - vllm_enable_sleep_mode (
bool, opcional, padrãoFalse) — 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 acordar o mecanismo adiciona latência de transferência entre host e dispositivo. - vllm_server_base_url (
str, opcional) — URL base para o servidor vLLM (por exemplo, ‘http://localhost:8000’). Se fornecida,vllm_server_hostevllm_server_portsã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ão8000) — Porta do servidor vLLM para conexão. Ignorado se vllm_server_base_url for fornecido. - vllm_group_port (
int, opcional, padrão51216) — 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 há necessidade de alterá-la. - vllm_server_timeout (
float, opcional, padrão240.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, umConnectionErrorserá lançado. - vllm_tensor_parallel_size (
int, opcional, padrão1) — Controla o tamanho da paralelização de tensor para o vLLM. Esta configuração só se aplica quandovllm_modeestá definido como'colocate'. Se você estiver usandovllm_mode='server', este parâmetro deve ser passado separadamente ao iniciar o servidor vLLM por meio da flag--vllm_tensor_parallel_size. - vllm_gpu_memory_utilization (
float, opcional, padrão0.3) — Controla a utilização de memória de GPU para o vLLM. Esta configuração só se aplica quandovllm_modeestá definido como'colocate'. Se você estiver usandovllm_mode='server', este parâmetro deve ser passado separadamente ao iniciar o servidor vLLM por meio da flag--vllm_gpu_memory_utilization. - vllm_max_model_length (
int, opcional) — Janela de contexto para o vLLM. Defina-a com pelo menos o comprimento máximo do prompt no conjunto de dados maismax_completion_length; se omitida, ela é inferida a partir da configuração do modelo.
Parâmetros que controlam o treinamento
- loss_type (
str, opcional, padrão"dapo") — Especifica a formulação de perda a ser utilizada. Os valores suportados são ‘grpo’, ‘bnpo’, ‘dr_grpo’ e ‘dapo’. ‘grpo’: Agrega as perdas no nível de token normalizando pelo comprimento da sequência. Não é recomendado devido ao viés de comprimento—essa abordagem tende a favorecer conclusões mais curtas com vantagens positivas e mais longas com vantagens negativas. ‘dapo’ (padrão): Agrega as perdas no nível de token normalizando pelo número de tokens ativos no lote acumulado global. Este método foi introduzido no paper DAPO para eliminar o viés de comprimento. ‘dr_grpo’: Agrega as perdas no nível de token normalizando por uma constante global. Este método foi introduzido no paper Dr. GRPO para eliminar o viés de comprimento. O valor da constante corresponde amax_completion_length. ‘bnpo’: Agrega as perdas no nível de token normalizando pelo número de tokens ativos no lote local. Observe que a normalização é realizada apenas sobre o lote local, portanto os resultados podem variar ligeiramente dependendo do tamanho do lote local, apesar de um tamanho de lote efetivo constante. Ao usarper_device_train_batch_size==1, a perda é equivalente à perda do GRPO. - num_iterations (
int, opcional, padrão1) — Número de iterações por lote (denotado como μ no algoritmo). - generation_batch_size (
int, opcional) — Tamanho do lote a ser usado para a geração. Se forNone, o valor padrão é o tamanho efetivo do lote de treinamento:per_device_train_batch_size * num_processes * steps_per_generation. - steps_per_generation (
int, opcional) — Número de etapas por geração. SeNone, o valor padrão égradient_accumulation_steps. - mask_truncated_completions (
bool, opcional, padrãoFalse) — Quando habilitado, as conclusões truncadas são excluídas do cálculo da perda, evitando que sejam penalizadas incorretamente e introduzam ruído durante o treinamento. De acordo com o paper DAPO, essa é uma boa prática para a estabilidade do treinamento.
Classe de configuração para o experimental.sdpo.SDPOTrainer.
SDPOTrainer
classe trl.experimental.sdpo.SDPOTrainer
< source >( model: typing.Union[str, transformers.modeling_utils.PreTrainedModel, torch.nn.Module]reward_funcs: typing.Any | list[typing.Any] | None = Noneargs: trl.experimental.sdpo.sdpo_config.SDPOConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonereward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)peft_config = None )
Trainer para Otimização de Política por Auto-Destilação (SDPO).
O SDPO amplia a otimização on-policy com auto-destilação a partir das próprias trajetórias de alta recompensa do modelo. Ele converte o feedback tokenizado em um sinal de aprendizado denso, sem nenhum professor externo ou modelo de recompensa explícito. O SDPO trata o modelo atual, condicionado ao feedback, como um auto-professor e destila suas previsões de próximo token informadas pelo feedback de volta para a política.
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.