SDFT

El ajuste fino mediante autodistilación (SDFT) se describe en el artículo Self-Distillation Enables Continual Learning de Idan Shenfeld, Mehul Damani, Jonas Hübotter y Pulkit Agrawal.

El aprendizaje continuo, que permite a los modelos adquirir nuevas habilidades y conocimientos sin degradar las capacidades existentes, sigue siendo un desafío fundamental para los modelos de base. Si bien el aprendizaje por refuerzo on-policy puede reducir el olvido, requiere funciones de recompensa explícitas que a menudo no están disponibles. El aprendizaje a partir de demostraciones de expertos, la alternativa principal, está dominado por el ajuste fino supervisado (SFT), que es inherentemente off-policy. Presentamos el Ajuste Fino por Auto-Destilación (SDFT), un método simple que permite el aprendizaje on-policy directamente a partir de demostraciones. SDFT aprovecha el aprendizaje en contexto (in-context learning) al utilizar un modelo condicionado por una demostración como su propio maestro, generando señales de entrenamiento on-policy que preservan las capacidades previas mientras se adquieren nuevas habilidades. En tareas de aprendizaje de habilidades y adquisición de conocimientos, SDFT supera consistentemente a SFT, logrando una mayor precisión en la nueva tarea mientras reduce sustancialmente el olvido catastrófico. En experimentos de aprendizaje secuencial, SDFT permite que un único modelo acumule múltiples habilidades con el tiempo sin regresión en el rendimiento, estableciendo la destilación on-policy como una vía práctica para el aprendizaje continuo a partir de demostraciones.

Cómo funciona

El ajuste fino supervisado simple entrena con el texto de demostración fuera de política, lo que tiende a sobrescribir las capacidades previas. SDFT aprende en su lugar en política: el estudiante genera a partir del prompt simple, un maestro —el mismo modelo al que se le muestra el prompt más el privileged_context del ejemplo— vuelve a puntuar esos tokens, y su distribución condicionada por la demostración se destila de vuelta en el estudiante. El maestro y el estudiante son una sola red que difiere solo en lo que ven, creando un bucle de destilación autoreferencial.

Elegir el modelo maestro

teacher_model_kind selecciona qué copia del modelo actúa como maestro. "base" (el valor predeterminado) congela los pesos iniciales como una referencia fija, en concordancia con el artículo; "live" reutiliza el estudiante actual para un auto-maestro sin retardo; "ema" mantiene una media móvil exponencial, resincronizada cada teacher_sync_steps pasos con una tasa de teacher_update_rate. Bajo PEFT, "base" se obtiene deshabilitando el adaptador durante la propagación hacia adelante del maestro para recuperar los pesos base, y "ema" con entrenamiento de LoRA puro mantiene la media móvil en un adaptador dedicado "teacher" en lugar de una segunda copia del modelo. "ema" con un modelo PEFT de LoRA no puro (p. ej. modules_to_save o bias) no está soportado, ya que una copia EMA separada no puede coincidir parámetro a parámetro con el estudiante.

Por defecto, el estudiante genera a partir del prompt simple; establezca generate_from_teacher=True para muestrear a partir del prompt condicionado por la demostración, intercambiando la fidelidad on-policy por rollouts de mayor calidad. El objetivo de destilación se define mediante distillation_mode (por defecto "topk_logits", con las alternativas "full_logits" y "sampled_token"), distillation_alpha y distillation_topk; num_loss_tokens_to_skip descarta los tokens iniciales de la finalización de la pérdida. El entrenamiento es solo de texto; la generación se ejecuta a través de transformers por defecto, o vLLM (modo colocate o server) cuando 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 generar desde el prompt condicionado por el teacher en lugar del prompt del student, establezca generate_from_teacher=True. Para personalizar cómo se construye el prompt del teacher, establezca teacher_prompt_template en experimental.sdft.SDFTConfig.

Servir el modelo maestro desde el servidor vLLM

Con teacher_model_kind="live", el modelo maestro es el estudiante actual, cuyos pesos ya mantiene el servidor de vLLM (se sincronizan para la generación en cada paso). Establece use_teacher_server=True para puntuar las log-probabilidades del maestro en ese mismo servidor, en lugar de ejecutar un paso de propagación hacia adelante de un maestro local separado, eliminando así al maestro por completo del paso de entrenamiento:

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",
)

Al usar el servidor de maestro:

use_vllm=True y vllm_mode="server" son obligatorios
teacher_model_kind debe ser "live" (el servidor mantiene los pesos actuales del estudiante)
distillation_mode debe ser "sampled_token" (KL inversa sobre el token realizado) o "topk_logits". El servidor devuelve los log-probs top-k propios del teacher, por lo que topk_logits destila sobre el soporte top-k del teacher (no puede usar el del student, a diferencia del objetivo local); con un teacher "live", los dos soportes coinciden casi por completo. full_logits no está disponible.

Columnas de datos esperadas

Cada ejemplo debe proporcionar:

prompt: el prompt dirigido al estudiante
privileged_context: solo la información adicional exclusiva del profesor, como una demostración, una pista o una retroalimentación privilegiada

Tanto los prompts de texto estándar como los prompts conversacionales son compatibles con el manejo de prompts del trainer.

Callbacks

El trainer emite un pequeño conjunto de hooks de callback que resultan útiles para depuración, observabilidad y pruebas. Estos hooks están diseñados como puntos de integración prácticos para flujos de trabajo experimentales de autodestilación.

Ganchos de auto-destilación compartidos:

on_self_distillation_batch_prepared: se dispara cuando un lote de autodestilación está listo. La carga incluye prompt_ids, completion_ids y old_per_token_logps cuando están disponibles las entradas para el recorte de muestreo por importancia.
on_generation_batch_built: se dispara cuando se crea un nuevo lote de generación con búfer. La carga incluye generate_every y steps_per_generation.

Hook específico de SDFT:

on_generation_prompts_selected: se dispara cuando SDFT elige la fuente de prompts para la generación on-policy. El payload incluye los generation_prompts seleccionados y el generation_prompt_text correspondiente.

Script de ejemplo

Use examples/sdft_privileged_context/sdft_privileged_context.py para iniciar el entrenamiento de SDFT desde la línea de comandos. El script admite cualquier LM causal del Hub, conjuntos de datos locales personalizados mediante --dataset_path y PEFT/LoRA a través de las banderas estándar 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

La implementación original está disponible en idanshen/Self-Distillation.

SDFTConfig

clase 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 controlan la pérdida de SDFT

distillation_alpha (float, opcional, valor predeterminado 0.5) — Coeficiente de interpolación de divergencia para la destilación de logits top-k de SDFT.
distillation_mode (Literal["sampled_token", "full_logits", "topk_logits"], opcional, valor predeterminado "topk_logits") — Modo del objetivo de destilación. SDFT usa destilación de logits top-k por defecto.
distillation_topk (int, opcional, valor predeterminado 100) — Número de tokens superiores utilizados por el objetivo de logit top-k predeterminado de SDFT.
distillation_is_clip (float, opcional, valor predeterminado 2.0) — Coeficiente de recorte para el muestreo de importancia en la autodestilación. None desactiva el recorte.
distillation_add_tail (bool, opcional, valor predeterminado False) — Si se debe agregar un cubo de cola para la masa de probabilidad no top-k.
num_loss_tokens_to_skip (int, opcional, valor predeterminado 0) — Número de tokens iniciales de la finalización que se excluirán de la pérdida de destilación.

Parámetros que controlan al maestro

teacher_model_kind (str, opcional, valor predeterminado "base") — Selección semántica del modelo maestro para SDFT. base utiliza el estudiante inicial, live utiliza el estudiante actual y ema utiliza un maestro con promedio exponencial.
teacher_update_rate (float, opcional, valor predeterminado 0.05) — Tasa de actualización EMA utilizada cuando teacher_model_kind="ema". Un valor de 1.0 reduce la actualización a una sobrescritura directa, resincronizando periódicamente al modelo maestro con los pesos actuales del modelo estudiante.
teacher_sync_steps (int, opcional, valor predeterminado 1) — Número de pasos del optimizador entre actualizaciones del modelo maestro.

Parámetros que controlan la generación condicionada por el modelo maestro

generate_from_teacher (bool, opcional, valor predeterminado False) — Si la generación on-policy debe usar el prompt condicionado por el teacher en lugar del prompt del student.
teacher_prompt_template (str, opcional, por defecto "{prompt}\n\n{privileged_context}") — Plantilla utilizada para combinar el prompt del estudiante y el contexto privilegiado en el prompt del teacher.

Parámetros que controlan el modelo

model_init_kwargs (dict[str, Any], opcional) — Argumentos de palabra clave para transformers.AutoModelForCausalLM.from_pretrained, utilizados cuando el argumento model del SDFTTrainer se proporciona como una cadena. El valor de revision también se utiliza al cargar la clase de procesamiento.
trust_remote_code (bool, opcional, valor predeterminado False) — Si se permite cargar modelos y tokenizadores que incluyen código Python personalizado desde el Hub. Se reenvía a from_pretrained y from_pretrained, tanto para el estudiante como para el profesor.
disable_dropout (bool, opcional, valor predeterminado True) — Si se desactiva el dropout en los modelos de estudiante y profesor.

Parámetros que controlan el preprocesamiento de datos

remove_unused_columns (bool, opcional, valor predeterminado False) — Indica si se deben conservar únicamente las columnas necesarias para el entrenador en el conjunto de datos. Mantenga este valor en False si proporciona columnas adicionales (como privileged_context) que el entrenador necesita.
max_prompt_length (int, opcional, valor predeterminado 512) — Longitud máxima del prompt. Los prompts más largos se recortan desde la izquierda.
shuffle_dataset (bool, opcional, valor predeterminado True) — Si se debe barajar el conjunto de datos de entrenamiento.

Parámetros que controlan la generación

num_generations (int, opcional, valor predeterminado 8) — Número de generaciones a muestrear. El tamaño de lote efectivo (num_processes per_device_batch_size gradient_accumulation_steps) debe ser divisible exactamente por este valor.
num_generations_eval (int, opcional) — Número de generaciones para muestrear durante la evaluación. Esto permite usar menos generaciones durante la evaluación para ahorrar cómputo. Si es None, usa el valor de num_generations.
max_completion_length (int, opcional, valor predeterminado 256) — Longitud máxima de la generación completada.
temperature (float, opcional, valor predeterminado 1.0) — Temperatura para el muestreo. A mayor temperatura, más aleatorias son las completaciones.
top_p (float, opcional, valor predeterminado 1.0) — Flotante que controla la probabilidad acumulada de los tokens superiores a considerar. Debe estar en (0, 1]. Establecerlo en 1.0 para considerar todos los tokens.
top_k (int, opcional, valor predeterminado 0) — Número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k. Si es 0, el filtrado top-k se desactiva y se consideran todos los tokens.
min_p (float, opcional) — Probabilidad mínima del token, que se escala por la probabilidad del token más probable. Debe ser un valor entre 0.0 y 1.0. Los valores típicos están en el rango de 0.01 a 0.2.
repetition_penalty (float, opcional, valor predeterminado 1.0) — Flotante que penaliza los nuevos tokens en función de si aparecen en el prompt y en el texto generado hasta el momento. Los valores > 1.0 animan al modelo a usar tokens nuevos, mientras que los valores < 1.0 animan al modelo a repetir tokens.
cache_implementation (str, opcional) — Implementación del método de caché para una generación más rápida cuando use_vllm está establecido en False.
generation_kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales para pasar a GenerationConfig (si se usa transformers) o SamplingParams (si se usa vLLM) al muestrear las completaciones. Esto se puede usar para personalizar aún más el comportamiento de la generación, como establecer suppress_tokens, num_beams, etc. Si contiene claves que entran en conflicto con los otros parámetros de generación (como min_p, top_p, etc.), los sobrescribirán.
chat_template_kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales para pasar a la función apply_chat_template al generar las completaciones.
ds3_gather_for_generation (bool, opcional, valor predeterminado True) — Esta configuración se aplica a DeepSpeed ZeRO-3. Si está habilitada, los pesos del modelo de política se recogen para la generación, mejorando la velocidad de generación. Sin embargo, deshabilitar esta opción permite entrenar modelos que superan la capacidad de VRAM de una sola GPU, aunque a costa de una generación más lenta. Deshabilitar esta opción no es compatible con la generación de vLLM.

Parámetros que controlan la aceleración de la generación impulsada por vLLM

use_vllm (bool, opcional, valor predeterminado False) — Si se usa vLLM para generar completions. Si se establece en True, el trainer usará vLLM para la generación en lugar del método predeterminado model.generate(). Requiere que vllm esté instalado.
use_teacher_server (bool, opcional, valor predeterminado False) — Calcula los logprobs del modelo maestro desde el servidor de generación vLLM en ejecución en lugar de una pasada local del maestro. Solo se admite para teacher_model_kind='live' con use_vllm=True y vllm_mode='server', y distillation_mode en {‘sampled_token’, ‘topk_logits’} (el servidor devuelve los logprobs top-k del maestro, no el vocabulario completo; topk_logits destila sobre el propio soporte top-k del maestro).
vllm_mode (str, opcional, valor predeterminado "colocate") — Modo a utilizar para la integración de vLLM cuando use_vllm se establece en True. Debe ser uno de 'server' o 'colocate'. 'server': El entrenador enviará solicitudes de generación a un servidor vLLM separado. Asegúrese de que un servidor vLLM esté en ejecución (inícielo con vllm serve). 'colocate': vLLM se ejecutará en el mismo proceso y compartirá las GPU de entrenamiento. Esto evita la necesidad de un servidor separado, pero puede causar contención de recursos con el entrenamiento.
vllm_model_impl (str, opcional, valor predeterminado "vllm") — Implementación del modelo a usar para vLLM. Debe ser transformers o vllm. transformers: usa el backend transformers para la implementación del modelo. vllm: usa la biblioteca vllm para la implementación del modelo.
vllm_enable_sleep_mode (bool, opcional, valor predeterminado False) — Activa el modo de suspensión de vLLM para descargar los pesos y la caché durante el paso del optimizador. Mantiene bajo el uso de memoria de GPU, pero despertar el motor añade latencia de transferencia entre el host y el dispositivo.
vllm_server_base_url (str, opcional) — URL base del servidor vLLM (p. ej., ‘http://localhost:8000’). Si se proporciona, vllm_server_host y vllm_server_port se ignoran.
vllm_server_host (str, opcional, valor predeterminado "0.0.0.0") — Host del servidor vLLM al que conectarse. Se ignora si se proporciona vllm_server_base_url.
vllm_server_port (int, opcional, valor predeterminado 8000) — Puerto del servidor vLLM al que conectarse. Se ignora si se proporciona vllm_server_base_url.
vllm_group_port (int, opcional, valor predeterminado 51216) — Número de puerto para el grupo de actualización de pesos. Se utiliza para comunicarse con el servidor de vLLM. A menos que el puerto esté ocupado, no es necesario cambiarlo.
vllm_server_timeout (float, opcional, valor predeterminado 240.0) — Duración total del tiempo de espera, en segundos, para que el servidor vLLM esté en funcionamiento. Si el servidor no está en funcionamiento después del tiempo de espera, se lanza un ConnectionError.
vllm_tensor_parallel_size (int, opcional, valor predeterminado 1) — Controla el tamaño de paralelismo de tensores para vLLM. Esta configuración solo se aplica cuando vllm_mode está establecido en 'colocate'. Si estás usando vllm_mode='server', este parámetro debe pasarse por separado al iniciar el servidor de vLLM mediante la bandera --vllm_tensor_parallel_size.
vllm_gpu_memory_utilization (float, opcional, valor predeterminado 0.3) — Controla la utilización de la memoria de GPU para vLLM. Esta configuración solo se aplica cuando vllm_mode está establecido en 'colocate'. Si estás usando vllm_mode='server', este parámetro debe pasarse por separado al iniciar el servidor de vLLM mediante la bandera --vllm_gpu_memory_utilization.
vllm_max_model_length (int, opcional) — Ventana de contexto para vLLM. Establézcala al menos en la longitud máxima de los prompts del conjunto de datos más max_completion_length; si se omite, se infiere desde la configuración del modelo.

Parámetros que controlan el entrenamiento

num_iterations (int, opcional, valor predeterminado 1) — Número de iteraciones por lote (denotado como μ en el algoritmo).
generation_batch_size (int, opcional) — Tamaño de lote a utilizar para la generación. Si es None, el valor predeterminado es el tamaño de lote efectivo de entrenamiento: per_device_train_batch_size * num_processes * steps_per_generation.
steps_per_generation (int, opcional) — Número de pasos por generación. Si es None, el valor predeterminado es gradient_accumulation_steps.

Clase de configuración para experimental.sdft.SDFTTrainer.

SDFTTrainer

clase 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 autodistilación on-policy de estilo SDFT con prompts de maestro explícitos.

entrenar

< source >

Parámetros

resume_from_checkpoint (str o bool, opcional) — Si es una str, ruta local a un punto de control guardado por una instancia anterior de Trainer. Si es un bool y es igual a True, carga el último punto de control en args.output_dir guardado por una instancia anterior de Trainer. Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí.
trial (optuna.Trial o dict[str, Any], opcional) — La ejecución del ensayo o el diccionario de hiperparámetros para la búsqueda de hiperparámetros.
ignore_keys_for_eval (list[str], opcional) — Una lista de claves en la salida de tu modelo (si es un diccionario) que deben ignorarse al recopilar predicciones para la evaluación durante el entrenamiento.

Devuelve

~trainer_utils.TrainOutput

Objeto que contiene el número de pasos globales, la pérdida de entrenamiento y las métricas.

Punto de entrada principal del entrenamiento.

save_model

< source >

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

Guardará el modelo, por lo que podrás recargarlo usando from_pretrained().

Solo se guardará desde el proceso 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, valor predeterminado "End of training") — Mensaje para el commit al hacer push.
blocking (bool, opcional, valor predeterminado True) — Si la función debe devolver el control solo cuando el git push haya terminado.
token (str, opcional, valor predeterminado None) — Token con permiso de escritura para sobrescribir los argumentos originales de Trainer.
revision (str, opcional) — La revisión de git desde la que se realizará el commit. Por defecto, es la cabecera de la rama “main”.
private (bool, opcional) — Si se debe hacer el repositorio privado cuando se crea. El valor predeterminado es args.hub_private_repo. No tiene efecto si el repositorio ya existe.
kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan a ~Trainer.create_model_card.

Sube self.model y self.processing_class al hub de modelos de 🤗 en el repositorio self.args.hub_model_id.

Update on GitHub

TRL

SDFT

Cómo funciona

Elegir el modelo maestro

Uso

Servir el modelo maestro desde el servidor vLLM

Columnas de datos esperadas

Callbacks

Script de ejemplo

SDFTConfig

clase trl.experimental.sdft.SDFTConfig

SDFTTrainer

clase trl.experimental.sdft.SDFTTrainer

entrenar

save_model

push_to_hub