Transformers documentation
Optimizer dan scheduler
Optimizer dan scheduler
Optimizer memperbarui bobot model selama pelatihan. Scheduler membungkus optimizer dan menyesuaikan learning rate pada setiap langkah pelatihan. Trainer membuat keduanya saat memanggil create_optimizer_and_scheduler().
┌────────────┐ ┌──────────────┐
│ Optimizer │ │ Scheduler │
│ (adamw_torch_fused)◄─│ (linear) │
│ │ │ │
│ param_groups | |
│ └ lr ◄────────┤ |
│ └ weight_decay │ │
└──────┬─────┘ └──────────────┘
│
┌──── EACH TRAINING STEP ───────────────────────────────────────────┐
│ │ │
│ model(batch) │ │
│ │ │ │
│ ▼ │ │
│ loss ──► loss.backward() ──► param.grad │
│ │ │
│ ┌─────────────┘ │
│ ▼ │
│ optimizer.step() │
│ │ │
│ ▼ │
│ param.data updated │
│ │ │
│ ▼ │
│ lr_scheduler.step() ──► recalculates lr │
│ │ writes to optimizer │
│ ▼ .param_groups['lr'] │
│ model.zero_grad() │
│ │
└───────────────────────────────────────────────────────────────────┘Konfigurasikan perilaku optimizer dan scheduler, seperti lr_scheduler_type() dan optim(), di TrainingArguments. Nilai default (optimizer adamw_torch dan scheduler warmup linear) merupakan titik awal yang baik untuk sebagian besar proses fine-tuning.
from transformers import TrainingArguments
args = TrainingArguments(
...,
# Optimizer
optim="adamw_torch", # or "adamw_torch_fused", "adafactor", "sgd", etc.
learning_rate=2e-5,
weight_decay=0.01,
adam_beta1=0.9,
adam_beta2=0.999,
adam_epsilon=1e-8,
# Scheduler
lr_scheduler_type="cosine", # "linear", "cosine", "constant_with_warmup", etc.
warmup_steps=500,
lr_scheduler_kwargs={"num_cycles": 3}, # scheduler-specific extras
)Penjadwal berbasis metrik
Beberapa scheduler beradaptasi terhadap dinamika pelatihan alih-alih mengikuti jadwal yang tetap.
GreedyLR memperbarui learning rate berdasarkan hasil evaluasi. Learning rate dinaikkan dengan membaginya oleh factor ketika metrik terus membaik, dan diturunkan dengan mengalikan factor ketika metrik tidak membaik. Ketika learning rate berhenti di min_lr dan tidak membaik setelah reset_start langkah, GreedyLR direset ke kondisi awalnya dan memulai siklus baru.
GreedyLR memerlukan evaluasi selama pelatihan. Atur eval_strategy ke "steps" atau "epoch".
args = TrainingArguments(
+ lr_scheduler_type="greedy",
+ lr_scheduler_kwargs={"patience": 10, "factor": 0.95, "min_lr": 1e-5},
+ eval_strategy="steps",
+ eval_steps=200,
... # remaining args from the TrainingArguments intro config
)Mode default
mode="min"berfungsi untuk loss. Jika Anda melacak metrik di mana nilai yang lebih tinggi lebih baik, seperti akurasi, berikan"mode": "max"dilr_scheduler_kwargs.
Lihat kelas GreedyLR untuk daftar lengkap parameter yang dapat dikonfigurasi.
Integrasi optimizer
Transformers mengintegrasikan optimizer pihak ketiga untuk skenario pelatihan yang khusus.
| Optimizer | Instal | optim="value" | Deskripsi |
|---|---|---|---|
| APOLLO | apollo-torch | apollo_adamw | Penuh-param yang hemat memori melalui proyeksi acak; rank-1 sudah cukup |
| GrokAdamW | grokadamw | grokadamw | Menargetkan generalisasi tertunda (grokking) |
| LOMO / AdaLomo | lomo-optim | lomo / adalomo | Menggabungkan langkah gradien + pembaruan untuk fine-tuning parameter penuh dengan memori rendah |
| Jadwal Bebas | schedulefree | schedule_free_adamw, schedule_free_radam, schedule_free_sgd | Menghilangkan annealing LR; gunakan bersama lr_scheduler_type="constant" |
| GaLore | galore-torch | galore_adamw, galore_adafactor, galore_adamw_8bit | Pembelajaran parameter penuh melalui proyeksi rank rendah gradien |
| StableAdamW | torch-optimi | stable_adamw | Pemotongan pembaruan AdamW + AdaFactor; tidak diperlukan pemotongan gradien |
pip install apollo-torch
Approximated Gradient Scaling for Memory Efficient LLM Optimization (APOLLO) adalah optimizer hemat memori untuk pembelajaran parameter penuh selama pretraining dan fine-tuning. Metode ini menyamai performa AdamW dengan biaya memori mirip SGD dengan menggunakan proyeksi acak yang murah alih-alih SVD. Untuk penghematan memori ekstrem, gunakan APOLLO-Mini, sebuah varian rank-1.
Gunakan parameter optim_target_modules untuk menentukan lapisan mana yang akan dilatih.
args = TrainingArguments(
+ optim="apollo_adamw",
+ optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
... # remaining args from the TrainingArguments intro config
)Lewatkan hiperparameter tambahan melalui optim_args.
Set
scaleken/r, di mananadalah dimensi ruang asli danradalah dimensi ruang low-rank. Menyesuaikan learning rate sambil mempertahankanscalepada nilai defaultnya mencapai efek yang serupa.
| parameter | deskripsi | APOLLO | APOLLO-Mini |
|---|---|---|---|
| rank | rank dari sub-ruang bantu untuk penskalaan gradien | 256 | 1 |
| scale_type | bagaimana faktor penskalaan diterapkan | channel (penskalaan per-channel) | tensor (skala per tensor) |
| scale | menyesuaikan pembaruan gradien untuk menstabilkan pelatihan | 1.0 | 128 |
| update_proj_gap | langkah-langkah sebelum memperbarui matriks proyeksi | 200 | 200 |
| proj | tipe proyeksi | random | random |
Aktifkan APOLLO-Mini dengan konfigurasi rank-1.
args = TrainingArguments(
optim="apollo_adamw",
optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
optim_args="proj=random,rank=1,scale=128.0,scale_type=tensor,update_proj_gap=200",
... # remaining args from the TrainingArguments intro config
)pip install grokadamw
GrokAdamW menargetkan grokking, yaitu fenomena di mana model menunjukkan generalisasi yang tertunda akibat gradien yang berubah lambat.
args = TrainingArguments(
+ optim="grokadamw",
... # remaining args from the TrainingArguments intro config
)pip install lomo-optim
Optimasi Memori Rendah (LOMO) mencakup dua optimizer untuk finetuning parameter penuh dengan memori rendah, yaitu LOMO dan AdaLomo. Keduanya menggabungkan perhitungan gradien dan pembaruan parameter ke dalam satu langkah. AdaLomo menambahkan laju belajar adaptif per parameter, serupa dengan Adam.
AdaLomo bekerja paling baik tanpa
grad_norm, meningkatkan kinerja dan throughput.
args = TrainingArguments(
+ optim="adalomo",
learning_rate=2e-6,
... # remaining args from the TrainingArguments intro config
)pip install schedulefree
Optimizer Schedule Free (SFO) menggantikan momentum dengan kombinasi rata-rata dan interpolasi, sehingga sepenuhnya menghilangkan kebutuhan untuk melakukan annealing pada learning rate.
SFO mendukung optimizer RAdam (schedule_free_radam), AdamW (schedule_free_adamw), dan SGD (schedule_free_sgd). Scheduler RAdam tidak memerlukan warmup_steps.
Pasangkan SFO dengan lr_scheduler_type="constant". Jenis scheduler lain tetap berfungsi, tetapi memengaruhi perilaku yang dimaksudkan oleh SFO.
args = TrainingArguments(
+ optim="schedule_free_radam",
+ lr_scheduler_type="constant",
learning_rate=2e-6,
... # remaining args from the TrainingArguments intro config
)pip install torch-optimi
StableAdamW memindahkan mekanisme pemotongan pembaruan (update clipping) dari AdaFactor ke AdamW, sehingga menghilangkan kebutuhan akan pemotongan gradien (gradient clipping). Selain itu, StableAdamW dapat digunakan sebagai pengganti langsung (drop-in replacement) untuk AdamW.
Jika Anda melatih dengan ukuran batch besar atau masih mengamati lonjakan loss, coba atur
beta_2di antara 0,95 dan 0,99.
args = TrainingArguments(
+ optim="stable_adamw",
learning_rate=2e-6,
... # remaining args from the TrainingArguments intro config
)pip install galore-torch trl
Gradient Low-Rank Projection (GaLore) mengurangi memori untuk pelatihan LLM. Berbeda dengan metode adaptasi peringkat rendah seperti LoRA, GaLore mempertahankan pembelajaran full-parameter.
Set optim di trl.SFTConfig ke optimizer GaLore ("galore_adamw", "galore_adafactor", atau "galore_adamw_8bit"). Tentukan modul target dengan optim_target_modules dan parameter khusus GaLore (rank, update_proj_gap, scale) melalui optim_args.
from trl import SFTConfig
args = SFTConfig(
output_dir="./galore",
max_steps=100,
optim="galore_adamw",
optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
optim_args="rank=64, update_proj_gap=100, scale=0.10",
)Tambahkan _layerwise ke nama optimizer untuk optimasi layerwise ("galore_adamw_layerwise"). Hanya linear layers yang ditargetkan oleh GaLore yang menggunakan dekomposisi low-rank. Semua layer lain dioptimalkan secara normal.
from trl import SFTConfig, SFTTrainer
args = SFTConfig(
output_dir="./galore",
max_steps=100,
optim="galore_adamw_layerwise",
optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
optim_args="rank=64, update_proj_gap=100, scale=0.10",
)Mode layerwise bersifat eksperimental. Mode ini hanya berjalan di GPU tunggal, tidak mendukung DistributedDataParallel (DDP), dan gradient clipping serta DeepSpeed mungkin tidak berfungsi.
Menyesuaikan optimizer dan scheduler
Buat optimizer dan scheduler kustom untuk menggunakan optimizer yang belum terintegrasi, menyesuaikan learning rate per lapisan, atau menerapkan logika kustom.
Lewatkan kelas dan kwargs
~Trainer.optimizer_cls_and_kwargs menerima kelas optimizer kustom sambil mendelegasikan pengelompokan parameter dan penempatan perangkat ke Trainer.
Trainer menunda pembuatan optimizer hingga create_optimizer() dijalankan, sehingga model sudah berada di perangkat yang benar.
import torch
trainer = Trainer(
...
optimizer_cls_and_kwargs=(
torch.optim.SGD,
{"momentum": 0.9, "nesterov": True}
),
)Lewatkan instance yang sudah dibangun
Lewatkan optimizer dan scheduler yang sudah didefinisikan ke ~Trainer.optimizers. Trainer akan melewati create_optimizer() dan create_scheduler() jika instance yang sudah dibuat disediakan. Jika Anda tidak melewati scheduler, Trainer akan membuatnya secara otomatis.
Bangun optimizer setelah menempatkan model Anda pada perangkat yang benar. Parameter diselesaikan saat konstruksi, sebelum
Trainermemindahkan model. Dalam pelatihan terdistribusi, perangkat yang tidak cocok dapat secara diam-diam menyebabkan perilaku yang salah.
import torch
from transformers import Trainer, get_cosine_schedule_with_warmup
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)
scheduler = get_cosine_schedule_with_warmup(
optimizer, num_warmup_steps=500, num_training_steps=10_000
)
trainer = Trainer(
...
optimizers=(optimizer, scheduler),
)Instans yang sudah dibangun sebelumnya melewati create_optimizer() dan create_scheduler(), sehingga Anda perlu menentukan grup parameter Anda sendiri.
Override metode optimizer dan scheduler
Subclass create_optimizer() dan create_scheduler() untuk kontrol penuh. Kedua metode ini dijalankan selama train().
Override create_scheduler() untuk menggunakan scheduler seperti OneCycleLR yang tidak tersedia di SchedulerType.
Untuk setiap metode, pastikan untuk menugaskan ke self dan mengembalikannya.
import torch
from transformers import Trainer
class MyTrainer(Trainer):
def create_scheduler(self, num_training_steps, optimizer=None):
optimizer = optimizer or self.optimizer
self.lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
optimizer,
max_lr=0.1,
total_steps=num_training_steps,
)
return self.lr_schedulerAnda tidak perlu menimpa create_optimizer() jika optimizer default sudah berfungsi. Memperluas sebuah method dengan super() lebih mudah daripada menggantinya sepenuhnya. Misalnya, tambahkan parameter group tambahan sambil mempertahankan hal lainnya tetap sama.
class MyTrainer(Trainer):
def create_optimizer(self, model=None):
super().create_optimizer(model) # builds the default two param groups
# add extra param group
self.optimizer.add_param_group({
"params": self.model.classifier.parameters(),
"lr": self.args.learning_rate * 10,
})
return self.optimizer