Usare gli endpoint batch per l'assegnazione dei punteggi batch

SI APPLICA A:Estensione dell'interfaccia della riga di comando di Azure v2 (corrente)Python SDK azure-ai-ml v2 (corrente)

Gli endpoint batch offrono un modo pratico per eseguire l'inferenza su grandi volumi di dati. Semplificano il processo di hosting dei modelli per l'assegnazione dei punteggi batch, quindi è possibile concentrarsi sull'apprendimento automatico, non sull'infrastruttura. Per altre informazioni, vedere Informazioni sugli endpoint di Azure Machine Learning?

Usare gli endpoint batch quando:

  • Sono disponibili modelli costosi che richiedono un tempo più lungo per eseguire l'inferenza.
  • È necessario eseguire l'inferenza su grandi quantità di dati, distribuite in più file.
  • Non si hanno requisiti di bassa latenza.
  • È possibile sfruttare la parallelizzazione.

In questo articolo si apprenderà come usare gli endpoint batch per eseguire il punteggio batch.

Suggerimento

È consigliabile leggere le sezioni Scenari (vedere la barra di spostamento a sinistra) per altre informazioni su come usare Gli endpoint Batch in scenari specifici, tra cui NLP, visione artificiale o come integrarli con altri servizi di Azure.

Informazioni su questo esempio

In questo esempio si distribuirà un modello per risolvere il problema di riconoscimento delle cifre di MNIST classico ("National Institute of Standards and Technology") per eseguire l'inferenza batch su grandi quantità di dati (file di immagine). Nella prima sezione di questa esercitazione verrà creata una distribuzione batch con un modello creato con Torch. Tale distribuzione diventerà quella predefinita nell'endpoint. Nella seconda metà verrà illustrato come creare una seconda distribuzione usando un modello creato con TensorFlow (Keras), quindi passare all'endpoint per iniziare a usare la nuova distribuzione come impostazione predefinita.

Le informazioni contenute in questo articolo si basano sugli esempi di codice contenuti nel repository azureml-examples . Per eseguire i comandi in locale senza dover copiare/incollare YAML e altri file, clonare prima il repository. Modificare quindi le cli/endpoints/batch directory in se si usa l'interfaccia della riga di comando di Azure o sdk/endpoints/batch se si usa Python SDK.

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli/endpoints/batch

Seguire il percorso in Jupyter Notebooks

È possibile seguire questo esempio nei notebook seguenti. Nel repository clonato aprire il notebook: mnist-batch.ipynb.

Prerequisiti

Prima di seguire la procedura descritta in questo articolo, assicurarsi di disporre dei prerequisiti seguenti:

Connettersi all'area di lavoro

Prima di tutto, connettersi all'area di lavoro di Azure Machine Learning in cui si funzionerà.

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Creare l'ambiente di calcolo

Gli endpoint batch vengono eseguiti nei cluster di calcolo. Supportano sia i cluster di calcolo di Azure Machine Learning (AmlCompute) sia i cluster Kubernetes. I cluster sono una risorsa condivisa in modo che un cluster possa ospitare una o più distribuzioni batch (insieme ad altri carichi di lavoro se desiderato).

Questo articolo usa un calcolo creato qui denominato batch-cluster. Modificare in base alle esigenze e fare riferimento al calcolo usando azureml:<your-compute-name> o crearne uno come illustrato.

az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5

Nota

Non viene addebitato alcun addebito per il calcolo a questo punto perché il cluster rimarrà a 0 nodi fino a quando non viene richiamato un endpoint batch e viene inviato un processo di assegnazione dei punteggi batch. Altre informazioni sulla gestione e sull'ottimizzazione dei costi per AmlCompute.

Registrazione del modello

Le distribuzioni batch possono distribuire solo modelli registrati nell'area di lavoro. È possibile ignorare questo passaggio se il modello che si sta tentando di distribuire è già registrato. In questo caso, si sta registrando un modello Torch per il problema di riconoscimento delle cifre popolare (MNIST).

Suggerimento

I modelli sono associati alla distribuzione anziché all'endpoint. Ciò significa che un singolo endpoint può servire modelli diversi o versioni di modelli diversi nello stesso endpoint, purché vengano distribuite in distribuzioni diverse.

MODEL_NAME='mnist'
az ml model create --name $MODEL_NAME --type "custom_model" --path "./mnist/model/"

Creare un endpoint batch

Un endpoint batch è un endpoint HTTPS che i client possono chiamare per attivare un processo di assegnazione dei punteggi batch. Un processo di assegnazione dei punteggi batch è un processo che assegna più input (per altre informazioni, vedere Quali sono gli endpoint batch?). Una distribuzione batch è un set di risorse di calcolo che ospitano il modello che esegue il punteggio batch effettivo. Un endpoint batch può avere più distribuzioni batch.

Suggerimento

Una delle distribuzioni batch fungerà da distribuzione predefinita per l'endpoint. La distribuzione predefinita verrà usata per eseguire il punteggio batch effettivo quando viene richiamato l'endpoint. Altre informazioni sugli endpoint batch e sulla distribuzione batch.

Passaggi

  1. Decidere il nome dell'endpoint. Il nome dell'endpoint verrà terminato nell'URI associato all'endpoint. A causa di questo, i nomi degli endpoint batch devono essere univoci all'interno di un'area di Azure. Ad esempio, può essere presente un solo endpoint batch con il nome mybatchendpoint in westus2.

    In questo caso, inserire il nome dell'endpoint in una variabile in modo da poterlo fare facilmente riferimento in un secondo momento.

    ENDPOINT_NAME="mnist-batch"
    
  2. Configurare l'endpoint batch

    Il file YAML seguente definisce un endpoint batch, che è possibile includere nel comando dell'interfaccia della riga di comando per la creazione di endpoint batch.

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
    name: mnist-batch
    description: A batch endpoint for scoring images from the MNIST dataset.
    auth_mode: aad_token
    

    Nella tabella seguente vengono descritte le proprietà chiave dell'endpoint. Per lo schema YAML completo dell'endpoint batch, vedere Schema YAML dell'endpoint batch dell'interfaccia della riga di comando (v2).

    Chiave Descrizione
    name Nome dell'endpoint batch. Deve essere univoco a livello di area di Azure.
    description Descrizione dell'endpoint batch. Questa proprietà è facoltativa.
    auth_mode Metodo di autenticazione per l'endpoint batch. Attualmente è supportata solo l'autenticazione basata su token di Azure Active Directory (aad_token).
  3. Creare l'endpoint:

    Eseguire il codice seguente per creare una distribuzione batch nell'endpoint batch e impostarla come distribuzione predefinita.

    az ml batch-endpoint create --file endpoint.yml  --name $ENDPOINT_NAME
    

Creare una distribuzione batch

Una distribuzione è un set di risorse necessarie per ospitare il modello che esegue l'inferenza effettiva. Per creare una distribuzione batch, sono necessari tutti gli elementi seguenti:

  • Modello registrato nell'area di lavoro.
  • Codice per assegnare un punteggio al modello.
  • Ambiente in cui viene eseguito il modello.
  • Impostazioni di calcolo e risorse già create.
  1. Le distribuzioni batch richiedono uno script di assegnazione dei punteggi che indica come deve essere eseguito un determinato modello e come devono essere elaborati i dati di input. Gli endpoint batch supportano gli script creati in Python. In questo caso, viene distribuito un modello che legge i file di immagine che rappresentano cifre e restituisce la cifra corrispondente. Lo script di assegnazione dei punteggi è il seguente:

    Nota

    Per i modelli MLflow, Azure Machine Learning genera automaticamente lo script di assegnazione dei punteggi, quindi non è necessario specificarne uno. Se il modello è un modello MLflow, è possibile ignorare questo passaggio. Per altre informazioni sul funzionamento degli endpoint batch con i modelli MLflow, vedere l'esercitazione dedicata Sull'uso di modelli MLflow nelle distribuzioni batch.

    Avviso

    Se si distribuisce un modello di Machine Learning automatizzato in un endpoint batch, si noti che lo script di assegnazione dei punteggi fornito da Machine Learning automatizzato funziona solo per gli endpoint online e non è progettato per l'esecuzione batch. Vedere Creare script di assegnazione dei punteggi per le distribuzioni batch per informazioni su come crearne uno a seconda delle operazioni eseguite dal modello.

    deployment-torch/code/batch_driver.py

    # Copyright (c) Microsoft. All rights reserved.
    # Licensed under the MIT license.
    
    import os
    import pandas as pd
    import torch
    import torchvision
    import glob
    from os.path import basename
    from mnist_classifier import MnistClassifier
    from typing import List
    
    
    def init():
        global model
        global device
    
        # AZUREML_MODEL_DIR is an environment variable created during deployment
        # It is the path to the model folder
        model_path = os.environ["AZUREML_MODEL_DIR"]
        model_file = glob.glob(f"{model_path}/*/*.pt")[-1]
    
        model = MnistClassifier()
        model.load_state_dict(torch.load(model_file))
        model.eval()
    
        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
    
    def run(mini_batch: List[str]) -> pd.DataFrame:
        print(f"Executing run method over batch of {len(mini_batch)} files.")
    
        results = []
        with torch.no_grad():
            for image_path in mini_batch:
                image_data = torchvision.io.read_image(image_path).float()
                batch_data = image_data.expand(1, -1, -1, -1)
                input = batch_data.to(device)
    
                # perform inference
                predict_logits = model(input)
    
                # Compute probabilities, classes and labels
                predictions = torch.nn.Softmax(dim=-1)(predict_logits)
                predicted_prob, predicted_class = torch.max(predictions, axis=-1)
    
                results.append(
                    {
                        "file": basename(image_path),
                        "class": predicted_class.numpy(),
                        "probability": predicted_prob.numpy(),
                    }
                )
    
        return pd.DataFrame(results)
    
  2. Creare un ambiente in cui verrà eseguita la distribuzione batch. Tale ambiente deve includere i pacchetti azureml-core e azureml-dataset-runtime[fuse], necessari per gli endpoint batch, oltre a qualsiasi dipendenza richiesta dal codice per l'esecuzione. In questo caso, le dipendenze sono state acquisite in :conda.yml

    deployment-torch/environment/conda.yml

    name: mnist-env
    channels:
      - conda-forge
    dependencies:
      - python=3.8.5
      - pip<22.0
      - pip:
        - torch==1.13.0
        - torchvision==0.14.0
        - pytorch-lightning
        - pandas
        - azureml-core
        - azureml-dataset-runtime[fuse]
    

    Importante

    I pacchetti azureml-core e azureml-dataset-runtime[fuse] sono richiesti dalle distribuzioni batch e devono essere inclusi nelle dipendenze dell'ambiente.

    Indicare l'ambiente come indicato di seguito:

    La definizione dell'ambiente verrà inclusa nella definizione di distribuzione stessa come ambiente anonimo. Nella distribuzione verranno visualizzate le righe seguenti:

    environment:
      name: batch-torch-py38
      image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
      conda_file: environment/conda.yml
    

    Avviso

    Gli ambienti curati non sono supportati nelle distribuzioni batch. Sarà necessario indicare il proprio ambiente. È sempre possibile usare l'immagine di base di un ambiente curato per semplificare il processo.

  3. Creare una definizione di distribuzione

    mnist-torch-deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchDeployment.schema.json
    name: mnist-torch-dpl
    description: A deployment using Torch to solve the MNIST classification dataset.
    endpoint_name: mnist-batch
    model: 
      path: model
    code_configuration:
      code: code
      scoring_script: batch_driver.py
    environment:
      name: batch-torch-py38
      image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
      conda_file: environment/conda.yml
    compute: azureml:batch-cluster
    resources:
      instance_count: 1
    max_concurrency_per_instance: 2
    mini_batch_size: 10
    output_action: append_row
    output_file_name: predictions.csv
    retry_settings:
      max_retries: 3
      timeout: 30
    error_threshold: -1
    logging_level: info
    

    Per lo schema YAML per la distribuzione batch completa, vedere Schema YAML per la distribuzione batch dell'interfaccia della riga di comando (v2).

    Chiave Descrizione
    name Nome della distribuzione.
    endpoint_name Nome dell'endpoint in cui creare la distribuzione.
    model Modello da usare per l'assegnazione dei punteggi batch. L'esempio definisce un modello inline usando path. I file del modello verranno caricati e registrati automaticamente con un nome e una versione generati automaticamente. Seguire lo schema del modello per altre opzioni. Come procedura consigliata per gli scenari di produzione, è necessario creare il modello separatamente e farvi riferimento qui. Per fare riferimento a un modello esistente, usare la azureml:<model-name>:<model-version> sintassi .
    code_configuration.code.path Directory locale che contiene tutto il codice sorgente Python per assegnare un punteggio al modello.
    code_configuration.scoring_script File Python nella directory precedente. Questo file deve avere una init() funzione e una run() funzione. Usare la init() funzione per qualsiasi preparazione costosa o comune , ad esempio caricare il modello in memoria. init() verrà chiamato una sola volta all'inizio del processo. Usare run(mini_batch) per assegnare un punteggio a ogni voce. Il valore di mini_batch è un elenco di percorsi di file. La run() funzione deve restituire un dataframe pandas o una matrice. Ogni elemento restituito indica un'esecuzione corretta dell'elemento mini_batchdi input in . Per altre informazioni su come creare uno script di assegnazione dei punteggi, vedere Informazioni sullo script di assegnazione dei punteggi.
    environment Ambiente per assegnare un punteggio al modello. L'esempio definisce un ambiente inline usando conda_file e image. Le conda_file dipendenze verranno installate nella parte superiore di image. L'ambiente verrà registrato automaticamente con un nome e una versione generati automaticamente. Seguire lo schema dell'ambiente per altre opzioni. Come procedura consigliata per gli scenari di produzione, è necessario creare l'ambiente separatamente e farvi riferimento qui. Per fare riferimento a un ambiente esistente, usare la azureml:<environment-name>:<environment-version> sintassi.
    compute Calcolo per l'esecuzione del punteggio batch. Nell'esempio viene usato l'oggetto creato all'inizio e lo fa riferimento usando azureml:<compute-name> la batch-cluster sintassi.
    resources.instance_count Numero di istanze da usare per ogni processo di assegnazione dei punteggi batch.
    max_concurrency_per_instance [Facoltativo] Numero massimo di esecuzioni parallele scoring_script per istanza.
    mini_batch_size [Facoltativo] Numero di file che possono scoring_script essere elaborati in una run() chiamata.
    output_action [Facoltativo] Come deve essere organizzato l'output nel file di output. append_row unisce tutti i run() risultati di output restituiti in un singolo file denominato output_file_name. summary_only non unisce i risultati dell'output e calcola error_thresholdsolo .
    output_file_name [Facoltativo] Nome del file di output del punteggio batch per append_rowoutput_action.
    retry_settings.max_retries [Facoltativo] Numero di tentativi massimi per un oggetto non riuscito scoring_scriptrun().
    retry_settings.timeout [Facoltativo] Timeout in secondi per un punteggio di un scoring_scriptrun() mini batch.
    error_threshold [Facoltativo] Numero di errori di assegnazione dei punteggi dei file di input che devono essere ignorati. Se il conteggio degli errori per l'intero input supera questo valore, il processo di assegnazione dei punteggi batch verrà terminato. L'esempio usa -1, che indica che qualsiasi numero di errori è consentito senza terminare il processo di assegnazione dei punteggi batch.
    logging_level [Facoltativo] Verbosità del log. I valori in aumento sono: WARNING, INFO e DEBUG.
  4. Creare la distribuzione:

    Eseguire il codice seguente per creare una distribuzione batch nell'endpoint batch e impostarla come distribuzione predefinita.

    az ml batch-deployment create --file deployment-torch/deployment.yml --endpoint-name $ENDPOINT_NAME --set-default
    

    Suggerimento

    Il --set-default parametro imposta la distribuzione appena creata come distribuzione predefinita dell'endpoint. È un modo pratico per creare una nuova distribuzione predefinita dell'endpoint, soprattutto per la prima creazione della distribuzione. Come procedura consigliata per gli scenari di produzione, è possibile creare una nuova distribuzione senza impostarla come predefinita, verificarla e aggiornare la distribuzione predefinita in un secondo momento. Per altre informazioni, vedere la sezione Distribuire un nuovo modello .

    Nota

    Come viene distribuito il lavoro?:

    Le distribuzioni batch distribuiscono il lavoro a livello di file, ovvero una cartella contenente 100 file con mini-batch di 10 file genererà 10 batch di 10 file ogni. Si noti che questo avviene indipendentemente dalle dimensioni dei file coinvolti. Se i file sono troppo grandi da elaborare in mini-batch di grandi dimensioni, è consigliabile suddividere i file in file più piccoli per ottenere un livello superiore di parallelismo o ridurre il numero di file per mini-batch. In questo momento, la distribuzione batch non può tenere conto delle differenze nella distribuzione delle dimensioni del file.

  5. Controllare i dettagli dell'endpoint batch e della distribuzione.

    Usare show per controllare i dettagli dell'endpoint e della distribuzione. Per controllare una distribuzione batch, eseguire il codice seguente:

    DEPLOYMENT_NAME="mnist-torch-dpl"
    az ml batch-deployment show --name $DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME
    

Eseguire l'endpoint e configurare input e output

Richiamare un endpoint batch attiva un processo di assegnazione dei punteggi batch. Un processo name verrà restituito dalla risposta invoke e può essere usato per tenere traccia dello stato di assegnazione dei punteggi batch. Il processo di assegnazione dei punteggi batch viene eseguito per un certo periodo di tempo. Suddivide l'intero input in più mini_batch processi e in parallelo nel cluster di calcolo. Gli output del processo di assegnazione dei punteggi batch verranno archiviati nell'archiviazione cloud, nell'archivio BLOB predefinito dell'area di lavoro o nell'archiviazione specificata.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Configurare gli input del processo

Gli endpoint batch supportano la lettura di file o cartelle che si trovano in posizioni diverse. Per altre informazioni su come i tipi supportati e su come specificarli, vedere Accesso ai dati dai processi di endpoint batch.

Suggerimento

È possibile usare cartelle/file di dati locali durante l'esecuzione di endpoint batch dall'interfaccia della riga di comando di Azure Machine Learning o da Azure Machine Learning SDK per Python. Tuttavia, questa operazione comporterà il caricamento dei dati locali nell'archivio dati predefinito di Azure Machine Learning dell'area di lavoro su cui si sta lavorando.

Importante

Avviso di deprecazione: i set di dati di tipo FileDataset (V1) sono deprecati e verranno ritirati in futuro. Gli endpoint batch esistenti che si basano su questa funzionalità continueranno a funzionare, ma gli endpoint batch creati con CLIv2 ga (2.4.0 e versioni successive) o l'API REST ga (2022-05-01 e versioni successive) non supporteranno il set di dati V1.

Configurare il percorso di output

I risultati dell'assegnazione dei punteggi batch vengono archiviati per impostazione predefinita nell'archivio BLOB predefinito dell'area di lavoro all'interno di una cartella denominata in base al nome del processo (GUID generato dal sistema). È possibile configurare dove archiviare gli output di assegnazione dei punteggi quando si richiama l'endpoint batch.

Usare output-path per configurare qualsiasi cartella in un archivio dati registrato di Azure Machine Learning. La sintassi per è --output-path la stessa --input di quando si specifica una cartella, azureml://datastores/<datastore-name>/paths/<path-on-datastore>/ovvero . Usare --set output_file_name=<your-file-name> per configurare un nuovo nome di file di output.

export OUTPUT_FILE_NAME=predictions_`echo $RANDOM`.csv
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --output-path azureml://datastores/workspaceblobstore/paths/$ENDPOINT_NAME --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

Avviso

È necessario usare un percorso di output univoco. Se il file di output esiste, il processo di assegnazione dei punteggi batch avrà esito negativo.

Importante

Contrariamente agli input, per gli output sono supportati solo gli archivi dati di Azure Machine Learning in esecuzione negli account di archiviazione BLOB.

Sovrascrivere la configurazione della distribuzione per ogni processo

Alcune impostazioni possono essere sovrascritte quando si richiama per usare al meglio le risorse di calcolo e per migliorare le prestazioni. Le impostazioni seguenti possono essere configurate in base al processo:

  • Usare il numero di istanze per sovrascrivere il numero di istanze da richiedere dal cluster di calcolo. Ad esempio, per un volume maggiore di input di dati, è possibile usare più istanze per velocizzare l'assegnazione dei punteggi batch end-to-end.
  • Usare le dimensioni mini batch per sovrascrivere il numero di file da includere in ogni mini batch. Il numero di mini batch viene deciso dai conteggi totali dei file di input e dai mini_batch_size. I mini_batch_size più piccoli generano più mini batch. I mini batch possono essere eseguiti in parallelo, ma potrebbe verificarsi un sovraccarico aggiuntivo per la pianificazione e la chiamata.
  • È possibile sovrascrivere altre impostazioni, tra cui numero massimo di tentativi, timeout e soglia di errore. Queste impostazioni potrebbero influire sul tempo di assegnazione dei punteggi del batch end-to-end per carichi di lavoro diversi.
export OUTPUT_FILE_NAME=predictions_`echo $RANDOM`.csv
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --mini-batch-size 20 --instance-count 5 --query name -o tsv)

Monitorare lo stato di esecuzione del processo di assegnazione dei punteggi batch

I processi di assegnazione dei punteggi batch richiedono in genere del tempo per elaborare l'intero set di input.

È possibile usare l'interfaccia della riga di comando job show per visualizzare il processo. Eseguire il codice seguente per controllare lo stato del processo dall'endpoint precedente invoke. Per altre informazioni sui comandi dei processi, eseguire az ml job -h.

STATUS=$(az ml job show -n $JOB_NAME --query status -o tsv)
echo $STATUS
if [[ $STATUS == "Completed" ]]
then
  echo "Job completed"
elif [[ $STATUS ==  "Failed" ]]
then
  echo "Job failed"
  exit 1
else 
  echo "Job status not failed or completed"
  exit 2
fi

Controllare i risultati dell'assegnazione dei punteggi batch

Seguire questa procedura per visualizzare i risultati di assegnazione dei punteggi in Azure Storage Explorer al completamento del processo:

  1. Eseguire il codice seguente per aprire il processo di assegnazione dei punteggi batch in studio di Azure Machine Learning. Il collegamento di Job Studio è incluso anche nella risposta di invoke, come valore di interactionEndpoints.Studio.endpoint.

    az ml job show -n $JOB_NAME --web
    
  2. Nel grafico del processo selezionare il batchscoring passaggio.

  3. Selezionare la scheda Output e log e quindi selezionare Mostra output dei dati.

  4. In Output dati selezionare l'icona per aprire Storage Explorer.

    Screenshot di Studio che mostra la posizione degli output dei dati.

    I risultati di assegnazione dei punteggi in Storage Explorer sono simili alla pagina di esempio seguente:

    Screenshot dell'output di assegnazione dei punteggi.

Aggiunta di distribuzioni a un endpoint

Dopo aver creato un endpoint batch con una distribuzione, è possibile continuare a perfezionare il modello e aggiungere nuove distribuzioni. Gli endpoint batch continueranno a gestire la distribuzione predefinita durante lo sviluppo e la distribuzione di nuovi modelli nello stesso endpoint. Le distribuzioni non possono influire l'una sull'altra.

In questo esempio si apprenderà come aggiungere una seconda distribuzione che risolve lo stesso problema MNIST, ma usando un modello compilato con Keras e TensorFlow.

Aggiunta di una seconda distribuzione

  1. Creare un ambiente in cui verrà eseguita la distribuzione batch. Includere nell'ambiente qualsiasi dipendenza richiesta dal codice per l'esecuzione. È anche necessario aggiungere la libreria azureml-core perché è necessaria per il funzionamento delle distribuzioni batch. La definizione di ambiente seguente include le librerie necessarie per eseguire un modello con TensorFlow.

    Non è necessario alcun passaggio aggiuntivo per l'interfaccia della riga di comando di Azure Machine Learning. La definizione dell'ambiente verrà inclusa nel file di distribuzione come ambiente anonimo.

    Il file conda usato ha l'aspetto seguente:

    deployment-keras/environment/conda.yml

    name: tensorflow-env
    channels:
      - conda-forge
    dependencies:
      - python=3.8.5
      - pip
      - pip:
        - pandas
        - tensorflow
        - pillow
        - azureml-core
        - azureml-dataset-runtime[fuse]
    
  2. Creare uno script di assegnazione dei punteggi per il modello:

    deployment-keras/code/batch_driver.py

    import os
    import numpy as np
    import pandas as pd
    import tensorflow as tf
    from typing import List
    from os.path import basename
    from PIL import Image
    from tensorflow.keras.models import load_model
    
    
    def init():
        global model
    
        # AZUREML_MODEL_DIR is an environment variable created during deployment
        model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model")
    
        # load the model
        model = load_model(model_path)
    
    
    def run(mini_batch: List[str]) -> pd.DataFrame:
        print(f"Executing run method over batch of {len(mini_batch)} files.")
    
        results = []
        for image_path in mini_batch:
            data = Image.open(image_path)
            data = np.array(data)
            data_batch = tf.expand_dims(data, axis=0)
    
            # perform inference
            pred = model.predict(data_batch)
    
            # Compute probabilities, classes and labels
            pred_prob = tf.math.reduce_max(tf.math.softmax(pred, axis=-1)).numpy()
            pred_class = tf.math.argmax(pred, axis=-1).numpy()
    
            results.append(
                {
                    "file": basename(image_path),
                    "class": pred_class[0],
                    "probability": pred_prob,
                }
            )
    
        return pd.DataFrame(results)
    
  3. Creare una definizione di distribuzione

    deployment-keras/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchDeployment.schema.json
    name: mnist-keras-dpl
    description: A deployment using Keras with TensorFlow to solve the MNIST classification dataset.
    endpoint_name: mnist-batch
    model: 
      path: model
    code_configuration:
      code: code
      scoring_script: batch_driver.py
    environment:
      name: batch-tensorflow-py38
      image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
      conda_file: environment/conda.yml
    compute: azureml:batch-cluster
    resources:
      instance_count: 1
    max_concurrency_per_instance: 2
    mini_batch_size: 10
    output_action: append_row
    output_file_name: predictions.csv
    
  4. Creare la distribuzione:

    Eseguire il codice seguente per creare una distribuzione batch nell'endpoint batch e impostarla come distribuzione predefinita.

    az ml batch-deployment create --file deployment-keras/deployment.yml --endpoint-name $ENDPOINT_NAME
    

    Suggerimento

    Il --set-default parametro non è presente in questo caso. Come procedura consigliata per gli scenari di produzione, è possibile creare una nuova distribuzione senza impostarla come predefinita, verificarla e aggiornare la distribuzione predefinita in un secondo momento.

Testare una distribuzione batch non predefinita

Per testare la nuova distribuzione non predefinita, è necessario conoscere il nome della distribuzione che si vuole eseguire.

DEPLOYMENT_NAME="mnist-keras-dpl"
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --deployment-name $DEPLOYMENT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Viene --deployment-name usato per specificare la distribuzione che si vuole eseguire. Questo parametro consente di eseguire invoke una distribuzione non predefinita e non aggiornerà la distribuzione predefinita dell'endpoint batch.

Aggiornare la distribuzione batch predefinita

Anche se è possibile richiamare una distribuzione specifica all'interno di un endpoint, in genere si vuole richiamare l'endpoint stesso e consentire all'endpoint di decidere quale distribuzione usare. Tale distribuzione è denominata distribuzione "predefinita". In questo modo è possibile modificare la distribuzione predefinita e quindi modificare il modello che gestisce la distribuzione senza modificare il contratto con l'utente che richiama l'endpoint. Usare le istruzioni seguenti per aggiornare la distribuzione predefinita:

az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

Eliminare l'endpoint batch e la distribuzione

Se non si userà la distribuzione batch precedente, è consigliabile eliminarla eseguendo il codice seguente. --yes viene usato per confermare l'eliminazione.

az ml batch-deployment delete --name mnist-torch-dpl --endpoint-name $ENDPOINT_NAME --yes

Eseguire il codice seguente per eliminare l'endpoint batch e tutte le distribuzioni sottostanti. I processi di assegnazione dei punteggi batch non verranno eliminati.

az ml batch-endpoint delete --name $ENDPOINT_NAME --yes

Passaggi successivi