TRL documentation

Pelatih CPO

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Pelatih CPO

model badge

Ikhtisar

Contrastive Preference Optimization (CPO) yang diperkenalkan dalam makalah Contrastive Preference Optimization: Pushing the Boundaries of LLM Performance in Machine Translation oleh Haoran Xu, Amr Sharaf, Yunmo Chen, Weiting Tan, Lingfeng Shen, Benjamin Van Durme, Kenton Murray, dan Young Jin Kim. Secara garis besar, CPO melatih model untuk menghindari pembuatan terjemahan yang memadai, tetapi tidak sempurna, dalam tugas Machine Translation (MT). Namun, CPO adalah aproksimasi umum dari kerugian DPO dan dapat diterapkan pada domain lain, seperti chat.

CPO bertujuan untuk memitigasi dua kekurangan mendasar dari SFT. Pertama, metodologi SFT yang meminimalkan selisih antara output prediksi dan referensi standar emas secara inheren membatasi kinerja model pada tingkat kualitas data pelatihan. Kedua, SFT tidak memiliki mekanisme untuk mencegah model menolak kesalahan dalam terjemahan. Tujuan CPO diturunkan dari tujuan DPO.

Mulai cepat

Contoh ini menunjukkan cara melatih model menggunakan metode CPO. Kami menggunakan model Qwen 0.5B sebagai model dasar. Kami menggunakan data preferensi dari dataset UltraFeedback. Anda dapat melihat data dalam dataset di sini:

Berikut adalah skrip untuk melatih model:

# 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()

Jalankan skrip menggunakan perintah berikut:

torchrun --nproc_per_node 8 train_cpo.py

Jenis dataset yang diharapkan

CPO memerlukan dataset preferensi. experimental.cpo.CPOTrainer mendukung format dataset percakapan dan standar. Ketika diberikan dataset percakapan, trainer akan secara otomatis menerapkan template chat ke dataset tersebut.

Metrik yang dicatat

Selama pelatihan dan evaluasi, kami mencatat metrik berikut:

  • rewards/chosen: rata-rata log probabilitas dari model kebijakan untuk respons yang dipilih, diskalakan dengan beta
  • rewards/rejected: rata-rata log probabilitas dari model kebijakan untuk respons yang ditolak, diskalakan dengan beta
  • rewards/accuracies: rata-rata seberapa sering reward yang dipilih > dari reward yang ditolak yang bersesuaian
  • rewards/margins: selisih rata-rata antara reward yang dipilih dan reward yang ditolak yang bersesuaian
  • nll_loss: rata-rata kerugian log likelihood negatif dari model kebijakan untuk respons yang dipilih

Variasi CPO

Optimasi Preferensi Sederhana (SimPO)

Simple Preference Optimization (SimPO) oleh Yu Meng, Mengzhou Xia, dan Danqi Chen mengusulkan algoritma optimasi preferensi yang lebih sederhana dan efektif daripada DPO tanpa menggunakan model referensi. Desain kunci dalam SimPO adalah (1) menggunakan log likelihood yang dinormalisasi berdasarkan panjang sebagai imbalan implisit, dan (2) mengintegrasikan margin imbalan target dalam tujuan peringkat Bradley-Terry. Kode resmi dapat ditemukan di princeton-nlp/SimPO.

Abstrak dari makalah tersebut adalah sebagai berikut:

Direct Preference Optimization (DPO) adalah algoritma optimasi preferensi offline yang banyak digunakan, yang mereparameterisasi fungsi reward dalam reinforcement learning from human feedback (RLHF) untuk meningkatkan kesederhanaan dan stabilitas pelatihan. Dalam karya ini, kami mengusulkan SimPO, sebuah pendekatan yang lebih sederhana namun lebih efektif. Efektivitas SimPO disebabkan oleh desain kunci: menggunakan probabilitas log rata-rata dari sebuah urutan sebagai reward implisit. Formulasi reward ini lebih selaras dengan generasi model dan menghilangkan kebutuhan akan model referensi, sehingga lebih efisien dalam komputasi dan memori. Selain itu, kami memperkenalkan target reward margin ke dalam tujuan Bradley-Terry untuk mendorong margin yang lebih besar antara respons pemenang dan kalah, yang semakin meningkatkan kinerja algoritma. Kami membandingkan SimPO dengan DPO dan varian terkininya di berbagai setup pelatihan state-of-the-art, termasuk model base dan instruction-tuned seperti Mistral dan Llama3. Kami mengevaluasi pada benchmark instruction-following yang luas, termasuk AlpacaEval 2, MT-Bench, dan benchmark Arena-Hard yang menantang dan baru-baru ini. Hasil kami menunjukkan bahwa SimPO secara konsisten dan signifikan melampaui pendekatan yang ada tanpa secara substansial meningkatkan panjang respons. Secara spesifik, SimPO melampaui DPO hingga 6,4 poin pada AlpacaEval 2 dan hingga 7,5 poin pada Arena-Hard. Model berkinerja terbaik kami, yang dibangun di atas Llama3-8B-Instruct, mencapai win rate length-controlled yang luar biasa sebesar 44,7 pada AlpacaEval 2 — melampaui Claude 3 Opus di leaderboard, dan win rate 33,8 pada Arena-Hard — menjadikannya model open-source 8B terkuat.

Loss SimPO terintegrasi dalam experimental.cpo.CPOTrainer, karena merupakan loss alternatif yang menambahkan reward margin, memungkinkan normalisasi panjang, dan tidak menggunakan regularisasi BC. Untuk menggunakan loss ini, cukup aktifkan loss_type="simpo" dan cpo_alpha=0.0 di experimental.cpo.CPOConfig serta atur simpo_gamma ke nilai yang direkomendasikan.

CPO-SimPO

Kami juga menawarkan penggunaan gabungan CPO dan SimPO, yang memungkinkan pelatihan yang lebih stabil dan peningkatan kinerja. Pelajari detail lebih lanjut di CPO-SimPO GitHub. Untuk menggunakan metode ini, cukup aktifkan SimPO dengan mengatur loss_type="simpo" dan cpo_alpha yang tidak nol di experimental.cpo.CPOConfig.

AlphaPO

Metode AlphaPO — Reward shape matters for LLM alignment (AlphaPO) oleh Aman Gupta, Shao Tang, Qingquan Song, Sirou Zhu, Jiwoo Hong, Ankan Saha, Viral Gupta, Noah Lee, Eunki Kim, Jason Zhu, Natesh Pillai, dan S. Sathiya Keerthi juga diimplementasikan dalam experimental.cpo.CPOTrainer. AlphaPO adalah metode alternatif yang menerapkan transformasi pada bentuk fungsi reward dalam konteks kerugian SimPO. Abstrak dari makalahnya adalah sebagai berikut:

Reinforcement Learning with Human Feedback (RLHF) dan variasinya telah membuat kemajuan besar menuju keselarasan yang efektif dari large language models (LLMs) untuk mengikuti instruksi dan mencerminkan nilai-nilai manusia. Baru-baru ini, Direct Alignment Algorithms (DAAs) muncul, di mana tahap pemodelan reward dari RLHF dilewati dengan mengkarakterisasi reward secara langsung sebagai fungsi dari kebijakan yang dipelajari. Beberapa contoh populer dari DAAs meliputi Direct Preference Optimization (DPO) dan Simple Preference Optimization (SimPO). Metode-metode ini sering kali mengalami likelihood displacement, yaitu fenomena di mana probabilitas respons yang lebih disukai sering kali berkurang secara tidak diinginkan. Dalam makalah ini, kami berargumen bahwa, untuk DAAs, bentuk (fungsi) reward sangat penting. Kami memperkenalkan AlphaPO, metode DAA baru yang memanfaatkan parameter α untuk membantu mengubah bentuk fungsi reward di luar log reward standar. AlphaPO membantu mempertahankan kontrol yang rinci atas likelihood displacement dan overoptimization. Dibandingkan dengan SimPO, salah satu DAA dengan kinerja terbaik, AlphaPO menghasilkan peningkatan relatif sekitar 7% hingga 10% dalam kinerja keselarasan untuk versi instruct dari Mistral-7B dan Llama3-8B, sambil mencapai peningkatan relatif 15% hingga 50% dibandingkan DPO pada model-model yang sama. Analisis dan hasil yang disajikan menyoroti pentingnya bentuk reward dan bagaimana bentuk tersebut dapat diubah secara sistematis untuk memengaruhi dinamika pelatihan, serta meningkatkan kinerja keselarasan.

Untuk menggunakan loss ini seperti yang dijelaskan dalam makalah, kita dapat mengatur loss_type="alphapo" yang secara otomatis mengatur loss_type="simpo" dan cpo_alpha=0.0, bersama dengan alpha dan simpo_gamma ke nilai yang direkomendasikan dalam experimental.cpo.CPOConfig. Sebagai alternatif, Anda dapat mengatur secara manual loss_type="simpo", cpo_alpha=0.0, bersama dengan alpha dan simpo_gamma ke nilai yang direkomendasikan. Varian lain dari metode ini juga dimungkinkan, seperti mengatur loss_type="ipo" dan alpha ke nilai apa pun yang tidak nol.

Fungsi kerugian

Algoritma CPO mendukung beberapa fungsi kerugian. Fungsi kerugian dapat diatur menggunakan parameter loss_type di experimental.cpo.CPOConfig. Fungsi kerugian berikut didukung:

loss_type=Deskripsi
"sigmoid" (default)Dengan data preferensi, kita dapat menyesuaikan klasifikator biner sesuai model Bradley-Terry, dan memang, para penulis DPO mengusulkan kerugian sigmoid pada kemungkinan yang dinormalisasi melalui logsigmoid untuk menyesuaikan regresi logistik.
"hinge"Para penulis RSO mengusulkan untuk menggunakan hinge loss pada likelihood ternormalisasi dari makalah SLiC. Dalam kasus ini, beta adalah kebalikan dari margin.
"ipo"Para penulis IPO memberikan pemahaman teoretis yang lebih mendalam tentang algoritma DPO dan mengidentifikasi masalah overfitting serta mengusulkan loss alternatif. Dalam hal ini, beta adalah kebalikan dari selisih antara rasio log-likelihood dari pasangan completion yang dipilih versus yang ditolak, sehingga semakin kecil beta, semakin besar selisih tersebut. Sesuai dengan makalahnya, loss dirata-ratakan atas log-likelihood dari completion (berbeda dengan DPO, yang hanya dijumlahkan).
"simpo"Metode SimPO juga diimplementasikan dalam experimental.cpo.CPOTrainer. SimPO adalah loss alternatif yang menambahkan reward margin, memungkinkan normalisasi panjang, dan tidak menggunakan regularisasi BC. Untuk menggunakan loss ini, cukup atur loss_type="simpo" dan cpo_alpha=0.0 di experimental.cpo.CPOConfig serta simpo_gamma ke nilai yang direkomendasikan.
"alphapo"Metode AlphaPO juga diimplementasikan dalam experimental.cpo.CPOTrainer. Ini adalah syntactic sugar yang secara otomatis mengatur loss_type="simpo" dan cpo_alpha=0.0. AlphaPO menerapkan transformasi pada bentuk fungsi reward dalam konteks kerugian SimPO ketika parameter alpha tidak nol.

Untuk Model Mixture of Experts: Mengaktifkan auxiliary loss

MOE paling efisien jika beban didistribusikan secara merata di antara para ahli.
Untuk memastikan bahwa MOE dilatih dengan cara yang serupa selama penyetelan preferensi, sangat bermanfaat untuk menambahkan kerugian bantu dari penyeimbang beban ke kerugian akhir.

Opsi ini diaktifkan dengan mengatur output_router_logits=True dalam konfigurasi model (misalnya, MixtralConfig).
Untuk mengatur seberapa besar kontribusi loss tambahan terhadap total loss, gunakan hiperparameter router_aux_loss_coef=... (default: 0.001) dalam konfigurasi model.

CPOTrainer

kelas trl.experimental.cpo.CPOTrainer

< >

( 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 )

Parameter

  • model (PreTrainedModel) — Model yang akan dilatih, sebaiknya berupa AutoModelForSequenceClassification.
  • args (experimental.cpo.CPOConfig) — Argumen konfigurasi CPO yang digunakan untuk pelatihan.
  • data_collator (DataCollator) — Data collator yang akan digunakan untuk pelatihan. Jika None ditentukan, data collator default (experimental.utils.DPODataCollatorWithPadding) akan digunakan, yang akan melakukan padding pada urutan hingga panjang maksimum dari urutan dalam batch, mengingat dataset berupa pasangan urutan.
  • train_dataset (Dataset) — Dataset yang digunakan untuk pelatihan.
  • eval_dataset (Dataset) — Dataset yang digunakan untuk evaluasi.
  • processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin atau ProcessorMixin, opsional) — Kelas pemrosesan yang digunakan untuk memproses data. Jika disediakan, kelas ini akan digunakan untuk memproses input secara otomatis untuk model, dan akan disimpan bersama model untuk memudahkan menjalankan ulang pelatihan yang terputus atau menggunakan kembali model yang telah dihaluskan.
  • model_init (Callable[[], transformers.PreTrainedModel]) — Inisialisator model yang akan digunakan untuk pelatihan. Jika None ditentukan, inisialisator model default akan digunakan.
  • callbacks (list[transformers.TrainerCallback]) — Callback yang akan digunakan untuk pelatihan.
  • optimizers (tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]) — Optimizer dan scheduler yang akan digunakan untuk pelatihan.
  • preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]) — Fungsi yang digunakan untuk memproses ulang logits sebelum menghitung metrik.
  • peft_config (PeftConfig, opsional) — Konfigurasi PEFT yang akan digunakan untuk pelatihan. Jika Anda meneruskan konfigurasi PEFT, model akan dibungkus dalam model PEFT.
  • compute_metrics (Callable[[EvalPrediction], dict], opsional) — Fungsi yang digunakan untuk menghitung metrik. Harus menerima EvalPrediction dan mengembalikan kamus string ke nilai metrik.

Inisialisasi CPOTrainer.

latih

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

Parameter

  • resume_from_checkpoint (str atau bool, opsional) — Jika berupa str, jalur lokal ke checkpoint yang disimpan oleh instance Trainer sebelumnya. Jika berupa bool dan bernilai True, muat checkpoint terakhir di args.output_dir yang disimpan oleh instance Trainer sebelumnya. Jika ada, pelatihan akan dilanjutkan dari status model/optimizer/scheduler yang dimuat di sini.
  • trial (optuna.Trial atau dict[str, Any], opsional) — Jalankan trial atau kamus hiperparameter untuk pencarian hiperparameter.
  • ignore_keys_for_eval (list[str], opsional) — Daftar kunci dalam output model Anda (jika berupa dictionary) yang harus diabaikan saat mengumpulkan prediksi untuk evaluasi selama pelatihan.

Mengembalikan

~trainer_utils.TrainOutput

Objek yang berisi jumlah langkah global, kerugian pelatihan, dan metrik.

Titik masuk utama pelatihan.

save_model

< >

( output_dir: str | None = None_internal_call: bool = False )

Akan menyimpan model, sehingga Anda dapat memuatnya kembali menggunakan from_pretrained().

Hanya akan menyimpan dari proses utama.

push_to_hub

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

Parameter

  • commit_message (str, opsional, default "End of training") — Pesan untuk commit saat melakukan push.
  • blocking (bool, opsional, default True) — Apakah fungsi harus hanya mengembalikan nilai setelah git push selesai.
  • token (str, opsional, defaultnya None) — Token dengan izin tulis untuk menimpa argumen asli Trainer.
  • revision (str, opsional) — Revisi git untuk di-commit. Secara default menggunakan head dari branch “main”.
  • private (bool, opsional) — Apakah membuat repo menjadi privat saat dibuat. Defaultnya adalah args.hub_private_repo. Tidak berpengaruh jika repo sudah ada.
  • kwargs (dict[str, Any], opsional) — Argumen kata kunci tambahan yang diteruskan ke ~Trainer.create_model_card.

Unggah self.model dan self.processing_class ke 🤗 model hub di repo self.args.hub_model_id.

CPOConfig

kelas trl.experimental.cpo.CPOConfig

< >

( 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 )

Parameter

  • max_length (int atau None, opsional, default 1024) — Panjang maksimum dari sekuens (prompt + completion) dalam batch. Argumen ini wajib diisi jika Anda ingin menggunakan data collator default.
  • max_completion_length (int, opsional) — Panjang maksimum dari completion. Argumen ini wajib jika Anda ingin menggunakan data collator default dan model Anda adalah encoder-decoder.
  • beta (float, opsional, default 0.1) — Parameter yang mengontrol deviasi dari model referensi. Nilai β yang lebih tinggi berarti deviasi yang lebih kecil dari model referensi. Untuk kerugian IPO (loss_type="ipo"), β adalah parameter regularisasi yang dilambangkan dengan τ dalam makalah.
  • label_smoothing (float, opsional, default 0.0) — Faktor label smoothing. Argumen ini wajib diisi jika Anda ingin menggunakan data collator default.
  • loss_type (str, opsional, defaultnya "sigmoid") — Jenis loss yang akan digunakan. Nilai yang mungkin adalah:
    • "sigmoid": kerugian sigmoid dari paper DPO asli.
    • "hinge": hinge loss pada likelihood ternormalisasi dari SLiC paper.
    • "ipo": kerugian IPO dari paper IPO.
    • "simpo": kerugian SimPO dari makalah SimPO.
    • "alphapo": kerugian AlphaPO dari paper AlphaPO. Ini secara otomatis mengatur loss_type="simpo" dan cpo_alpha=0.0.
  • disable_dropout (bool, opsional, default True) — Apakah akan menonaktifkan dropout pada model.
  • cpo_alpha (float, opsional, default 1.0) — Bobot regularizer BC dalam pelatihan CPO.
  • simpo_gamma (float, opsional, default 0.5) — Margin reward target untuk loss SimPO, hanya digunakan ketika loss_type="simpo".
  • alpha (float, opsional, default 0.0) — Parameter Alpha yang mengontrol bentuk fungsi reward di semua jenis loss. Ketika alpha=0 (default), menggunakan reward log probabilitas standar. Ketika alpha != 0, menerapkan transformasi AlphaPO: r = (1 - p^(-alpha)) / alpha dari paper AlphaPO. Parameter ini berfungsi dengan semua jenis loss.
  • generate_during_eval (bool, opsional, defaultnya False) — Jika True, menghasilkan dan mencatat kelengkapan dari model ke W&B atau Comet selama evaluasi.
  • is_encoder_decoder (bool, opsional) — Saat menggunakan argumen model_init (callable) untuk menginstansiasi model alih-alih argumen model, Anda perlu menentukan apakah model yang dikembalikan oleh callable tersebut adalah model encoder-decoder.
  • model_init_kwargs (dict[str, Any], opsional) — Argumen kata kunci untuk diteruskan ke AutoModelForCausalLM.from_pretrained saat menginstansiasi model dari sebuah string. Nilai revision juga digunakan saat memuat kelas pemrosesan.
  • trust_remote_code (bool, opsional, default False) — Apakah mengizinkan pemuatan model yang menyertakan kode Python kustom dari Hub. Diteruskan ke from_pretrained.
  • dataset_num_proc (int, opsional) — Jumlah proses yang digunakan untuk memproses dataset.

Kelas konfigurasi untuk experimental.cpo.CPOTrainer.

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan CPO. Untuk daftar lengkap argumen pelatihan, silakan merujuk ke dokumentasi TrainingArguments. Perhatikan bahwa nilai default dalam kelas ini mungkin berbeda dari yang ada di TrainingArguments.

Dengan HfArgumentParser, kita dapat mengubah kelas ini menjadi argumen argparse yang dapat ditentukan di baris perintah.

Parameter-parameter ini memiliki nilai default yang berbeda dari TrainingArguments:

  • logging_steps: Bawaan adalah 10 alih-alih 500.
  • gradient_checkpointing: Beralih ke True sebagai nilai bawaan, bukan False.
  • bf16: Beralih ke True jika fp16 tidak diatur, alih-alih False.
  • learning_rate: Bawaan adalah 1e-6 alih-alih 5e-5.
Update on GitHub