TRL documentation
SDPO
SDPO
Self-Distillation Policy Optimization (SDPO) fue introducida en 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 y Andreas Krause.
Los grandes modelos de lenguaje se están entrenando cada vez más con aprendizaje por refuerzo en dominios verificables, como el código y las matemáticas. Sin embargo, los métodos actuales para el aprendizaje por refuerzo con recompensas verificables (RLVR) solo aprenden de una recompensa de resultado escalar por intento, lo que crea un cuello de botella grave en la asignación de crédito. Muchos entornos verificables proporcionan de hecho una retroalimentación textual rica, como errores de tiempo de ejecución o evaluaciones de un juez, que explican por qué un intento falló. Formalizamos este escenario como aprendizaje por refuerzo con retroalimentación rica e introducimos Self-Distillation Policy Optimization (SDPO), que convierte la retroalimentación tokenizada en una señal de aprendizaje densa sin ningún maestro externo o modelo de recompensa explícito. SDPO trata al modelo actual condicionado a la retroalimentación como un auto-maestro y destila sus predicciones del siguiente token informadas por la retroalimentación de vuelta a la política. De esta manera, SDPO aprovecha la capacidad del modelo para identificar retrospectivamente sus propios errores en el contexto. En razonamiento científico, uso de herramientas y programación competitiva en LiveCodeBench v6, SDPO mejora la eficiencia de muestreo y la precisión final en comparación con líneas base fuertes de RLVR. Notablemente, SDPO también supera a las líneas base en entornos estándar de RLVR que solo devuelven retroalimentación escalar, utilizando los despliegues exitosos como retroalimentación implícita para los intentos fallidos. Finalmente, aplicar SDPO a preguntas individuales en tiempo de prueba acelera el descubrimiento en tareas de recompensa binaria difíciles, logrando la misma probabilidad de descubrimiento que el muestreo best-of-k o las conversaciones de múltiples turnos con 3x menos intentos.
Cómo funciona
SDPO se centra en el aprendizaje por refuerzo con recompensas verificables (RLVR), donde cada intento produce solo una recompensa escalar dispersa. Convierte esto en una señal densa a nivel de token: para cada prompt, la política muestrea num_generations finalizaciones puntuadas por reward_funcs, un rollout exitoso (junto con la retroalimentación opcional de privileged_context) se convierte en un reprompt del teacher, y la distribución del teacher sobre una finalización, informada por la retroalimentación, se destila de vuelta en la política. El teacher y el student son la misma red, por lo que no se necesita un teacher externo ni un modelo de recompensas más allá del verificador.
Modos de pérdida y el modelo maestro
distillation_weight controla cómo se combinan las dos señales como una combinación convexa: la pérdida es (1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss. 1.0 (el valor predeterminado) entrena únicamente con la pérdida de autodestilación, 0.0 vuelve al gradiente de política estándar de estilo GRPO, y los valores intermedios mezclan ambos. El objetivo de destilación en sí lo define distillation_mode: "sampled_token" (el valor predeterminado) utiliza una KL inversa a nivel de token y requiere distillation_alpha=1.0, mientras que "full_logits" y "topk_logits" destilan sobre el vocabulario completo o los distillation_topk principales.
teacher_model_kind elige los pesos del modelo maestro: "ema" (el valor predeterminado) sigue al estudiante mediante una media móvil exponencial sincronizada cada teacher_sync_steps pasos con una tasa de teacher_update_rate, "live" reutiliza directamente el estudiante actual y "base" congela los pesos iniciales. El reenvío de consultas lo controlan use_successful_as_teacher, success_reward_threshold, dont_reprompt_on_self_success y las cadenas reprompt_template / solution_template / feedback_template. La generación se ejecuta a través de transformers de forma predeterminada, o mediante vLLM (modo colocate o modo servidor) cuando use_vllm=True.
Columnas de datos esperadas
Cada ejemplo debe proporcionar:
prompt: el prompt dirigido al estudianteprivileged_context: texto privilegiado opcional, como la retroalimentación del entorno, utilizado cuandoinclude_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()SDPO siempre requiere una columna prompt. Para usar la retroalimentación del entorno, también incluya una columna privileged_context y establezca include_environment_feedback=True. SDPO usará los despliegues exitosos y, cuando esté habilitado, ese texto para construir reprompts del maestro para la autodestilación.
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 = 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",
)Al usar el servidor de maestro:
use_vllm=Trueyvllm_mode="server"son obligatoriosteacher_model_kinddebe ser"live"(el servidor mantiene los pesos actuales del estudiante)distillation_weightdebe ser1.0(destilación pura; una mezcla convexa con la pérdida de la política requiere los logits de todo el vocabulario)distillation_modedebe 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 quetopk_logitsdestila 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_logitsno está disponible.
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 incluyeprompt_ids,completion_idsyold_per_token_logpscuando 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 incluyegenerate_everyysteps_per_generation.
Hook específico de SDPO:
on_teacher_context_built: se dispara después de que SDPO construya las entradas condicionadas por el teacher. El payload incluyeteacher_input_ids,teacher_attention_mask,completion_maskyself_distillation_mask.
Script de ejemplo
Use examples/sdpo_math/sdpo_math.py para iniciar el entrenamiento de SDPO desde la línea de comandos. El script admite recompensas matemáticas verificables, retroalimentación del entorno mediante --feedback_column y PEFT/LoRA a través de las banderas estándar 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
clase 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 = 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 = 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 controlan el objetivo de la política en línea
- beta (
float, opcional, valor predeterminado0.0) — Coeficiente KL. Si es0.0(predeterminado), el modelo de referencia no se carga, lo que reduce el uso de memoria y mejora la velocidad de entrenamiento. DeepSeek-R1 incentiviza el razonamiento en LLMs mediante el aprendizaje por refuerzo utiliza un valor de0.001. - epsilon (
float, opcional, valor predeterminado0.2) — Valor para el recorte. - epsilon_high (
float, opcional) — Valor superior de epsilon para el recorte. Si no se especifica, toma por defecto el mismo valor que el límite inferior especificado en el argumentoepsilon. El paper DAPO recomienda0.28. - importance_sampling_level (
str, opcional, valor predeterminado"token") — Controla si las proporciones de muestreo de importancia se calculan a nivel de'token'o de'sequence'.'token'mantiene las proporciones crudas de log-probabilidad por token (un peso por token).'sequence'promedia las proporciones de log-probabilidad entre los tokens válidos para producir una única proporción por secuencia. El artículo de GSPO muestra que el muestreo a nivel de secuencia suele producir un entrenamiento más estable y una mejor alineación con las recompensas a nivel de secuencia. - reward_weights (
list[float], opcional) — Pesos para cada función de recompensa. Debe coincidir con el número de funciones de recompensa. Si esNone, todas las recompensas se ponderan por igual con un peso de1.0. - scale_rewards (
strobool, opcional, valor predeterminado"group") — Especifica la estrategia de escalado para las recompensas. Los valores admitidos son:Trueo'group'(predeterminado): las recompensas se escalan por la desviación estándar dentro de cada grupo, garantizando una varianza unitaria dentro de un grupo.'batch': las recompensas se escalan por la desviación estándar de todo el lote, tal como se recomienda en el artículo PPO Lite.Falseo'none': no se aplica ningún escalado. El artículo Dr. GRPO recomienda no escalar las recompensas, ya que el escalado por la desviación estándar introduce un sesgo de dificultad a nivel de pregunta.
Parámetros que controlan la pérdida de SDPO
- distillation_weight (
float, opcional, valor predeterminado1.0) — Peso de la combinación convexa entre los objetivos de política y de auto-destilación. La pérdida es(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss. Debe estar en[0, 1].1.0(valor predeterminado) entrena puramente con auto-destilación,0.0vuelve al gradiente de política estándar de estilo GRPO, y los valores intermedios combinan ambos. - distillation_alpha (
float, opcional, valor predeterminado1.0) — Coeficiente de interpolación de divergencia. El SDPO de tokens muestreados requiere la configuración oficial de KL inversadistillation_alpha=1.0. - distillation_mode (
Literal["sampled_token", "full_logits", "topk_logits"], opcional, valor predeterminado"sampled_token") — Modo del objetivo de destilación.sampled_tokenes el modo SDPO predeterminado y requieredistillation_alpha=1.0. - distillation_topk (
int, opcional) — Aproximación top-k para SDPO a nivel de logits. Debe establecerse cuandodistillation_mode=topk_logitsy dejarse sin establecer en caso contrario. - distillation_is_clip (
float, opcional, valor predeterminado2.0) — Coeficiente de recorte para el muestreo de importancia en la autodestilación.Nonedesactiva el recorte. - distillation_add_tail (
bool, opcional, valor predeterminadoFalse) — Si se debe agregar un cubo de cola para la masa de probabilidad no top-k.
Parámetros que controlan al maestro
- teacher_model_kind (
str, opcional, valor predeterminado"ema") — Selección semántica del modelo maestro.baseutiliza el estudiante inicial,liveutiliza el estudiante actual yemautiliza un maestro con promedio exponencial. - teacher_update_rate (
float, opcional, valor predeterminado0.05) — Tasa de actualización del teacher utilizada para la sincronización del teacher EMA. - teacher_sync_steps (
int, opcional, valor predeterminado1) — Frecuencia con la que se sincroniza el modelo teacher EMA.
Parámetros que controlan la repetición de prompts
- use_successful_as_teacher (
bool, opcional, valor predeterminadoTrue) — Usa los despliegues exitosos como retroalimentación implícita para la autodestilación. - success_reward_threshold (
float, opcional, valor predeterminado1.0) — Recompensa mínima para que un rollout se considere una demostración exitosa. - dont_reprompt_on_self_success (
bool, opcional, valor predeterminadoTrue) — Omite la solicitud de nueva respuesta cuando el modelo genera una respuesta correcta. - max_reprompt_len (
int, opcional, valor predeterminado10240) — Longitud máxima para el reprompting en autodistilación. - reprompt_template (
str, opcional, por defecto"{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n") — Plantilla para volver a solicitar al docente una demostración exitosa. - solution_template (
str, opcional, por defecto"\nCorrect solution -- \n\n{successful_previous_attempt}\n\n"): Plantilla para formatear el texto de la demostración exitosa. - feedback_template (
str, opcional, por defecto"\nThe following is feedback from your unsuccessful earlier attempt -- \n\n{feedback_raw}\n\n"): Plantilla para formatear la retroalimentación del entorno para volver a solicitar. - include_environment_feedback (
bool, opcional, valor predeterminadoFalse) — Si se debe incluir la retroalimentación del entorno en los reprompts del docente cuando está disponible. - environment_feedback_only_without_solution (
bool, opcional, valor predeterminadoFalse) — Si se debe usar solo el feedback cuando no hay una solución exitosa disponible. - remove_thinking_from_demonstration (
bool, opcional, valor predeterminadoFalse) — Si se deben eliminar los bloques <think>…</think> del texto de la demostración.
Parámetros que controlan los diagnósticos
- diagnostics_warning_interval (
int, opcional, valor predeterminado10) — Emite diagnósticos repetidos del entrenador cada N pasos degenerados consecutivos. Establece 0 para desactivarlo. - diagnostics_flat_tolerance (
float, opcional, valor predeterminado1e-8) — Tolerancia utilizada para determinar si la varianza de la recompensa o la actividad de reprompt es efectivamente cero.
Parámetros que controlan el modelo
- model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave paratransformers.AutoModelForCausalLM.from_pretrained, utilizados cuando el argumentomodeldeSDPOTrainerse proporciona como una cadena. El valor derevisiontambién se utiliza al cargar las clases de procesamiento. - trust_remote_code (
bool, opcional, valor predeterminadoFalse) — 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. También se aplica a la carga de modelos de recompensa y tokenizadores de recompensa. - disable_dropout (
bool, opcional, valor predeterminadoTrue) — Si se desactiva el dropout en el modelo. Esto es útil para el entrenamiento con un modelo de referencia, ya que evita que el modelo genere logprobs diferentes para la misma entrada.
Parámetros que controlan el preprocesamiento de datos
- remove_unused_columns (
bool, opcional, valor predeterminadoFalse) — Si se debe conservar únicamente la columna ‘prompt’ en el conjunto de datos. Si utiliza una función de recompensa personalizada que requiere cualquier columna distinta de ‘prompts’ y ‘completions’, debe mantener este valor enFalse. - max_prompt_length (
int, opcional, valor predeterminado512) — Longitud máxima del prompt. Los prompts más largos se recortan desde la izquierda. - shuffle_dataset (
bool, opcional, valor predeterminadoTrue) — Si se debe barajar el conjunto de datos de entrenamiento.
Parámetros que controlan la generación
- num_generations (
int, opcional, valor predeterminado8) — 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 esNone, usa el valor denum_generations. - max_completion_length (
int, opcional, valor predeterminado256) — Longitud máxima de la generación completada. - temperature (
float, opcional, valor predeterminado1.0) — Temperatura para el muestreo. A mayor temperatura, más aleatorias son las completaciones. - top_p (
float, opcional, valor predeterminado1.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 predeterminado0) — Número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k. Si es0, 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 predeterminado1.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 aGenerationConfig(si se usa transformers) oSamplingParams(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 establecersuppress_tokens,num_beams, etc. Si contiene claves que entran en conflicto con los otros parámetros de generación (comomin_p,top_p, etc.), los sobrescribirán. - chat_template_kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave adicionales para pasar a la funciónapply_chat_templateal generar las completaciones. - ds3_gather_for_generation (
bool, opcional, valor predeterminadoTrue) — 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 predeterminadoFalse) — Si se usa vLLM para generar completions. Si se establece enTrue, el trainer usará vLLM para la generación en lugar del método predeterminado model.generate(). Requiere quevllmesté instalado. - use_teacher_server (
bool, opcional, valor predeterminadoFalse) — 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 conteacher_model_kind='live'yuse_vllm=True,vllm_mode='server',distillation_weight=1.0(destilación pura) ydistillation_modeen {‘sampled_token’, ‘topk_logits’} (el servidor devuelve los logprobs top-k del maestro, no el vocabulario completo;topk_logitsdestila sobre el soporte top-k propio del maestro). - vllm_mode (
str, opcional, valor predeterminado"colocate") — Modo a utilizar para la integración de vLLM cuandouse_vllmse establece enTrue. 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 convllm 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 sertransformersovllm.transformers: usa el backendtransformerspara la implementación del modelo.vllm: usa la bibliotecavllmpara la implementación del modelo. - vllm_enable_sleep_mode (
bool, opcional, valor predeterminadoFalse) — 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_hostyvllm_server_portse 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 predeterminado8000) — Puerto del servidor vLLM al que conectarse. Se ignora si se proporciona vllm_server_base_url. - vllm_group_port (
int, opcional, valor predeterminado51216) — 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 predeterminado240.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 unConnectionError. - vllm_tensor_parallel_size (
int, opcional, valor predeterminado1) — Controla el tamaño de paralelismo de tensores para vLLM. Esta configuración solo se aplica cuandovllm_modeestá establecido en'colocate'. Si estás usandovllm_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 predeterminado0.3) — Controla la utilización de la memoria de GPU para vLLM. Esta configuración solo se aplica cuandovllm_modeestá establecido en'colocate'. Si estás usandovllm_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ásmax_completion_length; si se omite, se infiere desde la configuración del modelo.
Parámetros que controlan el entrenamiento
- loss_type (
str, opcional, valor predeterminado"dapo") — Especifica la formulación de pérdida a utilizar. Los valores admitidos son ‘grpo’, ‘bnpo’, ‘dr_grpo’ y ‘dapo’. ‘grpo’: Agrega las pérdidas a nivel de token normalizando sobre la longitud de la secuencia. No se recomienda debido al sesgo de longitud: este enfoque tiende a favorecer las finalizaciones más cortas con ventajas positivas y las más largas con ventajas negativas. ‘dapo’ (predeterminado): Agrega las pérdidas a nivel de token normalizando con el número de tokens activos en el lote acumulado global. Este método se introdujo en el paper de DAPO para eliminar el sesgo de longitud. ‘dr_grpo’: Agrega las pérdidas a nivel de token normalizando con una constante global. Este método se introdujo en el paper de Dr. GRPO para eliminar el sesgo de longitud. El valor de la constante corresponde amax_completion_length. ‘bnpo’: Agrega las pérdidas a nivel de token normalizando con el número de tokens activos en el lote local. Tenga en cuenta que la normalización se realiza solo sobre el lote local, por lo que los resultados pueden variar ligeramente dependiendo del tamaño del lote local, a pesar de un tamaño de lote efectivo constante. Al utilizarper_device_train_batch_size==1, la pérdida es equivalente a la pérdida de GRPO. - num_iterations (
int, opcional, valor predeterminado1) — 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 esNone, 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 esNone, el valor predeterminado esgradient_accumulation_steps. - mask_truncated_completions (
bool, opcional, valor predeterminadoFalse) — Cuando está habilitado, las completas truncadas se excluyen del cálculo de la pérdida, evitando que se penalicen incorrectamente y se introduzca ruido durante el entrenamiento. Según el artículo de DAPO, esta es una buena práctica para la estabilidad del entrenamiento.
Clase de configuración para experimental.sdpo.SDPOTrainer.
SDPOTrainer
clase 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 la Optimización de Políticas mediante Auto-Distilación (SDPO).
SDPO mejora la optimización on-policy mediante auto-destilación a partir de las propias trayectorias de alta recompensa del modelo. Convierte la retroalimentación tokenizada en una señal de aprendizaje densa sin necesidad de un maestro externo ni de un modelo de recompensa explícito. SDPO trata al modelo actual condicionado por la retroalimentación como un auto-maestro y destila sus predicciones del siguiente token informadas por la retroalimentación de vuelta a la política.
entrenar
< 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 (
strobool, opcional) — Si es unastr, ruta local a un punto de control guardado por una instancia anterior deTrainer. Si es unbooly es igual aTrue, carga el último punto de control en args.output_dir guardado por una instancia anterior deTrainer. Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí. - trial (
optuna.Trialodict[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.
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 predeterminadoTrue) — Si la función debe devolver el control solo cuando elgit pushhaya terminado. - token (
str, opcional, valor predeterminadoNone) — 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 esargs.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.