Transformers documentation
Optimizatörler ve zamanlayıcılar
Optimizatörler ve zamanlayıcılar
Bir optimizer, eğitim sırasında model ağırlıklarını günceller. Scheduler, optimizer'ı sarmalar ve her eğitim adımında öğrenme oranını ayarlar. Trainer, create_optimizer_and_scheduler() çağrısını yaptığında her ikisini de oluşturur.
┌────────────┐ ┌──────────────┐
│ 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() │
│ │
└───────────────────────────────────────────────────────────────────┘TrainingArguments içinde lr_scheduler_type() ve optim() gibi optimizör ve zamanlayıcı davranışlarını yapılandırın. Varsayılanlar (adamw_torch optimizörü ve linear ısınma zamanlayıcısı), çoğu ince ayar çalışması için iyi bir başlangıç noktasıdır.
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
)Metrik tabanlı zamanlayıcılar
Bazı zamanlayıcılar, sabit bir zaman çizelgesini takip etmek yerine eğitim dinamiklerine uyum sağlar.
GreedyLR, öğrenme oranını değerlendirme sonuçlarına göre günceller. Metrik sürekli iyileşiyorsa öğrenme oranını factor değerine bölerek artırır, metrik iyileşmiyorsa factor değerine çarparak azaltır. Öğrenme oranı min_lr değerinde durduktan ve reset_start adım boyunca iyileşme olmadığında, GreedyLR başlangıç durumuna sıfırlanır ve yeni bir döngü başlatır.
GreedyLR, eğitim sırasında değerlendirme gerektirir. eval_strategy değerini "steps" veya "epoch" olarak ayarlayın.
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
)Varsayılan
mode="min"kaybı (loss) için işe yarar. Doğruluk gibi daha yüksek değerin daha iyi olduğu bir metriği izliyorsanız,lr_scheduler_kwargsiçinde"mode": "max"parametresini iletin.
Yapılandırılabilir parametrelerin tam listesi için GreedyLR sınıfına bakın.
Optimizatör entegrasyonları
Transformers, özel eğitim senaryoları için üçüncü taraf optimizörleri entegre eder.
| Optimizatör | Yükle | optim="value" | Açıklama |
|---|---|---|---|
| APOLLO | apollo-torch | apollo_adamw | Rastgele projeksiyonlar aracılığıyla bellek verimli tam parametre; rank-1 yeterli |
| GrokAdamW | grokadamw | grokadamw | Gecikmiş genelleşmeyi (grokking) hedefler |
| LOMO / AdaLomo | lomo-optim | lomo / adalomo | Düşük bellek tam parametreli ince ayar için gradyan + güncelleme adımını birleştirir |
| Ücretsiz Planla | schedulefree | schedule_free_adamw, schedule_free_radam, schedule_free_sgd | LR annealing'i ortadan kaldırır; lr_scheduler_type="constant" ile birlikte kullanın |
| GaLore | galore-torch | galore_adamw, galore_adafactor, galore_adamw_8bit | Gradyan düşük-rank projeksiyonu ile tam parametre öğrenimi |
| StableAdamW | torch-optimi | stable_adamw | AdamW + AdaFactor güncelleme kırpma; gradyan kırpma gerekmez |
pip install apollo-torch
Approximated Gradient Scaling for Memory Efficient LLM Optimization (APOLLO), ön eğitim ve ince ayar sırasında tam parametre öğrenimi için bellek verimli bir optimizatördür. SVD yerine ucuz rastgele projeksiyonlar kullanarak SGD benzeri bellek maliyetiyle AdamW performansını eşitler. Aşırı bellek tasarrufu için, rank-1 varyantı olan APOLLO-Mini'yi kullanın.
Hangi katmanların eğitileceğini belirtmek için optim_target_modules parametresini kullanın.
args = TrainingArguments(
+ optim="apollo_adamw",
+ optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
... # remaining args from the TrainingArguments intro config
)Ek hiperparametreleri optim_args üzerinden iletin.
scaledeğerinin/rolarak ayarlayın; buradanorijinal uzay boyutunu,rise düşük rütbeli uzay boyutunu temsil eder.scaledeğerini varsayılan olarak bırakıp öğrenme oranını ayarlamak benzer bir etkiyi sağlar.
| parametre | açıklama | APOLLO | APOLLO-Mini |
|---|---|---|---|
| rank | gradiyan ölçekleme için yardımcı alt uzayın rütbesi | 256 | 1 |
| scale_type | ölçekleme faktörlerinin nasıl uygulandığı | channel (kanal başına ölçeklendirme) | tensor (tensor başına ölçeklendirme) |
| ölçek | eğitimi stabilize etmek için gradyan güncellemelerini ayarlar | 1.0 | 128 |
| update_proj_gap | projeksiyon matrislerini güncellemeden önceki adımlar | 200 | 200 |
| proj | projection türü | random | random |
APOLLO-Mini'yi rank-1 yapılandırmasıyla etkinleştirin.
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, yavaş değişen gradyanlar nedeniyle modellerin gecikmeli genelleme sergilediği grokking olgusunu hedefler.
args = TrainingArguments(
+ optim="grokadamw",
... # remaining args from the TrainingArguments intro config
)pip install lomo-optim
Düşük Bellek Optimizasyonu (LOMO), düşük bellekli tam parametreli ince ayar için LOMO ve AdaLomo olmak üzere iki optimizör içerir. Her ikisi de gradyan hesabını ve parametre güncellemelerini tek bir adımda birleştirir. AdaLomo, Adam'a benzer şekilde parametre başına uyarlama öğrenme oranı ekler.
AdaLomo,
grad_normkullanılmadan en iyi sonucu verir; bu sayede performans ve işleme hızı artar.
args = TrainingArguments(
+ optim="adalomo",
learning_rate=2e-6,
... # remaining args from the TrainingArguments intro config
)pip install schedulefree
Schedule Free optimizatörü (SFO), momentumu ortalama ve interpolasyon kombinasyonuyla değiştirir ve öğrenme hızını aşamalı olarak düşürme (annealing) ihtiyacını tamamen ortadan kaldırır.
SFO, RAdam (schedule_free_radam), AdamW (schedule_free_adamw) ve SGD (schedule_free_sgd) optimizörlerini destekler. RAdam zamanlayıcısı warmup_steps gerektirmez.
SFO'yu lr_scheduler_type="constant" ile eşleştirin. Diğer zamanlayıcı türleri çalışır ancak SFO'nun beklenen davranışını etkiler.
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, AdaFactor’ın güncelleme kırpma (clipping) mekanizmasını AdamW’ye taşır ve bu sayede gradyan kırpma ihtiyacını ortadan kaldırır. Bunun dışında, AdamW’nin doğrudan yerini alabilecek bir alternatiftir.
Büyük batch boyutlarıyla eğitim yapıyorsanız veya hâlâ loss sıçramaları gözlemliyorsanız,
beta_2değerini 0.95 ile 0.99 arasında ayarlamayı deneyin.
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), LLM eğitimi için bellek kullanımını azaltır. LoRA gibi düşük rütbeli uyarlama yöntemlerinin aksine GaLore, full-parameter öğrenmeyi korur.
trl.SFTConfig içinde optim alanını bir GaLore optimizatörüne ("galore_adamw", "galore_adafactor" veya "galore_adamw_8bit") ayarlayın. Hedef modülleri optim_target_modules ile ve GaLore'e özgü parametreleri (rank, update_proj_gap, scale) optim_args üzerinden belirtin.
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",
)Katman bazlı optimizasyon için optimizör adının sonuna _layerwise ekleyin ("galore_adamw_layerwise"). Sadece GaLore tarafından hedeflenen doğrusal katmanlar düşük rütbeli ayrıştırmayı kullanır. Diğer tüm katmanlar normal şekilde optimize edilir.
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",
)Layerwise modu deneyseldir. Yalnızca tek bir GPU üzerinde çalışır, DistributedDataParallel (DDP) desteklemez ve gradyan kırpma ile DeepSpeed çalışmayabilir.
Optimizatör ve zamanlayıcıyı özelleştirme
Henüz entegre edilmemiş bir optimizatör kullanmak, katman başına öğrenme oranlarını ayarlamak veya özel mantık uygulamak için özel bir optimizatör ve zamanlayıcı oluşturun.
Bir sınıf ve kwargs iletin
~Trainer.optimizer_cls_and_kwargs, Trainer'e parametre gruplandırma ve cihaz yerleşimi işlemlerini devrederek özel bir optimizör sınıfı kabul eder.
Trainer, modelin zaten doğru cihazda olmasını sağlamak için optimizatörün oluşturulmasını create_optimizer() çalışana kadar erteler.
import torch
trainer = Trainer(
...
optimizer_cls_and_kwargs=(
torch.optim.SGD,
{"momentum": 0.9, "nesterov": True}
),
)Önceden oluşturulmuş örnekleri iletin
~Trainer.optimizers içine önceden tanımlanmış bir optimizer ve scheduler geçirin. Trainer, hazır örnekler sağlandığında create_optimizer() ve create_scheduler() işlemlerini atlar. Scheduler geçmezseniz, Trainer otomatik olarak bir tane oluşturur.
Modelinizi doğru cihaza yerleştirdikten sonra optimizatörü oluşturun. Parametreler,
Trainermodeli taşımadan önce, inşaat sırasında çözümlenir. Dağıtık eğitimde, eşleşmeyen cihazlar sessizce hatalı davranışlara neden olabilir.
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),
)Hazır yapılandırılmış örnekler create_optimizer() ve create_scheduler() işlevlerini atlar; bu nedenle kendi parametre gruplarınızı belirtmeniz gerekir.
Optimizatör ve zamanlayıcı yöntemlerini geçersiz kılma
Tam kontrol için create_optimizer() ve create_scheduler() sınıflarını alt sınıflandırın. Her iki yöntem de train() sırasında çalışır.
SchedulerType içinde bulunmayan OneCycleLR gibi bir zamanlayıcı kullanmak için create_scheduler() işlevini geçersiz kılın.
Her yöntem için, self'e atama yaptığınızdan ve onu döndürdüğünüzden emin olun.
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_schedulerVarsayılan optimizör işe yarıyorsa create_optimizer() metodunu yeniden tanımlamanıza gerek yoktur. Bir metodu tamamen değiştirmek yerine super() ile genişletmek daha kolaydır. Örneğin, her şeyi aynı bırakıp ek bir parametre grubu ekleyebilirsiniz.
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