Planificatoare ale ratei de învățare (torch.optim.lr_scheduler) în PyTorch & Deep Learning Practic

from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR

warmup = LinearLR(optimizator, start_factor=0.1, total_iters=5)
cosinus = CosineAnnealingLR(optimizator, T_max=95, eta_min=1e-6)
scheduler = SequentialLR(optimizator, schedulers=[warmup, cosinus], milestones=[5])

for epoca in range(100):
    antreneaza(...)     # conține optimizator.step()
    scheduler.step()

Un planificator (scheduler) primește optimizatorul și modifică lr din grupurile lui de parametri la fiecare scheduler.step(). Documentația cere ca apelul să vină după optimizer.step(); din PyTorch 1.1.0, ordinea inversă sare peste prima valoare din program. Majoritatea planificatoarelor numără epoci, dar „epoca” este de fapt numărul de apeluri step(), deci poți apela pe lot dacă dai valorile în pași.

Pentru warmup urmat de altă curbă, documentația oferă SequentialLR: rulează planificatoarele pe rând, schimbând la pragurile din milestones. ChainedScheduler este altceva: aplică toate planificatoarele la fiecare pas, unul peste altul. LinearLR înmulțește rata cu un factor care crește liniar de la start_factor (implicit 1/3) la end_factor (implicit 1.0) în total_iters pași (implicit 5).

OneCycleLR schimbă rata după fiecare lot și se apelează după fiecare lot, nu după fiecare epocă. CosineAnnealingWarmRestarts poate fi apelat și după fiecare lot, cu epoca fracționară. ReduceLROnPlateau este diferit: primește o metrică la step(metrica) și înmulțește rata cu factor (implicit 0.1) dacă metrica nu se îmbunătățește timp de patience epoci (implicit 10).

Concepte cheie și caracteristici

Concept / Parametru	Descriere practică
StepLR(opt, step_size, gamma=0.1)	Înmulțește rata cu gamma la fiecare step_size epoci.
CosineAnnealingLR(opt, T_max, eta_min=0.0)	Coborâre după curbă cosinus până la eta_min în T_max pași.
LinearLR(opt, start_factor=1/3, end_factor=1.0, total_iters=5)	Schimbare liniară a factorului; folosit pentru warmup.
SequentialLR(opt, schedulers, milestones)	Planificatoare pe rând, schimbate la praguri.
ChainedScheduler(schedulers)	Toate planificatoarele aplicate la fiecare pas, în cascadă.
OneCycleLR(opt, max_lr, total_steps=None, epochs=None, steps_per_epoch=None)	Politica 1cycle; step() după fiecare lot.
ReduceLROnPlateau(opt, mode="min", factor=0.1, patience=10)	Reduce rata când metrica stagnează; step(val_loss).
scheduler.get_last_lr()	Lista ratelor curente, câte una pe grup de parametri.

Exemple practice și scenarii reale

Exemplul 1: OneCycleLR pe loturi

scheduler = torch.optim.lr_scheduler.OneCycleLR(
    optimizator, max_lr=1e-3, steps_per_epoch=len(train_loader), epochs=10)
for epoca in range(10):
    for x, y in train_loader:
        pierdere = criteriu(model(x), y)
        optimizator.zero_grad()
        pierdere.backward()
        optimizator.step()
        scheduler.step()      # după fiecare lot

Exemplul 2: ReduceLROnPlateau pe pierderea de validare

scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizator, mode="min", factor=0.5, patience=3)
for epoca in range(50):
    antreneaza(...)
    pierdere_val, _ = valideaza(...)
    scheduler.step(pierdere_val)
    print(scheduler.get_last_lr())

Exemplul 3: Starea planificatorului în checkpoint

torch.save({"model": model.state_dict(),
            "optimizator": optimizator.state_dict(),
            "scheduler": scheduler.state_dict(),
            "epoca": epoca}, "checkpoint.pt")

Greșeli frecvente și capcane

• Să apelezi scheduler.step() înainte de optimizer.step(). Se pierde prima valoare din program și PyTorch afișează un avertisment.
• Să folosești ChainedScheduler pentru „întâi warmup, apoi cosinus”. Pentru o succesiune folosești SequentialLR.
• Să apelezi OneCycleLR o dată pe epocă. Programul se întinde pe total_steps loturi; cu un apel pe epocă rata nu ajunge la valorile planificate.

Noțiuni și module înrudite

• torch-optimizers-adamw
• torch-training-loop
• torch-save-load-state-dict