Treningsløkke: Tap, optimizer og epoker
Deltakere vil skrive PyTorch-treningsløkken: zero_grad, forward, beregning av CrossEntropyLoss, backward og optimizer.step, samt følge tap og nøyaktighet over epokene.
Treningsløkke: Tap, optimizer og epoker er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 4 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.
De fire trinnene i enhver treningsløkke
PyTorch-treningsløkken har fire obligatoriske trinn som gjentas for hver batch: (1) nullstill gradientene, (2) forward-passering, (3) tilbakepropagering og (4) optimerertrinn. Hvis De hopper over eller bytter om på disse trinnene, kan det gi feil resultater uten tydelige varsler — gradienter akkumuleres, parametere oppdateres feil eller minne lekker. Å gjøre dette mønsteret til en vane er den viktigste ferdigheten ved trening av nevrale nettverk med PyTorch.
import torch
import torch.nn as nn
import torch.optim as optim
model = nn.Linear(2, 1)
optimizer = optim.SGD(model.parameters(), lr=0.01)
criterion = nn.MSELoss()
X = torch.randn(20, 2)
y = torch.randn(20, 1)
for step in range(1):
optimizer.zero_grad() # (1) zero grads
y_pred = model(X) # (2) forward
loss = criterion(y_pred, y) # (2) loss
loss.backward() # (3) backward
optimizer.step() # (4) update
print('Loss:', loss.item())Tapsfunksjoner: Velge riktig kriterium
Tapfunksjonen måler hvor feil modellens prediksjoner er. PyTorchs nn-modul tilbyr mange: nn.MSELoss for regresjon (gjennomsnittlig kvadratisk feil), nn.CrossEntropyLoss for klassifisering med flere klasser (kombinerer log-softmax og NLL), og nn.BCEWithLogitsLoss for binær klassifisering (kombinerer sigmoid og binært kryssentropitap). Å bruke feil tapsfunksjon for oppgaven er en vanlig nybegynnerfeil som hindrer modellen i å lære.
import torch
import torch.nn as nn
# Regression
mse = nn.MSELoss()
y_pred = torch.tensor([2.5, 3.0])
y_true = torch.tensor([2.0, 3.5])
print('MSE:', mse(y_pred, y_true).item())
# Multi-class: logits (raw scores), not softmax
ce = nn.CrossEntropyLoss()
logits = torch.tensor([[2.0, 0.5, 1.0]])
labels = torch.tensor([0])
print('CE:', ce(logits, labels).item())Optimaliserere: SGD, Adam og AdamW
En optimaliserer bruker beregnede gradienter til å oppdatere modellparametere. SGD (Stochastic Gradient Descent) er den klassiske optimalisereren; hvis De legger til momentum, går konvergensen raskere. Adam tilpasser læringsraten for hver parameter ved hjelp av estimater for første og andre moment, og konvergerer raskere i praksis. AdamW legger til riktig weight decay (L2-regularisering) og er standardvalget for transformermodeller. Alle optimaliserere finnes i torch.optim.
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
# Stochastic Gradient Descent with momentum
sgd = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
# Adam: adaptive learning rate
adam = optim.Adam(model.parameters(), lr=0.001,
betas=(0.9, 0.999))
# AdamW: Adam + proper weight decay
adamw = optim.AdamW(model.parameters(), lr=0.001,
weight_decay=0.01)Iterasjon over epoker og batcher
Trening kjøres vanligvis over mange epoker – fullstendige gjennomganger av treningsdatasettet. I hver epoke itererer De over batcher (delmengder av dataene). Ved å bruke en DataLoader håndteres stokking og oppdeling i batcher automatisk. Ved å følge med på gjennomsnittlig tap per epoke kan De overvåke om modellen konvergerer. Utskrift for hver epoke (eller hver N. batch) gir innsyn i treningsfremdriften.
import torch
from torch.utils.data import TensorDataset, DataLoader
import torch.nn as nn
import torch.optim as optim
X = torch.randn(200, 4)
y = torch.randn(200, 1)
dataset = TensorDataset(X, y)
loader = DataLoader(dataset, batch_size=32, shuffle=True)
model = nn.Linear(4, 1)
optimizer = optim.Adam(model.parameters())
criterion = nn.MSELoss()
for epoch in range(3):
total_loss = 0
for X_batch, y_batch in loader:
optimizer.zero_grad()
pred = model(X_batch)
loss = criterion(pred, y_batch)
loss.backward()
optimizer.step()
total_loss += loss.item()
print(f'Epoch {epoch}: avg_loss={total_loss/len(loader):.4f}')DataLoader: Oppdeling og stokking av data
DataLoader pakker inn et datasett og tilbyr en iterator som gir batcher. Viktige parametere: batch_size angir hvor mange eksempler som brukes per gradientoppdatering; shuffle=True stokker rekkefølgen i hver epoke (avgjørende under trening); num_workers aktiverer parallell lasting av data. For egendefinerte datasett oppretter De en underklasse av torch.utils.data.Dataset og implementerer __len__ og __getitem__.
import torch
from torch.utils.data import Dataset, DataLoader
class MyDataset(Dataset):
def __init__(self, X, y):
self.X = X
self.y = y
def __len__(self):
return len(self.X)
def __getitem__(self, idx):
return self.X[idx], self.y[idx]
X = torch.randn(100, 5)
y = torch.randint(0, 3, (100,))
dataset = MyDataset(X, y)
loader = DataLoader(dataset, batch_size=16, shuffle=True)
X_batch, y_batch = next(iter(loader))
print(X_batch.shape) # torch.Size([16, 5])CrossEntropyLoss: Logits og klasseindekser
nn.CrossEntropyLoss forventer rå logits (normaliserte poengsummer), ikke softmax-sannsynligheter. Funksjonen bruker log-softmax internt og beregner negativ log-sannsynlighet. Målverdiene skal være heltall som angir klasseindekser (ikke one-hot-vektorer). Dette er riktig tapsfunksjon for klassifisering med flere klasser, og den er numerisk mer stabil enn å bruke softmax og deretter NLLLoss manuelt. Modellens siste lag skal IKKE ha en softmax-aktivering når De bruker denne tapsfunksjonen.
import torch
import torch.nn as nn
criterion = nn.CrossEntropyLoss()
# Batch of 4 samples, 3 classes
logits = torch.tensor([
[2.1, 0.5, 0.3],
[0.1, 3.0, 0.2],
[0.8, 0.9, 2.0],
[1.5, 0.1, 0.4]
])
# True labels as class indices (not one-hot)
labels = torch.tensor([0, 1, 2, 0])
loss = criterion(logits, labels)
print('Loss:', loss.item())Følge med på nøyaktighet under trening
At tapet synker, bekrefter at modellen lærer, men nøyaktighet viser om prediksjonene faktisk er riktige. For klassifisering med flere klasser konverterer De logits til en predikert klasse med torch.argmax langs klassedimensjonen, og sammenligner deretter med de sanne etikettene. Ved å følge med på både treningstap og treningsnøyaktighet, og eventuelt valideringsnøyaktighet, får De et komplett bilde av læringsdynamikken.
import torch
def compute_accuracy(logits, labels):
preds = torch.argmax(logits, dim=1)
correct = (preds == labels).sum().item()
return correct / len(labels)
logits = torch.tensor([
[2.0, 0.1, 0.3],
[0.1, 0.2, 3.5],
[1.0, 0.5, 0.2]
])
labels = torch.tensor([0, 2, 0])
print('Accuracy:', compute_accuracy(logits, labels))
# 1.0 (all three correct)Valideringssløyfe: Evaluering uten oppdatering
Etter hver treningsepoke kjører De en valideringssløyfe for å vurdere ytelsen på data modellen ikke har sett. Pakk den inn i torch.no_grad() for å deaktivere gradientberegning, og kall model.eval() for å deaktivere stokastisiteten i Dropout og BatchNorm. Sammenligning av treningstap og valideringstap er det viktigste verktøyet for å oppdage overtilpasning – når valideringstapet øker mens treningstapet fortsetter å synke, har modellen overtilpasset treningssettet.
import torch
def validate(model, val_loader, criterion):
model.eval()
total_loss = 0
with torch.no_grad():
for X_batch, y_batch in val_loader:
logits = model(X_batch)
loss = criterion(logits, y_batch)
total_loss += loss.item()
model.train() # restore training mode
return total_loss / len(val_loader)
# Usage inside training loop:
# val_loss = validate(model, val_loader, criterion)
# print(f'Val loss: {val_loss:.4f}')Planlegging av læringsrate
En fast læringsrate fører ofte til langsom konvergens eller oscillasjon nær minimumspunktet. Læringsrateplanleggere justerer automatisk LR under treningen. StepLR reduserer LR med en faktor hver N. epoke; CosineAnnealingLR reduserer den jevnt mot nær null langs en cosinuskurve; ReduceLROnPlateau reduserer LR når valideringstapet slutter å forbedres. Planleggerne oppdateres etter optimalisereren, vanligvis én gang per epoke.
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.Adam(model.parameters(), lr=0.01)
# Decay LR by 0.5 every 2 epochs
scheduler = optim.lr_scheduler.StepLR(
optimizer, step_size=2, gamma=0.5
)
for epoch in range(6):
# ... training code ...
scheduler.step()
print(f'Epoch {epoch}: LR={scheduler.get_last_lr()[0]}')
# LR: 0.01, 0.01, 0.005, 0.005, 0.0025, 0.0025Lagre kontrollpunkter under trening
Trening kan ta timer eller dager – ved å lagre kontrollpunkter med jevne mellomrom beskytter De Dem mot krasj og kan gjenoppta treningen fra det beste punktet. Et godt kontrollpunkt lagrer modellens state dict, optimalisererens state dict (som inneholder momentumledd), epokenummeret og den beste valideringsmetrikken. Når De gjenoppretter optimalisererens tilstand, kan treningen fortsette nøyaktig der den ble avbrutt, inkludert momentum-buffere som påvirker de påfølgende oppdateringene.
import torch
def save_checkpoint(model, optimizer, epoch, loss, path):
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss
}, path)
def load_checkpoint(model, optimizer, path):
ckpt = torch.load(path)
model.load_state_dict(ckpt['model_state_dict'])
optimizer.load_state_dict(ckpt['optimizer_state_dict'])
return ckpt['epoch'], ckpt['loss']Komplett treningssløyfe: Sette alt sammen
En treningssløyfe av produksjonskvalitet kombinerer alle delene: DataLoader for batching, oppdateringen i fire trinn for hver batch, en valideringsgjennomgang per epoke, planlegging av læringsraten, sporing av tap og nøyaktighet samt lagring av kontrollpunkter. Koden nedenfor viser hele mønsteret med en enkel klassifiseringsmodell. For å tilpasse malen til et hvilket som helst overvåket læringsproblem trenger De bare å endre modellen, datasettet og tapsfunksjonen.
import torch, torch.nn as nn, torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
X_tr = torch.randn(160, 4); y_tr = torch.randint(0, 3, (160,))
X_val = torch.randn(40, 4); y_val = torch.randint(0, 3, (40,))
tr_loader = DataLoader(TensorDataset(X_tr, y_tr), 32, shuffle=True)
val_loader = DataLoader(TensorDataset(X_val, y_val), 32)
model = nn.Sequential(nn.Linear(4, 16), nn.ReLU(), nn.Linear(16, 3))
optimizer = optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()
for epoch in range(5):
model.train()
for Xb, yb in tr_loader:
optimizer.zero_grad()
loss = criterion(model(Xb), yb)
loss.backward(); optimizer.step()
model.eval()
with torch.no_grad():
val_loss = sum(criterion(model(Xb), yb).item()
for Xb, yb in val_loader) / len(val_loader)
print(f'Epoch {epoch}: val_loss={val_loss:.3f}')Kunnskapssjekk
Test forståelsen Deres av konseptene innen Machine Learning with Python fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at treningssløyfen i fire trinn (zero_grad, forward, backward, step) er grunnlaget for all PyTorch-trening, at DataLoader håndterer batching og stokking automatisk, og at CrossEntropyLoss med logits er standardvalget for klassifisering. Deretter skal vi utforske planlegging av læringsrate og hvordan læringsraten påvirker treningsdynamikken.
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
Ofte stilte spørsmål
Er leksjonen «Treningsløkke: Tap, optimizer og epoker» gratis?
Ja – hele teksten i «Treningsløkke: Tap, optimizer og epoker» 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 «Treningsløkke: Tap, optimizer og epoker»?
Deltakere vil skrive PyTorch-treningsløkken: zero_grad, forward, beregning av CrossEntropyLoss, backward og optimizer.step, samt følge tap og nøyaktighet over epokene. 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 4 av 4.
Hvor lang tid tar leksjonen «Treningsløkke: Tap, optimizer og epoker»?
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
- PyTorch-tensorer: Oppretting, operasjoner og GPU-overføring
- Autograd: Automatisk derivasjon for backpropagation
- Bygge et feedforward-nettverk med nn.Module
- Treningsløkke: Tap, optimizer og epoker