Eseguire il training di modelli TensorFlow su larga scala con Azure Machine Learning

  • Articolo
  • 15 minuti per la lettura

SI APPLICA A: Python SDK azure-ai-ml v2 (corrente)

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

Il codice di esempio in questo articolo esegue il training di un modello TensorFlow per classificare le cifre scritte a mano usando una rete neurale profonda (DNN); registrare il modello; e distribuirlo in un endpoint online.

Sia 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 usando risorse di calcolo cloud elastiche. È possibile compilare, distribuire, versione e monitorare i modelli di livello di produzione con Azure Machine Learning.

Prerequisiti

Per trarre vantaggio da questo articolo, è necessario:

È anche possibile trovare una versione completa Jupyter Notebook di questa guida nella pagina degli esempi di GitHub.

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

Configurare il processo

Questa sezione configura il processo per il training caricando i pacchetti Python necessari, connettendosi a un'area di lavoro, creando una risorsa di calcolo per eseguire un processo di comando e creando un ambiente per eseguire il processo.

Connettersi all'area di lavoro

Prima di tutto, è necessario connettersi all'area di lavoro di AzureML. L'area di lavoro di AzureML è la risorsa di primo livello per il servizio. Offre una posizione centralizzata per lavorare con tutti gli artefatti creati quando si usa Azure Machine Learning.

Viene usato DefaultAzureCredential per ottenere l'accesso all'area di lavoro. Questa credenziale deve essere in grado di gestire la maggior parte degli scenari di autenticazione di Azure SDK.

Se DefaultAzureCredential non funziona, vedere azure-identity reference documentation o Set up authentication per altre credenziali disponibili.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

Se si preferisce usare un browser per accedere ed eseguire l'autenticazione, rimuovere il commento dal codice seguente e usarlo.

# Handle to the workspace
# from azure.ai.ml import MLClient

# Authentication package
# from azure.identity import InteractiveBrowserCredential
# credential = InteractiveBrowserCredential()

Ottenere quindi un handle nell'area di lavoro specificando l'ID sottoscrizione, il nome del gruppo di risorse e il nome dell'area di lavoro. Per trovare questi parametri:

  1. Cercare il nome dell'area di lavoro nell'angolo superiore destro della barra degli strumenti studio di Azure Machine Learning.
  2. Selezionare il nome dell'area di lavoro per visualizzare il gruppo di risorse e l'ID sottoscrizione.
  3. Copiare i valori per Gruppo di risorse e ID sottoscrizione nel codice.
# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id="<SUBSCRIPTION_ID>",
    resource_group_name="<RESOURCE_GROUP>",
    workspace_name="<AML_WORKSPACE_NAME>",
)

Il risultato dell'esecuzione di questo script è un handle dell'area di lavoro che verrà usato per gestire altre risorse e processi.

Nota

  • La creazione MLClient non connetterà il client all'area di lavoro. L'inizializzazione del client è differita e attenderà la prima volta che deve effettuare una chiamata. In questo articolo questo problema verrà eseguito durante la creazione del calcolo.

Creare una risorsa di calcolo per eseguire il processo

AzureML richiede una risorsa di calcolo per eseguire un processo. Questa risorsa può essere un computer a nodo singolo o multinodo con sistema operativo Linux o Windows o un'infrastruttura di calcolo specifica, ad esempio Spark.

Nello script di esempio seguente viene effettuato il provisioning di un linux compute cluster. È possibile visualizzare la Azure Machine Learning pricing pagina per l'elenco completo delle dimensioni e dei prezzi delle macchine virtuali. Poiché per questo esempio è necessario un cluster GPU, è possibile selezionare un modello di STANDARD_NC6 e creare un ambiente di calcolo AzureML.

from azure.ai.ml.entities import AmlCompute

gpu_compute_target = "gpu-cluster"

try:
    # let's see if the compute target already exists
    gpu_cluster = ml_client.compute.get(gpu_compute_target)
    print(
        f"You already have a cluster named {gpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new gpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    gpu_cluster = AmlCompute(
        # Name assigned to the compute cluster
        name="gpu-cluster",
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_NC6",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )

    # Now, we pass the object to MLClient's create_or_update method
    gpu_cluster = ml_client.begin_create_or_update(gpu_cluster).result()

print(
    f"AMLCompute with name {gpu_cluster.name} is created, the compute size is {gpu_cluster.size}"
)

Creare un ambiente di processo

Per eseguire un processo AzureML, è necessario un ambiente. Un ambiente AzureML incapsula le dipendenze( ad esempio il runtime software e le librerie) necessarie per eseguire lo script di training di Machine Learning nella risorsa di calcolo. Questo ambiente è simile a un ambiente Python nel computer locale.

AzureML consente di usare un ambiente curato (o pronto), utile per scenari comuni di training e inferenza, oppure creare un ambiente personalizzato usando un'immagine Docker o una configurazione Conda.

In questo articolo verrà riutilizzato l'ambiente AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpuAzureML curato. Si userà la versione più recente di questo ambiente usando la @latest direttiva .

curated_env_name = "AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu@latest"

Configurare e inviare il processo di training

In questa sezione si inizierà introducendo i dati per il training. Verrà quindi illustrato come eseguire un processo di training usando uno script di training fornito. Si apprenderà come compilare il processo di training configurando il comando per l'esecuzione dello script di training. Si invierà quindi il processo di training da eseguire in AzureML.

Ottenere i dati di training

Si useranno i dati del database MNIST (Modified National Institute of Standards and Technology) di cifre scritte a mano. Questi dati vengono originati dal sito Web di Yan LeCun e archiviati in un account di archiviazione di Azure.

web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"

Per altre informazioni sul set di dati MNIST, visitare il sito Web di Yan LeCun.

Preparare lo script di training

In questo articolo è stato fornito lo script di training tf_mnist.py. In pratica, dovrebbe essere possibile eseguire qualsiasi script di training personalizzato così come è ed eseguirlo con AzureML senza dover modificare il codice.

Lo script di training fornito esegue le operazioni seguenti:

  • gestisce la pre-elaborazione dei dati, suddividendo i dati in dati di test ed eseguirne il training;
  • esegue il training di un modello, utilizzando i dati; E
  • restituisce il modello di output.

Durante l'esecuzione della pipeline si userà MLFlow per registrare i parametri e le metriche. Per informazioni su come abilitare il rilevamento MLFlow, vedere Tenere traccia di esperimenti e modelli di Machine Learning con MLflow.

Nello script tf_mnist.pydi training viene creata una semplice rete neurale profonda (DNN). Questa rete neurale neurale ha:

  • Livello di input con 28 * 28 = 784 neuroni. Ogni neurone rappresenta un pixel di immagine.
  • Due livelli nascosti. Il primo livello nascosto ha 300 neuroni e il secondo livello nascosto ha 100 neuroni.
  • Livello di output con 10 neuroni. Ogni neurone rappresenta un'etichetta di destinazione da 0 a 9.

Diagramma che mostra una rete neurale profonda con 784 neuroni a livello di input, due livelli nascosti e 10 neuroni a livello di output.

Compilare il processo di training

Ora che sono disponibili tutti gli asset necessari per eseguire il processo, è possibile compilarlo usando AzureML Python SDK v2. Per questo esempio verrà creato un oggetto command.

AzureML command è una risorsa che specifica tutti i dettagli necessari per eseguire il codice di training nel cloud. Questi dettagli includono gli input e gli output, il tipo di hardware da usare, il software da installare e come eseguire il codice. Contiene command informazioni per eseguire un singolo comando.

Configurare il comando

Si userà lo scopo command generico per eseguire lo script di training ed eseguire le attività desiderate. Creare un Command oggetto per specificare i dettagli di configurazione del processo di training.

from azure.ai.ml import command
from azure.ai.ml import UserIdentityConfiguration
from azure.ai.ml import Input

web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"

job = command(
    inputs=dict(
        data_folder=Input(type="uri_folder", path=web_path),
        batch_size=64,
        first_layer_neurons=256,
        second_layer_neurons=128,
        learning_rate=0.01,
    ),
    compute=gpu_compute_target,
    environment=curated_env_name,
    code="./src/",
    command="python tf_mnist.py --data-folder ${{inputs.data_folder}} --batch-size ${{inputs.batch_size}} --first-layer-neurons ${{inputs.first_layer_neurons}} --second-layer-neurons ${{inputs.second_layer_neurons}} --learning-rate ${{inputs.learning_rate}}",
    experiment_name="tf-dnn-image-classify",
    display_name="tensorflow-classify-mnist-digit-images-with-dnn",
)

  • Gli input per questo comando includono la posizione dei dati, le dimensioni del batch, il numero di neuroni nel primo e il secondo livello e la frequenza di apprendimento. Si noti che il percorso Web è stato passato direttamente come input.

  • Per i valori dei parametri:

    • specificare il cluster gpu_compute_target = "gpu-cluster" di calcolo creato per l'esecuzione di questo comando;
    • fornire l'ambiente curated_env_name curato dichiarato in precedenza;
    • configurare l'azione della riga di comando stessa, in questo caso il comando è python tf_mnist.py. È possibile accedere agli input e agli output nel comando tramite la ${{ ... }} notazione e
    • configurare i metadati, ad esempio il nome visualizzato e il nome dell'esperimento; dove un esperimento è un contenitore per tutte le iterazioni che esegue in un determinato progetto. Tutti i processi inviati con lo stesso nome dell'esperimento verranno elencati accanto all'altro in AzureML Studio.

  • In questo esempio si userà l'oggetto UserIdentity per eseguire il comando. L'uso di un'identità utente significa che il comando userà l'identità per eseguire il processo e accedere ai dati dal BLOB.

Inviare il processo

È ora possibile inviare il processo da eseguire in AzureML. Questa volta si userà create_or_update su ml_client.jobs.

ml_client.jobs.create_or_update(job)

Al termine, il processo registra un modello nell'area di lavoro (come risultato del training) e restituisce un collegamento per visualizzare il processo in AzureML Studio.

Avviso

Azure Machine Learning esegue script di training copiando l'intera directory di origine. Se si dispone di dati sensibili che non si desidera caricare, usare un file con estensione ignore o non includerlo nella directory di origine.

Cosa accade durante l'esecuzione del processo

Man mano che viene eseguito il processo, passa le 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 dei processi e possono essere visualizzati per monitorare lo stato di avanzamento. Se viene specificato un ambiente curato, verrà usato il backup dell'immagine memorizzata nella cache che verrà usato dall'ambiente curato.

  • Ridimensionamento: il cluster tenta di aumentare la scalabilità se richiede più nodi per eseguire l'esecuzione che sono attualmente disponibili.

  • Esecuzione: tutti gli script nella cartella script src vengono caricati nella destinazione di calcolo, gli archivi dati vengono montati o copiati e lo script viene eseguito. Gli output da stdout e la cartella ./logs vengono trasmessi alla cronologia dei processi e possono essere usati per monitorare il processo.

Ottimizzare gli iperparametri del modello

Dopo aver visto come eseguire un training TensorFlow usando l'SDK, vedere se è possibile migliorare ulteriormente l'accuratezza del modello. È possibile ottimizzare e ottimizzare gli iperparametri del modello usando le funzionalità di sweep Azure Machine Learning.

Per ottimizzare gli iperparametri del modello, definire lo spazio dei parametri in cui eseguire la ricerca durante il training. Questa operazione verrà eseguita sostituendo alcuni dei parametri (batch_size, , first_layer_neuronssecond_layer_neuronse learning_rate) passati al processo di training con input speciali dal azure.ml.sweep pacchetto.

from azure.ai.ml.sweep import Choice, LogUniform

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
# we do not apply the 'iris_csv' input again -- we will just use what was already defined earlier
job_for_sweep = job(
    batch_size=Choice(values=[32, 64, 128]),
    first_layer_neurons=Choice(values=[16, 64, 128, 256, 512]),
    second_layer_neurons=Choice(values=[16, 64, 256, 512]),
    learning_rate=LogUniform(min_value=-6, max_value=-1),
)

Si configurerà quindi lo sweep nel processo di comando usando alcuni parametri specifici dello sweep, ad esempio la metrica primaria da controllare e l'algoritmo di campionamento da usare.

Nel codice seguente viene usato il campionamento casuale per provare diversi set di configurazioni di iperparametri in un tentativo di ottimizzare la metrica primaria, validation_acc.

Viene anche definito un criterio di terminazione anticipata, ovvero .BanditPolicy Questo criterio funziona controllando il processo ogni due iterazioni. Se la metrica primaria, validation_acc, rientra all'esterno dell'intervallo superiore dieci%, AzureML termina il processo. Ciò consente al modello di continuare a esplorare gli iperparametri che non mostrano alcuna promessa di aiutare a raggiungere la metrica di destinazione.

from azure.ai.ml.sweep import BanditPolicy

sweep_job = job_for_sweep.sweep(
    compute=gpu_compute_target,
    sampling_algorithm="random",
    primary_metric="validation_acc",
    goal="Maximize",
    max_total_trials=8,
    max_concurrent_trials=4,
    early_termination_policy=BanditPolicy(slack_factor=0.1, evaluation_interval=2),
)

È ora possibile inviare questo processo come prima. Questa volta si eseguirà un processo di sweep che esegue lo spazzamento sul processo di training.

returned_sweep_job = ml_client.create_or_update(sweep_job)

# stream the output and wait until the job is finished
ml_client.jobs.stream(returned_sweep_job.name)

# refresh the latest status of the job after streaming
returned_sweep_job = ml_client.jobs.get(name=returned_sweep_job.name)

È possibile monitorare il processo usando il collegamento interfaccia utente studio presentato durante l'esecuzione del processo.

Trovare e registrare il modello migliore

Una volta completate tutte le esecuzioni, è possibile trovare l'esecuzione che ha prodotto il modello con la massima accuratezza.

from azure.ai.ml.entities import Model

if returned_sweep_job.status == "Completed":

    # First let us get the run which gave us the best result
    best_run = returned_sweep_job.properties["best_child_run_id"]

    # lets get the model from this run
    model = Model(
        # the script stores the model as "model"
        path="azureml://jobs/{}/outputs/artifacts/paths/outputs/model/".format(
            best_run
        ),
        name="run-model-example",
        description="Model created from run.",
        type="custom_model",
    )

else:
    print(
        "Sweep job status: {}. Please wait until it completes".format(
            returned_sweep_job.status
        )
    )

È quindi possibile registrare questo modello.

registered_model = ml_client.models.create_or_update(model=model)

Distribuire il modello come endpoint online

Dopo aver registrato il modello, è possibile distribuirlo come endpoint online, ovvero come servizio Web nel cloud di Azure.

Per distribuire un servizio di Machine Learning, in genere è necessario:

  • Asset del modello da distribuire. Questi asset includono il file e i metadati del modello già registrati nel processo di training.
  • Codice da eseguire come servizio. Il codice esegue il modello in una richiesta di input specificata (uno script di voce). Questo script di voce riceve i dati inviati a un servizio Web distribuito e lo passa al modello. Dopo aver elaborato i dati, lo script restituisce la risposta del modello al client. Lo script è specifico del modello e deve comprendere i dati previsti e restituiti dal modello. Quando si usa un modello MLFlow, AzureML crea automaticamente questo script.

Per altre informazioni sulla distribuzione, vedere Distribuire e assegnare punteggi a un modello di Machine Learning con endpoint online gestito con Python SDK v2.

Creare un nuovo endpoint online

Come primo passaggio per distribuire il modello, è necessario creare l'endpoint online. Il nome dell'endpoint deve essere univoco nell'intera area di Azure. Per questo articolo si creerà un nome univoco usando un identificatore univoco (UUID) universalmente univoco.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "tff-dnn-endpoint-" + str(uuid.uuid4())[:8]
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="Classify handwritten digits using a deep neural network (DNN) using TensorFlow",
    auth_mode="key",
)

endpoint = ml_client.begin_create_or_update(endpoint).result()

print(f"Endpint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Dopo aver creato l'endpoint, è possibile recuperarlo come segue:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Distribuire il modello nell'endpoint

Dopo aver creato l'endpoint, è possibile distribuire il modello con lo script di immissione. Un endpoint può avere più distribuzioni. Usando le regole, l'endpoint può quindi indirizzare il traffico a queste distribuzioni.

Nel codice seguente si creerà una singola distribuzione che gestisce il 100% del traffico in ingresso. È stato specificato un nome di colore arbitrario (tff-blu) per la distribuzione. È anche possibile usare qualsiasi altro nome, ad esempio tff-verde o tff-rosso per la distribuzione. Il codice per distribuire il modello nell'endpoint esegue le operazioni seguenti:

  • distribuisce la versione migliore del modello registrato in precedenza;
  • segna il modello usando il score.py file e
  • usa lo stesso ambiente curato (dichiarato in precedenza) per eseguire l'inferenza.
model = registered_model

from azure.ai.ml.entities import CodeConfiguration

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="tff-blue",
    endpoint_name=online_endpoint_name,
    model=model,
    code_configuration=CodeConfiguration(code="./src", scoring_script="score.py"),
    environment=curated_env_name,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Nota

Si prevede che questa distribuzione richiede un po' di tempo per terminare.

Testare la distribuzione con una query di esempio

Dopo aver distribuito il modello nell'endpoint, è possibile stimare l'output del modello distribuito usando il invoke metodo nell'endpoint. Per eseguire l'inferenza, usare il file sample-request.json di richiesta di esempio dalla cartella della richiesta .

# # predict using the deployed model
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./request/sample-request.json",
    deployment_name="tff-blue",
)

È quindi possibile stampare le stime restituite e tracciarle insieme alle immagini di input. Usare il colore del carattere rosso e l'immagine invertita (bianco su nero) per evidenziare gli esempi non classificati.

# compare actual value vs. the predicted values:
import matplotlib.pyplot as plt

i = 0
plt.figure(figsize=(20, 1))

for s in sample_indices:
    plt.subplot(1, n, i + 1)
    plt.axhline("")
    plt.axvline("")

    # use different color for misclassified sample
    font_color = "red" if y_test[s] != result[i] else "black"
    clr_map = plt.cm.gray if y_test[s] != result[i] else plt.cm.Greys

    plt.text(x=10, y=-10, s=result[i], fontsize=18, color=font_color)
    plt.imshow(X_test[s].reshape(28, 28), cmap=clr_map)

    i = i + 1
plt.show()

Nota

Poiché l'accuratezza del modello è elevata, potrebbe essere necessario eseguire la cella qualche volta prima di visualizzare un esempio non classificato.

Pulire le risorse

Se non si usa l'endpoint, eliminarlo per interrompere l'uso della risorsa. Assicurarsi che nessun'altra distribuzione usi l'endpoint prima di eliminarla.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Nota

Aspettatevi che questa pulizia possa richiedere un po' di tempo per terminare.

Passaggi successivi

In questo articolo è stato eseguito il training e la registrazione di un modello TensorFlow. Il modello è stato distribuito anche in un endpoint online. Per altre informazioni su Azure Machine Learning, vedere questi altri articoli.