TRL documentation
Treinador CPO
Treinador CPO
Visão geral
Contrastive Preference Optimization (CPO), conforme introduzido no artigo 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 e Young Jin Kim. Em linhas gerais, o CPO treina modelos para evitar a geração de traduções adequadas, mas não perfeitas, em tarefas de Machine Translation (MT). No entanto, o CPO é uma aproximação geral da perda DPO e pode ser aplicado a outros domínios, como chat.
O CPO visa mitigar duas deficiências fundamentais do SFT. Primeiro, a metodologia do SFT de minimizar a discrepância entre as saídas previstas e as referências padrão-ouro limita inerentemente o desempenho do modelo ao nível de qualidade dos dados de treinamento. Em segundo lugar, o SFT carece de um mecanismo para impedir que o modelo rejeite erros nas traduções. O objetivo do CPO é derivado do objetivo do DPO.
Início rápido
Este exemplo demonstra como treinar um modelo usando o método CPO. Usamos o modelo Qwen 0.5B como modelo base. Usamos os dados de preferência do conjunto de dados UltraFeedback. Você pode visualizar os dados do conjunto de dados aqui:
Abaixo está o script para treinar o 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()Execute o script usando o seguinte comando:
torchrun --nproc_per_node 8 train_cpo.py
Tipo de dataset esperado
O CPO requer um conjunto de dados de preferências. O experimental.cpo.CPOTrainer suporta tanto o formato conversacional quanto o formato padrão de conjuntos de dados. Quando fornecido com um conjunto de dados conversacional, o treinador aplicará automaticamente o modelo de chat ao conjunto de dados.
Métricas registradas
Durante o treinamento e a avaliação, registramos as seguintes métricas:
rewards/chosen: as probabilidades log médias do modelo de política para as respostas escolhidas, escalonadas por betarewards/rejected: as probabilidades log médias do modelo de política para as respostas rejeitadas, escalonadas por betarewards/accuracies: média de quantas vezes as recompensas escolhidas são > que as recompensas rejeitadas correspondentesrewards/margins: a diferença média entre as recompensas escolhidas e as recompensas rejeitadas correspondentesnll_loss: a perda média de log-verossimilhança negativa do modelo de política para as respostas escolhidas
Variantes do CPO
Otimização de Preferência Simples (SimPO)
Simple Preference Optimization (SimPO), de Yu Meng, Mengzhou Xia e Danqi Chen, propõe um algoritmo de otimização de preferências mais simples e eficaz que o DPO, sem utilizar um modelo de referência. Os principais designs do SimPO são (1) usar a log verossimilhança normalizada pelo comprimento como recompensa implícita e (2) incorporar uma margem de recompensa alvo no objetivo de classificação de Bradley-Terry. O código oficial pode ser encontrado em princeton-nlp/SimPO.
O resumo do artigo é o seguinte:
Direct Preference Optimization (DPO) é um algoritmo amplamente utilizado de otimização de preferências offline que reparametriza as funções de recompensa no aprendizado por reforço com feedback humano (RLHF) para aumentar a simplicidade e a estabilidade do treinamento. Neste trabalho, propomos o SimPO, uma abordagem mais simples e eficaz. A eficácia do SimPO é atribuída a um design-chave: usar a probabilidade log média de uma sequência como recompensa implícita. Essa formulação de recompensa se alinha melhor com a geração do modelo e elimina a necessidade de um modelo de referência, tornando-o mais eficiente em termos de computação e memória. Além disso, introduzimos uma margem de recompensa alvo no objetivo de Bradley-Terry para incentivar uma margem maior entre as respostas vencedoras e perdedoras, aprimorando ainda mais o desempenho do algoritmo. Comparamos o SimPO com o DPO e suas variantes mais recentes em diversos conjuntos de treinamento de última geração, incluindo modelos base e ajustados por instruções, como Mistral e Llama3. Avaliamos em extensos benchmarks de seguimento de instruções, incluindo AlpacaEval 2, MT-Bench e o recente e desafiador benchmark Arena-Hard. Nossos resultados demonstram que o SimPO supera consistentemente e significativamente as abordagens existentes sem aumentar substancialmente o comprimento das respostas. Especificamente, o SimPO supera o DPO em até 6,4 pontos no AlpacaEval 2 e em até 7,5 pontos no Arena-Hard. Nosso modelo de melhor desempenho, construído sobre o Llama3-8B-Instruct, alcança uma taxa de vitória controlada por comprimento impressionante de 44,7 no AlpacaEval 2 — superando o Claude 3 Opus no ranking — e uma taxa de vitória de 33,8 no Arena-Hard — tornando-o o modelo open-source de 8B mais forte.
A perda SimPO está integrada no experimental.cpo.CPOTrainer, pois é uma perda alternativa que adiciona uma margem de recompensa, permite normalização de comprimento e não usa regularização BC. Para usar essa perda, basta ativar loss_type="simpo" e cpo_alpha=0.0 no experimental.cpo.CPOConfig e definir o simpo_gamma para um valor recomendado.
CPO-SimPO
Também oferecemos o uso combinado de CPO e SimPO, que permite um treinamento mais estável e um desempenho aprimorado. Saiba mais detalhes em CPO-SimPO GitHub. Para usar este método, basta habilitar o SimPO definindo loss_type="simpo" e um cpo_alpha diferente de zero no experimental.cpo.CPOConfig.
AlphaPO
O 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 e S. Sathiya Keerthi também está implementado no experimental.cpo.CPOTrainer. O AlphaPO é um método alternativo que aplica uma transformação à forma da função de recompensa no contexto da perda SimPO. O resumo do artigo é o seguinte:
O Aprendizado por Reforço com Feedback Humano (RLHF) e suas variantes fizeram grandes avanços rumo ao alinhamento eficaz de grandes modelos de linguagem (LLMs) para seguir instruções e refletir valores humanos. Mais recentemente, surgiram os Algoritmos de Alinhamento Direto (DAAs), nos quais a etapa de modelagem de recompensa do RLHF é omitida ao caracterizar a recompensa diretamente como uma função da política sendo aprendida. Alguns exemplos populares de DAAs incluem a Otimização de Preferência Direta (DPO) e a Otimização de Preferência Simples (SimPO). Esses métodos frequentemente sofrem com o deslocamento de verossimilhança, um fenômeno pelo qual as probabilidades de respostas preferidas são frequentemente reduzidas de forma indesejada. Neste artigo, argumentamos que, para os DAAs, a forma da função de recompensa é importante. Introduzimos o AlphaPO, um novo método de DAA que utiliza um parâmetro α para ajudar a alterar a forma da função de recompensa além da recompensa log padrão. O AlphaPO ajuda a manter um controle detalhado sobre o deslocamento de verossimilhança e a sobreotimização. Em comparação com o SimPO, um dos DAAs com melhor desempenho, o AlphaPO leva a uma melhoria relativa de aproximadamente 7% a 10% no desempenho de alinhamento para as versões instruct do Mistral-7B e do Llama3-8B, ao mesmo tempo que alcança uma melhoria relativa de 15% a 50% em relação ao DPO nos mesmos modelos. A análise e os resultados apresentados destacam a importância da forma da recompensa e como é possível alterá-la sistematicamente para afetar a dinâmica do treinamento, bem como melhorar o desempenho de alinhamento.
Para usar essa perda conforme descrito no artigo, podemos definir loss_type="alphapo", o que define automaticamente loss_type="simpo" e cpo_alpha=0.0, junto com alpha e simpo_gamma para os valores recomendados no experimental.cpo.CPOConfig. Alternativamente, você pode definir manualmente loss_type="simpo", cpo_alpha=0.0, junto com alpha e simpo_gamma para os valores recomendados. Outras variantes desse método também são possíveis, como definir loss_type="ipo" e alpha para qualquer valor não nulo.
Funções de perda
O algoritmo CPO suporta várias funções de perda. A função de perda pode ser definida usando o parâmetro loss_type no experimental.cpo.CPOConfig. As seguintes funções de perda são suportadas:
loss_type= | Descrição |
|---|---|
"sigmoid" (padrão) | Dado os dados de preferência, podemos ajustar um classificador binário de acordo com o modelo de Bradley-Terry e, de fato, os autores do DPO propõem a perda sigmoide sobre a verossimilhança normalizada por meio do logsigmoid para ajustar uma regressão logística. |
"hinge" | Os autores do RSO propõem usar uma perda de hinge sobre a verossimilhança normalizada do artigo SLiC. Nesse caso, o beta é o recíproco da margem. |
"ipo" | Os autores do IPO fornecem uma compreensão teórica mais aprofundada dos algoritmos DPO e identificam um problema de overfitting, propondo uma perda alternativa. Neste caso, o beta é o recíproco da diferença entre as razões de log-verossimilhança do par de conclusões escolhidas versus rejeitadas, e, portanto, quanto menor o beta, maior é essa diferença. Conforme o artigo, a perda é média sobre as log-verossimilhanças da conclusão (ao contrário do DPO, que apenas soma). |
"simpo" | O método SimPO também está implementado no experimental.cpo.CPOTrainer. O SimPO é uma perda alternativa que adiciona uma margem de recompensa, permite normalização de comprimento e não usa regularização BC. Para usar essa perda, basta definir loss_type="simpo" e cpo_alpha=0.0 no experimental.cpo.CPOConfig e simpo_gamma para um valor recomendado. |
"alphapo" | O método AlphaPO também está implementado no experimental.cpo.CPOTrainer. Isso é um atalho sintático que define automaticamente loss_type="simpo" e cpo_alpha=0.0. O AlphaPO aplica uma transformação à forma da função de recompensa no contexto da perda SimPO quando o parâmetro alpha é diferente de zero. |
Para Modelos Mixture of Experts: Habilitando a perda auxiliar
MOEs são mais eficientes quando a carga é distribuída de forma aproximadamente igual entre os especialistas.
Para garantir que treinemos MOEs de maneira semelhante durante o ajuste de preferências, é benéfico adicionar a perda auxiliar do balanceador de carga à perda final.
Esta opção é ativada definindo output_router_logits=True na configuração do modelo (por exemplo, MixtralConfig).
Para ajustar a contribuição da perda auxiliar para a perda total, use o hiperparâmetro router_aux_loss_coef=... (padrão: 0.001) na configuração do modelo.
CPOTrainer
classe 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) — O modelo a ser treinado, de preferência um AutoModelForSequenceClassification.
- args (experimental.cpo.CPOConfig) — Os argumentos de configuração do CPO a serem usados para o treinamento.
- data_collator (
DataCollator) — O data collator a ser usado para o treinamento. Se None for especificado, o data collator padrão (experimental.utils.DPODataCollatorWithPadding) será utilizado, que irá aplicar padding nas sequências até o comprimento máximo das sequências no batch, dado um conjunto de dados de sequências em pares. - train_dataset (Dataset) — O conjunto de dados a ser usado para o treinamento.
- eval_dataset (Dataset) — O conjunto de dados a ser usado para avaliação.
- processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin ou ProcessorMixin, opcional) — Classe de processamento usada para processar os dados. Se fornecida, será usada para processar automaticamente as entradas do modelo e será salva junto com o modelo para facilitar a reexecução de um treinamento interrompido ou a reutilização do modelo ajustado.
- model_init (
Callable[[], transformers.PreTrainedModel]) — O inicializador de modelo a ser usado para o treinamento. Se None for especificado, o inicializador de modelo padrão será usado. - callbacks (
list[transformers.TrainerCallback]) — Os callbacks a serem usados para o treinamento. - optimizers (
tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]) — O otimizador e o agendador a serem usados para o treinamento. - preprocess_logits_for_metrics (
Callable[[torch.Tensor, torch.Tensor], torch.Tensor]) — A função a ser usada para pré-processar os logits antes de calcular as métricas. - peft_config (
PeftConfig, opcional) — A configuração PEFT a ser usada para o treinamento. Se você passar uma configuração PEFT, o modelo será envolvido em um modelo PEFT. - compute_metrics (
Callable[[EvalPrediction], dict], opcional) — A função a ser usada para calcular as métricas. Deve receber umEvalPredictione retornar um dicionário de strings para valores de métricas.
Inicialize o CPOTrainer.
treino
< 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 (
stroubool, opcional) — Se for umstr, caminho local para um checkpoint salvo por uma instância anterior deTrainer. Se for umboole for igual aTrue, carrega o último checkpoint em args.output_dir salvo por uma instância anterior deTrainer. Se presente, o treinamento será retomado a partir dos estados do modelo/otimizador/agendador carregados aqui. - trial (
optuna.Trialoudict[str, Any], opcional) — A execução do trial ou o dicionário de hiperparâmetros para a busca de hiperparâmetros. - ignore_keys_for_eval (
list[str], opcional) — Uma lista de chaves na saída do seu modelo (se for um dicionário) que devem ser ignoradas ao coletar previsões para avaliação durante o treinamento.
Retorna
~trainer_utils.TrainOutput
Objeto contendo a contagem de etapas globais, a perda de treinamento e as métricas.
Ponto de entrada principal do treinamento.
Salvará o modelo, para que você possa recarregá-lo usando from_pretrained().
Salvará apenas a partir do processo 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, padrão"End of training") — Mensagem a ser commitada durante o push. - blocking (
bool, opcional, padrãoTrue) — Se a função deve retornar apenas quando ogit pushtiver terminado. - token (
str, opcional, padrãoNone) — Token com permissão de escrita para sobrescrever os argumentos originais do Trainer. - revision (
str, opcional) — A revisão git de onde o commit será feito. O padrão é o topo do ramo “main”. - private (
bool, opcional) — Se o repositório deve ser privado quando for criado. O padrão éargs.hub_private_repo. Não tem efeito se o repositório já existir. - kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados para~Trainer.create_model_card.
Envie self.model e self.processing_class para o hub de modelos do 🤗 no repositório self.args.hub_model_id.
CPOConfig
classe 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 (
intouNone, opcional, padrão1024) — Comprimento máximo das sequências (prompt + completion) no lote. Este argumento é obrigatório se você quiser usar o data collator padrão. - max_completion_length (
int, opcional) — Comprimento máximo da conclusão. Este argumento é obrigatório se você deseja usar o data collator padrão e seu modelo for um encoder-decoder. - beta (
float, opcional, padrão0.1) — Parâmetro que controla o desvio em relação ao modelo de referência. Valores maiores de β indicam menor desvio em relação ao modelo de referência. Para a perda IPO (loss_type="ipo"), β é o parâmetro de regularização denotado por τ no artigo. - label_smoothing (
float, opcional, padrão0.0) — Fator de suavização de rótulos. Este argumento é obrigatório se você quiser usar o colador de dados padrão. - loss_type (
str, opcional, padrão é"sigmoid") — Tipo de perda a ser usado. Os valores possíveis são:"sigmoid": perda sigmoidal do artigo original do DPO."hinge": perda hinge sobre a verossimilhança normalizada do artigo SLiC."ipo": perda IPO do paper IPO."simpo": perda SimPO do paper SimPO."alphapo": perda AlphaPO do paper AlphaPO. Isso define automaticamenteloss_type="simpo"ecpo_alpha=0.0.
- disable_dropout (
bool, opcional, padrãoTrue) — Se deve desabilitar o dropout no modelo. - cpo_alpha (
float, opcional, padrão1.0) — Peso do regularizador BC no treinamento CPO. - simpo_gamma (
float, opcional, padrão0.5) — Margem de recompensa alvo para a perda SimPO, usada apenas quandoloss_type="simpo". - alpha (
float, opcional, padrão0.0) — Parâmetro que controla a forma da função de recompensa em todos os tipos de perda. Quando alpha=0 (padrão), utiliza recompensas de log probabilidade padrão. Quandoalpha != 0, aplica a transformação AlphaPO:r = (1 - p^(-alpha)) / alphado artigo AlphaPO. Este parâmetro funciona com todos os tipos de perda. - generate_during_eval (
bool, opcional, padrãoFalse) — SeTrue, gera e registra as conclusões do modelo no W&B ou Comet durante a avaliação. - is_encoder_decoder (
bool, opcional) — Ao usar o argumentomodel_init(chamável) para instanciar o modelo em vez do argumentomodel, você precisa especificar se o modelo retornado pelo chamável é um modelo encoder-decoder. - model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave para passar aAutoModelForCausalLM.from_pretrainedao instanciar o modelo a partir de uma string. O valor derevisiontambém é usado ao carregar a classe de processamento. - trust_remote_code (
bool, opcional, padrãoFalse) — Se permite carregar modelos que incluem código Python personalizado do Hub. Encaminhado para from_pretrained. - dataset_num_proc (
int, opcional) — Número de processos a serem usados para processar o conjunto de dados.
Classe de configuração para o experimental.cpo.CPOTrainer.
Esta classe inclui apenas os parâmetros específicos para o treinamento CPO. Para a lista completa de argumentos de treinamento, consulte a documentação de TrainingArguments. Observe que os valores padrão nesta classe podem diferir dos presentes em TrainingArguments.
Usando HfArgumentParser, podemos transformar essa classe em argumentos argparse que podem ser especificados na linha de comando.
Esses parâmetros possuem valores padrão diferentes de TrainingArguments:
logging_steps: O valor padrão é10em vez de500.gradient_checkpointing: O padrão éTrueem vez deFalse.bf16: Padrão éTruesefp16não estiver definido, em vez deFalse.learning_rate: O valor padrão é1e-6em vez de5e-5.