SDFT

O Fine-Tuning Auto-Destilado (SDFT) é descrito no artigo Self-Distillation Enables Continual Learning, de Idan Shenfeld, Mehul Damani, Jonas Hübotter e Pulkit Agrawal.

O aprendizado contínuo, que permite aos modelos adquirir novas habilidades e conhecimentos sem degradar as capacidades existentes, permanece um desafio fundamental para os modelos de fundação. Embora o aprendizado por reforço on-policy possa reduzir o esquecimento, ele requer funções de recompensa explícitas que frequentemente estão indisponíveis. O aprendizado a partir de demonstrações de especialistas, a alternativa principal, é dominado pelo ajuste fino supervisionado (SFT), que é inerentemente off-policy. Apresentamos o Self-Distillation Fine-Tuning (SDFT), um método simples que permite o aprendizado on-policy diretamente a partir de demonstrações. O SDFT aproveita o aprendizado in-context ao usar um modelo condicionado por demonstrações como seu próprio professor, gerando sinais de treinamento on-policy que preservam as capacidades anteriores enquanto adquirem novas habilidades. Em tarefas de aprendizado de habilidades e aquisição de conhecimento, o SDFT supera consistentemente o SFT, alcançando maior precisão em novas tarefas enquanto reduz substancialmente o esquecimento catastrófico. Em experimentos de aprendizado sequencial, o SDFT permite que um único modelo acumule múltiplas habilidades ao longo do tempo sem regressão de desempenho, estabelecendo a destilação on-policy como um caminho prático para o aprendizado contínuo a partir de demonstrações.

Como funciona

O ajuste fino supervisionado simples treina no texto de demonstração de forma off-policy, o que tende a sobrescrever as capacidades anteriores. O SDFT aprende de forma on-policy: o aluno gera a partir do prompt simples, um professor — o mesmo modelo que vê o prompt mais o privileged_context do exemplo — reavalia esses tokens, e sua distribuição condicionada à demonstração é destilada de volta para o aluno. Professor e aluno são uma única rede que difere apenas no que veem, criando um loop de destilação self.

Escolhendo o professor

teacher_model_kind seleciona qual cópia do modelo atua como professor. "base" (o padrão) congela os pesos iniciais como uma referência fixa, em conformidade com o artigo; "live" reutiliza o aluno atual para um auto-professor sem atraso; "ema" mantém uma média móvel exponencial, ressincronizada a cada teacher_sync_steps passos com a taxa teacher_update_rate. Sob PEFT, "base" é obtido desativando o adaptador durante o forward do professor para recuperar os pesos base, e "ema" com treinamento pure-LoRA mantém a média móvel em um adaptador dedicado "teacher" em vez de uma segunda cópia do modelo. "ema" com um modelo PEFT não pure-LoRA (por exemplo, modules_to_save ou bias) não é suportado, pois uma cópia EMA separada não pode ter parâmetros correspondentes aos do aluno.

Por padrão, o aluno gera a partir do prompt simples; defina generate_from_teacher=True para amostrar do prompt condicionado à demonstração, trocando a fidelidade on-policy por rollouts de maior qualidade. O objetivo de destilação é definido por distillation_mode (padrão "topk_logits", com as alternativas "full_logits" e "sampled_token"), distillation_alpha e distillation_topk; num_loss_tokens_to_skip exclui os tokens iniciais da conclusão do cálculo da perda. O treinamento é apenas de texto; a geração é executada por meio do transformers por padrão, ou pelo vLLM (modo colocate ou server) quando use_vllm=True.

Uso

from datasets import Dataset

from trl.experimental.sdft import SDFTConfig, SDFTTrainer

dataset = Dataset.from_dict(
    {
        "prompt": [[{"role": "user", "content": "Solve 2+2."}]],
        "privileged_context": ["Example answer: 4."],
    }
)

training_args = SDFTConfig(
    output_dir="sdft-model",
    distillation_alpha=0.5,
    distillation_mode="topk_logits",
    distillation_topk=5,
    max_completion_length=64,
)

trainer = SDFTTrainer(
    model="Qwen/Qwen2.5-1.5B-Instruct",
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

Para gerar a partir do prompt condicionado ao professor em vez do prompt do aluno, defina generate_from_teacher=True. Para personalizar como o prompt do professor é construído, defina teacher_prompt_template em experimental.sdft.SDFTConfig.

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 = SDFTConfig(
    output_dir="sdft-model",
    use_vllm=True,
    vllm_mode="server",
    teacher_model_kind="live",
    use_teacher_server=True,
    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_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.

Colunas esperadas do conjunto de dados

Cada exemplo deve fornecer:

prompt: o prompt voltado para o aluno
privileged_context: apenas as informações extras exclusivas do professor, como uma demonstração, dica ou feedback privilegiado

Tanto prompts de texto padrão quanto prompts conversacionais são suportados pelo tratamento de prompts do trainer.

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 SDFT:

on_generation_prompts_selected: disparado quando o SDFT escolhe a fonte de prompt para a geração on-policy. O payload inclui os generation_prompts selecionados e o generation_prompt_text correspondente.

Script de exemplo

Use examples/sdft_privileged_context/sdft_privileged_context.py para iniciar o treinamento SDFT pela linha de comando. O script suporta qualquer LM causal do Hub, conjuntos de dados locais personalizados via --dataset_path e PEFT/LoRA por meio das flags padrão de ModelConfig.

python examples/sdft_privileged_context/sdft_privileged_context.py \
    --model_name_or_path Qwen/Qwen3.5-0.8B \
    --dataset_name your-org/your-dataset \
    --output_dir outputs/sdft-qwen3.5-0.8b \
    --per_device_train_batch_size 1 \
    --gradient_accumulation_steps 16 \
    --learning_rate 2e-5 \
    --max_prompt_length 1024 \
    --max_completion_length 512 \
    --generate_from_teacher \
    --teacher_model_kind ema \
    --teacher_sync_steps 1 \
    --teacher_update_rate 0.05 \
    --eval_strategy steps \
    --eval_steps 50 \
    --report_to wandb

A implementação original está disponível em idanshen/Self-Distillation.

SDFTConfig

classe trl.experimental.sdft.SDFTConfig

< 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 = Truegradient_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 = 1teacher_model_kind: str = 'base'teacher_update_rate: float = 0.05teacher_sync_steps: int = 1distillation_alpha: float = 0.5distillation_mode: typing.Literal['sampled_token', 'full_logits', 'topk_logits'] = 'topk_logits'distillation_topk: int | None = 100distillation_is_clip: float | None = 2.0distillation_add_tail: bool = Falsegenerate_from_teacher: bool = Falseteacher_prompt_template: str = '{prompt}\n\n{privileged_context}'num_loss_tokens_to_skip: int = 0 )

Parâmetros que controlam a perda SDFT

distillation_alpha (float, opcional, padrão 0.5) — Coeficiente de interpolação de divergência para a destilação de logits top-k do SDFT.
distillation_mode (Literal["sampled_token", "full_logits", "topk_logits"], opcional, padrão "topk_logits") — Modo do objetivo de destilação. O SDFT usa por padrão a destilação de top-k logits.
distillation_topk (int, opcional, padrão 100) — Número de tokens principais usados pelo objetivo de logit top-k padrão do SDFT.
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.
num_loss_tokens_to_skip (int, opcional, padrão 0) — Número de tokens iniciais de conclusão a serem excluídos da perda de destilação.

Parâmetros que controlam o teacher

teacher_model_kind (str, opcional, padrão "base") — Escolha semântica do professor para SDFT. 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 EMA usada quando teacher_model_kind="ema". Um valor de 1.0 reduz a atualização a uma sobrescrita direta, ressincronizando periodicamente o teacher com os pesos atuais do student.
teacher_sync_steps (int, opcional, padrão 1) — Número de passos do otimizador entre atualizações do teacher.

Parâmetros que controlam a geração condicionada ao professor

generate_from_teacher (bool, opcional, padrão False) — Se a geração on-policy deve usar o prompt condicionado ao teacher em vez do prompt do student.
teacher_prompt_template (str, opcional, padrão "{prompt}\n\n{privileged_context}") — Modelo usado para combinar o prompt do aluno e o contexto privilegiado no prompt do professor.

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 SDFTTrainer é fornecido como uma string. O valor de revision também é usado ao carregar a classe 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, para o aluno e o professor.
disable_dropout (bool, opcional, padrão True) — Se deve desabilitar o dropout nos modelos de aluno e professor.

Parâmetros que controlam o pré-processamento de dados

remove_unused_columns (bool, opcional, padrão False) — Se apenas as colunas necessárias para o trainer devem ser mantidas no dataset. Mantenha como False se você fornecer colunas extras (como privileged_context) de que o trainer precisa.
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 e vllm_mode='server', 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 próprio suporte top-k do 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

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.

Classe de configuração para o experimental.sdft.SDFTTrainer.

SDFTTrainer

classe trl.experimental.sdft.SDFTTrainer

< source >

( model: typing.Union[str, transformers.modeling_utils.PreTrainedModel, torch.nn.Module]args: trl.experimental.sdft.sdft_config.SDFTConfig | 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 = 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: PeftConfig | None = None )

Trainer para auto-destilação on-policy no estilo SDFT com prompts de professor explícitos.

treino

< source >

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

< source >

( 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

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

TRL

SDFT

Como funciona

Escolhendo o professor

Uso

Servindo o modelo teacher a partir do servidor vLLM

Colunas esperadas do conjunto de dados

Callbacks

Script de exemplo

SDFTConfig

classe trl.experimental.sdft.SDFTConfig

SDFTTrainer

classe trl.experimental.sdft.SDFTTrainer

treino

save_model

push_to_hub