Självstudie: Träna din första maskininlärningsmodell (del 2 av 3)

Den här självstudien visar hur du tränar en maskininlärningsmodell i Azure Machine Learning. Den här självstudien är del 2 i en självstudieserie i tre delar.

I del 1: Kör "Hello world!" i serien har du lärt dig hur du använder ett kontrollskript för att köra ett jobb i molnet.

I den här självstudien tar du nästa steg genom att skicka ett skript som tränar en maskininlärningsmodell. Det här exemplet hjälper dig att förstå Azure Machine Learning förenklar konsekvent beteende mellan lokal felsökning och fjärrkörningar.

I den här kursen får du:

Förutsättningar

• Slutförande av del 1 av serien.

Skapa träningsskript

Först definierar du arkitekturen för neurala nätverk i model.py fil. All din träningskod kommer att gå till src underkatalogen, inklusive model.py.

Träningskoden kommer från det här introduktions exemplet från PyTorch. Observera att de Azure Machine Learning gäller för alla maskininlärningskoder, inte bara PyTorch.

1. Skapa en model.py-fil i undermappen src. Kopiera den här koden till filen:

   import torch.nn as nn
   import torch.nn.functional as F
   class Net(nn.Module):
       def __init__(self):
           super(Net, self).__init__()
           self.conv1 = nn.Conv2d(3, 6, 5)
           self.pool = nn.MaxPool2d(2, 2)
           self.conv2 = nn.Conv2d(6, 16, 5)
           self.fc1 = nn.Linear(16 * 5 * 5, 120)
           self.fc2 = nn.Linear(120, 84)
           self.fc3 = nn.Linear(84, 10)
       def forward(self, x):
           x = self.pool(F.relu(self.conv1(x)))
           x = self.pool(F.relu(self.conv2(x)))
           x = x.view(-1, 16 * 5 * 5)
           x = F.relu(self.fc1(x))
           x = F.relu(self.fc2(x))
           x = self.fc3(x)
           return x
   

2. Spara filen genom att välja Spara i verktygsfältet. Stäng fliken om du vill.

3. Definiera sedan träningsskriptet, även i undermappen src. Det här skriptet laddar ned CIFAR10-datauppsättningen med hjälp av PyTorch-API:er, uppsättningar nätverket som definierats i model.py och tränar det för två epoker med hjälp av torchvision.dataset standard SGD och korsenisk förlust.

   Skapa ett train.py-skript i undermappen src:

   import torch
   import torch.optim as optim
   import torchvision
   import torchvision.transforms as transforms
   
   from model import Net
   
   # download CIFAR 10 data
   trainset = torchvision.datasets.CIFAR10(
       root="../data",
       train=True,
       download=True,
       transform=torchvision.transforms.ToTensor(),
   )
   trainloader = torch.utils.data.DataLoader(
       trainset, batch_size=4, shuffle=True, num_workers=2
   )
   
   if __name__ == "__main__":
   
       # define convolutional network
       net = Net()
   
       # set up pytorch loss /  optimizer
       criterion = torch.nn.CrossEntropyLoss()
       optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
   
       # train the network
       for epoch in range(2):
   
           running_loss = 0.0
           for i, data in enumerate(trainloader, 0):
               # unpack the data
               inputs, labels = data
   
               # zero the parameter gradients
               optimizer.zero_grad()
   
               # forward + backward + optimize
               outputs = net(inputs)
               loss = criterion(outputs, labels)
               loss.backward()
               optimizer.step()
   
               # print statistics
               running_loss += loss.item()
               if i % 2000 == 1999:
                   loss = running_loss / 2000
                   print(f"epoch={epoch + 1}, batch={i + 1:5}: loss {loss:.2f}")
                   running_loss = 0.0
   
       print("Finished Training")
   

4. Nu har du följande mappstruktur:

   

Testa lokalt

Välj Spara och kör skriptet i terminalen för att köra train.py skript direkt på beräkningsinstansen.

När skriptet har slutförts väljer du Uppdatera ovanför filmapparna. Du ser den nya datamappen med namnet get-started/data Expandera den här mappen för att visa nedladdade data.

Skapa kontrollskriptet

Skillnaden mellan följande kontrollskript och det som du använde för att skicka "Hello world!" är att du lägger till några extra rader för att ställa in miljön.

Skapa en ny Python-fil i mappen get-started med namnet run-pytorch.py :

# run-pytorch.py
from azureml.core import Workspace
from azureml.core import Experiment
from azureml.core import Environment
from azureml.core import ScriptRunConfig

if __name__ == "__main__":
    ws = Workspace.from_config()
    experiment = Experiment(workspace=ws, name='day1-experiment-train')
    config = ScriptRunConfig(source_directory='./src',
                             script='train.py',
                             compute_target='cpu-cluster')

    # use curated pytorch environment 
    env = ws.environments['AzureML-PyTorch-1.6-CPU']
    config.run_config.environment = env

    run = experiment.submit(config)

    aml_url = run.get_portal_url()
    print(aml_url)

Förstå kodändringarna

Skicka körningen till Azure Machine Learning

1. Välj Spara och kör skriptet i terminalen för att köra run-pytorch.py skript.

2. Du ser en länk i terminalfönstret som öppnas. Välj länken för att visa körningen.

   Anteckning

   Du kan se några varningar som börjar med Fel vid inläsning av azureml_run_type_providers.... Du kan ignorera dessa varningar. Använd länken längst ned i de här varningarna för att visa dina utdata.

Visa utdata

1. På sidan som öppnas visas körningsstatusen. Första gången du kör det här skriptet skapar Azure Machine Learning en ny Docker-avbildning från PyTorch-miljön. Hela körningen kan ta 3 till 4 minuter att slutföra. Den här avbildningen återanvänds i framtida körningar så att de körs mycket snabbare.
2. Du kan se Docker-byggloggar i Azure Machine Learning Studio. Välj fliken Utdata + loggar och välj sedan 20_image_build_log.txt.
3. När statusen för körningen är Slutförd väljer du Utdata + loggar.
4. Välj 70_driver_log.txt för att visa utdata för körningen.

Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
...
Files already downloaded and verified
epoch=1, batch= 2000: loss 2.19
epoch=1, batch= 4000: loss 1.82
epoch=1, batch= 6000: loss 1.66
epoch=1, batch= 8000: loss 1.58
epoch=1, batch=10000: loss 1.52
epoch=1, batch=12000: loss 1.47
epoch=2, batch= 2000: loss 1.39
epoch=2, batch= 4000: loss 1.38
epoch=2, batch= 6000: loss 1.37
epoch=2, batch= 8000: loss 1.33
epoch=2, batch=10000: loss 1.31
epoch=2, batch=12000: loss 1.27
Finished Training

Om du ser ett Your total snapshot size exceeds the limit fel finns datamappen i värdet som används source_directory i ScriptRunConfig .

Välj ... i slutet av mappen och välj sedan Flytta för att flytta data till mappen kom igång.

Logga träningsmått

Nu när du har en modellträning i Azure Machine Learning kan du börja spåra några prestandamått.

Det aktuella träningsskriptet skriver ut mått till terminalen. Azure Machine Learning en mekanism för att logga mått med fler funktioner. Genom att lägga till några kodrader får du möjlighet att visualisera mått i studio och jämföra mått mellan flera körningar.

Ändra train.py att inkludera loggning

1. Ändra ditt train.py så att det innehåller ytterligare två kodrader:

   import torch
   import torch.optim as optim
   import torchvision
   import torchvision.transforms as transforms
   from model import Net
   from azureml.core import Run
   # ADDITIONAL CODE: get run from the current context
   run = Run.get_context()
   # download CIFAR 10 data
   trainset = torchvision.datasets.CIFAR10(
       root='./data',
       train=True,
       download=True,
       transform=torchvision.transforms.ToTensor()
   )
   trainloader = torch.utils.data.DataLoader(
       trainset,
       batch_size=4,
       shuffle=True,
       num_workers=2
   )
   if __name__ == "__main__":
       # define convolutional network
       net = Net()
       # set up pytorch loss /  optimizer
       criterion = torch.nn.CrossEntropyLoss()
       optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
       # train the network
       for epoch in range(2):
           running_loss = 0.0
           for i, data in enumerate(trainloader, 0):
               # unpack the data
               inputs, labels = data
               # zero the parameter gradients
               optimizer.zero_grad()
               # forward + backward + optimize
               outputs = net(inputs)
               loss = criterion(outputs, labels)
               loss.backward()
               optimizer.step()
               # print statistics
               running_loss += loss.item()
               if i % 2000 == 1999:
                   loss = running_loss / 2000
                   # ADDITIONAL CODE: log loss metric to AML
                   run.log('loss', loss)
                   print(f'epoch={epoch + 1}, batch={i + 1:5}: loss {loss:.2f}')
                   running_loss = 0.0
       print('Finished Training')
   

2. Spara filen och stäng sedan fliken om du vill.

Förstå de ytterligare två kodraderna

I train.py du åtkomst till körningsobjektet inifrån själva träningsskriptet med hjälp av metoden och Run.get_context() använder den för att logga mått:

# ADDITIONAL CODE: get run from the current context
run = Run.get_context()

...
# ADDITIONAL CODE: log loss metric to AML
run.log('loss', loss)

Mått i Azure Machine Learning är:

• Ordnat efter experiment och körning, så det är enkelt att hålla reda på och jämföra mått.
• Den är utrustad med ett användargränssnitt så att du kan visualisera träningsprestanda i studio.
• Utformad för skalning, så att du behåller dessa fördelar även när du kör hundratals experiment.

Skicka körningen till Azure Machine Learning

Välj fliken för run-pytorch.py och välj sedan Spara och kör skript i terminalen för att köra skriptet run-pytorch.py skriptet.

Den här gången när du besöker Studio går du till fliken Mått där du nu kan se liveuppdateringar om modellträningsförlusten! Det kan ta 1 till 2 minuter innan träningen börjar.

Nästa steg

I den här sessionen har du uppgraderat från en grundläggande "Hello world!" skript till ett mer realistiskt träningsskript som krävde att en specifik Python-miljö skulle köras. Du har sett hur du använder Azure Machine Learning miljöer. Slutligen såg du hur du med några rader kod kan logga mått till Azure Machine Learning.

Det finns andra sätt att skapa Azure Machine Learning miljöer, inklusive från en pip requirements.txtfil eller från en befintlig lokal Conda-miljö.

I nästa session får du se hur du arbetar med data i Azure Machine Learning genom att ladda upp CIFAR10-datauppsättningen till Azure.