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

Articolo
10/16/2024

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

In questo esempio vengono eseguiti il training e la registrazione di un modello TensorFlow per classificare le cifre scritte a mano usando una rete neurale profonda.

Che si stia sviluppando un modello TensorFlow da zero o si stia portando un modello esistente nel cloud, è possibile usare Azure Machine Learning per aumentare il numero di processi di training open source per creare, distribuire e monitorare modelli per ambienti di produzione, nonché controllarne le versioni.

Prerequisiti

Eseguire questo codice in uno degli ambienti seguenti:

Istanza di calcolo di Azure Machine Learning: nessun download o installazione necessaria
- Completare l'Avvio rapido: Iniziare a usare il servizio Azure Machine Learning per creare un server notebook dedicato precaricato con l'SDK e il repository di esempio.
- Nella cartella di Deep Learning degli esempi nel server del notebook trovare un notebook completato ed espanso passando a questa directory: how-to-use-azureml > ml-frameworks > tensorflow > train-hyperparameter-tune-deploy-with-tensorflow.
Server Jupyter Notebook personale
- Installare Azure Machine Learning SDK (>= 1.15.0).
- Creare un file di configurazione dell'area di lavoro.
- Scaricare i file di script di esempio, tf_mnist.py e utils.py
È anche possibile trovare una versione completa di questa guida per il notebook Jupyter nella pagina degli esempi di GitHub. Il notebook include sezioni espanse relative all'ottimizzazione intelligente degli iperparametri, alla distribuzione modello e ai widget del notebook.

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 urllib
import shutil
import azureml

from azureml.core import Experiment
from azureml.core import Workspace, Run
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 dell'area di lavoro dal file config.json creato nella sezione dei prerequisiti.

ws = Workspace.from_config()

Creare un set di dati di file

L'oggetto FileDataset fa riferimento a uno o più file nell'archivio dati dell'area di lavoro o negli URL pubblici. I file possono essere di qualsiasi formato e la classe offre la possibilità di scaricarli o montarli nel contesto di calcolo. Creando un oggetto FileDataset, si crea un riferimento alla posizione dell'origine dati. Nel set di dati verranno archiviate anche le eventuali trasformazioni applicate al set di dati. I dati rimangono nell'attuale posizione, quindi non si incorre in costi aggiuntivi di archiviazione. Per altre informazioni sul pacchetto Dataset, vedere l'articolo Come creare set di dati di registrazione.

from azureml.core.dataset import Dataset

web_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path = web_paths)

Usare il metodo register() per registrare il set di dati nell'area di lavoro in modo che sia possibile condividerlo con altri, riutilizzarlo in vari esperimenti e farvi riferimento per nome nello script di training.

dataset = dataset.register(workspace=ws,
                           name='mnist-dataset',
                           description='training and test dataset',
                           create_new_version=True)

# list the files referenced by dataset
dataset.to_path()

Creare una destinazione di calcolo

Creare una destinazione di calcolo in cui eseguire il processo TensorFlow. 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.

cluster_name = "gpu-cluster"

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)

    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

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

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. Azure Machine Learning include diversi ambienti curati CPU e GPU per TensorFlow corrispondenti a versioni diverse di TensorFlow. È possibile usare la versione più recente di questo ambiente usando la direttiva @latest. Per altre informazioni, vedere Ambienti curati di Azure Machine Learning.

Se si vuole usare un ambiente curato, il codice sarà simile all'esempio seguente:

curated_env_name = 'AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu'
tf_env = Environment.get(workspace=ws, name=curated_env_name)

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


tf_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:


tf_env = Environment.from_conda_specification(name='AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu', file_path='./conda_dependencies.yml')

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


tf_env = tf_env.clone(new_name='my-AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-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:
  - azureml-defaults
  - tensorflow-gpu==2.2.0

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 di Azure/AzureML-Containers.

tf_env = Environment.from_conda_specification(name='AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu', file_path='./conda_dependencies.yml')

# Specify a GPU base image
tf_env.docker.enabled = True
tf_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.

from azureml.core import ScriptRunConfig

args = ['--data-folder', dataset.as_mount(),
        '--batch-size', 64,
        '--first-layer-neurons', 256,
        '--second-layer-neurons', 128,
        '--learning-rate', 0.01]

src = ScriptRunConfig(source_directory=script_folder,
                      script='tf_mnist.py',
                      arguments=args,
                      compute_target=compute_target,
                      environment=tf_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 TensorFlow per configurare i processi di training di TensorFlow, 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 oggetti estimator in ScriptRunConfig.

Inviare un'esecuzione

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

run = Experiment(workspace=ws, name='Tutorial-TF-Mnist').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.

Facoltativo: specificando i parametri model_framework, model_framework_version e resource_configuration, diventa disponibile la distribuzione modello senza codice. In questo modo il modello viene distribuito direttamente come servizio Web dal modello registrato e l'oggetto ResourceConfiguration definisce la risorsa di calcolo per il servizio Web.

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = run.register_model(model_name='tf-mnist', 
                           model_path='outputs/model',
                           model_framework=Model.Framework.TENSORFLOW,
                           model_framework_version='2.0',
                           resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5))

È anche possibile scaricare una copia locale del modello usando l'oggetto Run. Nello script di training tf_mnist.py un oggetto saver di TensorFlow 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)
run.download_files(prefix='outputs/model', output_directory='./model', append_prefix=False)

Training distribuito

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

Azure Machine Learning supporta l'esecuzione di processi TensorFlow distribuiti con l'API di training distribuita predefinita di Horovod e TensorFlow.

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

Distribuire un modello TensorFlow

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.

(Anteprima) Distribuzione modello senza codice

Importante

Questa funzionalità è attualmente in anteprima pubblica. Questa versione di anteprima viene fornita senza contratto di servizio, pertanto se ne sconsiglia l’uso per i carichi di lavoro in ambienti di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate.

Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

Invece della tradizionale route di distribuzione, per TensorFlow è anche possibile usare la funzionalità di distribuzione senza codice (anteprima). Registrando il modello come illustrato in precedenza, ovvero con i parametri model_framework, model_framework_version e resource_configuration, è possibile usare la funzione statica deploy() per distribuire il modello.

service = Model.deploy(ws, "tensorflow-web-service", [model])

L'articolo completo illustra il processo di distribuzione in Azure Machine Learning in modo più approfondito.

Passaggi successivi

In questo articolo sono stati eseguiti il training e la registrazione di un modello TensorFlow e sono state illustrate le opzioni per la distribuzione. Per altre informazioni su Azure Machine Learning, vedere gli altri articoli elencati di seguito.

Condividi tramite