TRL documentation

SDPO

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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 aluno
  • privileged_context: texto privilegiado opcional, como feedback do ambiente, usado quando include_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=True e vllm_mode="server" são obrigatórios
  • teacher_model_kind deve ser "live" (o servidor mantém os pesos atuais do aluno)
  • distillation_weight deve ser 1.0 (destilação pura; uma mistura convexa com a perda da política requer os logits de vocabulário completo)
  • distillation_mode deve ser "sampled_token" (KL reversa no token realizado) ou "topk_logits". O servidor retorna os próprios log-probs top-k do teacher, portanto topk_logits destila 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_logits nã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 inclui prompt_ids, completion_ids e old_per_token_logps quando 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 inclui generate_every e steps_per_generation.

Hook específico do SDPO:

  • on_teacher_context_built: disparado após o SDPO construir as entradas condicionadas ao teacher. O payload inclui teacher_input_ids, teacher_attention_mask, completion_mask e self_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 no

SDPOConfig

classe trl.experimental.sdpo.SDPOConfig

< >

( 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ão 0.0) — Coeficiente KL. Se 0.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 de 0.001.
  • epsilon (float, opcional, padrão 0.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 argumento epsilon. O paper DAPO recomenda 0.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. Se None, todas as recompensas são ponderadas igualmente com peso 1.0.
  • scale_rewards (str ou bool, opcional, padrão "group") — Especifica a estratégia de escalonamento para as recompensas. Os valores suportados são: True ou '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. False ou '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ão 1.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.0 retorna ao gradiente de política padrão no estilo GRPO, e valores intermediários misturam ambos.
  • distillation_alpha (float, opcional, padrão 1.0) — Coeficiente de interpolação de divergência. O SDPO de tokens amostrados requer a configuração oficial de reverse-KL distillation_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 requer distillation_alpha=1.0.
  • distillation_topk (int, opcional) — Aproximação top-k para SDPO em nível de logits. Deve ser definido quando distillation_mode=topk_logits e deixado indefinido caso contrário.
  • distillation_is_clip (float, opcional, padrão 2.0) — Coeficiente de clipping para amostragem de importância na auto-destilação. None desativa o clipping.
  • distillation_add_tail (bool, opcional, padrão False) — 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. base usa o aluno inicial, live usa o aluno atual e ema usa um professor com média exponencial.
  • teacher_update_rate (float, opcional, padrão 0.05) — Taxa de atualização do teacher usada para a sincronização do teacher EMA.
  • teacher_sync_steps (int, opcional, padrão 1) — Com que frequência sincronizar o modelo teacher EMA.

Parâmetros que controlam o reprompting

  • use_successful_as_teacher (bool, opcional, padrão True) — Usa rollouts bem-sucedidos como feedback implícito para autodestilação.
  • success_reward_threshold (float, opcional, padrão 1.0) — Recompensa mínima para que um rollout seja considerado uma demonstração bem-sucedida.
  • dont_reprompt_on_self_success (bool, opcional, padrão True) — Pula a reavaliação quando o modelo gera a resposta correta.
  • max_reprompt_len (int, opcional, padrão 10240) — 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ão False) — Se deve incluir feedback do ambiente nos reprompts do professor quando disponível.
  • environment_feedback_only_without_solution (bool, opcional, padrão False) — Se deve usar apenas o feedback quando não há uma solução bem-sucedida disponível.
  • remove_thinking_from_demonstration (bool, opcional, padrão False) — Se deve remover blocos <think>…</think> do texto da demonstração.

Parâmetros que controlam os diagnósticos

  • diagnostics_warning_interval (int, opcional, padrão 10) — Emite diagnósticos repetidos do trainer a cada N passos degenerados consecutivos. Defina como 0 para desativar.
  • diagnostics_flat_tolerance (float, opcional, padrão 1e-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 para transformers.AutoModelForCausalLM.from_pretrained, usados quando o argumento model do SDPOTrainer é fornecido como uma string. O valor de revision também é usado ao carregar as classes de processamento.
  • trust_remote_code (bool, opcional, padrão False) — 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ão True) — 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ão False) — 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 como False.
  • max_prompt_length (int, opcional, padrão 512) — Comprimento máximo do prompt. Prompts mais longos são truncados pela esquerda.
  • shuffle_dataset (bool, opcional, padrão True) — Se deve embaralhar o conjunto de dados de treinamento.

Parâmetros que controlam a geração

  • num_generations (int, opcional, padrão 8) — 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. Se None, usa o valor de num_generations.
  • max_completion_length (int, opcional, padrão 256) — Comprimento máximo da conclusão gerada.
  • temperature (float, opcional, padrão 1.0) — Temperatura para amostragem. Quanto maior a temperatura, mais aleatórias são as conclusões.
  • top_p (float, opcional, padrão 1.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ão 0) — Número de tokens do 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 a 0.2.
  • repetition_penalty (float, opcional, padrão 1.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 ao 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 conflitam com os outros parâmetros de geração (como min_p, top_p, etc.), eles os sobrescreverão.
  • chat_template_kwargs (dict[str, Any], opcional) — Argumentos de palavra-chave adicionais para passar à função apply_chat_template ao gerar completions.
  • 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 do vLLM.

Parâmetros que controlam a aceleração da geração com vLLM

  • use_vllm (bool, opcional, padrão False) — Se deve usar o vLLM para gerar completions. Se definido como True, o trainer usará o vLLM para geração em vez do padrão model.generate(). Requer que vllm esteja instalado.
  • use_teacher_server (bool, opcional, padrão False) — 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 para teacher_model_kind='live' com use_vllm=True, vllm_mode='server', distillation_weight=1.0 (destilação pura) e distillation_mode em {‘sampled_token’, ‘topk_logits’} (o servidor retorna os top-k logprobs do teacher, não o vocabulário completo; topk_logits destila 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 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_model_impl (str, opcional, padrão "vllm") — Implementação do modelo a ser usada para o vLLM. Deve ser uma de 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_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 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_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_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 há necessidade de alterá-la.
  • 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 será lançado.
  • vllm_tensor_parallel_size (int, opcional, padrão 1) — Controla o tamanho da paralelização de tensor para o vLLM. Esta 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_gpu_memory_utilization (float, opcional, padrão 0.3) — Controla a utilização de memória de GPU para o vLLM. Esta 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_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 mais max_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 a max_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 usar per_device_train_batch_size==1, a perda é equivalente à perda do GRPO.
  • num_iterations (int, opcional, padrão 1) — 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 for None, 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. Se None, o valor padrão é gradient_accumulation_steps.
  • mask_truncated_completions (bool, opcional, padrão False) — 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

< >

( 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

< >

( 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 (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 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.

save_model

< >

( output_dir: str | None = None_internal_call: bool = False )

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

Salvará apenas a partir do processo principal.

push_to_hub

< >

( 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ã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 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.

Update on GitHub