TRL documentation
Entrenador CPO
Entrenador CPO
Resumen
Optimización de Preferencias Contrastivas (CPO), tal como se introduce en el artículo Contrastive Preference Optimization: Pushing the Boundaries of LLM Performance in Machine Translation de Haoran Xu, Amr Sharaf, Yunmo Chen, Weiting Tan, Lingfeng Shen, Benjamin Van Durme, Kenton Murray y Young Jin Kim. En términos generales, CPO entrena a los modelos para evitar generar traducciones adecuadas, pero no perfectas, en tareas de Traducción Automática (MT). Sin embargo, CPO es una aproximación general de la pérdida DPO y puede aplicarse a otros dominios, como el chat.
CPO busca mitigar dos deficiencias fundamentales de SFT. En primer lugar, la metodología de SFT de minimizar la discrepancia entre las salidas predichas y las referencias de calidad estándar limita inherentemente el rendimiento del modelo al nivel de calidad de los datos de entrenamiento. En segundo lugar, SFT carece de un mecanismo para evitar que el modelo rechace los errores en las traducciones. El objetivo de CPO se deriva del objetivo de DPO.
Inicio rápido
Este ejemplo demuestra cómo entrenar un modelo utilizando el método CPO. Utilizamos el modelo Qwen 0.5B como modelo base. Utilizamos los datos de preferencia del conjunto de datos UltraFeedback. Puede ver los datos del conjunto de datos aquí:
A continuación se muestra el script para entrenar el modelo:
# train_cpo.py
from datasets import load_dataset
from trl.experimental.cpo import CPOConfig, CPOTrainer
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 = CPOConfig(output_dir="Qwen2-0.5B-CPO")
trainer = CPOTrainer(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_cpo.py
Tipo de conjunto de datos esperado
CPO requiere un conjunto de datos de preferencia. El experimental.cpo.CPOTrainer admite tanto el formato conversacional como el formato estándar de conjuntos de datos. Cuando se proporciona un conjunto de datos conversacional, el entrenador aplica automáticamente la plantilla de chat al conjunto de datos.
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 correspondientesnll_loss: la pérdida media de verosimilitud negativa del modelo de política para las respuestas elegidas
Variantes de CPO
Optimización de preferencias simple (SimPO)
Simple Preference Optimization (SimPO), de Yu Meng, Mengzhou Xia y Danqi Chen, propone un algoritmo de optimización de preferencias más simple y efectivo que DPO, sin utilizar un modelo de referencia. Los diseños clave de SimPO son (1) utilizar la verosimilitud logarítmica normalizada por longitud como recompensa implícita, y (2) incorporar un margen de recompensa objetivo en el objetivo de clasificación de Bradley-Terry. El código oficial se encuentra en princeton-nlp/SimPO.
El resumen del artículo es el siguiente:
Direct Preference Optimization (DPO) es un algoritmo de optimización de preferencias offline ampliamente utilizado que reparametriza las funciones de recompensa en el aprendizaje por refuerzo con retroalimentación humana (RLHF) para mejorar la simplicidad y la estabilidad del entrenamiento. En este trabajo, proponemos SimPO, un enfoque más simple pero más efectivo. La efectividad de SimPO se atribuye a un diseño clave: utilizar la probabilidad logarítmica promedio de una secuencia como recompensa implícita. Esta formulación de recompensa se alinea mejor con la generación del modelo y elimina la necesidad de un modelo de referencia, lo que lo hace más eficiente en términos de cómputo y memoria. Además, introducimos un margen de recompensa objetivo en el objetivo de Bradley-Terry para fomentar un margen mayor entre las respuestas ganadoras y perdedoras, mejorando aún más el rendimiento del algoritmo. Comparamos SimPO con DPO y sus variantes más recientes en diversos entornos de entrenamiento de última generación, que incluyen tanto modelos base como modelos ajustados con instrucciones, como Mistral y Llama3. Evaluamos en amplias pruebas de seguimiento de instrucciones, incluyendo AlpacaEval 2, MT-Bench y el reciente y desafiante benchmark Arena-Hard. Nuestros resultados demuestran que SimPO supera de manera consistente y significativa a los enfoques existentes sin aumentar sustancialmente la longitud de la respuesta. Específicamente, SimPO supera a DPO en hasta 6,4 puntos en AlpacaEval 2 y en hasta 7,5 puntos en Arena-Hard. Nuestro modelo de mejor rendimiento, construido sobre Llama3-8B-Instruct, logra una notable tasa de victoria controlada por longitud del 44,7 en AlpacaEval 2, superando a Claude 3 Opus en el ranking, y una tasa de victoria del 33,8 en Arena-Hard, lo que lo convierte en el modelo de código abierto de 8B más fuerte.
La pérdida SimPO está integrada en experimental.cpo.CPOTrainer, ya que es una pérdida alternativa que añade un margen de recompensa, permite la normalización por longitud y no utiliza regularización BC. Para usar esta pérdida, solo hay que activar loss_type="simpo" y cpo_alpha=0.0 en experimental.cpo.CPOConfig y establecer simpo_gamma en un valor recomendado.
CPO-SimPO
También ofrecemos el uso combinado de CPO y SimPO, lo que permite un entrenamiento más estable y un mejor rendimiento. Obtenga más detalles en CPO-SimPO GitHub. Para usar este método, simplemente active SimPO estableciendo loss_type="simpo" y un cpo_alpha no nulo en experimental.cpo.CPOConfig.
AlphaPO
El método AlphaPO — Reward shape matters for LLM alignment (AlphaPO) de Aman Gupta, Shao Tang, Qingquan Song, Sirou Zhu, Jiwoo Hong, Ankan Saha, Viral Gupta, Noah Lee, Eunki Kim, Jason Zhu, Natesh Pillai y S. Sathiya Keerthi también está implementado en experimental.cpo.CPOTrainer. AlphaPO es un método alternativo que aplica una transformación a la forma de la función de recompensa en el contexto de la pérdida SimPO. El resumen del artículo es el siguiente:
El Aprendizaje por Refuerzo con Retroalimentación Humana (RLHF) y sus variantes han logrado avances significativos hacia la alineación efectiva de los grandes modelos de lenguaje (LLMs) para que sigan instrucciones y reflejen los valores humanos. Más recientemente, han surgido los Algoritmos de Alineación Directa (DAAs), en los que se omite la etapa de modelado de recompensas del RLHF al caracterizar la recompensa directamente como una función de la política que se está aprendiendo. Algunos ejemplos populares de DAAs incluyen la Optimización de Preferencias Directas (DPO) y la Optimización de Preferencias Simple (SimPO). Estos métodos suelen sufrir de desplazamiento de verosimilitud, un fenómeno por el cual las probabilidades de las respuestas preferidas se reducen de manera indeseada. En este artículo, argumentamos que, para los DAAs, la forma de la función de recompensa es importante. Introducimos AlphaPO, un nuevo método DAA que aprovecha un parámetro α para ayudar a cambiar la forma de la función de recompensa más allá de la recompensa log estándar. AlphaPO ayuda a mantener un control detallado sobre el desplazamiento de verosimilitud y la sobreoptimización. En comparación con SimPO, uno de los DAAs con mejor rendimiento, AlphaPO logra una mejora relativa de aproximadamente el 7% al 10% en el rendimiento de alineación para las versiones instruct de Mistral-7B y Llama3-8B, mientras que alcanza una mejora relativa del 15% al 50% sobre DPO en los mismos modelos. El análisis y los resultados presentados destacan la importancia de la forma de la recompensa y cómo se puede cambiar de manera sistemática para afectar la dinámica de entrenamiento, así como mejorar el rendimiento de alineación.
Para usar esta pérdida tal como se describe en el artículo, podemos establecer loss_type="alphapo", lo que configura automáticamente loss_type="simpo" y cpo_alpha=0.0, junto con alpha y simpo_gamma a los valores recomendados en experimental.cpo.CPOConfig. Alternativamente, puedes configurar manualmente loss_type="simpo", cpo_alpha=0.0, junto con alpha y simpo_gamma a los valores recomendados. También son posibles otras variantes de este método, como establecer loss_type="ipo" y alpha a cualquier valor no nulo.
Funciones de pérdida
El algoritmo CPO admite varias funciones de pérdida. La función de pérdida se puede configurar mediante el parámetro loss_type en experimental.cpo.CPOConfig. Las funciones de pérdida admitidas son las siguientes:
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 ofrecen una comprensión teórica más profunda de los algoritmos DPO e identifican un problema de sobreajuste, proponiendo una función de pérdida alternativa. En este caso, beta es el recíproco de la diferencia entre las razones de verosimilitud logarítmica de la pareja de finalización elegida frente a la rechazada, por lo que cuanto menor sea beta, mayor será esta diferencia. Según el artículo, la pérdida se promedia sobre las verosimilitudes logarítmicas de la finalización (a diferencia de DPO, que solo las suma). |
"simpo" | El método SimPO también está implementado en experimental.cpo.CPOTrainer. SimPO es una función de pérdida alternativa que añade un margen de recompensa, permite la normalización por longitud y no utiliza regularización BC. Para usar esta función de pérdida, simplemente establezca loss_type="simpo" y cpo_alpha=0.0 en experimental.cpo.CPOConfig y simpo_gamma a un valor recomendado. |
"alphapo" | El método AlphaPO también está implementado en experimental.cpo.CPOTrainer. Esto es azúcar sintáctico que establece automáticamente loss_type="simpo" y cpo_alpha=0.0. AlphaPO aplica una transformación a la forma de la función de recompensa en el contexto de la pérdida SimPO cuando el parámetro alpha es distinto de cero. |
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.
CPOTrainer
clase trl.experimental.cpo.CPOTrainer
< source >( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str, NoneType] = Noneargs: trl.experimental.cpo.cpo_config.CPOConfig | 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.cpo.CPOConfig) — Los argumentos de configuración de CPO 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 utilizará 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 CPOTrainer.
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.
CPOConfig
clase trl.experimental.cpo.CPOConfig
< 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 = -1max_length: int | None = 1024max_completion_length: int | None = Nonebeta: float = 0.1label_smoothing: float = 0.0loss_type: str = 'sigmoid'disable_dropout: bool = Truecpo_alpha: float = 1.0simpo_gamma: float = 0.5alpha: float = 0.0generate_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 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"), β es el parámetro de regularización denotado por τ en el artículo. - label_smoothing (
float, opcional, valor predeterminado0.0) — Factor de suavizado de etiquetas. Este argumento es obligatorio si se desea usar el collator de datos predeterminado. - loss_type (
str, opcional, por defecto"sigmoid") — Tipo de pérdida a utilizar. Los valores posibles son:"sigmoid": pérdida sigmoid de el artículo original de DPO."hinge": pérdida de bisagra sobre la verosimilitud normalizada del artículo SLiC."ipo": pérdida IPO del artículo IPO."simpo": pérdida SimPO del artículo SimPO."alphapo": pérdida AlphaPO del artículo AlphaPO. Esto establece automáticamenteloss_type="simpo"ycpo_alpha=0.0.
- disable_dropout (
bool, opcional, valor predeterminadoTrue) — Si se debe deshabilitar el dropout en el modelo. - cpo_alpha (
float, opcional, valor predeterminado1.0) — Peso del regularizador BC en el entrenamiento CPO. - simpo_gamma (
float, opcional, valor predeterminado0.5) — Margen de recompensa objetivo para la pérdida SimPO, utilizado solo cuandoloss_type="simpo". - alpha (
float, opcional, valor predeterminado0.0) — Parámetro que controla la forma de la función de recompensa en todos los tipos de pérdida. Cuando alpha=0 (predeterminado), se utilizan recompensas de probabilidad logarítmica estándar. Cuandoalpha != 0, se aplica la transformación AlphaPO:r = (1 - p^(-alpha)) / alphadel artículo AlphaPO. Este parámetro funciona con todos los tipos de pérdida. - 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.cpo.CPOTrainer.
Esta clase incluye solo los parámetros específicos para el entrenamiento CPO. 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.