TRL documentation
Entrenador DPO
Entrenador DPO
Resumen
TRL admite el Trainer de Direct Preference Optimization (DPO) para entrenar modelos de lenguaje, tal como se describe en el artículo Direct Preference Optimization: Your Language Model is Secretly a Reward Model de Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning y Chelsea Finn.
El resumen del artículo es el siguiente:
Si bien los modelos de lenguaje (LM) a gran escala sin supervisión aprenden un amplio conocimiento del mundo y algunas habilidades de razonamiento, lograr un control preciso de su comportamiento es difícil debido a la naturaleza completamente no supervisada de su entrenamiento. Los métodos existentes para obtener dicha capacidad de dirección recopilan etiquetas humanas sobre la calidad relativa de las generaciones del modelo y ajustan el LM no supervisado para alinearlo con estas preferencias, a menudo mediante aprendizaje por refuerzo con retroalimentación humana (RLHF). Sin embargo, el RLHF es un procedimiento complejo y a menudo inestable, que primero ajusta un modelo de recompensa que refleja las preferencias humanas y luego ajusta el gran LM no supervisado utilizando aprendizaje por refuerzo para maximizar esta recompensa estimada sin desviarse demasiado del modelo original. En este artículo, introducimos una nueva parametrización del modelo de recompensa en el RLHF que permite la extracción de la política óptima correspondiente en forma cerrada, lo que nos permite resolver el problema estándar de RLHF con solo una pérdida de clasificación simple. El algoritmo resultante, al que llamamos Optimización Directa de Preferencias (DPO), es estable, eficiente y computacionalmente ligero, eliminando la necesidad de muestrear del LM durante el ajuste fino o realizar un ajuste significativo de hiperparámetros. Nuestros experimentos muestran que DPO puede ajustar los LM para alinearse con las preferencias humanas igual o mejor que los métodos existentes. Notablemente, el ajuste fino con DPO supera al RLHF basado en PPO en la capacidad de controlar el sentimiento de las generaciones, y iguala o mejora la calidad de las respuestas en la resumición y el diálogo de un solo turno, siendo sustancialmente más simple de implementar y entrenar.
Este método de post-entrenamiento fue aportado por Kashif Rasul y posteriormente refactorizado por Quentin Gallouédec.
Inicio rápido
Este ejemplo demuestra cómo entrenar un modelo de lenguaje utilizando el DPOTrainer de TRL. Entrenamos un modelo Qwen 3 0.6B en el conjunto de datos UltraFeedback.
from trl import DPOTrainer
from datasets import load_dataset
trainer = DPOTrainer(
model="Qwen/Qwen3-0.6B",
train_dataset=load_dataset("trl-lib/ultrafeedback_binarized", split="train"),
)
trainer.train()Tipo y formato de datos esperados
DPO requiere un conjunto de datos de preferencias. El DPOTrainer es compatible con los formatos de conjunto de datos estándar y conversacional. Cuando se proporciona un conjunto de datos conversacional, el entrenador aplicará automáticamente la plantilla de chat al conjunto de datos.
# Standard format
## Explicit prompt (recommended)
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Implicit prompt
preference_example = {"chosen": "The sky is blue.", "rejected": "The sky is green."}
# Conversational format
## Explicit prompt (recommended)
preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
"chosen": [{"role": "assistant", "content": "It is blue."}],
"rejected": [{"role": "assistant", "content": "It is green."}]}
## Implicit prompt
preference_example = {"chosen": [{"role": "user", "content": "What color is the sky?"},
{"role": "assistant", "content": "It is blue."}],
"rejected": [{"role": "user", "content": "What color is the sky?"},
{"role": "assistant", "content": "It is green."}]}Si tu conjunto de datos no está en uno de estos formatos, puedes preprocesarlo para convertirlo al formato esperado. Aquí tienes un ejemplo con el conjunto de datos Vezora/Code-Preference-Pairs:
from datasets import load_dataset
dataset = load_dataset("Vezora/Code-Preference-Pairs")
def preprocess_function(example):
return {
"prompt": [{"role": "user", "content": example["input"]}],
"chosen": [{"role": "assistant", "content": example["accepted"]}],
"rejected": [{"role": "assistant", "content": example["rejected"]}],
}
dataset = dataset.map(preprocess_function, remove_columns=["instruction", "input", "accepted", "ID"])
print(next(iter(dataset["train"]))){
"prompt": [{"role": "user", "content": "Create a nested loop to print every combination of numbers [...]"}],
"chosen": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
"rejected": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
}Mirando más a fondo el método DPO
La optimización de preferencias directas (DPO) es un método de entrenamiento diseñado para alinear un modelo de lenguaje con datos de preferencia. En lugar de pares de entrada–salida supervisados, el modelo se entrena con pares de finalizaciones para el mismo prompt, donde una finalización es preferida sobre la otra. El objetivo optimiza directamente el modelo para ampliar el margen entre las verosimilitudes logarítmicas de las finalizaciones preferidas y no preferidas, en relación con un modelo de referencia, sin requerir un modelo de recompensa explícito. En la práctica, esto se logra típicamente suprimiendo la verosimilitud de las finalizaciones no preferidas, en lugar de aumentar la verosimilitud de las preferidas.
Esta sección detalla cómo funciona DPO en la práctica, cubriendo los pasos clave: preprocesamiento y cálculo de la pérdida.
Preprocesamiento y tokenización
Durante el entrenamiento, se espera que cada ejemplo contenga un prompt junto con una finalización preferida (chosen) y una finalización no preferida (rejected). Para más detalles sobre los formatos esperados, consulte Dataset formats.
El DPOTrainer tokeniza cada entrada utilizando el tokenizer del modelo.
Cálculo de la pérdida

La pérdida utilizada en DPO se define de la siguiente manera:
donde es el prompt, es la finalización preferida y es la finalización no preferida. es el modelo de política que se está entrenando, es el modelo de referencia, es la función sigmoide, y es un hiperparámetro que controla la intensidad de la señal de preferencia.
Tipos de pérdida
Se han propuesto varias formulaciones del objetivo en la literatura. Inicialmente, el objetivo de DPO se definió tal como se presentó anteriormente.
loss_type= | Descripción |
|---|---|
"sigmoid" (predeterminado) | Dado los datos de preferencia, podemos ajustar un clasificador binario según el modelo de Bradley-Terry y, de hecho, los autores de DPO proponen la pérdida sigmoide sobre la verosimilitud normalizada mediante logsigmoid para ajustar una regresión logística. |
"hinge" | Los autores de RSO proponen utilizar una pérdida de bisagra sobre la verosimilitud normalizada del artículo SLiC. En este caso, beta es el recíproco del margen. |
"ipo" | Los autores de IPO argumentan que la transformación logit puede sobreajustar y proponen la transformación identidad para optimizar las preferencias directamente; TRL expone esto como loss_type="ipo". |
"exo_pair" | Los autores de EXO proponen la optimización de preferencias con KL inversa. label_smoothing debe ser estrictamente mayor que 0.0; un valor recomendado es 1e-3 (véase la ecuación 16 para la variante de pares simplificada). El método completo utiliza K>2 finalizaciones SFT y se aproxima a PPO a medida que K aumenta. |
"nca_pair" | Los autores de NCA demuestran que NCA optimiza la verosimilitud absoluta de cada respuesta en lugar de la verosimilitud relativa. |
"robust" | Los autores de Robust DPO proponen una pérdida DPO no sesgada bajo preferencias ruidosas. Utilice label_smoothing en DPOConfig para modelar la probabilidad de inversión de etiquetas; los valores válidos están en el rango [0.0, 0.5). |
"bco_pair" | Los autores de BCO entrenan un clasificador binario cuyo logit actúa como recompensa, de modo que el clasificador mapea pares {prompt, completion elegida} a 1 y pares {prompt, completion rechazada} a 0. |
"sppo_hard" | Los autores de SPPO afirman que SPPO es capaz de resolver el equilibrio de Nash de forma iterativa, impulsando las recompensas elegidas para que sean lo más cercanas posible a 1/2 y las recompensas rechazadas para que sean lo más cercanas posible a -1/2, y que puede aliviar los problemas de escasez de datos. La implementación aproxima este algoritmo empleando probabilidades de etiquetas duras, asignando 1 al ganador y 0 al perdedor. |
"aot" o loss_type="aot_unpaired" | Los autores de AOT proponen la Alineación de Preferencias Distribucional mediante Transporte Óptimo. loss_type="aot" es para datos emparejados; loss_type="aot_unpaired" es para datos no emparejados. Ambos aplican la dominancia estocástica mediante cuantiles ordenados; los tamaños de lote por GPU más grandes ayudan. |
"apo_zero" o loss_type="apo_down" | El método APO introduce un objetivo anclado. apo_zero aumenta el peso de los ganadores y reduce el de los perdedores (útil cuando el modelo rinde por debajo de los ganadores). apo_down reduce el peso de ambos, con una presión mayor sobre los perdedores (útil cuando el modelo ya supera a los ganadores). |
"discopop" | El artículo DiscoPOP utiliza LLMs para descubrir funciones de pérdida de optimización de preferencias offline más eficientes. En el artículo, la función de pérdida DiscoPOP propuesta (que es una función de pérdida modulada por log-ratio) superó a otras funciones de pérdida de optimización en diferentes tareas (generación de texto positivo de IMDb, resumen TLDR de Reddit y Alpaca Eval 2.0). |
"sft" | La pérdida de SFT (Supervised Fine-Tuning) es la pérdida de log-verosimilitud negativa, utilizada para entrenar al modelo a generar respuestas preferidas. |
"sigmoid_norm" | Los autores de SimPO abordan el sesgo de longitud en la pérdida sigmoide original normalizando por el número de tokens no enmascarados; TRL expone esto como loss_type="sigmoid_norm". |
"udpo" | Los autores de UDPO proponen una pérdida DPO no sesgada para preferencias ruidosas que, a diferencia de "robust", permanece no sesgada cuando la probabilidad de inversión se sobreestima. Utilice label_smoothing en DPOConfig para establecer la probabilidad de inversión ε; los valores válidos están en el rango [0.0, 0.5). |
Métricas registradas
Durante el entrenamiento y la evaluación, registramos las siguientes métricas:
global_step: El número total de pasos del optimizador realizados hasta el momento.epoch: El número de época actual, basado en la iteración del conjunto de datos.num_tokens: El número total de tokens procesados hasta el momento.loss: La pérdida DPO promedio durante el intervalo de registro actual.entropy: La entropía media de la distribución de tokens predicha por el modelo sobre los tokens no enmascarados.aux_loss: La pérdida auxiliar de equilibrio de carga de un modelo Mixture-of-Experts, antes de que se escale porrouter_aux_loss_coefy se sume a la pérdida. Se registra solo cuando el modelo es un modelo MoE yrouter_aux_loss_coefes distinto de cero.mean_token_accuracy: La proporción de tokens no enmascarados para los que la predicción top-1 del modelo coincide con el token de la finalización elegida.learning_rate: la tasa de aprendizaje actual, que puede cambiar dinámicamente si se utiliza un programador.grad_norm: La norma L2 de los gradientes, calculada antes del recorte de gradientes.logits/chosen: Los valores de logit promedio asignados por el modelo a los tokens de la finalización elegida.logits/rejected: Los valores de logit promedio asignados por el modelo a los tokens de la finalización rechazada.logps/chosen: La probabilidad logarítmica media asignada por el modelo a los tokens de la finalización elegida.logps/rejected: La probabilidad logarítmica media asignada por el modelo a los tokens de la finalización rechazada.rewards/chosen: La recompensa implícita promedio calculada para la finalización elegida, calculada como .rewards/rejected: La recompensa implícita promedio calculada para la finalización rechazada, calculada como .rewards/margins: El margen medio de recompensa implícita entre las finalizaciones elegidas y rechazadas.rewards/accuracies: La proporción de ejemplos en los que la recompensa implícita para la finalización elegida es mayor que la de la finalización rechazada.
Personalización
Compatibilidad y restricciones
Algunas combinaciones de argumentos están restringidas intencionalmente en la implementación actual de DPOTrainer:
use_weighting=Trueno se admite conloss_type="aot"oloss_type="aot_unpaired".- Los adaptadores PEFT que apuntan a
lm_headno son compatibles (usamodules_to_save=["lm_head"]en su lugar). sync_ref_model=Trueno se admite al entrenar con modelos PEFT que no conservan unref_modelindependiente.sync_ref_model=Trueno se puede combinar conprecompute_ref_log_probs=True.precompute_ref_log_probs=Trueno se admite conIterableDataset(entrenamiento o evaluación).
Combinaciones de pérdidas múltiples
El entrenador DPO permite combinar varias funciones de pérdida con pesos diferentes, lo que habilita estrategias de optimización más sofisticadas. Esto resulta especialmente útil para implementar algoritmos como MPO (Mixed Preference Optimization). MPO es un enfoque de entrenamiento que combina múltiples objetivos de optimización, tal como se describe en el artículo Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization.
Para combinar varias pérdidas, especifique los tipos de pérdida y los pesos correspondientes como listas:
# MPO: Combines DPO (sigmoid) for preference and BCO (bco_pair) for quality
training_args = DPOConfig(
loss_type=["sigmoid", "bco_pair", "sft"], # loss types to combine
loss_weights=[0.8, 0.2, 1.0] # corresponding weights, as used in the MPO paper
)Inicialización del modelo
Puedes pasar directamente los kwargs del método from_pretrained() a DPOConfig. Por ejemplo, si quieres cargar un modelo en una precisión diferente, de forma análoga a
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)puede hacerlo pasando el argumento model_init_kwargs={"dtype": torch.bfloat16} a DPOConfig.
from trl import DPOConfig
training_args = DPOConfig(
model_init_kwargs={"dtype": torch.bfloat16},
)Tenga en cuenta que se admiten todos los argumentos de palabra clave de from_pretrained().
Entrenar adaptadores con PEFT
Soportamos una integración estrecha con la biblioteca 🤗 PEFT, lo que permite a cualquier usuario entrenar adaptadores de manera conveniente y compartirlos en el Hub, en lugar de entrenar el modelo completo.
from datasets import load_dataset
from trl import DPOTrainer
from peft import LoraConfig
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
trainer = DPOTrainer(
"Qwen/Qwen3-0.6B",
train_dataset=dataset,
peft_config=LoraConfig(),
)
trainer.train()También puedes continuar entrenando tu PeftModel. Para ello, primero carga un PeftModel fuera de DPOTrainer y pásalo directamente al trainer sin pasar el argumento peft_config.
from datasets import load_dataset
from trl import DPOTrainer
from peft import AutoPeftModelForCausalLM
model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
trainer = DPOTrainer(
model=model,
train_dataset=dataset,
)
trainer.train()Al entrenar adaptadores, normalmente se utiliza una tasa de aprendizaje más alta (≈1e‑5) que en el ajuste fino completo, ya que solo se están aprendiendo parámetros nuevos.
DPOConfig(learning_rate=1e-5, ...)
Experimentación rápida para DPO
RapidFire AI es un motor de experimentación de código abierto que se integra sobre TRL y permite lanzar múltiples configuraciones de DPO a la vez, incluso en una sola GPU. En lugar de probar las configuraciones de forma secuencial, RapidFire permite ver todas sus curvas de aprendizaje antes, detener las ejecuciones con bajo rendimiento y clonar las prometedoras con nuevas configuraciones en curso sin reiniciar. Para obtener más información, consulte RapidFire AI Integration.
Entrenar con Unsloth
Unsloth es un marco de código abierto para el ajuste fino y el aprendizaje por refuerzo que entrena LLM (como Llama, Mistral, Gemma, DeepSeek, entre otros) hasta 2 veces más rápido con hasta un 70% menos de VRAM, al tiempo que ofrece un flujo de trabajo simplificado y compatible con Hugging Face para el entrenamiento, la evaluación y la implementación. Para obtener más información, consulte Integración de Unsloth.
Llamadas a herramientas con DPO
El DPOTrainer admite por completo el ajuste fino de modelos con capacidades de tool calling. En este caso, cada ejemplo del conjunto de datos debe incluir:
- Los mensajes de la conversación (prompt, chosen y rejected), incluidos los llamados a herramientas (
tool_calls) y las respuestas de herramientas (mensajes con el roltool) - La lista de herramientas disponibles en la columna
tools, generalmente proporcionada como esquemas JSON
Para obtener detalles sobre la estructura esperada del conjunto de datos, consulte la sección Formato de conjunto de datos — Llamadas a herramientas.
Entrenamiento de modelos de visión y lenguaje
DPOTrainer admite por completo el entrenamiento de modelos de visión-lenguaje (VLM). Para entrenar un VLM, proporcione un conjunto de datos con una columna image (una imagen por muestra) o una columna images (lista de imágenes por muestra). Para obtener más información sobre la estructura esperada del conjunto de datos, consulte la sección Formato del conjunto de datos — Conjunto de datos de visión.
Un ejemplo de este tipo de conjunto de datos es el conjunto de datos RLAIF-V Dataset.
from trl import DPOConfig, DPOTrainer
from datasets import load_dataset
trainer = DPOTrainer(
model="Qwen/Qwen2.5-VL-3B-Instruct",
args=DPOConfig(max_length=None),
train_dataset=load_dataset("HuggingFaceH4/rlaif-v_formatted", split="train"),
)
trainer.train()En el caso de los VLM, la truncación puede eliminar los tokens de imagen, lo que provoca errores durante el entrenamiento. Para evitarlo, establece
max_length=Noneen DPOConfig. Esto permite que el modelo procese la longitud completa de la secuencia sin truncar los tokens de imagen.DPOConfig(max_length=None, ...)Solo usa
max_lengthcuando hayas verificado que la truncación no eliminará los tokens de imagen para todo el conjunto de datos.
DPOTrainer
clase trl.DPOTrainer
< source >( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.dpo_config.DPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )
Parámetros
- model (
stro PreTrainedModel oPeftModel) — Modelo a entrenar. Puede ser:- Una cadena, que es el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co, o una ruta a un directorio que contiene los pesos del modelo guardados con save_pretrained, por ejemplo,
'./my_model_directory/'. El modelo se carga usando<ModelArchitecture>.from_pretrained(donde<ModelArchitecture>se deriva de la configuración del modelo) con los argumentos de palabra clave enargs.model_init_kwargs. Sidtypeno se especifica enargs.model_init_kwargs, el valor predeterminado esfloat32. Esto difiere de from_pretrained, donde (desde Transformers v5) el dtype se infiere de la configuración del modelo. - Un objeto PreTrainedModel. Solo se admiten modelos de lenguaje causales.
- Un objeto
PeftModel. Solo se admiten modelos de lenguaje causales.
- Una cadena, que es el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co, o una ruta a un directorio que contiene los pesos del modelo guardados con save_pretrained, por ejemplo,
- ref_model (PreTrainedModel, opcional) —
Modelo de referencia utilizado para calcular las probabilidades logarítmicas de referencia. Si se proporciona, este modelo se utiliza directamente como la política de referencia. No puede ser un PeftModel. Si es None, el entrenador utilizará automáticamente la política inicial correspondiente a model, es decir, el estado del modelo antes de que comience el entrenamiento DPO.
- Si se proporciona, este modelo se utiliza directamente como la política de referencia. No puede ser un
PeftModel. - Si
None, el trainer usará automáticamente la política inicial correspondiente amodel, es decir, el estado del modelo antes de que comience el entrenamiento DPO.
- Si se proporciona, este modelo se utiliza directamente como la política de referencia. No puede ser un
- args (DPOConfig, opcional) —
Configuración para este entrenador. Si es
None, se utiliza una configuración predeterminada. - data_collator (
DataCollator, opcional) — Función para formar un lote a partir de una lista de elementos deltrain_datasetoeval_datasetprocesado. Por defecto, seráDataCollatorForPreferencesi el modelo es un modelo de lenguaje yDataCollatorForVisionPreferencesi el modelo es un modelo de visión-lenguaje. Los collators personalizados deben truncar las secuencias antes de aplicar el relleno; el trainer no aplica truncamiento posterior a la colación. - train_dataset (Dataset o IterableDataset) —
Conjunto de datos para usar en el entrenamiento. Este trainer admite tanto el tipo modelado de lenguaje como el tipo
prompt-completion . El formato de las muestras puede ser:
- Estándar: Cada muestra contiene texto plano.
- Conversacional: Cada muestra contiene mensajes estructurados (p. ej., rol y contenido).
Cuando
train_datasetes un IterableDataset (por ejemplo, un dataset de streaming),max_stepsdebe establecerse en los argumentos de entrenamiento, ya que su longitud no se puede inferir y se requiere el número total de pasos de entrenamiento para acotar el bucle de entrenamiento y configurar el programador de tasa de aprendizaje. - eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict o
dict[str, Dataset | IterableDataset]) — Conjunto de datos para usar en la evaluación. Debe cumplir los mismos requisitos quetrain_dataset. - processing_class (PreTrainedTokenizerBase o ProcessorMixin, opcional) —
Clase de procesamiento utilizada para procesar los datos. El lado de relleno debe estar configurado en “left”. Si es
None, la clase de procesamiento se carga desde el nombre del modelo con from_pretrained. Debe establecerse un token de relleno,tokenizer.pad_token. Si la clase de procesamiento no ha establecido un token de relleno, se utilizarátokenizer.eos_tokencomo valor predeterminado. - compute_metrics (
Callable[[EvalPrediction], dict], opcional) — La función que se utilizará para calcular métricas durante la evaluación. Debe recibir un EvalPrediction y devolver un diccionario de cadenas a valores de métricas. Al pasar SFTConfig conbatch_eval_metricsestablecido enTrue, su funcióncompute_metricsdebe recibir un argumento booleanocompute_result. Esto se activará después del último lote de evaluación para indicar que la función necesita calcular y devolver las estadísticas de resumen globales en lugar de acumular las estadísticas a nivel de lote. Los logits que recibe se recalculan con una pasada de adelante adicional. Esto está obsoleto y se eliminará en v2.0.0. - callbacks (lista de TrainerCallback, opcional) —
Lista de callbacks para personalizar el bucle de entrenamiento. Se añadirán a la lista de callbacks predeterminados detallada en aquí.
Si deseas eliminar uno de los callbacks predeterminados, utiliza el método remove_callback.
- optimizers (
tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opcional, por defecto(None, None)) — Una tupla que contiene el optimizador y el programador a utilizar. Por defecto, se utilizará una instancia deAdamWen su modelo y un programador dado por get_linear_schedule_with_warmup controlado porargs. - quantization_config (BitsAndBytesConfig, opcional) —
Configuración de cuantización utilizada al cargar el modelo desde un identificador de modelo. Combínala con
peft_configpara el entrenamiento QLoRA. Se ignora si el modelo ya está instanciado. - peft_config (
PeftConfig, opcional) — Configuración de PEFT utilizada para envolver el modelo. Si esNone, el modelo no se envuelve.
Trainer para el método de Direct Preference Optimization (DPO). Este algoritmo fue propuesto inicialmente en el artículo Direct Preference Optimization: Your Language Model is Secretly a Reward Model. Esta clase es un envoltorio de la clase Trainer y hereda todos sus atributos y métodos.
Ejemplo:
>>> from trl import DPOTrainer
>>> from datasets import load_dataset
>>> dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
>>> trainer = DPOTrainer(
... model="Qwen/Qwen2.5-0.5B-Instruct",
... train_dataset=dataset,
... )
>>> trainer.train()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.
DPOConfig
clase trl.DPOConfig
< source >( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_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 = Truelabel_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] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: list[str] = <factory>loss_weights: list[float] | None = Noneld_alpha: float | None = Nonef_divergence_type: str = 'reverse_kl'f_alpha_divergence_coef: float = 0.5label_smoothing: float = 0.0beta: float = 0.1use_weighting: bool = Falsediscopop_tau: float = 0.05activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512pad_token: str | None = None )
Parámetros que controlan el modelo
- model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave para from_pretrained, utilizados cuando el argumentomodelde DPOTrainer se proporciona como una cadena. El valor derevisiontambién se utiliza al cargar la clase 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. - router_aux_loss_coef (
float, opcional) — Coeficiente de la pérdida auxiliar de equilibrado de carga para modelos Mixture-of-Experts (MoE), que se añade a la pérdida de entrenamiento con este peso. Si no se establece, se utiliza el valor declarado en la configuración del modelo. Establezca0.0para desactivarlo. Falla si se utiliza con un modelo que no es MoE. - disable_dropout (
bool, opcional, valor predeterminadoTrue) — Si se desactiva el dropout en el modelo y el modelo de referencia.
Parámetros que controlan el preprocesamiento de datos
- dataset_num_proc (
int, opcional) — Número de procesos a utilizar para procesar el conjunto de datos. - max_length (
intoNone, opcional, valor predeterminado1024) — Longitud máxima de la secuencia tokenizada. Las secuencias más largas quemax_lengthse truncan por la izquierda o por la derecha según eltruncation_mode. Si esNone, no se aplica truncamiento. - truncation_mode (
str, opcional, valor predeterminado"keep_start") — Modo de truncado a utilizar cuando la secuencia superamax_length. El único valor admitido es"keep_start". El valor"keep_end"está obsoleto y se eliminará en la v2.0.0. - padding_free (
bool, opcional, valor predeterminadoFalse) — Indica si se deben realizar las pasadas hacia adelante sin relleno, aplanando todas las secuencias del lote en una única secuencia continua. Esto reduce el uso de memoria al eliminar la sobrecarga de relleno. Actualmente, esto solo se admite con FlashAttention 2 o 3, que pueden manejar de manera eficiente la estructura de lote aplanada. Temporalmente no disponible: desde la refactorización de DPO, establecerlo enTrueemite una advertencia y recurre al relleno estándar. Se planea que vuelva a estar disponible en una actualización futura. - pad_to_multiple_of (
intostr, opcional, valor predeterminado"auto") — Si se establece, las secuencias se rellenarán hasta un múltiplo de este valor."auto"rellena hasta un múltiplo de 128 en Neuron (AWS Trainium), que compila una vez por forma de entrada, y no rellena en otros entornos. - precompute_ref_log_probs (
bool, opcional, valor predeterminadoFalse) — Si se deben precalcular las probabilidades logarítmicas del modelo de referencia para todo el conjunto de datos de entrenamiento antes de iniciar el entrenamiento. Esto permite ahorrar memoria durante el entrenamiento, ya que no es necesario mantener el modelo de referencia en memoria. - precompute_ref_batch_size (
int, opcional) — Tamaño de lote a utilizar al precalcular las probabilidades de registro del modelo de referencia. Esto se puede establecer en un valor mayor que el tamaño de lote de entrenamiento para acelerar el preprocesamiento. Si esNone, el valor predeterminado esper_device_train_batch_sizepara el entrenamiento yper_device_eval_batch_sizepara la evaluación.
Parámetros que controlan el entrenamiento
- loss_type (
list[str], opcional, valor predeterminado["sigmoid"]) — Tipo de pérdida a utilizar. Los valores posibles son:'sigmoid','hinge','ipo','exo_pair','nca_pair','robust','bco_pair','sppo_hard','aot','aot_unpaired','apo_zero','apo_down','discopop','sft','sigmoid_norm','udpo'. Si se proporcionan varios tipos de pérdida, se combinarán utilizando los pesos especificados enloss_weights. - loss_weights (
list[float], opcional) — Lista de pesos de pérdida para combinaciones de múltiples pérdidas. Se utiliza al combinar varios tipos de pérdida. Ejemplo:[0.8, 0.2, 1.0]para MPO. Si no se proporciona, los pesos por defecto son iguales (1.0) para todos los tipos de pérdida. - ld_alpha (
float, opcional) — Parámetro α del paper LD-DPO, que controla el ponderado de las log-probabilidades de los tokens verbosos en las respuestas. Si esNone, no se aplica ponderación a la parte verbosa y la pérdida es equivalente a la pérdida estándar de DPO. Debe estar en [0.0, 1.0]:ld_alpha=1.0no aplica ponderación, yld_alpha=0.0enmascara los tokens más allá de las longitudes compartidas. - f_divergence_type (
str, opcional, valor predeterminado"reverse_kl") — regularizador de f-divergencia entre la política y la referencia (artículo f-DPO). Los valores posibles son:reverse_kl(valor predeterminado),forward_kl,js_divergence,alpha_divergence. Solo los tipos de pérdida basados en la diferencia de recompensa entre la opción elegida y la rechazada admiten un valor no predeterminado:'sigmoid','sigmoid_norm','hinge','ipo','exo_pair','robust','discopop','sft','udpo'. Los demás tipos de pérdida no tienen una generalización válida de f-divergencia y se rechazan si se usa un valor no predeterminado. - f_alpha_divergence_coef (
float, opcional, valor predeterminado0.5) — coeficiente α para el regularizador de α-divergencia u^-α, utilizado solo cuandof_divergence_type='alpha_divergence'. - label_smoothing (
float, opcional, valor predeterminado0.0) — Parámetro de suavizado de etiquetas utilizado en Robust DPO, UDPO y EXO. En Robust DPO y UDPO, se interpreta como la probabilidad ε de que una etiqueta de preferencia se invierta y debe estar en [0.0, 0.5); un valor típico recomendado por el artículo de Robust DPO es 0.1. UDPO lo utiliza para establecer a = ε / (1 - ε), y el artículo de UDPO recomienda a = 0.8, es decir, ε = 4/9. En EXO, corresponde al parámetro de suavizado de etiquetas ε, para el cual el artículo recomienda un valor típico de 1e-3. - beta (
float, opcional, valor predeterminado0.1) — Parámetro que controla la desviación respecto al modelo de referencia. Un β más alto implica una menor desviación respecto al modelo de referencia. Para la pérdida IPO (loss_type='ipo'), este valor es el parámetro de regularización denotado por τ en el artículo. - use_weighting (
bool, opcional, valor predeterminadoFalse) — Si se aplica un ponderación de estilo WPO a los pares de preferencia utilizando las probabilidades de secuencia normalizadas por longitud de la política. - discopop_tau (
float, opcional, valor predeterminado0.05) — Parámetro τ/temperatura del artículo DiscoPOP, que controla la forma de la pérdida modulada por log-ratio cuando se usaloss_type='discopop'. El artículo recomienda el valor predeterminadodiscopop_tau=0.05. - activation_offloading (
bool, opcional, valor predeterminadoFalse) — Si se deben descargar las activaciones a la CPU. - sync_ref_model (
bool, opcional, valor predeterminadoFalse) — Indica si se debe sincronizar el modelo de referencia con el modelo activo cadaref_model_sync_stepspasos, utilizando el parámetroref_model_mixup_alpha. Esta sincronización proviene del artículo TR-DPO.sync_ref_model=Trueaún no es compatible con PEFT ni conprecompute_ref_log_probs=True. - ref_model_mixup_alpha (
float, opcional, valor predeterminado0.6) — Parámetro α del artículo TR-DPO, que controla la mezcla entre la política actual y la política de referencia anterior durante las actualizaciones. La política de referencia se actualiza según la ecuación:π_ref = α * π_θ + (1 - α) * π_ref_prev. Para usar este parámetro, debe establecersync_ref_model=True. - ref_model_sync_steps (
int, opcional, valor predeterminado512) — parámetro τ del artículo TR-DPO, que determina la frecuencia con la que la política actual se sincroniza con la política de referencia. Para usar este parámetro, debes establecersync_ref_model=True.
Parámetros obsoletos
Clase de configuración para DPOTrainer.
Esta clase incluye solo los parámetros específicos para el entrenamiento con DPO. Para obtener la lista completa de argumentos de entrenamiento, consulte la documentación de TrainingArguments. Tenga en cuenta que los valores predeterminados de esta clase pueden diferir de los de TrainingArguments.
Con HfArgumentParser podemos convertir esta clase en argumentos de argparse que se pueden especificar en la línea de comandos.
Estos parámetros tienen valores predeterminados diferentes de TrainingArguments:
logging_steps: El valor predeterminado es10en lugar de500.gradient_checkpointing: El valor predeterminado esTrueen lugar deFalse.bf16: Por defecto, esTruesifp16no está establecido, en lugar deFalse.learning_rate: El valor predeterminado es1e-6en lugar de5e-5.