Hugging Face's logo

TRL documentation

ORPO Trainer

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

ORPO Trainer

model badge model badge

Ikhtisar

Odds Ratio Preference Optimization (ORPO) diperkenalkan dalam ORPO: Monolithic Preference Optimization without Reference Model oleh Jiwoo Hong, Noah Lee, dan James Thorne.

Abstrak dari makalah tersebut adalah sebagai berikut:

Meskipun algoritma penyesuaian preferensi terbaru untuk model bahasa telah menunjukkan hasil yang menjanjikan, fine-tuning bersupervisi (SFT) tetap menjadi hal yang krusial untuk mencapai konvergensi yang sukses. Dalam makalah ini, kami mempelajari peran penting SFT dalam konteks penyesuaian preferensi, dengan menekankan bahwa penalti kecil untuk gaya generasi yang tidak disukai sudah cukup untuk SFT yang selaras dengan preferensi. Berdasarkan fondasi ini, kami memperkenalkan algoritma optimasi rasio peluang monolitik bebas model referensi yang sederhana dan inovatif, ORPO, yang menghilangkan kebutuhan akan fase penyesuaian preferensi tambahan. Kami mendemonstrasikan, baik secara empiris maupun teoretis, bahwa rasio peluang merupakan pilihan yang masuk akal untuk membedakan gaya yang disukai dan tidak disukai selama SFT di berbagai ukuran dari 125M hingga 7B. Secara spesifik, fine-tuning Phi-2 (2.7B), Llama-2 (7B), dan Mistral (7B) dengan ORPO hanya menggunakan UltraFeedback melampaui kinerja model bahasa state-of-the-art dengan lebih dari 7B dan 13B parameter: mencapai hingga 12.20% pada AlpacaEval_{2.0} (Gambar 1), 66.19% pada IFEval (longgar tingkat instruksi, Tabel 6), dan 7.32 pada MT-Bench (Gambar 12). Kami merilis kode dan checkpoint model untuk Mistral-ORPO-alpha (7B) dan Mistral-ORPO-beta (7B).

Metode ini mempelajari peran penting SFT dalam konteks penyesuaian preferensi. Dengan menggunakan data preferensi, metode ini mengasumsikan bahwa penalti kecil untuk generasi yang tidak disukai, ditambah dengan sinyal adaptasi yang kuat ke respons yang dipilih melalui suku rasio log odds sederhana yang ditambahkan ke kerugian NLL, sudah cukup untuk SFT yang selaras dengan preferensi.

Dengan demikian, ORPO adalah algoritma optimasi preferensi tanpa model referensi yang menghilangkan kebutuhan akan fase penyesuaian preferensi tambahan, sehingga menghemat komputasi dan memori.

Kode resmi dapat ditemukan di xfactlab/orpo.

Metode post-training ini disumbangkan oleh Kashif Rasul, Lewis Tunstall, dan Alvaro Bartolome.

Mulai cepat

Contoh ini menunjukkan cara melatih model menggunakan metode ORPO. 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_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()

Jalankan skrip menggunakan perintah berikut:

torchrun --nproc_per_node 8 train_orpo.py

Distribusi di 8 GPU, pelatihan memakan waktu sekitar 30 menit. Anda dapat memverifikasi kemajuan pelatihan dengan memeriksa grafik reward. Tren peningkatan pada margin reward menunjukkan bahwa model sedang membaik dan menghasilkan respons yang lebih baik seiring waktu.

orpo qwen2 reward margin

Untuk melihat bagaimana kinerja model terlatih, Anda dapat menggunakan 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.

Jenis dataset yang diharapkan

ORPO memerlukan dataset preferensi. experimental.orpo.ORPOTrainer mendukung format dataset percakapan dan standar. Ketika diberikan dataset percakapan, trainer akan secara otomatis menerapkan template chat ke dataset tersebut.

Meskipun experimental.orpo.ORPOTrainer mendukung prompt eksplisit maupun implisit, kami merekomendasikan penggunaan prompt eksplisit. Jika diberikan dataset prompt implisit, trainer akan secara otomatis mengekstrak prompt dari kolom "chosen" dan "rejected". Untuk informasi lebih lanjut, lihat bagian preference style.

Tips penggunaan

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.

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
  • log_odds_chosen: rasio log odds rata-rata dari respons yang dipilih dibandingkan dengan respons yang ditolak
  • log_odds_ratio: rata-rata dari log(sigmoid(log_odds_chosen))
  • nll_loss: rata-rata kerugian log likelihood negatif dari bagian SFT dari kerugian atas respons yang dipilih

ORPOTrainer

kelas trl.experimental.orpo.ORPOTrainer

< >

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

Parameter

  • model (PreTrainedModel) — Model yang akan dilatih, sebaiknya berupa AutoModelForSequenceClassification.
  • args (experimental.orpo.ORPOConfig) — Argumen konfigurasi ORPO yang akan 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 ORPOTrainer.

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.

ORPOConfig

kelas trl.experimental.orpo.ORPOConfig

< >

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

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 rasio bobot loss relatif dalam loss ORPO. Dalam makalah, parameter ini dilambangkan dengan λ. Dalam kode, parameter ini dilambangkan dengan alpha.
  • disable_dropout (bool, opsional, default True) — Apakah akan menonaktifkan dropout pada model.
  • padding_value (int, opsional) — Nilai padding yang akan digunakan. Jika None, nilai padding dari tokenizer yang digunakan.
  • 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.orpo.ORPOTrainer.

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan ORPO. 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

←Online DPO SDFT→