Transformers documentation

Optimizer dan scheduler

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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" di lr_scheduler_kwargs.

Lihat kelas GreedyLR untuk daftar lengkap parameter yang dapat dikonfigurasi.

Integrasi optimizer

Transformers mengintegrasikan optimizer pihak ketiga untuk skenario pelatihan yang khusus.

OptimizerInstaloptim="value"Deskripsi
APOLLOapollo-torchapollo_adamwPenuh-param yang hemat memori melalui proyeksi acak; rank-1 sudah cukup
GrokAdamWgrokadamwgrokadamwMenargetkan generalisasi tertunda (grokking)
LOMO / AdaLomolomo-optimlomo / adalomoMenggabungkan langkah gradien + pembaruan untuk fine-tuning parameter penuh dengan memori rendah
Jadwal Bebasschedulefreeschedule_free_adamw, schedule_free_radam, schedule_free_sgdMenghilangkan annealing LR; gunakan bersama lr_scheduler_type="constant"
GaLoregalore-torchgalore_adamw, galore_adafactor, galore_adamw_8bitPembelajaran parameter penuh melalui proyeksi rank rendah gradien
StableAdamWtorch-optimistable_adamwPemotongan pembaruan AdamW + AdaFactor; tidak diperlukan pemotongan gradien
APOLLO
GrokAdamW
LOMO
Jadwal Bebas
StableAdamW
GaLore
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 scale ke n/r, di mana n adalah dimensi ruang asli dan r adalah dimensi ruang low-rank. Menyesuaikan learning rate sambil mempertahankan scale pada nilai defaultnya mencapai efek yang serupa.

parameterdeskripsiAPOLLOAPOLLO-Mini
rankrank dari sub-ruang bantu untuk penskalaan gradien2561
scale_typebagaimana faktor penskalaan diterapkanchannel (penskalaan per-channel)tensor (skala per tensor)
scalemenyesuaikan pembaruan gradien untuk menstabilkan pelatihan1.0128
update_proj_gaplangkah-langkah sebelum memperbarui matriks proyeksi200200
projtipe proyeksirandomrandom

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
)

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 Trainer memindahkan 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_scheduler

Anda 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
Update on GitHub