# SDFT

El ajuste fino mediante autodistilación (SDFT) se describe en el artículo [Self-Distillation Enables Continual Learning](https://huggingface.co/papers/2601.19897) 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 *auto*referencial.

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

```python
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](/docs/trl/main/es/sdft_trainer#trl.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:

```python
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`](https://github.com/huggingface/trl/blob/main/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`.

```bash
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](https://github.com/idanshen/Self-Distillation).

## SDFTConfig[[trl.experimental.sdft.SDFTConfig]]

#### trl.experimental.sdft.SDFTConfig[[trl.experimental.sdft.SDFTConfig]]

```python
trl.experimental.sdft.SDFTConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 5e-05, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool = True, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = False, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | None = None, trust_remote_code: bool = False, disable_dropout: bool = True, max_prompt_length: int | None = 512, num_generations: int = 8, num_generations_eval: int | None = None, max_completion_length: int | None = 256, ds3_gather_for_generation: bool = True, shuffle_dataset: bool = True, generation_batch_size: int | None = None, steps_per_generation: int | None = None, temperature: float = 1.0, top_p: float = 1.0, top_k: int = 0, min_p: float | None = None, generation_kwargs: dict[str, typing.Any] | None = None, chat_template_kwargs: dict[str, typing.Any] | None = None, repetition_penalty: float = 1.0, cache_implementation: str | None = None, use_vllm: bool = False, use_teacher_server: bool = False, vllm_mode: str = 'colocate', vllm_model_impl: str = 'vllm', vllm_enable_sleep_mode: bool = False, vllm_server_base_url: str | None = None, vllm_server_host: str = '0.0.0.0', vllm_server_port: int = 8000, vllm_group_port: int = 51216, vllm_server_timeout: float = 240.0, vllm_tensor_parallel_size: int = 1, vllm_gpu_memory_utilization: float = 0.3, vllm_max_model_length: int | None = None, num_iterations: int = 1, teacher_model_kind: str = 'base', teacher_update_rate: float = 0.05, teacher_sync_steps: int = 1, distillation_alpha: float = 0.5, distillation_mode: typing.Literal['sampled_token', 'full_logits', 'topk_logits'] = 'topk_logits', distillation_topk: int | None = 100, distillation_is_clip: float | None = 2.0, distillation_add_tail: bool = False, generate_from_teacher: bool = False, teacher_prompt_template: str = '{prompt}\n\n{privileged_context}', num_loss_tokens_to_skip: int = 0)
```

[Fuente](https://github.com/huggingface/trl/blob/main/trl/experimental/sdft/sdft_config.py#L24)

**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 por defecto la destilación de top-k logits.

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 autodistilación. `None` desactiva el recorte.

distillation_add_tail (`bool`, *opcional*, valor predeterminado `False`) : Si se debe añadir 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 de completado iniciales 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"`) : Elección del maestro semántico 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 al 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*, valor predeterminado `"{prompt}\n\n{privileged_context}"`) : Plantilla utilizada para combinar el prompt del estudiante y el contexto privilegiado en el prompt del profesor.

**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` de `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](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) y [from_pretrained](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoProcessor.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`) : 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 truncan 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 de la finalización.

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]. Establezca 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 escalará 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 se habilita, los pesos del modelo de política se recopilan para la generación, lo que mejora 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 completaciones. Si se establece en `True`, el entrenador 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 maestro desde el servidor de generación vLLM en ejecución en lugar de una forward 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*, por defecto `"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 trainer 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 GPUs 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`) : Habilita el modo de suspensión de vLLM para descargar los pesos/la caché durante el paso del optimizador. Mantiene bajo el uso de memoria de la GPU, pero despertar el motor añade latencia de transferencia entre el host y el dispositivo.

vllm_server_base_url (`str`, *opcional*) : URL base para el 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 de 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 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 de 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 del prompt en el conjunto de datos más `max_completion_length`; si se omite, se infiere de 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](/docs/trl/main/es/sdft_trainer#trl.experimental.sdft.SDFTTrainer).

## SDFTTrainer[[trl.experimental.sdft.SDFTTrainer]]

#### trl.experimental.sdft.SDFTTrainer[[trl.experimental.sdft.SDFTTrainer]]

```python
trl.experimental.sdft.SDFTTrainer(model: typing.Union[str, transformers.modeling_utils.PreTrainedModel, torch.nn.Module], args: trl.experimental.sdft.sdft_config.SDFTConfig | None = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), peft_config: PeftConfig | None = None)
```

[Fuente](https://github.com/huggingface/trl/blob/main/trl/experimental/sdft/sdft_trainer.py#L206)

Trainer para autodistilación on-policy de estilo SDFT con prompts de maestro explícitos.

#### train[[trl.experimental.sdft.SDFTTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Fuente](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L1450)

**Parámetros:**

resume_from_checkpoint (`str` o `bool`, *opcional*) : Si es un `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 su 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[[trl.experimental.sdft.SDFTTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Fuente](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L4077)

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

Solo se guardará desde el proceso principal.

#### push_to_hub[[trl.experimental.sdft.SDFTTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L4337)

**Parámetros:**

commit_message (`str`, *opcional*, por defecto `"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 privada la repositorio cuando se crea. El valor predeterminado es `args.hub_private_repo`. No tiene efecto si la repositorio ya existe.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan a `~Trainer.create_model_card`.

**Devuelve:**

La URL del repositorio donde se subió el modelo si `blocking=False`, o un objeto `Future` que rastrea el progreso del commit si `blocking=True`.

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