TRL documentation
Entrenador de DPO en línea
Entrenador de DPO en línea
Resumen
Online DPO fue propuesto en Direct Language Model Alignment from Online AI Feedback por Shangmin Guo, Biao Zhang, Tianlin Liu, Tianqi Liu, Misha Khalman, Felipe Llinares, Alexandre Rame, Thomas Mesnard, Yao Zhao, Bilal Piot, Johan Ferret y Mathieu Blondel.
El resumen del artículo es el siguiente:
Los métodos de alineación directa desde preferencias (DAP), como DPO, han surgido recientemente como alternativas eficientes al aprendizaje por refuerzo con retroalimentación humana (RLHF), que no requieren un modelo de recompensa separado. Sin embargo, los conjuntos de datos de preferencias utilizados en los métodos DAP suelen recopilarse antes del entrenamiento y nunca se actualizan, por lo que la retroalimentación es puramente offline. Además, las respuestas en estos conjuntos de datos a menudo se muestrean de un modelo de lenguaje distinto al que se está alineando, y dado que el modelo evoluciona durante el entrenamiento, la fase de alineación es inevitablemente off-policy. En este estudio, planteamos que la retroalimentación online es clave y mejora los métodos DAP. Nuestro método, retroalimentación de IA online (OAIF), utiliza un LLM como anotador: en cada iteración de entrenamiento, muestreamos dos respuestas del modelo actual y solicitamos al anotador LLM que elija cuál es preferida, proporcionando así retroalimentación online. A pesar de su simplicidad, demostramos mediante evaluación humana en varias tareas que OAIF supera tanto a los métodos DAP offline como a los métodos RLHF. Además, mostramos que la retroalimentación utilizada en OAIF es fácilmente controlable, mediante prompts de instrucción al anotador LLM.
Este método de post-entrenamiento fue aportado por Michael Noukhovitch, Shengyi Costa Huang, Quentin Gallouédec y Edward Beeching.
Inicio rápido
Este ejemplo demuestra cómo entrenar un modelo utilizando el método DPO en línea. Utilizamos el modelo Qwen 0.5B como modelo base y el modelo de recompensa trl-lib/Qwen2-0.5B-Reward. Usamos los prompts del conjunto de datos UltraFeedback. Puede ver los prompts del conjunto de datos aquí:
A continuación se muestra el script para entrenar el modelo:
# train_online_dpo.py
from datasets import load_dataset
from trl.experimental.online_dpo import OnlineDPOConfig, OnlineDPOTrainer
from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
reward_model = AutoModelForSequenceClassification.from_pretrained("trl-lib/Qwen2-0.5B-Reward", num_labels=1)
train_dataset = load_dataset("trl-lib/ultrafeedback-prompt", split="train")
training_args = OnlineDPOConfig(output_dir="Qwen2-0.5B-OnlineDPO")
trainer = OnlineDPOTrainer(
model=model, reward_funcs=reward_model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset
)
trainer.train()Ejecute el script usando el siguiente comando:
accelerate launch train_online_dpo.py
Distribuido en 8 GPUs, el entrenamiento tarda aproximadamente 1 hora. Puedes verificar el progreso del entrenamiento consultando el gráfico de recompensa. Una tendencia al alza tanto en la recompensa de las finalizaciones rechazadas como en las elegidas indica que el modelo está mejorando y generando mejores respuestas con el tiempo.

Para ver cómo rinde el modelo entrenado, puedes usar el Transformers Chat CLI.
$ transformers chat trl-lib/Qwen2-0.5B-OnlineDPO
<quentin_gallouedec>:
What is the best programming language?
<trl-lib/Qwen2-0.5B-OnlineDPO>:
The best programming language depends on your specific needs and priorities. Some people prefer imperative programming languages (like Haskell or Lisp), while others prefer functional programming languages (like Scala or Python). It's important to consider your work style, programming environment, and project requirements when choosing a programming language.
Tipo de conjunto de datos esperado
DPO en línea solo requiere un conjunto de datos solo de prompts (a diferencia de DPO fuera de línea, que espera un conjunto de datos de preferencias). El experimental.online_dpo.OnlineDPOTrainer admite tanto el formato de conjunto de datos conversacional como el estándar. Cuando se proporciona un conjunto de datos conversacional, el entrenador aplicará automáticamente la plantilla de chat al conjunto de datos.
Consejos de uso
Fomentar la generación del token EOS
Al utilizar un modelo de recompensa, es posible que se desee que el modelo genere completaciones dentro de una longitud dada. Durante el entrenamiento, el modelo generará completaciones hasta la longitud máxima especificada en el argumento max_new_tokens de experimental.online_dpo.OnlineDPOConfig. Si se desea penalizar al modelo por no generar un token EOS antes de alcanzar la longitud máxima, se puede utilizar el argumento missing_eos_penalty de experimental.online_dpo.OnlineDPOConfig:
training_args = OnlineDPOConfig(..., max_new_tokens=128, missing_eos_penalty=1.0)Registro de completions
Para comprender mejor el comportamiento de tu modelo durante el entrenamiento, puedes registrar periódicamente las muestras de finalización utilizando LogCompletionsCallback.
trainer = OnlineDPOTrainer(..., eval_dataset=eval_dataset)
completions_callback = LogCompletionsCallback(trainer, num_prompts=8)
trainer.add_callback(completions_callback)Esta devolución de llamada registra las completaciones generadas por el modelo directamente en Weights & Biases.

Métricas registradas
Durante el entrenamiento y la evaluación, registramos las siguientes métricas. Aquí hay un ejemplo de ejecución registrada en Weights and Biases
objective/kl: La divergencia de Kullback-Leibler (KL) media entre el modelo actual y el modelo de referencia.objective/entropy: La entropía media del modelo, que indica el grado de aleatoriedad de las acciones elegidas por el modelo.objective/non_score_reward: La recompensa media de fuentes no relacionadas con la puntuación, básicamentebeta * kl.sum(1), dondebetaes el coeficiente de penalización KL ykles la divergencia KL por token.objective/rlhf_reward: La recompensa media de RLHF, que esscores - non_score_reward. Larlhf_rewardes el objetivo final del entrenamiento de DPO en línea. Si el entrenamiento funciona como se espera, esta métrica debería seguir aumentando.objective/scores: Las puntuaciones medias devueltas por el modelo de recompensa.objective/scores_margin: El margen medio de puntuación (según el modelo de recompensa externo) entre las finalizaciones elegidas y rechazadas.rewards/chosen: La recompensa media (según el modelo de recompensa implícito de online DPO) de las finalizaciones elegidas.rewards/rejected: La recompensa media (según el modelo de recompensa implícito de DPO en línea) de las finalizaciones rechazadas.rewards/accuracies: Las precisiones del modelo de recompensa implícito de DPO en línea.rewards/margins: El margen medio de recompensa (según el modelo de recompensa implícito de DPO en línea) entre las finalizaciones elegidas y rechazadas.logps/chosen: Las probabilidades logarítmicas medias de las finalizaciones elegidas.logps/rejected: Las probabilidades logarítmicas medias de las finalizaciones rechazadas.val/contain_eos_token: La proporción de finalizaciones que contienen un token EOS.beta: El parámetro que controla el peso del término de pérdida que representa la desviación respecto al modelo de referencia. Generalmente se mantiene fijo, pero puede hacerse dinámico pasando una lista a experimental.online_dpo.OnlineDPOConfig.
Experimentos de benchmark
Para validar que la implementación de DPO en línea funciona, realizamos experimentos con los modelos Pythia 1B, 2.8B y 6.9B en un nodo único de 8 x H100. A continuación, se muestran los comandos que utilizamos para ejecutar los experimentos, con el script de ejemplo de DPO en línea tal como existía en ese momento (examples/scripts/online_dpo.py, eliminado posteriormente) — para reproducirlos, ejecute desde un checkout de v1.10.0 (git checkout v1.10.0). Tomamos los modelos SFT / RM directamente de The N+ Implementation Details of RLHF with PPO: A Case Study on TL;DR Summarization.
# 1B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/multi_gpu.yaml \
examples/scripts/online_dpo.py \
--model_name_or_path trl-lib/pythia-1b-deduped-tldr-sft \
--reward_model_path trl-lib/pythia-1b-deduped-tldr-rm \
--dataset_name trl-lib/tldr \
--learning_rate 5.0e-7 \
--output_dir pythia-1b-deduped-tldr-online-dpo \
--beta 0.1 \
--per_device_train_batch_size 8 \
--gradient_accumulation_steps 2 \
--num_train_epochs 3 \
--max_new_tokens 53 \
--warmup_steps 0.1 \
--missing_eos_penalty 1.0 \
--save_steps 0.1 \
--push_to_hub
# 2.8B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
examples/scripts/online_dpo.py \
--model_name_or_path trl-lib/pythia-2.8b-deduped-tldr-sft \
--reward_model_path trl-lib/pythia-2.8b-deduped-tldr-rm \
--dataset_name trl-lib/tldr \
--learning_rate 5.0e-7 \
--output_dir pythia-2.8b-deduped-tldr-online-dpo \
--beta 0.1 \
--per_device_train_batch_size 8 \
--gradient_accumulation_steps 2 \
--num_train_epochs 3 \
--max_new_tokens 53 \
--warmup_steps 0.1 \
--missing_eos_penalty 1.0 \
--save_steps 0.1 \
--push_to_hub
# 6.9B Online DPO experiment
accelerate launch --config_file examples/accelerate_configs/deepspeed_zero2.yaml \
examples/scripts/online_dpo.py \
--model_name_or_path trl-lib/pythia-6.9b-deduped-tldr-sft \
--reward_model_path trl-lib/pythia-6.9b-deduped-tldr-rm \
--dataset_name trl-lib/tldr \
--learning_rate 5.0e-7 \
--output_dir pythia-6.9b-deduped-tldr-online-dpo \
--beta 0.1 \
--per_device_train_batch_size 4 \
--gradient_accumulation_steps 4 \
--num_train_epochs 3 \
--max_new_tokens 53 \
--warmup_steps 0.1 \
--missing_eos_penalty 1.0 \
--save_steps 0.1 \
--push_to_hubLos puntos de control y el seguimiento de experimentos están disponibles en:
La tasa de victorias del checkpoint de DPO en línea aumenta a medida que escalamos los tamaños de los modelos. Esta es una buena señal de que la implementación de DPO en línea funciona como se esperaba.
OnlineDPOTrainer
clase trl.experimental.online_dpo.OnlineDPOTrainer
< source >( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str]ref_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, NoneType] = Nonereward_funcs: str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]] | list[str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]]] | None = Noneargs: trl.experimental.online_dpo.online_dpo_config.OnlineDPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: typing.Union[datasets.arrow_dataset.Dataset, torch.utils.data.IterableDataset, NoneType] = Noneeval_dataset: typing.Union[datasets.arrow_dataset.Dataset, torch.utils.data.IterableDataset, dict[str, typing.Union[datasets.arrow_dataset.Dataset, torch.utils.data.IterableDataset]], NoneType] = 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 = Nonepeft_config: PeftConfig | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None)preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None )
Parámetros
- model (
str | nn.Module | PreTrainedModel) — Modelo que se va 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 con from_pretrained utilizando los argumentos de palabra clave enargs.model_init_kwargs. - Un objeto PreTrainedModel. 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 o
torch.nn.ModuleoNone) — El modelo de referencia que se usará para el entrenamiento. Si se especifica None, el modelo de referencia se creará a partir del modelo. - reward_funcs (
RewardFunc | list[RewardFunc]) — Funciones de recompensa que se utilizarán para calcular las recompensas. Para calcular las recompensas, se llaman a todas las funciones de recompensa con los prompts y las completions y se suman las recompensas. Puede ser:- Una única función de recompensa: puede ser una cadena (ruta al modelo), un PreTrainedModel o una función de llamada personalizada.
- Una lista de funciones de recompensa: todas deben ser de tipos compatibles.
- args (experimental.online_dpo.OnlineDPOConfig) — Los argumentos de configuración de DPO en línea para usar en el entrenamiento.
- data_collator (
DataCollator) — El data collator a utilizar para el entrenamiento. Si se especifica None, se utilizará el data collator por defecto (experimental.utils.DPODataCollatorWithPadding) que rellenará las secuencias hasta la longitud máxima de las secuencias del batch, dado un conjunto de datos de secuencias emparejadas. - train_dataset (Dataset o IterableDataset) — El conjunto de datos que se utilizará para el entrenamiento.
- eval_dataset (Dataset, IterableDataset o
dict[str, Dataset | IterableDataset]) — El conjunto de datos que se utilizará para la evaluación. - processing_class (PreTrainedTokenizerBase o ProcessorMixin, opcional) — Clase de procesamiento utilizada para procesar los datos. Si se proporciona, se usará para procesar automáticamente las entradas del modelo y se guardará junto con el modelo para facilitar la reanudación de un entrenamiento interrumpido o la reutilización del modelo afinado.
- reward_processing_classes (PreTrainedTokenizerBase o
list[PreTrainedTokenizerBase], opcional) — Clases de procesamiento correspondientes a las funciones de recompensa especificadas enreward_funcs. Puede ser:- Una única clase de procesamiento: se utiliza cuando
reward_funcscontiene solo una función de recompensa. - Una lista de clases de procesamiento: debe coincidir con el orden y la longitud de las funciones de recompensa en
reward_funcs.
Si se establece en
None, el tokenizador para cada función de recompensa basada en un modelo se carga automáticamente usando from_pretrained. - Una única clase de procesamiento: se utiliza cuando
- peft_config (PeftConfig, opcional) —
Configuración de PEFT utilizada para envolver el modelo. Si es
None, el modelo no se envuelve. - compute_metrics (
Callable[[EvalPrediction], dict], opcional) — La función que se utilizará para calcular las métricas. Debe recibir unEvalPredictiony devolver un diccionario de cadenas a valores de métricas. - callbacks (
list[transformers.TrainerCallback]) — Los callbacks a utilizar para el entrenamiento. - optimizers (
tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]) — El optimizador y el programador de tasa de aprendizaje a utilizar para el entrenamiento. - preprocess_logits_for_metrics (
Callable[[torch.Tensor, torch.Tensor], torch.Tensor]) — La función que se utilizará para preprocesar los logits antes de calcular las métricas.
Inicializa OnlineDPOTrainer.
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 = 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”. - 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.
OnlineDPOConfig
clase trl.experimental.online_dpo.OnlineDPOConfig
< source >( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 5e-07lr_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 = 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 = -1reward_model_path: str | None = Nonemax_new_tokens: int = 64max_length: int = 512temperature: float = 0.9top_p: float = 1.0top_k: int = 0min_p: float | None = Nonerepetition_penalty: float = 1.0generation_kwargs: dict | None = Nonecache_implementation: str | None = Nonemissing_eos_penalty: float | None = Nonebeta: list[float] = <factory>loss_type: str = 'sigmoid'disable_dropout: bool = Trueuse_vllm: bool = Falsevllm_model_impl: str = 'vllm'vllm_structured_outputs_regex: str | None = Nonevllm_gpu_memory_utilization: float | None = 0.55vllm_mode: str = 'colocate'vllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_server_timeout: float = 240.0vllm_group_port: int = 51216vllm_tensor_parallel_size: int = 1vllm_enable_sleep_mode: bool = Falseds3_gather_for_generation: bool = Truemodel_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falsereward_weights: list[float] | None = None )
Parámetros
- reward_model_path (
str, opcional) — Ruta al modelo de recompensa. - max_new_tokens (
int, opcional, valor predeterminado64) — Número máximo de tokens que se generarán por cada finalización. - max_length (
int, opcional, valor predeterminado512) — Longitud total máxima de la secuencia (prompt + completion) utilizada para calcular las probabilidades logarítmicas. Si la secuencia supera este límite, se recortarán los tokens más a la izquierda para conservar la mayor parte posible de la completion. No se aplica cuando las entradas contienen imágenes, ya que el recorte eliminaría los tokens de imagen. - temperature (
float, opcional, valor predeterminado0.9) — Temperatura para el muestreo. A mayor temperatura, más aleatorias son las finalizaciones. - missing_eos_penalty (
float, opcional) — Penalización aplicada a la puntuación cuando el modelo no genera un token EOS. Esto es útil para alentar la generación de completados más cortos que la longitud máxima (max_new_tokens). La penalización debe ser un valor positivo. - beta (
floatolist[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 del modelo de referencia. Para la pérdida IPO (loss_type="ipo"), β es el parámetro de regularización denotado por τ en el artículo. Si se proporciona una lista de flotantes, el β se selecciona para cada nueva época y el último β se utiliza para el resto de las épocas. - loss_type (
str, opcional, por defecto"sigmoid") — Tipo de pérdida a utilizar. Los valores posibles son: - disable_dropout (
bool, opcional, valor predeterminadoTrue) — Si se desactiva el dropout en el modelo y el modelo de referencia.
Parámetros que controlan la generación
- 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 en1.0para 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 entre0.0y1.0. Los valores típicos están en el rango0.01-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.0animan al modelo a usar tokens nuevos, mientras que los valores <1.0animan al modelo a repetir tokens. - cache_implementation (
str, opcional) — Implementación del método de caché para una generación más rápida cuandouse_vllmestá establecido enFalse. - generation_kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave adicionales para pasar a GenerationConfig (si se usa transformers) o aSamplingParams(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.
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. - vllm_model_impl (
str, opcional, valor predeterminado"vllm") — Implementación del modelo a usar para vLLM. Debe ser"transformers"o"vllm"."transformers": usa el backendtransformerspara la implementación del modelo."vllm": usa la bibliotecavllmpara la implementación del modelo. - vllm_mode (
str, opcional, por defecto"colocate") — Modo a usar para la integración de vLLM cuandouse_vllmestá establecido enTrue. Debe ser uno de"server"o"colocate"."server": El trainer enviará solicitudes de generación a un servidor vLLM separado. Asegúrate de que un servidor vLLM esté en ejecución (inícialo 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 provocar una contención de recursos con el entrenamiento.
- vllm_structured_outputs_regex (
str, opcional) — Expresión regular para las salidas estructuradas de vLLM. Si esNone(valor predeterminado), las salidas estructuradas están deshabilitadas.
Parámetros que controlan el servidor de vLLM (solo se usan cuando `vllm_mode` es `"server"`)
- 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 de vLLM al que conectarse. Se ignora si se proporcionavllm_server_base_url. - vllm_server_port (
int, opcional, valor predeterminado8000) — Puerto del servidor vLLM al que conectarse. Se ignora si se proporcionavllm_server_base_url. - 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_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.
Parámetros que controlan la ejecución de vLLM colocada (solo se usan cuando `vllm_mode` es `"colocate"`)
- vllm_gpu_memory_utilization (
float, opcional, valor predeterminado0.55) — 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_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á utilizandovllm_mode="server", este parámetro debe pasarse por separado al iniciar el servidor de vLLM mediante la bandera--vllm_tensor_parallel_size. - 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.
Otros parámetros
- 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. - model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave para pasar aAutoModelForCausalLM.from_pretrainedal instanciar el modelo desde una cadena. El valor derevisiontambién se utiliza al cargar las clases de procesamiento de recompensas. - trust_remote_code (
bool, opcional, valor predeterminadoFalse) — Si se permite cargar modelos que incluyen código Python personalizado desde el Hub. Se reenvía a from_pretrained. También se aplica a las cargas de modelos de recompensa y tokenizadores de recompensa. - reward_weights (
list[float], opcional) — Pesos para combinar múltiples funciones de recompensa. Debe coincidir con el número de funciones de recompensa. Si esNone, todas las funciones de recompensa tienen el mismo peso.
Clase de configuración para experimental.online_dpo.OnlineDPOTrainer.
Esta clase incluye solo los parámetros específicos para el entrenamiento de Online 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 es5e-7en lugar de5e-5.remove_unused_columns: Por defecto esFalseen lugar deTrue.