Machine Learning Academy · Oppitunti

Syöttöä eteenpäin välittävän verkon rakentaminen nn.Modulella

Oppijat periyttävät luokan nn.Modulesta, pinoavat Linear- ja ReLU-kerrokset __init__-metodissa, toteuttavat forward-vaiheen ja varmistavat tulosmuodot esimerkkisyötteellä.

Oppitunti 3/413 vaihetta

Syöttöä eteenpäin välittävän verkon rakentaminen nn.Modulella on ilmainen Machine Learning Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Machine Learning Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Machine Learning Academy-kurssilla on yhteensä 4 oppituntia.

Mikä on nn.Module?

nn.Module on PyTorchin kaikkien neuroverkkokomponenttien perusluokka. Jokainen kerros, aktivointifunktio, häviöfunktio ja kokonainen malli PyTorchissa periytyy nn.Module-luokasta. Se tarjoaa valmiina parametrien hallinnan, laitteiden välisen siirtämisen, serialisoinnin sekä koulutus- ja evaluointitilojen vaihtamisen. Kun periytätte siitä oman luokan, saatte kaikki nämä toiminnot käyttöön ilman lisätyötä ja tarvitsette määrittää vain arkkitehtuurin ja forward-passiin liittyvän toiminnan.

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

nn.Module-luokan periyttäminen: init ja forward

Mukautetun verkon luomiseen tarvitaan kaksi metodia. Metodissa __init__ kutsutaan super().__init__()-metodia ja määritellään kaikki opittavat kerrokset attribuuteiksi. Metodissa forward kuvataan, miten data kulkee näiden kerrosten läpi. PyTorch seuraa kaikkia nn.Module- tai nn.Parameter-olioita, jotka on määritetty self-olion attribuuteiksi, ja käsittelee niitä koulutettavina komponentteina. Kun mallia kutsutaan funktion tavoin (model(x)), se kutsuu automaattisesti forward-metodia ja suorittaa kaikki rekisteröidyt hookit.

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)

Lineaariset kerrokset: nn.Linear

nn.Linear(in_features, out_features) suorittaa muunnoksen y = x @ W.T + b, jossa W on painomatriisi ja b biasvektori. Kerros alustaa painot automaattisesti Kaimingin uniformijakaumasta ja biasit uniformijakaumasta. Se on feedforward-verkkojen perusrakennusosa, ja kerroksia kutsutaan myös fully connected- tai dense-kerroksiksi.

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)

Aktivointifunktiot: ReLU, Sigmoid, Tanh

Aktivointifunktiot tuovat mukaan epälineaarisuuden, jonka ansiosta verkko voi oppia monimutkaisia rakenteita, joita pelkkien lineaaristen kerrosten pino ei pysty esittämään. ReLU (max(0, x)) on piilokerrosten oletusvalinta — se on nopea ja ehkäisee katoavia gradientteja. Sigmoid puristaa tulosteen välille [0, 1], joten sitä käytetään binäärisen luokituksen tulosteissa. Tanh puristaa tulosteen välille [-1, 1], ja sitä käytetään yleisesti RNN-verkoissa. Kaikki nämä ovat käytettävissä moduuleina nn-moduulissa.

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

Kerrosten pinoaminen nn.Sequential-moduulilla

nn.Sequential on kätevä säilö, joka välittää kunkin moduulin tulosteen seuraavan moduulin syötteeksi. Se sopii erinomaisesti yksinkertaisiin feedforward-arkkitehtuureihin, joissa data kulkee lineaarisesti. Monimutkaisempiin verkkoihin, joissa on ohitusyhteyksiä, useita syötteitä tai haarautuvia polkuja, tarvitaan täysi nn.Module-aliluokan toteutus. Sequential-verkkoja voi silti laajentaa periyttämällä ja käyttämällä Sequential-moduulia alilohkona.

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

Tulosteen muotojen tarkistaminen esimerkkisyötteellä

Verkkoja rakennettaessa tärkeä virheenkorjaustekniikka on ajaa esimerkkitensori mallin läpi ennen koulutusta. Näin varmistetaan, että kaikkien kerrosten dimensiot ovat yhteensopivia, ja muotojen yhteensopimattomuudet havaitaan heti. Esimerkkitensorilla on sama muoto kuin oikealla datalla, mutta se sisältää satunnaisia arvoja — sen tehtävä on vain suorittaa forward-polku. Tehkää tämä aina uuden arkkitehtuurin määrittämisen jälkeen.

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!

Parametrien luetteleminen ja laskeminen

Mallin koulutettavien parametrien kokonaismäärän ymmärtäminen antaa käsityksen sen kapasiteetista ja muistivaatimuksista. model.parameters() palauttaa iteraattorin kaikista opittavista tensoreista, ja model.named_parameters() yhdistää jokaiseen tensoriin sen nimen tarkastelua varten. Tiivis parametrilaskuri on yksi ensimmäisistä apuohjelmista, jonka jokainen PyTorchin käyttäjä yleensä rakentaa.

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)

Mallin siirtäminen GPU:lle

Mallin siirtäminen GPU:lle on yhtä helppoa kuin kutsua model.to(device)-metodia. Tämä siirtää kaikki moduuliin rekisteröidyt parametrit ja puskurit kohdelaitteelle. Tämän kutsun jälkeen kaikki forward-passiin liittyvät laskutoimitukset suoritetaan automaattisesti GPU:lla, kunhan myös syötetensorit ovat samalla laitteella. CPU- ja GPU-tensorien sekoittaminen aiheuttaa ajonaikaisen virheen.

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)

Koulutus- ja evaluointitila

Jotkin kerrokset (Dropout, BatchNorm) toimivat eri tavoin koulutuksen ja päättelyn aikana. Kutsumalla model.train()-metodia otetaan käyttöön stokastinen toiminta (satunnainen dropout ja erätilastot), kun taas model.eval() vaihtaa toiminnan deterministiseen päättelytilaan. Jos model.eval()-metodia ei kutsuta ennen evaluointia, tulokset ovat epäjohdonmukaisia, koska Dropout nollaa aktivaatioita satunnaisesti. Yhdistäkää nämä kutsut päättelyn aikana aina torch.no_grad()-kontekstiin tehokkuuden maksimoimiseksi.

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

Mukautettu verkko: monikerroksinen perceptron

Kun kaikki yhdistetään, monikerroksinen perceptron (MLP) on feedforward-verkko, jossa syötteen ja tulosteen välissä on yksi tai useampi piilokerros. Kukin piilokerros suorittaa lineaarisen muunnoksen ja sen jälkeen epälineaarisen aktivoinnin. Tulostekerroksen aktivointi riippuu tehtävästä: regressiossa aktivointia ei käytetä, moniluokkaisessa luokituksessa käytetään softmaxia ja binäärisessä luokituksessa sigmoidia. Alla olevassa esimerkissä rakennetaan kolmikerroksinen MLP kymmenen luokan luokitusta varten.

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

Verkon tilan tallentaminen ja lataaminen

Neuroverkon kouluttaminen on kallista, joten malli tallennetaan koulutuksen jälkeen. PyTorchissa on tapana tallentaa vain state_dict — parametrien tensorit sisältävän sanakirjan — koko malliolion sijaan. Näin vältetään pickle-riippuvuus luokan määritelmästä. Palauttamista varten luokaa uusi malli-instanssi samalla arkkitehtuurilla ja ladatkaa sitten tilasanakirja komennolla load_state_dict. Asettakaa aina model.eval() mallin lataamisen jälkeen, kun käytätte sitä päättelyyn.

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

Pikatesti

Testatkaa ymmärrystänne tämän oppitunnin Pythonin koneoppimista koskevista käsitteistä.

Vastaa interaktiivisessa oppitunnissa

Oppitunnin kertaus

Tässä oppitunnissa opitte, että nn.Module on perusluokka kaikille PyTorchin neuroverkoille: __init__ määrittelee kerrokset ja forward datan kulun, nn.Sequential tarjoaa yksinkertaisen säilön lineaarisille kerrospinoille, ja model.train() / model.eval() vaihtaa Dropoutin ja BatchNormin kaltaisten kerrosten toimintaa. Seuraavaksi kirjoitamme täydellisen koulutussilmukan, joka sisältää häviön, optimoijan ja useita epookkeja.

Aloita maksutta

Opi Python tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 30
Oppitunnit: 120

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Syöttöä eteenpäin välittävän verkon rakentaminen nn.Modulella” ilmainen?

Kyllä – oppitunnin ”Syöttöä eteenpäin välittävän verkon rakentaminen nn.Modulella” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Machine Learning Academy-kurssin, päivitä CoddyKit PROhon. Machine Learning Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Syöttöä eteenpäin välittävän verkon rakentaminen nn.Modulella”?

Oppijat periyttävät luokan nn.Modulesta, pinoavat Linear- ja ReLU-kerrokset __init__-metodissa, toteuttavat forward-vaiheen ja varmistavat tulosmuodot esimerkkisyötteellä. Harjoittelet Machine Learning Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Machine Learning Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Machine Learning Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Syöttöä eteenpäin välittävän verkon rakentaminen nn.Modulella”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Machine Learning Academy-oppitunnilla?

Kyllä. Jokainen Machine Learning Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

PyTorch-tensorit: luominen, operaatiot ja siirto GPU:lle
Autograd: automaattinen derivointi takaisinkuljetusta varten
Syöttöä eteenpäin välittävän verkon rakentaminen nn.Modulella
Koulutussilmukka: häviö, optimoija ja epookit

← Takaisin: Machine Learning Academy