Machine Learning Academy · leksjon

Læringsrate: Den viktigste hyperparameteren

Deltakere vil kjøre en test av et område med læringsrater, plotte tap mot læringsrate, identifisere det optimale området og bruke en CosineAnnealingLR-plan for å unngå platåer.

Leksjon 1 av 413 trinn

Læringsrate: Den viktigste hyperparameteren er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hvorfor læringsraten betyr mest

Læringsraten (LR) er den hyperparameteren som i størst grad avgjør om et nevralt nettverk trenes vellykket. Den bestemmer hvor stort steg optimalisereren tar i retning av den negative gradienten. Er den for stor, divergerer modellen; er den for liten, tar treningen svært lang tid eller setter seg fast. I motsetning til arkitekturvalg må LR justeres nesten hver gang De endrer datasettet, modellstørrelsen 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')

Effekten av LR på tapskurver

Ulike læringsrater gir gjenkjennelige mønstre i tapskurven. For høy: tapet oscillerer voldsomt eller øker etter noen få trinn. For lav: tapet synker ekstremt langsomt og blir nesten flatt. Akkurat passe: tapet synker jevnt og stabilt. Det er vanlig praksis å plotte tap mot batch/epoke for noen representative LR-verdier (for eksempel 1e-4, 1e-3, 1e-2, 1e-1) før De starter en lang treningskjøring.

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 av læringsrateområdet

LR-områdetesten (gjort populær av Leslie Smith) finner automatisk en god LR. Start med en svært liten LR og øk den eksponentielt over mange minibatcher mens De registrerer tapet. Tapet synker først, og stiger deretter bratt når LR blir for stor. Den optimale LR-en er omtrent 10 ganger mindre enn punktet der tapet begynner å stige. Denne testen tar bare noen få minutter og eliminerer behovet for et kostbart rutenettsøk 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, losses

Oppvarming: Starte lavt og øke

Oppvarming av læringsraten starter treningen med en svært liten LR og øker den gradvis til målraten i løpet av de første hundre stegene eller epokene. Dette hindrer store og ustabile oppdateringer helt i starten, når vektene er tilfeldig initialisert og gradientene er støyende. Oppvarming er spesielt viktig for transformere og trening med store batcher, der store innledende steg kan sende modellen til et dårlig område i tapslandskapet som er vanskelig å komme ut av.

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}')

Stegvis reduksjon med StepLR

StepLR reduserer læringsraten med en multiplikativ faktor gamma hver step_size-te epoke. Det er for eksempel vanlig å halvere LR hver tiende epoke (gamma=0.5, step_size=10) ved bildeklassifisering. Stegvis reduksjon er enkel å forstå og fungerer godt når De omtrent vet hvor mange epoker modellen trenger for å stabilisere seg. Planleggeren må kalles etter optimaliserertrinnet 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 ...

Cosinusannealing: Jevn reduksjon mot null

CosineAnnealingLR reduserer LR langs en cosinuskurve fra den opprinnelige LR-en til et minimum (eta_min, standardverdi 0) over T_max trinn. Cosinusformen gir en rask innledende reduksjon med en myk avslutning nær null. CosineAnnealingWarmRestarts legger til periodiske omstarter som kan unnslippe lokale minima, og skaper et karakteristisk sagtannmønster for LR. Cosinusplaner er blant de mest brukte 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 epochs

ReduceLROnPlateau: Adaptiv planlegging

ReduceLROnPlateau overvåker en metrikk (vanligvis valideringstap) og reduserer LR med en faktor når metrikken slutter å forbedres i et angitt antall epoker (patience). Dette er den mest adaptive planleggeren fordi den reagerer på den faktiske treningsdynamikken i stedet for en forhåndsbestemt plan. Den er spesielt effektiv når De er usikker på hvor mange epoker treningen vil ta, eller når fremdriften er ujevn.

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 forholdet til LR

Batchstørrelse og læringsrate henger tett sammen. Når De dobler batchstørrelsen, beregnes gradientene som gjennomsnitt over dobbelt så mange eksempler – de blir mindre støyende. En vanlig tommelfingerregel er regelen for lineær skalering: multipliser LR med samme faktor som økningen i batchstørrelse. Hvis De for eksempel dobler batchstørrelsen fra 64 til 128, bør De også doble LR. Denne regelen fungerer godt i det moderate området, men bryter sammen for svært store batcher.

# 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 training

Gradientklipping: Hindre eksploderende gradienter

Når LR er litt for høy eller gradientene naturlig er store (vanlig i RNN-er), hindrer gradientklipping at parameteroppdateringene blir katastrofalt store. torch.nn.utils.clip_grad_norm_ skalerer gradientvektoren på nytt slik at den får en maksimal L2-norm. Klippingen skjer etter kallet til .backward(), men før optimizer.step(). En maksimal norm på 1.0 er en vanlig standardverdi for rekurrente nettverk.

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()

Finne LR med PyTorch Lightning eller en manuell sløyfe

Mange bruker PyTorch Lightning's innebygde LR-finner, som automatiserer LR-områdetesten. Hvis De bruker rå PyTorch, kan De implementere testen manuelt ved å øke LR eksponentielt over 100 minibatcher og plotte tap mot LR på en logaritmisk skala. Det optimale området er der tapet synker brattest. Verktøy som torch-lr-finder pakker dette inn i ett enkelt funksjonskall for enkelhets 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 state

LR-oppsummering og praktiske regler

De viktigste praktiske reglene for læringsrate er: start med 1e-3 for Adam og 0.01 for SGD som standardverdier. Kjør alltid en rask LR-områdetest når De bruker et nytt datasett eller en ny arkitektur. Bruk cosinusannealing eller ReduceLROnPlateau i stedet for en fast LR for best mulig konvergens. Skaler LR lineært med batchstørrelsen. Bruk alltid gradientklipping for RNN-er. Innsatsen De legger i justering av LR, gir større uttelling enn nesten enhver annen optimalisering.

# 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}')

Kunnskapssjekk

Test forståelsen Deres av konseptene innen Machine Learning with Python fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at læringsraten er den viktigste hyperparameteren for å kontrollere konvergenshastighet og stabilitet, at LR-områdetesten raskt finner en god LR ved å gå fra liten til stor verdi og se etter den bratteste reduksjonen i tapet, og at planleggere som CosineAnnealingLR og ReduceLROnPlateau automatisk justerer LR under treningen for bedre sluttresultater. Deretter skal vi utforske batchnormalisering for raskere og mer stabil trening.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Læringsrate: Den viktigste hyperparameteren» gratis?

Ja – hele teksten i «Læringsrate: Den viktigste hyperparameteren» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Læringsrate: Den viktigste hyperparameteren»?

Deltakere vil kjøre en test av et område med læringsrater, plotte tap mot læringsrate, identifisere det optimale området og bruke en CosineAnnealingLR-plan for å unngå platåer. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Machine Learning Academy?

Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Læringsrate: Den viktigste hyperparameteren»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?

Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Læringsrate: Den viktigste hyperparameteren
Batch-normalisering: Stabilere og raskere trening
Dropout-regularisering for å forhindre overtilpasning
Vektinitialisering: Xavier- og He-initialisering

← Tilbake til Machine Learning Academy