Learning rate: Den vigtigste hyperparameter
De lærende kører en test af et interval af learning rates, afbilder loss som funktion af LR, identificerer det optimale interval og anvender en CosineAnnealingLR-plan for at undgå plateauer.
Learning rate: Den vigtigste hyperparameter er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvorfor læringsraten betyder mest
Læringsraten (LR) er den hyperparameter, der har størst indflydelse på, om et neuralt netværk trænes korrekt. Den styrer, hvor stort et skridt optimeringsalgoritmen tager i retningen af den negative gradient. Hvis den er for stor, divergerer modellen; hvis den er for lille, tager træningen en evighed eller går i stå. I modsætning til arkitekturvalg skal LR næsten altid justeres, når du ændrer datasættet, modellens størrelse eller batchstørrelsen.
import torch
import torch.nn as nn
import torch.optim as optim
model = nn.Linear(1, 1)
# Too large: diverges
optimizer_big = optim.SGD(model.parameters(), lr=10.0)
# Too small: barely moves
optimizer_small = optim.SGD(model.parameters(), lr=1e-6)
# Good: converges steadily
optimizer_good = optim.SGD(model.parameters(), lr=0.01)
print('LR comparison: 10.0, 1e-6, 0.01')LR's effekt på losskurver
Forskellige læringsrater giver genkendelige mønstre i losskurven. For høj: loss svinger voldsomt eller stiger efter nogle få trin. For lav: loss falder ekstremt langsomt og er næsten flad. Præcis passende: loss falder jævnt og konsekvent. Det er almindelig praksis at plotte loss i forhold til batch/epoke for nogle få repræsentative LR-værdier (f.eks. 1e-4, 1e-3, 1e-2, 1e-1), før du starter en lang træning.
import torch
import torch.nn as nn
import torch.optim as optim
def train_one_lr(lr, steps=50):
model = nn.Linear(1, 1)
opt = optim.SGD(model.parameters(), lr=lr)
X = torch.randn(100, 1)
y = 2 * X + 1
losses = []
for _ in range(steps):
opt.zero_grad()
loss = nn.MSELoss()(model(X), y)
loss.backward(); opt.step()
losses.append(loss.item())
return losses[-1]
for lr in [1e-4, 1e-2, 0.1, 1.0]:
final = train_one_lr(lr)
print(f'LR={lr:.4f}: final_loss={final:.4f}')Test af læringsrateintervallet
LR-intervaltesten (gjort populær af Leslie Smith) finder automatisk en god LR. Start med en meget lille LR, og øg den eksponentielt over mange minibatches, mens du registrerer loss. Loss falder først og stiger derefter kraftigt, når LR er for stor. Den optimale LR er omtrent 10 gange mindre end det punkt, hvor loss begynder at stige. Denne test tager kun få minutter og fjerner behovet for en dyr gittersøgning over LR.
import torch
import torch.nn as nn
import torch.optim as optim
import math
def lr_range_test(model, loader, criterion, start_lr=1e-7, end_lr=10, num_iter=100):
optimizer = optim.SGD(model.parameters(), lr=start_lr)
lrs, losses = [], []
mult = (end_lr / start_lr) ** (1 / num_iter)
lr = start_lr
for i, (X, y) in enumerate(loader):
if i >= num_iter: break
optimizer.zero_grad()
loss = criterion(model(X), y)
loss.backward(); optimizer.step()
lrs.append(lr)
losses.append(loss.item())
lr *= mult
for pg in optimizer.param_groups:
pg['lr'] = lr
return lrs, lossesWarm-up: Start småt og øg gradvist
Warm-up af læringsraten starter træningen med en meget lille LR og øger den gradvist til målraten over de første par hundrede trin eller epoker. Det forhindrer store, ustabile opdateringer helt i begyndelsen, hvor vægtene er initialiseret tilfældigt, og gradienterne er støjfyldte. Warm-up er især vigtigt for Transformers og træning med store batches, hvor store indledende trin kan sende modellen til et dårligt område i loss-landskabet, som er svært at komme væk fra.
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
def warmup_lambda(current_step, warmup_steps=100):
if current_step < warmup_steps:
return current_step / warmup_steps
return 1.0
scheduler = optim.lr_scheduler.LambdaLR(
optimizer, lr_lambda=warmup_lambda
)
for step in range(5):
scheduler.step()
print(f'Step {step}: LR={optimizer.param_groups[0]["lr"]:.6f}')Planlægning med trinvist fald med StepLR
StepLR reducerer læringsraten med en multiplikativ faktor gamma for hver step_size epoker. Hvis du f.eks. halverer LR hver 10. epoke (gamma=0.5, step_size=10), får du en almindelig plan for billedklassifikation. Trinvist fald er let at forstå og fungerer godt, når du nogenlunde ved, hvor mange epoker modellen skal bruge for at falde til ro. Planlæggeren skal kaldes efter optimeringsalgoritmens trin i hver epoke.
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = optim.lr_scheduler.StepLR(
optimizer, step_size=3, gamma=0.5
)
for epoch in range(9):
# (training happens here)
scheduler.step()
print(f'After epoch {epoch}: LR={optimizer.param_groups[0]["lr"]:.4f}')
# 0.1 -> 0.1 -> 0.1 -> 0.05 -> 0.05 -> 0.05 -> 0.025 ...Cosinus-annealing: Jævnt fald til nul
CosineAnnealingLR reducerer LR efter en cosinuskurve fra den oprindelige LR til et minimum (eta_min, standardværdien er 0) over T_max trin. Cosinusformen giver et hurtigt indledende fald og en blød landing nær nul. CosineAnnealingWarmRestarts tilføjer periodiske genstarter, der slipper væk fra lokale minima og skaber et karakteristisk savtaksmønster for LR. Cosinusplaner er blandt de mest udbredte i moderne deep learning.
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(
optimizer, T_max=10, eta_min=1e-4
)
for epoch in range(10):
scheduler.step()
lr = optimizer.param_groups[0]['lr']
print(f'Epoch {epoch}: LR={lr:.5f}')
# Smoothly decays from 0.1 to 0.0001 over 10 epochsReduceLROnPlateau: Adaptiv planlægning
ReduceLROnPlateau overvåger en metrik (normalt validerings-loss) og reducerer LR med en faktor, når metrikken ikke længere forbedres i et angivet antal epoker (patience). Dette er den mest adaptive planlægger, fordi den reagerer på den faktiske træningsdynamik i stedet for en forudbestemt plan. Den er især effektiv, når du er usikker på, hvor mange epoker træningen vil tage, eller når træningsfremskridtet er ujævnt.
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.Adam(model.parameters(), lr=0.01)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
mode='min', # reduce when metric stops going down
factor=0.5, # multiply LR by 0.5
patience=3, # wait 3 epochs before reducing
min_lr=1e-6
)
# Each epoch, pass the validation loss
for epoch in range(10):
val_loss = 1.0 / (epoch + 1) # simulated decreasing loss
scheduler.step(val_loss)
print(f'Epoch {epoch}: LR={optimizer.param_groups[0]["lr"]}')Batchstørrelse og dens forhold til LR
Batchstørrelse og læringsrate hænger tæt sammen. Når du fordobler batchstørrelsen, beregnes gennemsnittet af gradienterne over dobbelt så mange eksempler — de bliver mindre støjfyldte. En almindelig tommelfingerregel er reglen om lineær skalering: gang LR med den samme faktor som stigningen i batchstørrelsen. Hvis du f.eks. fordobler batchstørrelsen fra 64 til 128, bør du også fordoble LR. Reglen fungerer godt i det moderate område, men bryder sammen ved meget store batches.
# Linear scaling rule: if base LR=0.01 with batch_size=64
# and you change to batch_size=256 (4x larger):
base_lr = 0.01
base_batch = 64
new_batch = 256
scaled_lr = base_lr * (new_batch / base_batch)
print(f'Scaled LR: {scaled_lr}') # 0.04
# But use warm-up when scaling to very large batches
# to avoid instability at the start of trainingGradientklipning: Forebyggelse af eksploderende gradienter
Når LR er lidt for høj, eller gradienterne naturligt er store (hvilket er almindeligt i RNN'er), forhindrer gradientklipning, at parameteropdateringerne bliver katastrofalt store. torch.nn.utils.clip_grad_norm_ skalerer gradientvektoren om, så den har en maksimal L2-norm. Klipningen sker efter kaldet til .backward(), men før optimizer.step(). En maksimal norm på 1.0 er en almindelig standardværdi for rekurrente netværk.
import torch
import torch.nn as nn
import torch.optim as optim
model = nn.LSTM(4, 8, batch_first=True)
optimizer = optim.Adam(model.parameters(), lr=0.001)
x = torch.randn(16, 10, 4) # batch=16, seq=10, features=4
out, _ = model(x)
loss = out.sum()
loss.backward()
# Clip gradients before optimizer step
total_norm = nn.utils.clip_grad_norm_(
model.parameters(), max_norm=1.0
)
print(f'Gradient norm before clip: {total_norm:.4f}')
optimizer.step()Find LR med PyTorch Lightning eller et manuelt loop
Mange udviklere bruger PyTorch Lightnings indbyggede LR-finder, som automatiserer LR-intervaltesten. Hvis du bruger rå PyTorch, kan du implementere intervaltesten manuelt ved at øge LR eksponentielt over 100 minibatches og plotte loss i forhold til LR på en logaritmisk skala. Det bedste område er dér, hvor loss falder stejlest. Værktøjer som torch-lr-finder-pakken samler dette i ét funktionskald for nemheds skyld.
# Manual LR finder sketch (pseudocode)
import math
# 1. Save initial model state
# torch.save(model.state_dict(), 'init.pt')
# 2. Sweep LR exponentially from 1e-7 to 1
start, end, steps = 1e-7, 1.0, 100
mult = (end / start) ** (1 / steps)
lr = start
for i, (X, y) in enumerate(train_loader):
if i >= steps: break
# train one step with current lr...
lr *= mult
# 3. Plot lrs vs losses on log-linear scale
# 4. Pick LR where loss drops fastest
# 5. Restore initial model stateOpsummering af LR og praktiske regler
De vigtigste praktiske regler for læringsraten er: Start med 1e-3 for Adam og 0.01 for SGD som standardværdier. Kør altid en hurtig LR-intervaltest, når du bruger et nyt datasæt eller en ny arkitektur. Brug cosinus-annealing eller ReduceLROnPlateau i stedet for en fast LR for at opnå den bedste konvergens. Skaler LR lineært med batchstørrelsen. Brug altid gradientklipning til RNN'er. Den tid, du bruger på at justere LR, giver større udbytte end næsten enhver anden optimering.
# Quick reference for default starting points
defaults = {
'SGD': {'lr': 0.01, 'momentum': 0.9},
'Adam': {'lr': 1e-3, 'betas': (0.9, 0.999)},
'AdamW': {'lr': 1e-3, 'weight_decay': 0.01},
'RMSprop': {'lr': 1e-4}
}
print('Default LR starting points:')
for opt, params in defaults.items():
print(f' {opt}: {params}')Hurtigt tjek
Test din forståelse af begreberne inden for maskinlæring med Python fra denne lektion.
Opsummering af lektionen
I denne lektion lærte du, at læringsraten er den mest kritiske hyperparameter for konvergenshastighed og stabilitet, at LR-intervaltesten hurtigt finder en god LR ved at gå fra lille til stor og finde det stejleste fald i loss, og at planlæggere som CosineAnnealingLR og ReduceLROnPlateau automatisk justerer LR under træningen for at give bedre slutresultater. Nu skal vi se på batchnormalisering for hurtigere og mere stabil træning.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Learning rate: Den vigtigste hyperparameter” gratis?
Ja — hele teksten til “Learning rate: Den vigtigste hyperparameter” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Learning rate: Den vigtigste hyperparameter”?
De lærende kører en test af et interval af learning rates, afbilder loss som funktion af LR, identificerer det optimale interval og anvender en CosineAnnealingLR-plan for at undgå plateauer. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “Learning rate: Den vigtigste hyperparameter”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Learning rate: Den vigtigste hyperparameter
- Batchnormalisering: Stabil og hurtigere træning
- Dropout-regularisering for at forhindre overfitting
- Vægtinitialisering: Xavier- og He-initialisering