TRL documentation
ORPO Trainer
ORPO Trainer
Resumen
Odds Ratio Preference Optimization (ORPO) fue introducido en ORPO: Monolithic Preference Optimization without Reference Model por Jiwoo Hong, Noah Lee y James Thorne.
El resumen del artículo es el siguiente:
Si bien los algoritmos recientes de alineación de preferencias para modelos de lenguaje han demostrado resultados prometedores, el ajuste fino supervisado (SFT) sigue siendo imperativo para lograr una convergencia exitosa. En este artículo, estudiamos el papel crucial del SFT en el contexto de la alineación de preferencias, enfatizando que una penalización menor para el estilo de generación desfavorecido es suficiente para un SFT alineado con preferencias. Sobre esta base, introducimos un algoritmo monolítico de optimización de preferencias basado en la razón de probabilidades, libre de un modelo de referencia, sencillo e innovador, ORPO, que elimina la necesidad de una fase adicional de alineación de preferencias. Demostramos, tanto empíricamente como teóricamente, que la razón de probabilidades es una elección sensata para contrastar los estilos favorecidos y desfavorecidos durante el SFT en tamaños diversos, desde 125M hasta 7B. Específicamente, el ajuste fino de Phi-2 (2.7B), Llama-2 (7B) y Mistral (7B) con ORPO utilizando únicamente UltraFeedback supera el rendimiento de modelos de lenguaje de última generación con más de 7B y 13B parámetros: alcanzando hasta 12.20% en AlpacaEval_{2.0} (Figura 1), 66.19% en IFEval (nivel de instrucción, suelto, Tabla 6) y 7.32 en MT-Bench (Figura 12). Publicamos el código y los puntos de control de los modelos Mistral-ORPO-alpha (7B) y Mistral-ORPO-beta (7B).
Estudia el papel crucial del SFT en el contexto de la alineación de preferencias. Utilizando datos de preferencias, el método postula que una penalización menor para la generación desfavorecida, junto con una señal de adaptación fuerte hacia la respuesta elegida mediante un simple término de razón de logaritmos de probabilidades añadido a la pérdida NLL, es suficiente para un SFT alineado con las preferencias.
Por lo tanto, ORPO es un algoritmo de optimización de preferencias sin modelo de referencia que elimina la necesidad de una fase adicional de alineación de preferencias, ahorrando así cómputo y memoria.
El código oficial se puede encontrar en xfactlab/orpo.
Este método de post-entrenamiento fue aportado por Kashif Rasul, Lewis Tunstall y Alvaro Bartolome.
Inicio rápido
Este ejemplo demuestra cómo entrenar un modelo utilizando el método ORPO. Utilizamos el modelo Qwen 0.5B como modelo base. Utilizamos los datos de preferencia del conjunto de datos UltraFeedback. Puedes ver los datos del conjunto de datos aquí:
A continuación se muestra el script para entrenar el modelo:
# train_orpo.py
from datasets import load_dataset
from trl.experimental.orpo import ORPOConfig, ORPOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
train_dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
training_args = ORPOConfig(output_dir="Qwen2-0.5B-ORPO")
trainer = ORPOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
trainer.train()Ejecute el script usando el siguiente comando:
torchrun --nproc_per_node 8 train_orpo.py
Distribuido en 8 GPUs, el entrenamiento tarda aproximadamente 30 minutos. Puedes verificar el progreso del entrenamiento consultando el gráfico de recompensa. Una tendencia al alza en el margen de recompensa 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-ORPO
<quentin_gallouedec>:
What is the best programming language?
<trl-lib/Qwen2-0.5B-ORPO>:
It's challenging to determine the best programming language as no one language is perfect, as the complexity of a task and the type of project are significant factors. Some popular languages include Java, Python, JavaScript, and
C++. If you have specific needs or requirements for a specific project, it's important to choose the language that best suits those needs.
Here are some other factors to consider when choosing a programming language for a project:
• Language proficiency: A good programming language is more likely to be easy to understand and use, and will allow developers to collaborate on projects more efficiently.
• Ease of use: There are tools and libraries available to make programming more accessible, so developers should choose a language that can help them get started easier.
• Code readability: A clear and concise codebase should be easy to read and understand, especially when working with large projects.
• Tool and framework support: There are numerous libraries available for Python, Java, and JavaScript, along with tools like IDEs and static code analysis tools.
• Accessibility: Some languages and tools have features that make them more accessible to developers with disabilities, such as support for screen readers.
• Version control: As your projects grow and complexity increases, version control tools can be beneficial for tracking changes.
Tipo de conjunto de datos esperado
ORPO requiere un conjunto de datos de preferencia. El experimental.orpo.ORPOTrainer 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.
Aunque el experimental.orpo.ORPOTrainer admite tanto prompts explícitos como implícitos, recomendamos usar prompts explícitos. Si se proporciona un conjunto de datos con prompts implícitos, el entrenador extraerá automáticamente el prompt de las columnas "chosen" y "rejected". Para obtener más información, consulte la sección preference style.
Consejos de uso
Para los modelos Mixture of Experts: habilitar la pérdida auxiliar
Los MOEs son más eficientes cuando la carga se distribuye de manera aproximadamente equitativa entre los expertos.
Para garantizar que entrenemos los MOEs de forma similar durante el ajuste de preferencias, es beneficioso añadir la pérdida auxiliar del equilibrador de carga a la pérdida final.
Esta opción se habilita configurando output_router_logits=True en la configuración del modelo (p. ej. MixtralConfig).
Para escalar cuánto contribuye la pérdida auxiliar a la pérdida total, use el hiperparámetro router_aux_loss_coef=... (valor predeterminado: 0.001) en la configuración del modelo.
Métricas registradas
Durante el entrenamiento y la evaluación, registramos las siguientes métricas:
rewards/chosen: las probabilidades logarítmicas medias del modelo de política para las respuestas elegidas, escaladas por betarewards/rejected: las probabilidades logarítmicas medias del modelo de política para las respuestas rechazadas, escaladas por betarewards/accuracies: media de la frecuencia con la que las recompensas elegidas son > que las recompensas rechazadas correspondientesrewards/margins: la diferencia media entre las recompensas elegidas y las recompensas rechazadas correspondienteslog_odds_chosen: la media de la razón de verosimilitud logarítmica de las respuestas elegidas frente a las rechazadaslog_odds_ratio: la media delog(sigmoid(log_odds_chosen))nll_loss: la pérdida media de verosimilitud negativa (negative log likelihood) de la parte SFT de la pérdida sobre las respuestas elegidas
ORPOTrainer
clase trl.experimental.orpo.ORPOTrainer
< source >( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str, NoneType] = Noneargs: trl.experimental.orpo.orpo_config.ORPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | dict[str, datasets.arrow_dataset.Dataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = Nonemodel_init: collections.abc.Callable[[], transformers.modeling_utils.PreTrainedModel] | 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 = Nonepeft_config: PeftConfig | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalLoopOutput], dict] | None = None )
Parámetros
- model (PreTrainedModel) — El modelo a entrenar, preferiblemente un AutoModelForSequenceClassification.
- args (experimental.orpo.ORPOConfig) — Los argumentos de configuración de ORPO que se usarán para 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) — El conjunto de datos que se utilizará para el entrenamiento.
- eval_dataset (Dataset) — El conjunto de datos que se utilizará para la evaluación.
- processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin 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.
- model_init (
Callable[[], transformers.PreTrainedModel]) — El inicializador de modelo a utilizar para el entrenamiento. Si se especifica None, se utilizará el inicializador de modelo predeterminado. - 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. - peft_config (
PeftConfig, opcional) — La configuración de PEFT que se usará para el entrenamiento. Si se pasa una configuración de PEFT, el modelo se envolverá en un modelo PEFT. - 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.
Inicializa ORPOTrainer.
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.
ORPOConfig
clase trl.experimental.orpo.ORPOConfig
< 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 | None = Nonegradient_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 = -1max_length: int | None = 1024max_completion_length: int | None = Nonebeta: float = 0.1disable_dropout: bool = Truepadding_value: int | None = Nonegenerate_during_eval: bool = Falseis_encoder_decoder: bool | None = Nonemodel_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falsedataset_num_proc: int | None = None )
Parámetros
- max_length (
intoNone, opcional, valor predeterminado1024) — Longitud máxima de las secuencias (prompt + completion) en el lote. Este argumento es obligatorio si se desea utilizar el data collator predeterminado. - max_completion_length (
int, opcional) — Longitud máxima de la finalización. Este argumento es obligatorio si se desea usar el collator de datos predeterminado y el modelo es de codificador-decodificador. - beta (
float, opcional, valor predeterminado0.1) — Parámetro que controla el peso relativo de la pérdida de ratio en la pérdida ORPO. En el artículo, se denota con λ. En el código, se denota conalpha. - disable_dropout (
bool, opcional, valor predeterminadoTrue) — Si se debe deshabilitar el dropout en el modelo. - padding_value (
int, opcional) — Valor de relleno a utilizar. Si esNone, se utiliza el valor de relleno del tokenizador. - generate_during_eval (
bool, opcional, valor predeterminadoFalse) — Si esTrue, genera y registra las respuestas del modelo en W&B o Comet durante la evaluación. - is_encoder_decoder (
bool, opcional) — Al usar el argumentomodel_init(llamable) para instanciar el modelo en lugar del argumentomodel, debe especificar si el modelo devuelto por el llamable es un modelo encoder-decoder. - 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 la clase de procesamiento. - 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. - dataset_num_proc (
int, opcional) — Número de procesos a utilizar para procesar el conjunto de datos.
Clase de configuración para experimental.orpo.ORPOTrainer.
Esta clase incluye solo los parámetros específicos para el entrenamiento ORPO. 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.