Pelatih SFT

Ikhtisar

TRL mendukung Trainer Supervised Fine-Tuning (SFT) untuk melatih model bahasa.

SFTTrainer tidak secara bawaan mendukung model difusi seperti DiffusionGemma, tetapi dapat dengan mudah diperluas untuk melakukannya, lihat contoh SFT block-diffusion.

Metode pasca-pelatihan ini disumbangkan oleh Younes Belkada.

Mulai cepat

Contoh ini menunjukkan cara melatih model bahasa menggunakan SFTTrainer dari TRL. Kami melatih model Qwen 3 0.6B pada Capybara dataset, yaitu dataset multi-turn yang ringkas dan beragam untuk menguji penalaran dan generalisasi.

from trl import SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/Capybara", split="train"),
)
trainer.train()

Jenis dan format dataset yang diharapkan

SFT mendukung dataset language modeling dan prompt-completion. SFTTrainer kompatibel dengan format dataset standar dan konversasional. Ketika diberikan dataset konversasional, trainer akan secara otomatis menerapkan chat template ke dataset tersebut.

# Standard language modeling
{"text": "The sky is blue."}

# Conversational language modeling
{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}

# Standard prompt-completion
{"prompt": "The sky is",
 "completion": " blue."}

# Conversational prompt-completion
{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "completion": [{"role": "assistant", "content": "It is blue."}]}

Jika dataset Anda tidak dalam salah satu format ini, Anda dapat melakukan pra-pemrosesan untuk mengonversinya ke format yang diharapkan. Berikut adalah contoh dengan dataset FreedomIntelligence/medical-o1-reasoning-SFT:

from datasets import load_dataset

dataset = load_dataset("FreedomIntelligence/medical-o1-reasoning-SFT", "en")

def preprocess_function(example):
    return {
        "prompt": [{"role": "user", "content": example["Question"]}],
        "completion": [
            {"role": "assistant", "content": f"<think>{example['Complex_CoT']}</think>{example['Response']}"}
        ],
    }

dataset = dataset.map(preprocess_function, remove_columns=["Question", "Response", "Complex_CoT"])
print(next(iter(dataset["train"])))

{
    "prompt": [
        {
            "content": "Given the symptoms of sudden weakness in the left arm and leg, recent long-distance travel, and the presence of swollen and tender right lower leg, what specific cardiac abnormality is most likely to be found upon further evaluation that could explain these findings?",
            "role": "user",
        }
    ],
    "completion": [
        {
            "content": "<think>Okay, let's see what's going on here. We've got sudden weakness [...] clicks into place!</think>The specific cardiac abnormality most likely to be found in [...] the presence of a PFO facilitating a paradoxical embolism.",
            "role": "assistant",
        }
    ],
}

Menggali lebih dalam ke metode SFT

Supervised Fine-Tuning (SFT) adalah metode paling sederhana dan paling umum digunakan untuk menyesuaikan model bahasa ke dataset target. Model dilatih secara penuh dengan cara supervised menggunakan pasangan sekuens input dan output. Tujuannya adalah meminimalkan negative log-likelihood (NLL) dari sekuens target, dengan mengondisikan pada input.

Bagian ini menguraikan cara kerja SFT dalam praktiknya, mencakup langkah-langkah utama: pra-pemrosesan, tokenisasi, dan perhitungan loss.

Pra-pemrosesan dan tokenisasi

Selama pelatihan, setiap contoh diharapkan berisi field teks atau pasangan (prompt, completion), tergantung pada format dataset. Untuk detail lebih lanjut mengenai format yang diharapkan, lihat Dataset formats. SFTTrainer melakukan tokenisasi setiap input menggunakan tokenizer model. Jika prompt dan completion disediakan secara terpisah, keduanya digabungkan sebelum tokenisasi.

Menghitung loss

sft_figure

Loss yang digunakan dalam SFT adalah loss cross-entropy tingkat token, yang didefinisikan sebagai: $\mathcal{L}_{\text{SFT}}(\theta) = - \sum_{t=1}^{T} \log p_\theta(y_t \mid y_{<t}),$

di mana $y_t$ adalah token target pada timestep $t$ , dan model dilatih untuk memprediksi token berikutnya berdasarkan token sebelumnya. Dalam praktiknya, token padding diabaikan saat perhitungan loss.

Makalah On the Generalization of SFT: A Reinforcement Learning Perspective with Reward Rectification mengusulkan fungsi loss alternatif yang disebut Dynamic Fine-Tuning (DFT), yang bertujuan untuk meningkatkan generalisasi dengan memperbaiki sinyal reward. Metode ini dapat diaktifkan dengan mengatur loss_type="dft" di SFTConfig. Untuk detail lebih lanjut, lihat Paper Index - Dynamic Fine-Tuning.

Perpindahan dan penutupan label

Selama pelatihan, loss dihitung menggunakan one-token shift: model dilatih untuk memprediksi setiap token dalam urutan berdasarkan semua token sebelumnya. Secara spesifik, urutan input digeser ke kanan satu posisi untuk membentuk label target. Token padding (jika ada) diabaikan dalam perhitungan loss dengan menerapkan ignore index (default: -100) pada posisi yang sesuai. Hal ini memastikan bahwa loss hanya berfokus pada token yang bermakna, bukan token padding.

Metrik yang dicatat

Selama pelatihan dan evaluasi, kami mencatat metrik berikut:

global_step: Total jumlah langkah optimizer yang telah dilakukan sejauh ini.
epoch: Nomor epoch saat ini, berdasarkan iterasi dataset.
num_tokens: Total jumlah token yang diproses sejauh ini.
loss: Rata-rata loss cross-entropy yang dihitung pada token yang tidak di-mask selama interval logging saat ini.
entropy: Entropi rata-rata dari distribusi token yang diprediksi model pada token yang tidak dimasker.
aux_loss: kerugian bantu penyeimbangan beban dari model Mixture-of-Experts, sebelum dikalikan dengan router_aux_loss_coef dan ditambahkan ke kerugian. Dicatat hanya ketika model adalah model MoE dan router_aux_loss_coef tidak nol.
mean_token_accuracy: Proporsi token yang tidak dimasker di mana prediksi top-1 model cocok dengan token ground truth.
learning_rate: Laju pembelajaran saat ini, yang dapat berubah secara dinamis jika penjadwal digunakan.
grad_norm: Norm L2 dari gradien, dihitung sebelum pemotongan gradien.

Kustomisasi

Inisialisasi model

Anda dapat langsung meneruskan kwargs dari metode from_pretrained() ke SFTConfig. Misalnya, jika Anda ingin memuat model dalam presisi yang berbeda, serupa dengan

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)

Anda dapat melakukannya dengan meneruskan argumen model_init_kwargs={"dtype": torch.bfloat16} ke SFTConfig.

from trl import SFTConfig

training_args = SFTConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)

Perhatikan bahwa semua argumen kata kunci dari from_pretrained() didukung.

Packing

SFTTrainer mendukung example packing, di mana beberapa contoh dikemas ke dalam urutan input yang sama untuk meningkatkan efisiensi pelatihan. Untuk mengaktifkan packing, cukup lewati packing=True ke konstruktor SFTConfig.

training_args = SFTConfig(packing=True)

Untuk detail lebih lanjut tentang packing, lihat Packing.

Latih hanya pada pesan asisten

Untuk melatih hanya pada pesan asisten, gunakan dataset conversational dan atur assistant_only_loss=True di SFTConfig. Pengaturan ini memastikan bahwa loss dihitung hanya pada respons asisten, mengabaikan pesan pengguna atau sistem.

training_args = SFTConfig(assistant_only_loss=True)

train_on_assistant

Fungsionalitas ini memerlukan template chat yang menyertakan kata kunci {% generation %} dan {% endgeneration %}. Untuk keluarga model yang dikenal (misalnya Qwen3), TRL secara otomatis memperbaiki template ketika assistant_only_loss=True. Lihat Chat Templates untuk daftar lengkap template pelatihan bawaan. Untuk model lain, periksa apakah template chat Anda menyertakan kata kunci ini. Lihat HuggingFaceTB/SmolLM3-3B sebagai contoh.

Dengan dataset visi, loss khusus asisten memerlukan transformers>=5.18.0 dan dataset language modeling percakapan.

Latih hanya pada penyelesaian

Untuk melatih hanya pada completion, gunakan dataset prompt-completion. Secara default, trainer menghitung loss hanya pada token completion, mengabaikan token prompt. Jika Anda ingin melatih pada seluruh sequence, set completion_only_loss=False di SFTConfig.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

# Load a prompt-completion dataset; loss is computed on the completion only by default
dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    args=SFTConfig(completion_only_loss=True),  # True by default for prompt-completion datasets
    train_dataset=dataset,
)
trainer.train()

train_on_completion

Pelatihan hanya pada completion kompatibel dengan pelatihan hanya pada pesan asisten. Dalam kasus ini, gunakan dataset conversational prompt-completion dan atur assistant_only_loss=True di SFTConfig.

Latih adapter dengan PEFT

Kami mendukung integrasi yang erat dengan pustaka 🤗 PEFT, memungkinkan setiap pengguna untuk dengan mudah melatih adapter dan membagikannya di Hub, alih-alih melatih seluruh model.

from datasets import load_dataset
from trl import SFTTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    "Qwen/Qwen3-0.6B",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()

Anda juga dapat melanjutkan pelatihan PeftModel Anda. Untuk itu, pertama muat PeftModel di luar SFTTrainer lalu teruskan secara langsung ke trainer tanpa meneruskan argumen peft_config.

from datasets import load_dataset
from trl import SFTTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()

Saat melatih adapter, Anda biasanya menggunakan tingkat pembelajaran yang lebih tinggi (≈1e‑4) karena hanya parameter baru yang dipelajari.
SFTConfig(learning_rate=1e-4, ...)

Eksperimen Cepat untuk SFT

RapidFire AI adalah mesin eksperimen open-source yang berada di atas TRL dan memungkinkan Anda meluncurkan beberapa konfigurasi SFT sekaligus, bahkan pada satu GPU. Alih-alih mencoba konfigurasi secara berurutan, RapidFire memungkinkan Anda melihat semua kurva pembelajaran mereka lebih awal, menghentikan run yang kinerjanya rendah, dan mengkloning yang menjanjikan dengan pengaturan baru saat berjalan tanpa perlu memulai ulang. Untuk informasi lebih lanjut, lihat RapidFire AI Integration.

Latih dengan Unsloth

Unsloth adalah kerangka kerja sumber terbuka untuk penyesuaian halus (fine-tuning) dan pembelajaran penguatan yang melatih LLM (seperti Llama, Mistral, Gemma, DeepSeek, dan lainnya) hingga 2× lebih cepat dengan pengurangan VRAM hingga 70%, sambil menyediakan alur kerja yang ringkas dan kompatibel dengan Hugging Face untuk pelatihan, evaluasi, dan penerbitan. Untuk informasi lebih lanjut, lihat Integrasi Unsloth.

Contoh penyetelan instruksi

Penyesuaian instruksi mengajarkan model bahasa dasar untuk mengikuti instruksi pengguna dan terlibat dalam percakapan. Hal ini membutuhkan:

Template chat: Mendefinisikan cara menyusun percakapan menjadi urutan teks, termasuk penanda peran (user/assistant), token khusus, dan batas giliran. Baca lebih lanjut tentang template chat di Template chat.
Dataset percakapan: Berisi pasangan instruksi-respons

Contoh ini menunjukkan cara mengubah model Qwen 3 0.6B Base menjadi model yang mengikuti instruksi menggunakan dataset Capybara dan template chat dari HuggingFaceTB/SmolLM3-3B. SFT Trainer secara otomatis menangani pembaruan tokenizer dan konfigurasi token khusus.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen3-0.6B-Base",
    args=SFTConfig(
        output_dir="Qwen3-0.6B-Instruct",
        chat_template_path="HuggingFaceTB/SmolLM3-3B",
    ),
    train_dataset=load_dataset("trl-lib/Capybara", split="train"),
)
trainer.train()

Beberapa model dasar, seperti yang berasal dari Qwen, memiliki template chat yang sudah didefinisikan di dalam tokenizer model tersebut. Dalam kasus ini, tidak perlu menerapkan clone_chat_template(), karena tokenizer sudah menangani formatnya. Namun, tetap perlu menyelaraskan token EOS dengan template chat untuk memastikan respons model berakhir dengan benar. Dalam kasus ini, tentukan eos_token di SFTConfig; misalnya, untuk Qwen/Qwen2.5-1.5B, Anda harus mengatur eos_token="<|im_end|>".

Setelah dilatih, model Anda kini dapat mengikuti instruksi dan terlibat dalam percakapan menggunakan template chat barunya.

>>> from transformers import pipeline
>>> pipe = pipeline("text-generation", model="Qwen3-0.6B-Instruct/checkpoint-5000")
>>> prompt = "<|im_start|>user\nWhat is the capital of France? Answer in one word.<|im_end|>\n<|im_start|>assistant\n"
>>> response = pipe(prompt)
>>> response[0]["generated_text"]
'<|im_start|>user\nWhat is the capital of France? Answer in one word.<|im_end|>\n<|im_start|>assistant\nThe capital of France is Paris.'

Sebagai alternatif, gunakan format percakapan terstruktur (disarankan):

>>> prompt = [{"role": "user", "content": "What is the capital of France? Answer in one word."}]
>>> response = pipe(prompt)
>>> response[0]["generated_text"]
[{'role': 'user', 'content': 'What is the capital of France? Answer in one word.'}, {'role': 'assistant', 'content': 'The capital of France is Paris.'}]

Pemanggilan Alat dengan SFT

SFTTrainer sepenuhnya mendukung fine-tuning model dengan kemampuan tool calling. Dalam hal ini, setiap contoh dataset harus mencakup:

Pesan percakapan, termasuk panggilan alat (tool_calls) dan respons alat (pesan dengan peran tool)
Daftar alat yang tersedia di kolom tools, biasanya disediakan sebagai skema JSON

Untuk detail mengenai struktur dataset yang diharapkan, lihat bagian Dataset Format — Tool Calling.

Pelatihan Model Bahasa Visual

SFTTrainer sepenuhnya mendukung pelatihan Vision-Language Models (VLM). Untuk melatih VLM, berikan dataset dengan kolom image (satu gambar per sampel) atau kolom images (daftar gambar per sampel). Untuk informasi lebih lanjut tentang struktur dataset yang diharapkan, lihat bagian Dataset Format — Vision Dataset. Contoh dataset seperti itu adalah LLaVA Instruct Mix.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=SFTConfig(max_length=None),
    train_dataset=load_dataset("trl-lib/llava-instruct-mix", split="train"),
)
trainer.train()

Untuk VLM, pemotongan dapat menghapus token gambar, yang menyebabkan kesalahan selama pelatihan. Untuk menghindari hal ini, atur max_length=None di SFTConfig. Ini memungkinkan model untuk memproses panjang urutan penuh tanpa memotong token gambar.
SFTConfig(max_length=None, ...)
Gunakan max_length hanya jika Anda telah memverifikasi bahwa pemotongan (truncation) tidak akan menghapus token gambar untuk seluruh dataset.

SFTTrainer

kelas trl.SFTTrainer

< source >

( model: str | PreTrainedModel | PeftModelargs: trl.trainer.sft_config.SFTConfig | transformers.training_args.TrainingArguments | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_loss_func: collections.abc.Callable | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = Nonepreprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonequantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = Noneformatting_func: collections.abc.Callable[[dict], str] | None = None )

Parameter

model (str atau PreTrainedModel atau PeftModel) — Model yang akan dilatih. Bisa berupa:
- String, berupa model id dari model pretrained yang dihosting di dalam model repo di huggingface.co, atau path ke directory yang berisi model weights yang disimpan menggunakan save_pretrained, misalnya './my_model_directory/'. Model dimuat menggunakan <ModelArchitecture>.from_pretrained (di mana <ModelArchitecture> diturunkan dari model config) dengan keyword arguments di args.model_init_kwargs. Jika dtype tidak ditentukan di args.model_init_kwargs, default-nya adalah float32. Ini berbeda dari from_pretrained, di mana (sejak Transformers v5) dtype disimpulkan dari model config.
- Objek PreTrainedModel. Hanya model bahasa kausal yang didukung.
- Objek PeftModel. Hanya model bahasa kausal yang didukung.
args (SFTConfig, opsional) — Konfigurasi untuk trainer ini. Jika None, konfigurasi default akan digunakan.
data_collator (DataCollator, opsional) — Fungsi yang digunakan untuk membentuk batch dari daftar elemen train_dataset atau eval_dataset yang telah diproses. Nilai defaultnya adalah DataCollatorForLanguageModeling, atau DataCollatorForVisionLanguageModeling jika dataset berisi gambar.
train_dataset (Dataset atau IterableDataset) — Dataset yang digunakan untuk pelatihan. Trainer ini mendukung tipe language modeling dan tipe prompt-completion . Format sampel dapat berupa:
- Standar: Setiap sampel berisi teks polos.
- Konversasional: Setiap sampel berisi pesan terstruktur (misalnya, peran dan konten).
Trainer juga mendukung dataset yang sudah di-tokenisasi sebelumnya, yang dikenali melalui kolom wajib input_ids. Kolom opsional labels (-100 pada token yang dikecualikan dari loss) digunakan apa adanya jika ada; jika tidak, label dibangun dari kolom opsional assistant_masks / completion_mask (yang kemudian digabungkan lalu dihapus, completion_mask hanya jika completion_only_loss=True), atau secara default menggunakan salinan dari input_ids. Seuensi dipangkas hingga max_length selama persiapan. Dengan skip_prepare_dataset=True, persiapan dilewati dan collator diharapkan menangani dataset apa adanya.

Ketika train_dataset adalah IterableDataset (misalnya dataset streaming), max_steps harus diatur dalam argumen pelatihan, karena panjangnya tidak dapat disimpulkan dan jumlah total langkah pelatihan diperlukan untuk membatasi loop pelatihan serta mengonfigurasi penjadwal laju pembelajaran.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict atau dict[str, Dataset | IterableDataset]) — Dataset yang digunakan untuk evaluasi. Dataset ini harus memenuhi persyaratan yang sama dengan train_dataset.
processing_class (PreTrainedTokenizerBase, ProcessorMixin, opsional) — Kelas pemrosesan yang digunakan untuk memproses data. Jika None, kelas pemrosesan dimuat dari nama model dengan from_pretrained. Token padding, tokenizer.pad_token, harus disetel. Jika kelas pemrosesan belum menyetel token padding, tokenizer.eos_token akan digunakan sebagai default.
compute_loss_func (Callable, opsional) — Fungsi yang menerima output model, label, dan jumlah item dalam seluruh batch yang terakumulasi (batch_size * gradient_accumulation_steps) dan mengembalikan loss. Ini sudah tidak didukung dan akan dihapus di v2.0.0: subclass SFTTrainer dan override compute_loss sebagai gantinya.
compute_metrics (Callable[[EvalPrediction], dict], opsional) — Fungsi yang akan digunakan untuk menghitung metrik saat evaluasi. Harus menerima EvalPrediction dan mengembalikan kamus dari string ke nilai metrik. Saat meneruskan SFTConfig dengan batch_eval_metrics diset ke True, fungsi compute_metrics Anda harus menerima argumen boolean compute_result. Ini akan dipicu setelah batch evaluasi terakhir untuk memberi sinyal bahwa fungsi perlu menghitung dan mengembalikan statistik ringkasan global, bukan mengakumulasi statistik tingkat batch. Logits yang diterimanya dihitung ulang dengan satu langkah forward tambahan. Ini sudah tidak didukung dan akan dihapus di v2.0.0.
callbacks (daftar TrainerCallback, opsional) — Daftar callback untuk menyesuaikan loop pelatihan. Callback ini akan ditambahkan ke daftar callback default yang dijelaskan di sini.
Jika Anda ingin menghapus salah satu callback default yang digunakan, gunakan metode remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opsional, defaultnya (None, None)) — Tuple yang berisi optimizer dan scheduler yang akan digunakan. Secara default akan menggunakan instance AdamW pada model Anda dan scheduler yang diberikan oleh get_linear_schedule_with_warmup yang dikendalikan oleh args.
optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], opsional) — Tuple yang berisi kelas optimizer dan argumen kata kunci yang akan digunakan. Menimpa optim dan optim_args di args. Tidak kompatibel dengan argumen optimizers .
Berbeda dengan optimizers, argumen ini menghindari kebutuhan untuk menempatkan parameter model pada perangkat yang benar sebelum menginisialisasi Trainer.
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], opsional) — Fungsi yang memproses ulang logits tepat sebelum disimpan ke cache pada setiap langkah evaluasi. Fungsi ini harus menerima dua tensor, yaitu logits dan label, lalu mengembalikan logits setelah diproses sesuai keinginan. Modifikasi yang dilakukan oleh fungsi ini akan tercermin dalam prediksi yang diterima oleh compute_metrics.
Perhatikan bahwa label (parameter kedua) akan menjadi None jika dataset tidak memilikinya.
quantization_config (BitsAndBytesConfig, opsional) — Konfigurasi kuantisasi yang digunakan saat memuat model dari pengidentifikasi model. Gabungkan dengan peft_config untuk pelatihan QLoRA. Diabaikan jika model sudah diinstansiasi.
peft_config (PeftConfig, opsional) — Konfigurasi PEFT yang digunakan untuk membungkus model. Jika None, model tidak dibungkus.
formatting_func (Callable, opsional) — Fungsi formatting yang diterapkan pada dataset sebelum tokenisasi. Menerapkan fungsi formatting secara eksplisit mengonversi dataset menjadi tipe language modeling.

Trainer untuk metode Supervised Fine-Tuning (SFT).

Kelas ini adalah pembungkus dari kelas Trainer dan mewarisi semua atribut serta metodenya.

Contoh:

>>> from trl import SFTTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("roneneldan/TinyStories", split="train[:1%]")

>>> trainer = SFTTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()

latih

< source >

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

< source >

( 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

< source >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | 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”.
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.

SFTConfig

kelas trl.SFTConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 2e-05lr_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 = 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 = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonechat_template_path: str | None = Nonedataset_text_field: str = 'text'dataset_kwargs: dict[str, typing.Any] | str | None = Nonedataset_num_proc: int | None = Noneeos_token: str | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'shuffle_dataset: bool = Falsepacking: bool = Falsepacking_strategy: str = 'bfd'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'eval_packing: bool | None = Nonecompletion_only_loss: bool | None = Noneassistant_only_loss: bool = Falseloss_type: str = 'nll'activation_offloading: bool = Falsepad_token: str | None = None )

Parameter yang mengontrol model

model_init_kwargs (dict[str, Any], opsional) — Argumen kata kunci untuk from_pretrained, digunakan ketika argumen model dari SFTTrainer diberikan sebagai string. Nilai revision juga digunakan saat memuat kelas pemrosesan.
trust_remote_code (bool, opsional, default False) — Apakah mengizinkan pemuatan model dan tokenizer yang menyertakan kode Python kustom dari Hub. Diteruskan ke from_pretrained dan from_pretrained.
router_aux_loss_coef (float, opsional) — Koefisien dari loss tambahan penyeimbangan beban untuk model Mixture-of-Experts (MoE), yang ditambahkan ke loss pelatihan dengan bobot ini. Jika tidak diatur, nilai yang dideklarasikan oleh konfigurasi model akan digunakan. Atur ke 0.0 untuk menonaktifkannya. Gagal jika digunakan dengan model non-MoE.
chat_template_path (str, opsional) — Jika ditentukan, mengatur template chat model. Ini bisa berupa path ke tokenizer (direktori lokal atau model Hugging Face Hub) atau path langsung ke file template Jinja. Saat menggunakan file Jinja, Anda harus memastikan bahwa token khusus yang dirujuk dalam template ditambahkan ke tokenizer dan bahwa lapisan embedding model di-resize sesuai.

Parameter yang mengontrol pra-pemrosesan data

dataset_text_field (str, opsional, default "text") — Nama kolom yang berisi data teks dalam dataset.
dataset_kwargs (dict[str, Any], opsional) — Kamus berisi argumen kata kunci opsional untuk persiapan dataset. Satu-satunya kunci yang didukung adalah skip_prepare_dataset. Jika dataset berisi gambar, skip_prepare_dataset secara otomatis diperlakukan sebagai True terlepas dari nilai yang diberikan, karena pra-pemrosesan dilakukan secara langsung.
dataset_num_proc (int, opsional) — Jumlah proses yang digunakan untuk memproses dataset.
eos_token (str, opsional) — Token yang digunakan untuk menandakan akhir giliran atau urutan. Jika None, nilainya secara default adalah processing_class.eos_token.
max_length (int atau None, opsional, default 1024) — Panjang maksimum dari urutan yang ditokenisasi. Urutan yang lebih panjang dari max_length akan dipangkas dari kiri atau kanan tergantung pada truncation_mode. Jika None, pemangkasan tidak diterapkan. Ketika packing diaktifkan, nilai ini mengatur panjang urutan.
truncation_mode (str, opsional, default "keep_start") — Mode pemotongan yang digunakan ketika urutan melebihi max_length. Nilai yang didukung hanyalah "keep_start". Nilai "keep_end" sudah tidak didukung lagi dan akan dihapus pada v2.0.0.
shuffle_dataset (bool, opsional, default False) — Apakah dataset akan diacak.
packing (bool, opsional, default False) — Apakah akan mengelompokkan beberapa urutan menjadi blok berpanjang tetap untuk meningkatkan efisiensi komputasi dan mengurangi padding. Menggunakan max_length untuk mendefinisikan panjang urutan.
packing_strategy (str, opsional, defaultnya "bfd") — Strategi untuk mem-packing urutan. Bisa berupa "bfd" (best-fit decreasing, memotong bagian yang meluber), "bfd_split" (best-fit decreasing, memecah urutan yang meluber), atau "wrapped" (agresif, memotong di tengah urutan).
padding_free (bool, opsional, default False) — Apakah akan melakukan forward pass tanpa padding dengan meratakan semua urutan dalam batch menjadi satu urutan kontinu. Hal ini mengurangi penggunaan memori dengan menghilangkan overhead padding. Saat ini, ini hanya didukung dengan FlashAttention 2 atau 3, yang dapat menangani struktur batch yang telah diratakan secara efisien. Ketika packing diaktifkan dengan strategi "bfd", padding-free diaktifkan, terlepas dari nilai parameter ini.
pad_to_multiple_of (int atau str, opsional, default "auto") — Jika diset, urutan akan di-*pad* menjadi kelipatan dari nilai ini. "auto" melakukan *padding* menjadi kelipatan 128 pada Neuron (AWS Trainium), yang dikompilasi sekali per bentuk input, dan tidak melakukan *padding* di tempat lain.
eval_packing (bool, opsional) — Apakah dataset eval akan dikemas. Jika None, menggunakan nilai yang sama dengan packing.

Parameter yang mengontrol pelatihan

completion_only_loss (bool, opsional) — Apakah loss hanya dihitung pada bagian completion dari sequence. Jika diset ke True, loss hanya dihitung pada completion, yang hanya didukung untuk dataset prompt-completion. Jika False, loss dihitung pada seluruh sequence. Jika None (default), perilakunya bergantung pada dataset: loss dihitung pada completion untuk dataset prompt-completion, dan pada sequence penuh untuk dataset language modeling.
assistant_only_loss (bool, opsional, default False) — Apakah loss hanya dihitung pada bagian asisten dari urutan. Jika diset ke True, loss hanya dihitung pada respons asisten, yang hanya didukung untuk dataset percakapan. Jika False, loss dihitung pada seluruh urutan.
loss_type (str, opsional, default ke "nll") — Jenis loss yang akan digunakan. Nilai yang mungkin adalah:
- "nll": negative log-likelihood standar.
- "dft": Dynamic Fine-Tuning, seperti yang dijelaskan dalam makalah ini.
- "chunked_nll": alias yang tidak didukung lagi dari "nll", yang menghitung loss dengan cara yang sama. Akan dihapus pada v2.0.0.
activation_offloading (bool, opsional, default False) — Apakah akan memindahkan aktivasi ke CPU.

Parameter yang tidak didukung lagi

pad_token —
Parameter pad_token sudah tidak didukung dan akan dihapus pada versi v2.0.0. Tetapkan tokenizer.pad_token secara langsung dan teruskan sebagai processing_class ke trainer sebagai gantinya.

Kelas konfigurasi untuk SFTTrainer.

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan SFT. 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: Beralih ke 2e-5 sebagai nilai default, bukan 5e-5.

Update on GitHub