Share via

Esercitazione: Eseguire il training del primo modello di Machine Learning (SDK v1, parte 2 di 3)

  • Articolo

SI APPLICA A:Azureml di Python SDK v1

Questa esercitazione illustra come eseguire il training di un modello di Machine Learning in Azure Machine Learning. Questa esercitazione fa parte di una serie di esercitazioni in tre parti.

Nella parte 1: Eseguire "Hello world!" della serie, si è appreso come usare uno script di controllo per eseguire un processo nel cloud.

In questa esercitazione si eseguirà il passaggio successivo inviando uno script che esegue il training di un modello di Machine Learning. Questo esempio illustra come Azure Machine Learning renda possibile un comportamento coerente tra il debug locale e le esecuzioni remote.

In questa esercitazione:

  • Creare uno script di training.
  • Usare Conda per definire un ambiente di Azure Machine Learning.
  • Creare uno script di controllo.
  • Comprendere le classi di Azure Machine Learning (Environment, Run, Metrics).
  • Inviare ed eseguire lo script di training.
  • Visualizzare l'output del codice nel cloud.
  • Registrare le metriche in Azure Machine Learning.
  • Visualizzare le metriche nel cloud.

Prerequisiti

  • Completamento della parte 1 della serie.

Creare gli script di training

Prima di tutto si definisce l'architettura di rete neurale in un file di model.py . Tutto il codice di training verrà inserito nella src sottodirectory, incluso model.py.

Il codice di training viene tratto da questo esempio introduttivo da PyTorch. Si noti che i concetti su Azure Machine Learning si applicano a qualsiasi codice di Machine Learning, non solo a PyTorch.

  1. Creare un file model.py nella sottocartella src . Copiare questo codice nel file:

    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. Sulla barra degli strumenti selezionare Salva per salvare il file. Chiudere la scheda se si desidera.

  3. Definire quindi lo script di training, anche nella sottocartella src . Questo script scarica il set di dati CIFAR10 usando le API PyTorch torchvision.dataset , configura la rete definita in model.py e la esegue il training per due epoche usando sgd standard e perdita di entropia incrociata.

    Creare uno script train.py nella sottocartella 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. È ora disponibile la struttura di cartelle seguente:

    La struttura della directory mostra train.py nella sottodirectory src

Test in locale

Selezionare Salva ed eseguire script nel terminale per eseguire lo script di train.py direttamente nell'istanza di calcolo.

Al termine dello script, selezionare Aggiorna sopra le cartelle file. Verrà visualizzata la nuova cartella dati denominata get-started/data Espandi questa cartella per visualizzare i dati scaricati.

Screenshot delle cartelle che mostra una nuova cartella dati creata eseguendo il file in locale.

Creare un ambiente Python

Azure Machine Learning si basa sul concetto di ambiente per rappresentare un ambiente Python riproducibile e dotato di versione per l'esecuzione di esperimenti. La creazione di un ambiente da un ambiente Conda o pip locale è semplice.

Prima di tutto si creerà un file con le dipendenze del pacchetto.

  1. Creare un nuovo file nella cartella get-started denominata pytorch-env.yml:

    name: pytorch-env
channels:
    - defaults
    - pytorch
dependencies:
    - python=3.7
    - pytorch
    - torchvision

  2. Sulla barra degli strumenti selezionare Salva per salvare il file. Chiudere la scheda se si desidera.

Creare lo script di controllo

La differenza tra lo script di controllo seguente e quella usata per inviare "Hello world!" è che si aggiungono un paio di righe aggiuntive per impostare l'ambiente.

Creare un nuovo file Python nella cartella introduttiva denominata 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')

    # set up pytorch environment
    env = Environment.from_conda_specification(
        name='pytorch-env',
        file_path='pytorch-env.yml'
    )
    config.run_config.environment = env

    run = experiment.submit(config)

    aml_url = run.get_portal_url()
    print(aml_url)

Suggerimento

Se è stato usato un nome diverso quando è stato creato il cluster di calcolo, assicurarsi di modificare anche il nome nel codice compute_target='cpu-cluster' .

Informazioni sulle modifiche al codice

env = ...

Fa riferimento al file di dipendenza creato in precedenza.

config.run_config.environment = env

Aggiunge l'ambiente a ScriptRunConfig.

Inviare l'esecuzione ad Azure Machine Learning

  1. Selezionare Salva ed eseguire script nel terminale per eseguire lo script di run-pytorch.py .

  2. Verrà visualizzato un collegamento nella finestra del terminale visualizzata. Selezionare il collegamento per visualizzare il processo.

    Nota

    È possibile che vengano visualizzati alcuni avvisi che iniziano con Errore durante il caricamento di azureml_run_type_providers.... È possibile ignorare questi avvisi. Usare il collegamento nella parte inferiore di questi avvisi per visualizzare l'output.

Visualizzare l'output

  1. Nella pagina visualizzata verrà visualizzato lo stato del processo. Alla prima esecuzione di questo script, Azure Machine Learning creerà una nuova immagine Docker dall'ambiente PyTorch. L'intero processo potrebbe richiedere circa 10 minuti per completare. Questa immagine verrà riutilizzata nei processi futuri per renderli più rapidi.
  2. È possibile visualizzare i log di compilazione Docker nella studio di Azure Machine Learning. Selezionare la scheda Output e log e quindi selezionare 20_image_build_log.txt.
  3. Al termine dello stato del processo, selezionare Output + log.
  4. Selezionare std_log.txt per visualizzare l'output del processo.
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ../data/cifar-10-python.tar.gz
Extracting ../data/cifar-10-python.tar.gz to ../data
epoch=1, batch= 2000: loss 2.19
epoch=1, batch= 4000: loss 1.82
epoch=1, batch= 6000: loss 1.66
...
epoch=2, batch= 8000: loss 1.51
epoch=2, batch=10000: loss 1.49
epoch=2, batch=12000: loss 1.46
Finished Training

Se viene visualizzato un errore Your total snapshot size exceeds the limit, la cartella dati si trova nel source_directory valore usato in ScriptRunConfig.

Selezionare ... alla fine della cartella e quindi selezionare Sposta per spostare i dati nella cartella introduttiva .

Registrare le metriche di training

Dopo aver creato un training del modello in Azure Machine Learning, è possibile iniziare a tenere traccia di alcune metriche delle prestazioni.

Lo script di training corrente stampa le metriche nel terminale. Azure Machine Learning offre un meccanismo per registrare le metriche con più funzionalità. Aggiungendo alcune righe di codice, è possibile visualizzare le metriche nello studio e confrontare le metriche tra più processi.

Modificare train.py per includere la registrazione

  1. Modificare lo script train.py per includere due righe di codice:

    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. Salvare questo file, quindi chiudere la scheda se si desidera.

Informazioni sulle due righe di codice aggiuntive

In train.py si accede all'oggetto run dall'interno dello script di training stesso usando il Run.get_context() metodo e usarlo per registrare le metriche:

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

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

Le metriche in Azure Machine Learning sono:

  • Organizzate per esperimento ed esecuzione, per cui è facile tenerne traccia e confrontarle.
  • Dotate di interfaccia utente per poter visualizzare le prestazioni del training in Studio.
  • Progettate per la scalabilità, per continuare a sfruttare questi vantaggi anche quando si eseguono centinaia di esperimenti.

Aggiornare il file dell'ambiente Conda

Lo script train.py ha appena acquisito una nuova dipendenza da azureml.core. Aggiornare pytorch-env.yml in modo da riflettere questa modifica:

name: pytorch-env
channels:
    - defaults
    - pytorch
dependencies:
    - python=3.7
    - pytorch
    - torchvision
    - pip
    - pip:
        - azureml-sdk

Assicurarsi di salvare questo file prima di inviare l'esecuzione.

Inviare l'esecuzione ad Azure Machine Learning

Selezionare la scheda per lo script run-pytorch.py , quindi selezionare Salva ed eseguire script nel terminale per eseguire nuovamente lo script run-pytorch.py . Assicurarsi di aver salvato prima le modifiche pytorch-env.yml .

Questa volta, quando si visita Studio, passare alla scheda Metriche, dove è ora possibile visualizzare gli aggiornamenti dinamici sulla perdita di training del modello. Il training può richiedere da 1 a 2 minuti prima dell'inizio del training.

Grafico della perdita di training nella scheda Metriche.

Passaggi successivi

In questa sessione è stato eseguito l'aggiornamento da uno script "Hello world!" di base a uno script di training più realistico che richiedeva l'esecuzione di un ambiente Python specifico. È stato illustrato come usare ambienti di Azure Machine Learning curati. Si è infine visto come con poche righe di codice sia possibile registrare le metriche in Azure Machine Learning.

Esistono altri modi per creare ambienti di Azure Machine Learning, ad esempio da un file pip requirements.txt o anche da un ambiente Conda locale esistente.

Nella sessione successiva si vedrà come usare i dati in Azure Machine Learning caricando in Azure il set di dati CIFAR10.

Esercitazione: Usare i dati personali

Nota

Se si sceglie di terminare questa serie di esercitazioni senza procedere con il passaggio successivo, assicurarsi di pulire le risorse.