Condividi tramite

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

  • Articolo

Si applica a: Python SDK azureml v1

Questa esercitazione illustra come eseguire il training di un modello di Machine Learning in Azure Machine Learning. Questa esercitazione è la seconda parte di una serie di esercitazioni in due 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

Per prima cosa, è necessario definire l'architettura della rete neurale in un file model.py. Tutto il codice di training, incluso model.py, viene inserito nella sottodirectory src.

Il codice di training è tratto da questo esempio introduttivo di PyTorch. 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. Selezionare Salva sulla barra degli strumenti per salvare il file. Chiudere la scheda, se lo si desidera.

  3. Definire quindi lo script di training, anche nella sottocartella src. Questo script scarica il set di dati CIFAR10 usando le API torchvision.dataset di PyTorch, configura la rete definita in model.py e ne esegue il training per due periodi usando il metodo SGD standard e la 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. A questo punto è disponibile la struttura di cartelle seguente:

    La struttura di directory mostra train.py nella sottodirectory src

Test in locale

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

Al completamento dello script, selezionare Aggiorna sopra le cartelle di file. Viene visualizzata la nuova cartella dati denominata get-started/data. Espandere la cartella per visualizzare i dati scaricati.

Screenshot delle cartelle che mostra la nuova cartella di 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.

Per prima cosa viene creato un file con le dipendenze del pacchetto.

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

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

  2. Selezionare Salva sulla barra degli strumenti per salvare il file. Chiudere la scheda, se lo si desidera.

Creare lo script di controllo

Rispetto allo script di controllo usato per inviare "Hello World", nello script seguente sono state aggiunte altre due righe per impostare l'ambiente.

Creare un nuovo file Python nella cartella get-started denominato 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 al momento della creazione del cluster di elaborazione, assicurarsi di modificare il nome anche nel codice compute_target='cpu-cluster'.

Informazioni sulle modifiche al codice

env = ...

Fa riferimento al file delle dipendenze creato in precedenza.

config.run_config.environment = env

Aggiunge l'ambiente a ScriptRunConfig.

Inviare l'esecuzione ad Azure Machine Learning

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

  2. Viene aperta una finestra del terminale con un collegamento. 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 tali avvisi. Usare il collegamento presente nella parte inferiore di questi avvisi per visualizzare l'output.

Visualizzare l'output

  1. Nella pagina che si apre viene visualizzato lo stato del processo. Alla prima esecuzione di questo script, Azure Machine Learning crea una nuova immagine Docker dall'ambiente PyTorch. Il completamento dell'intero processo può richiedere circa 10 minuti. Questa immagine verrà riutilizzata in processi futuri per velocizzarne l'esecuzione.
  2. È possibile visualizzare i log di compilazione di Docker nello studio di Azure Machine Learning. per visualizzare i log di compilazione:
    1. Selezionare la scheda Output e log.
    2. Selezionare la cartella azureml-logs.
    3. Selezionare 20_image_build_log.txt.
  3. Quando lo stato del processo è Completato, selezionare Output e log.
  4. Selezionare user_logs, quindi 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 l'errore Your total snapshot size exceeds the limit, significa che la cartella data si trova nel valore source_directory usato in ScriptRunConfig.

Selezionare ... alla fine della cartella e quindi selezionare Sposta per spostare data nella cartella get-started.

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 confrontarle tra più processi.

Modificare train.py per includere la registrazione

  1. Modificare lo script train.py in modo da includere altre 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. Fare clic su Salva per salvare il file e quindi chiudere la scheda, se lo si desidera.

Informazioni sulle due righe di codice aggiuntive

In train.py si accede all'oggetto run dall'interno dello script di training tramite il metodo Run.get_context() e lo si usa 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 il file prima di inviare l'esecuzione.

Inviare l'esecuzione ad Azure Machine Learning

Selezionare la scheda per lo script run-pytorch.py e quindi selezionare Salva ed esegui script nel terminale per eseguire nuovamente lo script run-pytorch.py. Assicurarsi di salvare prima le modifiche apportate a 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. Potrebbero essere necessari 1 o 2 minuti prima che il training abbia inizio.

Grafico della perdita di training nella scheda Metriche.

Pulire le risorse

Se si prevede di continuare ora con un'altra esercitazione o di avviare i propri processi di training, passare a Risorse correlate.

Arrestare l'istanza di ambiente di calcolo

Se non si intende usarla, arrestare l'istanza di ambiente di calcolo:

  1. Nello studio, a sinistra, selezionare Ambiente di calcolo.
  2. Nelle schede in alto selezionare Istanze di ambiente di calcolo
  3. Selezionare l'istanza di ambiente di calcolo nell'elenco.
  4. Sulla barra degli strumenti in alto selezionare Arresta.

Eliminare tutte le risorse

Importante

Le risorse create possono essere usate come prerequisiti per altre esercitazioni e procedure dettagliate per Azure Machine Learning.

Se le risorse create non servono più, eliminarle per evitare addebiti:

  1. Nella casella di ricerca della portale di Azure immettere Gruppi di risorse e selezionarlo nei risultati.

  2. Nell'elenco selezionare il gruppo di risorse creato.

  3. Nella pagina Panoramica selezionare Elimina gruppo di risorse.

    Screenshot delle opzioni da selezionare per eliminare un gruppo di risorse nel portale di Azure.

  4. Immettere il nome del gruppo di risorse. Quindi seleziona Elimina.

È anche possibile mantenere il gruppo di risorse ma eliminare una singola area di lavoro. Visualizzare le proprietà dell'area di lavoro e selezionare Elimina.

In questa sessione si è passati da uno script "Hello world!" di base a uno script di training più realistico che per l'esecuzione ha richiesto un ambiente Python specifico. Si è visto anche 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.