Condividi tramite

Eseguire il training di modelli di PyTorch su larga scala con Azure Machine Learning SDK (v1)

  • Articolo

Si applica a: Python SDK azureml v1

Questo articolo illustra come eseguire gli script di training di PyTorch su scala aziendale usando Azure Machine Learning.

Gli script di esempio in questo articolo vengono usati per classificare le immagini di pollo e tacchino e creare una rete neurale di Deep Learning basata sull'esercitazione relativa all'apprendimento induttivo di PyTorch. L'apprendimento induttivo è una tecnica che applica le conoscenze acquisite dalla risoluzione di un problema a un problema diverso ma ad esso correlato. L'apprendimento induttivo riduce il processo di training richiedendo meno dati, tempo e risorse di calcolo rispetto al training da zero. Per altre informazioni sull'apprendimento induttivo, vedere l'articolo Deep Learning e apprendimento automatico.

Che si stia eseguendo il training di un modello PyTorch di Deep Learning dal principio o si stia portando un modello esistente nel cloud, è possibile usare Azure Machine Learning per aumentare il numero di processi di training open source usando risorse di calcolo in un cloud elastico. Con Azure Machine Learning è possibile compilare, distribuire, controllare la versione e monitorare i modelli negli ambienti di produzione.

Prerequisiti

Eseguire questo codice in uno degli ambienti seguenti:

Prima di poter eseguire il codice riportato in questo articolo per creare un cluster GPU, è necessario richiedere un aumento della quota per l'area di lavoro.

Configurare l'esperimento

In questa sezione viene configurato l'esperimento di training caricando i pacchetti Python necessari, inizializzando un'area di lavoro, creando la destinazione di calcolo e definendo l'ambiente di training.

Importare pacchetti

Prima di tutto, importare le librerie Python necessarie.

import os
import shutil

from azureml.core.workspace import Workspace
from azureml.core import Experiment
from azureml.core import Environment

from azureml.core.compute import ComputeTarget, AmlCompute
from azureml.core.compute_target import ComputeTargetException

Inizializzare un'area di lavoro

L'area di lavoro di Azure Machine Learning è la risorsa di primo livello per il servizio. Fornisce una posizione centralizzata per lavorare con tutti gli artefatti creati. In Python SDK è possibile accedere agli artefatti dell'area di lavoro creando un oggetto workspace.

Creare un oggetto workspace dal file config.json creato nella sezione dei prerequisiti.

ws = Workspace.from_config()

Ottenere i dati

Il set di dati è costituito da circa 120 immagini di training per tacchini e polli, con 100 immagini di convalida per ogni classe. Il set di dati verrà scaricato ed estratto come parte dello script di training pytorch_train.py. Le immagini sono un subset del set di dati Open Images v5. Per altri passaggi sulla creazione di un file JSONL per eseguire il training con i propri dati, vedere questo notebook di Jupyter.

Preparare lo script di training

In questa esercitazione lo script di training pytorch_train.py è già disponibile. In pratica, è possibile eseguire qualsiasi script di training personalizzato ed eseguirlo senza modifiche con Azure Machine Learning.

Creare una cartella per gli script di training.

project_folder = './pytorch-birds'
os.makedirs(project_folder, exist_ok=True)
shutil.copy('pytorch_train.py', project_folder)

Creare una destinazione di calcolo

Creare una destinazione di calcolo in cui eseguire il processo PyTorch. In questo esempio creare un cluster di elaborazione di Azure Machine Learning abilitato per GPU.

Importante

Prima di poter creare un cluster GPU, è necessario richiedere un aumento della quota per l'area di lavoro.


# Choose a name for your CPU cluster
cluster_name = "gpu-cluster"

# Verify that cluster does not exist already
try:
    compute_target = ComputeTarget(workspace=ws, name=cluster_name)
    print('Found existing compute target')
except ComputeTargetException:
    print('Creating a new compute target...')
    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_NC6', 
                                                           max_nodes=4)

    # Create the cluster with the specified name and configuration
    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    # Wait for the cluster to complete, show the output log
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

Se invece si vuole creare un cluster CPU, specificare una dimensione di macchina virtuale diversa per il parametro vm_size, ad esempio STANDARD_D2_V2.

Per altre informazioni sulle destinazioni di calcolo, vedere l'articolo Cosa sono le destinazioni di calcolo in Azure Machine Learning?.

Definire l'ambiente

Per definire l'ambiente di Azure Machine Learning che incapsula le dipendenze dello script di training, è possibile definire un ambiente personalizzato o usare un ambiente di Azure Machine Learning curato.

Usare un ambiente curato

Se non si vuole definire un ambiente personalizzato, Azure Machine Learning offre ambienti curati predefiniti. Esistono diversi ambienti curati CPU e GPU per PyTorch corrispondenti a versioni diverse di PyTorch.

Se si intende usare un ambiente curato, è possibile eseguire il comando seguente:

curated_env_name = 'AzureML-PyTorch-1.6-GPU'
pytorch_env = Environment.get(workspace=ws, name=curated_env_name)

Per visualizzare i pacchetti inclusi nell'ambiente curato, è possibile scrivere le dipendenze Conda su disco:

pytorch_env.save_to_directory(path=curated_env_name)

Assicurarsi che l'ambiente curato includa tutte le dipendenze richieste dallo script di training. In caso contrario, sarà necessario modificare l'ambiente per includere le dipendenze mancanti. Se l'ambiente viene modificato, è necessario assegnargli un nuovo nome, perché il prefisso 'AzureML' è riservato agli ambienti curati. Se il file YAML delle dipendenze Conda è stato modificato, è possibile usarlo per creare un nuovo ambiente con un altro nome, ad esempio:

pytorch_env = Environment.from_conda_specification(name='pytorch-1.6-gpu', file_path='./conda_dependencies.yml')

Se invece l'oggetto dell'ambiente curato è stato modificato direttamente, è possibile clonare l'ambiente specificando un nuovo nome:

pytorch_env = pytorch_env.clone(new_name='pytorch-1.6-gpu')

Creare un ambiente personalizzato

È anche possibile creare un ambiente di Azure Machine Learning personalizzato che incapsula le dipendenze dello script di training.

Per prima cosa, definire le dipendenze Conda in un file YAML. In questo esempio al file viene assegnato il nome conda_dependencies.yml.

channels:
- conda-forge
dependencies:
- python=3.7
- pip=21.3.1
- pip:
  - azureml-defaults
  - torch==1.6.0
  - torchvision==0.7.0
  - future==0.17.1
  - pillow

Creare un ambiente di Azure Machine Learning da questa specifica di ambiente Conda. Verrà creato un pacchetto dell'ambiente in un contenitore Docker in fase di esecuzione.

Per impostazione predefinita, se non viene specificata alcuna immagine di base, Azure Machine Learning userà come immagine di base un'immagine azureml.core.environment.DEFAULT_CPU_IMAGE della CPU. Poiché in questo esempio viene eseguito il training in un cluster GPU, è necessario specificare un'immagine di base GPU che includa i driver e le dipendenze GPU necessari. Azure Machine Learning gestisce un set di immagini di base pubblicate in Registro Azure Container che è possibile usare. Per altre informazioni, vedere il repository GitHub AzureML-Containers.

pytorch_env = Environment.from_conda_specification(name='pytorch-1.6-gpu', file_path='./conda_dependencies.yml')

# Specify a GPU base image
pytorch_env.docker.enabled = True
pytorch_env.docker.base_image = 'mcr.microsoft.com/azureml/openmpi3.1.2-cuda10.1-cudnn7-ubuntu18.04'

Suggerimento

Facoltativamente, è possibile acquisire tutte le dipendenze direttamente in un'immagine Docker o in un Dockerfile personalizzato e creare l'ambiente da questo. Per altre informazioni, vedere Eseguire il training di un modello usando un'immagine Docker personalizzata.

Per altre informazioni sulla creazione e l'utilizzo di ambienti, vedere Creare e usare ambienti software in Azure Machine Learning.

Configurare e inviare un'esecuzione di training

Creare un oggetto ScriptRunConfig

Creare un oggetto ScriptRunConfig per specificare i dettagli di configurazione del processo di training, tra cui script di training, ambiente da usare e destinazione di calcolo in cui eseguirlo. Qualsiasi argomento dello script di training verrà passato tramite la riga di comando, se specificato nel parametro arguments. Il codice seguente consente di configurare un processo PyTorch a nodo singolo.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory=project_folder,
                      script='pytorch_train.py',
                      arguments=['--num_epochs', 30, '--output_dir', './outputs'],
                      compute_target=compute_target,
                      environment=pytorch_env)

Avviso

Azure Machine Learning esegue gli script di training copiando l'intera directory di origine. Se sono presenti dati sensibili che non si intende caricare, usare un file .ignore oppure non includerli nella directory di origine. Accedere invece ai dati usando un set di dati di Azure Machine Learning.

Per altre informazioni sulla configurazione dei processi con ScriptRunConfig, vedere Configurare e inviare esecuzioni di training.

Avviso

Se in precedenza si usava l'oggetto estimator di PyTorch per configurare i processi di training di PyTorch, tenere presente che tali oggetti sono stati deprecati a partire dall'SDK versione 1.19.0. Con Azure Machine Learning SDK >= 1.15.0, ScriptRunConfig rappresenta la modalità consigliata per configurare i processi di training, inclusi quelli che usano framework di Deep Learning. Per domande frequenti sulla migrazione, vedere la guida alla migrazione degli strumenti di stima in ScriptRunConfig.

Inviare l'esecuzione

L'oggetto Run fornisce l'interfaccia per la cronologia di esecuzione mentre il processo è in corso e dopo il completamento.

run = Experiment(ws, name='Tutorial-pytorch-birds').submit(src)
run.wait_for_completion(show_output=True)

Cosa accade durante un'esecuzione

Il processo di esecuzione si articola nelle fasi seguenti:

  • Preparazione: viene creata un'immagine Docker in base all'ambiente definito. L'immagine viene caricata nel registro contenitori dell'area di lavoro e memorizzata nella cache per le esecuzioni successive. I log vengono inoltre trasmessi alla cronologia di esecuzione ed è possibile visualizzarli per monitorare lo stato di avanzamento. Se invece viene specificato un ambiente curato, verrà usata l'immagine memorizzata nella cache in cui è stato eseguito il backup dell'ambiente curato.

  • Ridimensionamento: il cluster prova ad aumentare il numero di nodi se, per completare l'esecuzione, il cluster Batch per intelligenza artificiale richiede più nodi di quelli attualmente disponibili.

  • Esecuzione: tutti gli script disponibili nella cartella degli script vengono caricati nella destinazione di calcolo, gli archivi dati vengono montati o copiati e viene eseguito l'oggetto script. Gli output di stdout e la cartella ./logs vengono trasmessi alla cronologia di esecuzione e possono essere usati per monitorare l'esecuzione.

  • Post-elaborazione: la cartella ./outputs dell'esecuzione viene copiata nella cronologia di esecuzione.

Registrare o scaricare un modello

Dopo aver eseguito il training del modello, è possibile registrarlo nell'area di lavoro. Con la registrazione dei modelli è possibile archiviare i modelli e creare le relative versioni nell'area di lavoro per semplificare la gestione e la distribuzione dei modelli.

model = run.register_model(model_name='pytorch-birds', model_path='outputs/model.pt')

Suggerimento

La procedura di distribuzione contiene una sezione sulla registrazione dei modelli, ma è possibile passare direttamente alla creazione di una destinazione di calcolo per la distribuzione, poiché è già presente un modello registrato.

È anche possibile scaricare una copia locale del modello usando l'oggetto Run. Nello script di training pytorch_train.py un oggetto saver PyTorch rende persistente il modello in una cartella locale (locale rispetto alla destinazione di calcolo). È possibile usare l'oggetto Run per scaricare una copia.

# Create a model folder in the current directory
os.makedirs('./model', exist_ok=True)

# Download the model from run history
run.download_file(name='outputs/model.pt', output_file_path='./model/model.pt'),

Training distribuito

Azure Machine Learning supporta anche processi PyTorch distribuiti a più nodi in modo da poter ridimensionare i carichi di lavoro di training. È possibile eseguire facilmente i processi PyTorch distribuiti e l'orchestrazione verrà gestita automaticamente da Azure Machine Learning.

Azure Machine Learning supporta l'esecuzione di processi PyTorch distribuiti con il modulo DistributedDataParallel predefinito di Horovod e PyTorch.

Per altre informazioni sul training distribuito, vedere la guida al training della GPU distribuita.

Eseguire l'esportazione in ONNX

Per ottimizzare l'inferenza con il runtime ONNX, convertire il modello PyTorch sottoposto a training nel formato ONNX. L'inferenza o il punteggio del modello è la fase in cui il modello distribuito viene usato per la stima, più comunemente su dati di produzione. Per un esempio, vedere l'esercitazione Esportazione del modello da PyTorch a ONNX.

Passaggi successivi

In questo articolo è stato eseguito il training e la registrazione di una rete neurale di Deep Learning con PyTorch in Azure Machine Learning. Per informazioni su come distribuire un modello, continuare con l'articolo sulla distribuzione modello.