Zelfstudie: Uw eerste machine learning model (deel 2 van 3)

Deze zelfstudie laat zien hoe u een machine learning-model traint in Azure Machine Learning. Deze zelfstudie is deel 2 van een driedelige zelfstudiereeks.

In deel 1: 'Hallo wereld!' uitvoeren van de reeks hebt u geleerd hoe u een besturingsscript gebruikt om een taak uit te voeren in de cloud.

In deze zelfstudie voert u de volgende stap uit door een script te verzenden dat een machine learning-model traint. Dit voorbeeld helpt u inzicht te krijgen in de manier waarop Azure Machine Learning consistent gedrag tussen lokale foutopsporing en externe uitvoeringen vereenvoudigt.

In deze zelfstudie gaat u:

Vereisten

• Voltooiing van deel 1 van de serie.

Trainingsscripts maken

Eerst definieert u de architectuur van het neurale netwerk in een model.py bestand. Al uw trainingscode gaat naar de src subdirectory, inclusief model.py.

De trainingscode is afkomstig uit dit inleidende voorbeeld van PyTorch. Houd er rekening mee dat de concepten van Azure Machine Learning van toepassing zijn op alle machine learning-code, niet alleen op PyTorch.

1. Maak een model.py in de submap src. Kopieer deze code naar het bestand :

   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. Selecteer Opslaan op de werkbalk om het bestand op te slaan. Sluit het tabblad als u wilt.

3. Definieer vervolgens het trainingsscript, ook in de submap src. Met dit script downloadt u de CIFAR10-gegevensset met behulp van PyTorch-API's, stelt u het netwerk in dat is gedefinieerd in model.py en traint u deze voor twee tijdvakken met behulp van torchvision.dataset standaard-SGD- en cross-entropy-verlies.

   Maak een train.py script in de submap 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. U hebt nu de volgende mapstructuur:

   

Lokaal testen

Selecteer Script opslaan en uitvoeren in de terminal om het script train.py uit te voeren op de reken-instantie.

Nadat het script is voltooid, selecteert u Vernieuwen boven de bestandsmappen. U ziet de nieuwe gegevensmap get-started/data Vouw deze map uit om de gedownloade gegevens weer te geven.

Het besturingsscript maken

Het verschil tussen het volgende besturingsscript en het script dat u hebt gebruikt voor het verzenden van 'Hello World!' is dat u een paar extra regels toevoegt om de omgeving in te stellen.

Maak een nieuw Python-bestand in de map aan de slag met de naam 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)

De codewijzigingen begrijpen

De uitvoering versturen naar Microsoft Azure Machine Learning

1. Selecteer Script opslaan en uitvoeren in de terminal om het script run-pytorch.py uitvoeren.

2. U ziet een koppeling in het terminalvenster dat wordt geopend. Selecteer de koppeling om de run te bekijken.

   Notitie

   Mogelijk ziet u enkele waarschuwingen die beginnen met Fout tijdens het laden azureml_run_type_providers.... U kunt deze waarschuwingen negeren. Gebruik de koppeling onder aan deze waarschuwingen om uw uitvoer weer te geven.

De uitvoer weergeven

1. Op de pagina die wordt geopend, ziet u de status van de run. De eerste keer dat u dit script uitvoert, wordt in Azure Machine Learning een nieuwe docker-installatiekopie van uw PyTorch-omgeving gemaakt. Het kan 3 tot 4 minuten duren voordat de volledige run is voltooid. Deze installatiekopie wordt opnieuw gebruikt in toekomstige uitvoeringen, waardoor deze veel sneller worden uitgevoerd.
2. U kunt de Docker-buildlogboeken bekijken in Azure Machine Learning Studio. Selecteer het tabblad Uitvoer en logboeken en selecteer vervolgens 20_image_build_log.txt.
3. Wanneer de status van de run Voltooid is, selecteert u Uitvoer en logboeken.
4. Selecteer 70_driver_log.txt om de uitvoer van uw run weer te geven.

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

Als u een fout Your total snapshot size exceeds the limit ziet, bevindt de gegevensmap zich in de source_directory waarde die wordt gebruikt in ScriptRunConfig .

Selecteer de ... aan het einde van de map en selecteer vervolgens Verplaatsen om gegevens naar de map aan de slag te verplaatsen.

Metrische gegevens van training registreren

Nu u een modeltraining in Azure Machine Learning hebt, kunt u een aantal prestatiegegevens gaan bijhouden.

Met het huidige trainingsscript worden metrische gegevens naar de terminal afgedrukt. Azure Machine Learning biedt een mechanisme voor het vastleggen van metrische gegevens met meer functionaliteit. Door een paar regels code toe te voegen, beschikt u over de mogelijkheid om metrische gegevens te visualiseren in de studio en om de metrische gegevens tussen meerdere uitvoeringen te vergelijken.

Wijzigingen train.py om logboekregistratie op te nemen

1. Pas uw train.py script aan met nog twee regels code:

   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. Sla dit bestand op en sluit het tabblad als u wilt.

Meer informatie over de twee extra regels code

In train.py gaat u vanuit het trainingsscript zelf toegang krijgen tot het run-object met behulp van de methode en gebruikt u dit om Run.get_context() metrische gegevens te loggen:

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

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

De metrische gegevens in Azure Machine Learning zijn:

• Geordend op experiment en uitvoering, zodat u gemakkelijk metrische gegevens kunt bijhouden en vergelijken.
• Voorzien van een gebruikersinterface, zodat u de trainingsprestaties in de studio kunt visualiseren.
• Ontworpen om te worden geschaald, dus u behoudt deze voordelen, zelfs als u honderden experimenten uitvoert.

De uitvoering versturen naar Microsoft Azure Machine Learning

Selecteer het tabblad voor het run-pytorch.py script en selecteer vervolgens Script opslaan en uitvoeren in de terminal om het script opnieuw run-pytorch.py uitvoeren.

Wanneer u deze keer de studio bezoekt, gaat u naar het tabblad Metrische gegevens, waar u nu live-updates kunt zien van het modeltrainingsverlies. Het kan 1 tot 2 minuten duren voordat de training begint.

Volgende stappen

In deze sessie hebt u een upgrade uitgevoerd van een basis 'Hallo wereld!' script naar een realistischer trainingsscript dat vereist dat een specifieke Python-omgeving wordt uitgevoerd. U hebt gezien hoe u gecureerde Azure Machine Learning gebruikt. Ten slotte hebt u gezien hoe u in een paar regels code de metrische gegevens kunt vastleggen voor Azure Machine Learning.

Er zijn andere manieren om Azure Machine Learning-omgevingen te maken, zoals van een TXT-bestand met PIP-vereisten of van een bestaande lokale Conda-omgeving.

In de volgende sessie ziet u hoe u kunt werken met gegevens in Azure Machine Learning door de CIFAR10-gegevensset naar Azure te uploaden.