Machine Learning Academy · leksjon

Bygge et feedforward-nettverk med nn.Module

Deltakere vil lage en underklasse av nn.Module, sette sammen Linear- og ReLU-lag i __init__, implementere forward-steget og kontrollere utdataformene med en dummy-inndata.

Leksjon 3 av 413 trinn

Bygge et feedforward-nettverk med nn.Module er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 3 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.

Hva er nn.Module?

nn.Module er PyTorchs basisklasse for alle komponenter i nevrale nettverk. Hvert lag, hver aktiveringsfunksjon, tapsfunksjon og komplette modell i PyTorch arver fra nn.Module. Klassen tilbyr administrasjon av parametere, flytting mellom enheter, serialisering og bytte mellom trenings- og evalueringsmodus som standard. Ved å arve fra klassen får De all denne funksjonaliteten gratis og trenger bare å definere arkitekturen og forward-passeringen.

import torch.nn as nn

# Inspect what nn.Module gives you
model = nn.Linear(4, 2)
print(type(model))               # <class 'torch.nn.modules.linear.Linear'>
print(isinstance(model, nn.Module))  # True
print(list(model.parameters()))  # weight and bias tensors

Arve fra nn.Module: __init__ og forward

For å opprette et tilpasset nettverk kreves to metoder. I __init__ kaller De super().__init__() og definerer alle lærbare lag som attributter. I forward beskriver De hvordan data flyter gjennom disse lagene. PyTorch sporer alle nn.Module- eller nn.Parameter-objekter som tilordnes til self, som trenbare komponenter. Når modellen kalles som en funksjon (model(x)), påkalles forward automatisk, og alle registrerte hooks kjøres.

import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

model = SimpleNet(4, 16, 3)
print(model)

Lineære lag: nn.Linear

nn.Linear(in_features, out_features) utfører transformasjonen y = x @ W.T + b, der W er en vektingsmatrise og b er en biasvektor. Laget initialiserer automatisk vektene med en kaiming-uniformfordeling og biasverdiene med en uniform fordeling. Det er en byggestein i feedforward-nettverk, også kalt fullt tilkoblede eller tette lag.

import torch
import torch.nn as nn

layer = nn.Linear(5, 3)  # 5 inputs, 3 outputs

print('Weight shape:', layer.weight.shape)  # (3, 5)
print('Bias shape:',   layer.bias.shape)    # (3,)

# Forward pass with a batch of 8 samples
x = torch.randn(8, 5)
out = layer(x)
print('Output shape:', out.shape)   # (8, 3)

Aktiveringsfunksjoner: ReLU, Sigmoid, Tanh

Aktiveringsfunksjoner tilfører ikke-linearitet, slik at nettverket kan lære komplekse mønstre som en stabel med lineære lag ikke kan representere. ReLU (max(0, x)) er standarden for skjulte lag — den er rask og motvirker forsvinnende gradienter. Sigmoid begrenser utdataene til [0, 1] og brukes for utdata ved binær klassifisering. Tanh begrenser utdataene til [-1, 1] og brukes ofte i RNN-er. Alle er tilgjengelige som moduler i nn.

import torch
import torch.nn as nn

x = torch.tensor([-2.0, -0.5, 0.0, 0.5, 2.0])

print('ReLU:   ', nn.ReLU()(x))
# tensor([0.0, 0.0, 0.0, 0.5, 2.0])

print('Sigmoid:', nn.Sigmoid()(x))
# tensor([0.12, 0.38, 0.50, 0.62, 0.88])

print('Tanh:   ', nn.Tanh()(x))
# tensor([-0.96, -0.46,  0.00,  0.46,  0.96])

Stable lag med nn.Sequential

nn.Sequential er en praktisk beholder som sender utdataene fra hver modul videre som inndata til den neste. Den egner seg godt for enkle feedforward-arkitekturer der data flyter lineært. For mer komplekse nettverk med hoppkoblinger, flere inndata eller forgrenede baner trenger De den fullstendige tilnærmingen med en underklasse av nn.Module. Sekvensielle nettverk kan likevel utvides ved å lage en underklasse og bruke Sequential som en delblokk.

import torch
import torch.nn as nn

# Build with nn.Sequential
model = nn.Sequential(
    nn.Linear(10, 64),
    nn.ReLU(),
    nn.Linear(64, 32),
    nn.ReLU(),
    nn.Linear(32, 1)
)

x = torch.randn(16, 10)    # batch of 16
out = model(x)
print(out.shape)            # torch.Size([16, 1])

Verifisere utdataformer med dummy-inndata

En viktig feilsøkingsteknikk ved bygging av nettverk er å sende en dummy-tensor gjennom modellen før treningen starter. Dette bekrefter at dimensjonene til alle lag er kompatible, og avdekker umiddelbart formmismatcher. Dummy-tensoren har samme form som de virkelige dataene, men inneholder tilfeldige verdier — den tester bare forward-banen. Gjør alltid dette etter at De har definert en ny arkitektur.

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )
    def forward(self, x):
        return self.net(x)

model = MLP()
dummy = torch.randn(32, 784)   # batch of 32 MNIST images
out = model(dummy)
print(out.shape)                # torch.Size([32, 10]) -- correct!

Liste opp og telle parametere

Ved å kjenne det totale antallet trenbare parametere i en modell får De en forståelse av modellens kapasitet og minnekrav. model.parameters() returnerer en iterator over alle lærbare tensorer, mens model.named_parameters() kobler hver tensor til navnet sitt for inspeksjon. En kompakt parameterteller er et av de første verktøyene alle som arbeider med PyTorch, bygger.

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10)
)

total_params = sum(p.numel() for p in model.parameters())
trainable = sum(p.numel() for p in model.parameters()
                if p.requires_grad)

print(f'Total params:     {total_params:,}')   # 203,530
print(f'Trainable params: {trainable:,}')       # 203,530

for name, p in model.named_parameters():
    print(name, p.shape)

Flytte modellen til GPU

Det er så enkelt som å kalle model.to(device) for å flytte modellen til GPU-en. Dette overfører alle parametere og buffere som er registrert i modulen, til målenheten. Etter dette kallet utføres alle beregninger i forward-passeringen automatisk på GPU-en — så lenge inndatatensorene også befinner seg på samme enhet. Hvis CPU- og GPU-tensorer blandes, oppstår en kjøretidsfeil.

import torch
import torch.nn as nn

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

model = nn.Sequential(
    nn.Linear(4, 8),
    nn.ReLU(),
    nn.Linear(8, 2)
).to(device)   # move entire model to device

# Input must be on the same device
x = torch.randn(5, 4).to(device)
out = model(x)
print(out.device)   # cuda:0 (or cpu)

Treningsmodus kontra evalueringsmodus

Noen lag (Dropout, BatchNorm) oppfører seg forskjellig under trening og inferens. Når De kaller model.train(), aktiveres stokastisk atferd (tilfeldig dropout og batchstatistikk); model.eval() bytter til deterministisk inferensatferd. Hvis De glemmer å kalle model.eval() før evaluering, blir resultatene inkonsistente fordi Dropout tilfeldig setter aktiveringer til null. Koble alltid disse kallene sammen med torch.no_grad() under inferens for best mulig effektivitet.

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(4, 8),
    nn.Dropout(p=0.5),
    nn.Linear(8, 2)
)

# Training mode: dropout is active
model.train()
x = torch.randn(4, 4)
print(model(x))   # some activations zeroed randomly

# Eval mode: dropout is disabled
model.eval()
with torch.no_grad():
    print(model(x))   # deterministic output

Tilpasset nettverk: flerlagsperseptron

La oss sette alt sammen: Et flerlagsperseptron (MLP) er et feedforward-nettverk med ett eller flere skjulte lag mellom inndataene og utdataene. Hvert skjult lag utfører en lineær transformasjon etterfulgt av en ikke-lineær aktivering. Aktiveringen i utgangslaget avhenger av oppgaven — ingen aktivering for regresjon, softmax for fl klasseklassifisering og sigmoid for binær klassifisering. Eksemplet nedenfor bygger et MLP med tre lag for klassifisering i 10 klasser.

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, in_dim, hidden_dims, out_dim):
        super().__init__()
        layers = []
        prev = in_dim
        for h in hidden_dims:
            layers.append(nn.Linear(prev, h))
            layers.append(nn.ReLU())
            prev = h
        layers.append(nn.Linear(prev, out_dim))
        self.net = nn.Sequential(*layers)

    def forward(self, x):
        return self.net(x)

model = MLP(784, [256, 128, 64], 10)
dummy = torch.randn(32, 784)
print(model(dummy).shape)  # torch.Size([32, 10])

Lagre og laste inn nettverkstilstand

Trening av nevrale nettverk er kostbart, så De bør lagre modellen etter treningen. PyTorchs konvensjon er å lagre bare state_dict — en ordbok med parametertensorer — i stedet for hele modellobjektet. Dette unngår at pickle er avhengig av klassedefinisjonen. For å gjenopprette modellen oppretter De en ny modellinstans med samme arkitektur og laster deretter inn tilstandsordboken med load_state_dict. Kall alltid model.eval() etter innlasting når modellen skal brukes til inferens.

import torch
import torch.nn as nn

model = nn.Linear(4, 2)

# Save only parameters (recommended)
torch.save(model.state_dict(), '/tmp/model.pt')

# Restore
new_model = nn.Linear(4, 2)  # same architecture
new_model.load_state_dict(torch.load('/tmp/model.pt'))
new_model.eval()

x = torch.randn(3, 4)
print(new_model(x))   # same output as original model

Hurtigsjekk

Test forståelsen Deres av konsepter innen maskinlæring med Python fra denne leksjonen.

Oppsummering av leksjonen

I denne leksjonen lærte De at nn.Module er basisklassen for alle nevrale nettverk i PyTorch, og at __init__ brukes til å definere lag mens forward definerer dataflyten. De lærte også at nn.Sequential tilbyr en enkel beholder for lineære stabler av lag, og at model.train() / model.eval() endrer atferden til lag som Dropout og BatchNorm. Neste gang skriver vi den komplette treningsløkken, inkludert tap, optimerer og flere epoker.

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

Ofte stilte spørsmål

Er leksjonen «Bygge et feedforward-nettverk med nn.Module» gratis?

Ja – hele teksten i «Bygge et feedforward-nettverk med nn.Module» 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 «Bygge et feedforward-nettverk med nn.Module»?

Deltakere vil lage en underklasse av nn.Module, sette sammen Linear- og ReLU-lag i __init__, implementere forward-steget og kontrollere utdataformene med en dummy-inndata. 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 3 av 4.

Hvor lang tid tar leksjonen «Bygge et feedforward-nettverk med nn.Module»?

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

  1. PyTorch-tensorer: Oppretting, operasjoner og GPU-overføring
  2. Autograd: Automatisk derivasjon for backpropagation
  3. Bygge et feedforward-nettverk med nn.Module
  4. Treningsløkke: Tap, optimizer og epoker
← Tilbake til Machine Learning Academy