Harjoita malleja PyTorchin avulla

  • 7 minuuttia

PyTorch on yleisesti käytetty koneoppimisen ympäristö syväoppimismallien harjoittamiseen. Azure Databricksissä PyTorch on esiasentettu koneoppimisklustereihin .

Huomautus

Tämän osion koodikatkelmia annetaan esimerkkeinä avainkohtien korostamiseksi. Voit suorittaa koodin täydestä, toimivasta esimerkistä harjoituksessa myöhemmin tässä moduulissa.

PyTorch-verkon määrittäminen

PyTorchissa mallit perustuvat määrittämääsi verkkoon. Verkko koostuu useista kerroksista, joista kullakin on määritetyt syötteet ja tulokset. Lisäksi työ määrittää eteenpäin olevan funktion, joka käyttää funktioita kuhunkin tasoon, kun tietoja välitetään verkon kautta.

Seuraava esimerkkikoodi määrittää verkon.

import torch
import torch.nn as nn
import torch.nn.functional as F

class MyNet(nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.layer1 = nn.Linear(4, 5)
        self.layer2 = nn.Linear(5, 5)
        self.layer3 = nn.Linear(5, 3)

    def forward(self, x):
        layer1_output = torch.relu(self.layer1(x))
        layer2_output = torch.relu(self.layer2(layer1_output))
        y = self.layer3(layer2_output)
        return y

Vaikka koodi saattaa aluksi tuntua monimutkaiselta, tämä luokka määrittää suhteellisen yksinkertaisen verkon, jossa on kolme kerrosta:

  • Syötetaso, joka hyväksyy neljä syötearvoa ja luo viisi tulostearvoa seuraavalle kerrokselle.
  • Kerros, joka hyväksyy viisi syötettä ja luo viisi tulostetta.
  • Lopullinen tulostekerros, joka hyväksyy viisi syötettä ja luo kolme tulosta.

Eteenpäin-funktio käyttää syötetiedoissa kerroksia (x), joka siirtää kunkin kerroksen tuloksen seuraavaan ja palauttaa lopuksi viimeisen tason tuloksen (joka sisältää otsikon ennustevektorin, y). Tasojen 1 ja 2 tulosteissa käytetään korjaavan lineaarisen yksikön (ReLU) aktivointifunktiota, joka rajoittaa tulostearvot positiivisiin lukuihin.

Huomautus

Käytetyn tappiotyypin mukaan voit halutessasi käyttää aktivointifunktiota, kuten log_softmax , paluuarvoon ja pakottaa sen alueelle 0–1. Jotkin tappioehdot (kuten CrossEntropyLoss, joita käytetään yleisesti moniluokkaluokittelussa) käyttävät kuitenkin automaattisesti sopivaa funktiota.

Jos haluat luoda mallin harjoittamista varten, sinun tarvitsee vain luoda tällainen verkkoluokan esiintymä:

myModel = MyNet()

Tietojen valmisteleminen mallinnusta varten

PyTorch-tasot toimivat tiedoissa, jotka on muotoiltu kymmeniksi – matriisin kaltaisiin rakenteisiin. On olemassa erilaisia funktioita, jotka muuntavat muita yleisiä tietomuotoja kymmeniksi. Voit myös määrittää PyTorch-tietojen lataustoiminnon tietojen ytimen lukemiseksi malliksi harjoittamista tai päättelemistä varten.

Kuten useimmissa valvotuissa koneoppimistekniikoissa, sinun tulee määrittää erilliset tietojoukot harjoittamista ja vahvistusta varten. Tämän erottelun avulla voit varmistaa, että malli ennustaa oikein, kun siinä esitetään tietoja, joita ei ole harjoitettu.

Seuraava koodi määrittää kaksi tietojen lataajaa: toisen harjoittamiseen ja toinen testaukseen. Tämän esimerkin kunkin lataustoiminnon lähdetietojen oletetaan olevan ominaisuusarvojen Numpy-matriisi ja numpy-matriisi, joka sisältää vastaavat otsikkoarvot.

# Create a dataset and loader for the training data and labels
train_x = torch.Tensor(x_train).float()
train_y = torch.Tensor(y_train).long()
train_ds = td.TensorDataset(train_x,train_y)
train_loader = td.DataLoader(train_ds, batch_size=20,
    shuffle=False, num_workers=1)

# Create a dataset and loader for the test data and labels
test_x = torch.Tensor(x_test).float()
test_y = torch.Tensor(y_test).long()
test_ds = td.TensorDataset(test_x,test_y)
test_loader = td.DataLoader(test_ds, batch_size=20,
    shuffle=False, num_workers=1)

Tässä esimerkissä lataajat jakavat tiedot 30 erän eriin, jotka välitetään eteenpäin-funktioon koulutuksen tai päätelmien aikana.

Valitse tappiokriteeri ja optimoijan algoritmi

Mallia harjoitetaan ruokkimalla harjoitustiedot verkkoon, mittaamalla menetystä (ennustettujen ja todellisten arvojen välinen koostettu ero) ja optimoimalla verkko säätämällä painoja ja tasapainoja tappion minimoimiseksi. Menetyksen laskemista ja pienentämista säätelevät valitsemasi tappiokriteerin ja optimoijan algoritmin tarkat tiedot.

Tappion ehdot

PyTorch tukee useita menetyksen ehtofunktioita, muun muassa seuraavia:

  • cross_entropy: Funktio, joka mittaa useiden muuttujien ennustettujen ja todellisten arvojen koosteeroa (jota käytetään yleensä mittaamaan luokkatodennäköisyyksien menetystä moniluokkaluokittelussa).
  • binary_cross_entropy: Funktio, joka mittaa ennustetun ja todellisen todennäköisyyden eroa (käytetään yleensä mittaamaan luokkatodennäköisyyksien menetystä binaariluokittelussa).
  • mse_loss: Funktio, joka mittaa ennustettujen ja todellisten numeeristen arvojen keskiarvon neliömäistä menetystä (käytetään yleensä regressiossa).

Jos haluat määrittää tappiokriteerin, jota haluat käyttää mallisi harjoittamiseen, luo esiintymä halutusta funktiosta. Näin:

import torch.nn as nn

loss_criteria = nn.CrossEntropyLoss

Juomaraha

Lisätietoja PyTorchin käytettävissä olevista tappioehdoista on PyTorchin dokumentaation tappiofunktioiden kohdassa.

Optimoijan algoritmit

Kun tappio on laskettu, optimoijan avulla määritetään, miten painoja ja saldoja parhaiten säädetään sen minimoimiseksi. Optimoijat ovat gradienttimenetelmän erityistoteutuksia funktion pienentämistä varten. PyTorch-käyttöjärjestelmässä käytettävissä olevia optimointityökaluja ovat muun muassa seuraavat:

Jos haluat käyttää jotakin näistä algoritmeista mallin harjoittamiseen, sinun on luotava optimoijan esiintymä ja määritettävä tarvittavat parametrit. Määritetyt parametrit vaihtelevat valitun optimoijan mukaan, mutta useimmat edellyttävät, että määrität oppimisnopeuden , joka ohjaa kunkin optimoinnin yhteydessä tehtyjen muutosten kokoa.

Seuraava koodi luo Adam-optimoijan esiintymän.

import torch.optim as opt

learning_rate = 0.001
optimizer = opt.Adam(model.parameters(), lr=learning_rate)

Juomaraha

Lisätietoja PyTorchin käytettävissä olevista optimoijista on PyTorchin dokumentaation kohdassa Algoritmit .

Luo juna- ja testifunktioita

Kun olet määrittänyt verkon ja valmistellut tiedot sille, voit käyttää tietoja mallin kouluttamiseen ja testaamiseen välittämällä harjoitustiedot verkon kautta, laskemalla menetyksen, optimoimalla verkon painotuksia ja puolueellistuksia sekä vahvistamalla verkon suorituskyvyn testitiedoilla. On tavallista määrittää funktio, joka välittää tietoja verkon kautta harjoittamaan mallia harjoitustiedoilla, ja erillinen funktio, joka testaa mallia testitiedoilla.

Luo junafunktio

Seuraavassa esimerkissä näytetään funktio, jolla malli harjoitetaan.

def train(model, data_loader, optimizer):

    # Use GPU if available, otherwise CPU
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)
    
    # Set the model to training mode (to enable backpropagation)
    model.train()
    train_loss = 0
    
    # Feed the batches of data forward through the network
    for batch, tensor in enumerate(data_loader):
        data, target = tensor # Specify features and labels in a tensor
        optimizer.zero_grad() # Reset optimizer state
        out = model(data) # Pass the data through the network
        loss = loss_criteria(out, target) # Calculate the loss
        train_loss += loss.item() # Keep a running total of loss for each batch

        # backpropagate adjustments to weights/bias
        loss.backward()
        optimizer.step()

    #Return average loss for all batches
    avg_loss = train_loss / (batch+1)
    print('Training set: Average loss: {:.6f}'.format(avg_loss))
    return avg_loss

Seuraavassa esimerkissä näytetään funktio, jolla mallia testataan.

def test(model, data_loader):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)
    # Switch the model to evaluation mode (so we don't backpropagate)
    model.eval()
    test_loss = 0
    correct = 0

    # Pass the data through with no gradient computation
    with torch.no_grad():
        batch_count = 0
        for batch, tensor in enumerate(data_loader):
            batch_count += 1
            data, target = tensor
            # Get the predictions
            out = model(data)

            # calculate the loss
            test_loss += loss_criteria(out, target).item()

            # Calculate the accuracy
            _, predicted = torch.max(out.data, 1)
            correct += torch.sum(target==predicted).item()
            
    # Calculate the average loss and total accuracy for all batches
    avg_loss = test_loss/batch_count
    print('Validation set: Average loss: {:.6f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        avg_loss, correct, len(data_loader.dataset),
        100. * correct / len(data_loader.dataset)))
    return avg_loss

Harjoita mallia useiden aikakausien aikana

Jos haluat harjoittaa syväoppimismallin, suorita harjoitusfunktio yleensä useita kertoja ( epochs), jonka tavoitteena on vähentää kunkin aikakauden harjoitustiedoista laskettua menetystä. Voit käyttää testausfunktiota sen vahvistamiseksi, että testitiedoista kärsityt menetykset (joissa mallia ei harjoitettu) vähentyvät myös harjoittamisen menetyksen mukaisesti – toisin sanoen mallin harjoittaminen ei tuota mallia, joka on ylikuormitettu harjoitustietoihin.

Juomaraha

Sinun ei tarvitse suorittaa testifunktiota jokaista aikakautta varten. Saatat haluta suorittaa sen joka toinen aikakausi tai kerran lopussa. Mallin testaamisesta harjoittamisen aikana voi kuitenkin olla hyötyä, kun määritetään, kuinka monesta aikakaudesta malli alkaa ylikuormittua.

Seuraavassa koodissa mallia junissa on yli 50 aikakautta.

epochs = 50
for epoch in range(1, epochs + 1):

    # print the epoch number
    print('Epoch: {}'.format(epoch))
    
    # Feed training data into the model to optimize the weights
    train_loss = train(model, train_loader, optimizer)
    print(train_loss)
    
    # Feed the test data into the model to check its performance
    test_loss = test(model, test_loader)
    print(test_loss)

Harjoitetun mallin tilan tallentaminen

Kun olet harjoittanut mallin onnistuneesti, voit säästää sen painoja ja puolueellistuksia seuraavasti:

model_file = '/dbfs/my_model.pkl'
torch.save(model.state_dict(), model_file)

Jos haluat ladata ja käyttää mallia myöhemmin, luo esiintymä verkkoluokasta, johon malli perustuu, ja lataa tallennetut painot ja poikkeavukset.

model = myNet()
model.load_state_dict(torch.load(model_file))