Distribuire modelli di Machine Learning in Azure

  • Articolo

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1Azureml di Python SDK v1

Informazioni su come distribuire il modello di Machine Learning o Deep Learning come servizio Web nel cloud di Azure.

Nota

Gli endpoint di Azure Machine Learning (v2) offrono un'esperienza di distribuzione migliorata e più semplice. Gli endpoint supportano sia scenari di inferenza in tempo reale che batch. Gli endpoint forniscono un'interfaccia unificata per richiamare e gestire le distribuzioni di modelli tra tipi di calcolo. Vedere Che cosa sono gli endpoint di Azure Machine Learning?.

Flusso di lavoro per la distribuzione di un modello

Il flusso di lavoro è simile indipendentemente dal punto in cui si distribuisce il modello:

  1. Registrare il modello.
  2. Preparare uno script di voce.
  3. Preparare una configurazione di inferenza.
  4. Distribuire il modello in locale per assicurarsi che tutto funzioni.
  5. Scegliere una destinazione di calcolo.
  6. Distribuire il modello nel cloud.
  7. Testare il servizio Web risultante.

Per altre informazioni sui concetti coinvolti nel flusso di lavoro di distribuzione di Machine Learning, vedere Gestire, distribuire e monitorare i modelli con Azure Machine Learning.

Prerequisiti

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

Importante

I comandi dell'interfaccia della riga di comando di Azure in questo articolo richiedono l'estensione azure-cli-ml, o v1, per Azure Machine Learning. Il supporto per l'estensione v1 terminerà il 30 settembre 2025. Sarà possibile installare e usare l'estensione v1 fino a tale data.

È consigliabile passare all'estensione , o v2, prima del ml30 settembre 2025. Per altre informazioni sull'estensione v2, vedere Estensione dell'interfaccia della riga di comando di Azure ML e Python SDK v2.

Connettersi all'area di lavoro

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

Per visualizzare le aree di lavoro a cui si ha accesso, usare i comandi seguenti:

az login
az account set -s <subscription>
az ml workspace list --resource-group=<resource-group>

Registrare il modello

Una situazione tipica per un servizio di Machine Learning distribuito è che sono necessari i componenti seguenti:

  • Risorse che rappresentano il modello specifico da distribuire, ad esempio un file di modello pytorch.
  • Codice in esecuzione nel servizio che esegue il modello in un determinato input.

Azure Machine Learnings consente di separare la distribuzione in due componenti separati, in modo da poter mantenere lo stesso codice, aggiornando semplicemente il modello. Viene definito il meccanismo in base al quale si carica un modello separatamente dal codice come "registrazione del modello".

Quando si registra un modello, il modello viene caricato nel cloud (nell'account di archiviazione predefinito dell'area di lavoro) e quindi montato nello stesso ambiente di calcolo in cui è in esecuzione il servizio Web.

Negli esempi seguenti viene illustrato come registrare un modello.

Importante

È consigliabile usare solo i modelli creati o ottenuti da un'origine attendibile. I modelli serializzati andranno trattati come codice, perché sono state individuate vulnerabilità di sicurezza in numerosi formati più diffusi. Inoltre, è possibile che venga intenzionalmente eseguito il training dei modelli con finalità dannose, per fornire un output errato o non accurato.

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

I comandi seguenti scaricano un modello e quindi lo registrano con l'area di lavoro di Azure Machine Learning:

wget https://aka.ms/bidaf-9-model -O model.onnx --show-progress
az ml model register -n bidaf_onnx \
    -p ./model.onnx \
    -g <resource-group> \
    -w <workspace-name>

Impostare -p sul percorso di una cartella o di un file che si vuole registrare.

Per altre informazioni su az ml model register, vedere la documentazione di riferimento.

Registrare un modello da un processo di training di Azure Machine Learning

Se è necessario registrare un modello creato in precedenza tramite un processo di training di Azure Machine Learning, è possibile specificare l'esperimento, l'esecuzione e il percorso del modello:

az ml model register -n bidaf_onnx --asset-path outputs/model.onnx --experiment-name myexperiment --run-id myrunid --tag area=qna

Il --asset-path parametro fa riferimento alla posizione cloud del modello. In questo esempio viene usato il percorso di un singolo file. Per includere più file nella registrazione del modello, impostare --asset-path sul percorso di una cartella contenente i file.

Per altre informazioni su az ml model register, vedere la documentazione di riferimento.

Nota

È anche possibile registrare un modello da un file locale tramite il portale dell'interfaccia utente dell'area di lavoro.

Attualmente sono disponibili due opzioni per caricare un file di modello locale nell'interfaccia utente:

  • Dai file locali, che registrano un modello v2.
  • Dai file locali (in base al framework) che registrano un modello v1.

Si noti che solo i modelli registrati tramite i file locali (basati sull'ingresso del framework) ( noti come modelli v1) possono essere distribuiti come servizi Web usando SDKv1/CLIv1.

Definire uno script di immissione fittizio

Lo script di avvio riceve i dati inviati a un servizio Web distribuito e li passa al modello. Restituisce quindi la risposta del modello al client. Lo script è specifico del modello. Lo script di immissione deve comprendere i dati previsti e restituiti dal modello.

Le due operazioni da eseguire nello script di immissione sono:

  1. Caricamento del modello (usando una funzione denominata init())
  2. Esecuzione del modello sui dati di input (usando una funzione denominata run())

Per la distribuzione iniziale, usare uno script di immissione fittizio che stampa i dati ricevuti.

import json


def init():
    print("This is init")


def run(data):
    test = json.loads(data)
    print(f"received data {test}")
    return f"test is {test}"

Salvare il file come echo_score.py all'interno di una directory denominata source_dir. Questo script fittizio restituisce i dati inviati, quindi non usa il modello. È tuttavia utile per testare che lo script di assegnazione dei punteggi sia in esecuzione.

Definire una configurazione di inferenza

Una configurazione di inferenza descrive il contenitore e i file Docker da usare durante l'inizializzazione del servizio Web. Tutti i file all'interno della directory di origine, incluse le sottodirectory, verranno compressi e caricati nel cloud quando si distribuisce il servizio Web.

La configurazione di inferenza seguente specifica che la distribuzione di Machine Learning userà il file echo_score.py nella ./source_dir directory per elaborare le richieste in ingresso e che userà l'immagine Docker con i pacchetti Python specificati nell'ambiente project_environment .

È possibile usare qualsiasi ambiente di inferenza di Azure Machine Learning curato come immagine Docker di base durante la creazione dell'ambiente di progetto. Verranno installate le dipendenze necessarie nella parte superiore e l'immagine Docker risultante verrà archiviata nel repository associato all'area di lavoro.

Nota

Il caricamento della directory di origine dell'inferenza di Azure Machine Learning non rispetta .gitignore o .amlignore

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

Una configurazione di inferenza minima può essere scritta come segue:

{
    "entryScript": "echo_score.py",
    "sourceDirectory": "./source_dir",
    "environment": {
        "docker": {
            "arguments": [],
            "baseDockerfile": null,
            "baseImage": "mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04",
            "enabled": false,
            "sharedVolumes": true,
            "shmSize": null
        },
        "environmentVariables": {
            "EXAMPLE_ENV_VAR": "EXAMPLE_VALUE"
        },
        "name": "my-deploy-env",
        "python": {
            "baseCondaEnvironment": null,
            "condaDependencies": {
                "channels": [],
                "dependencies": [
                    "python=3.6.2",
                    {
                        "pip": [
                            "azureml-defaults"
                        ]
                    }
                ],
                "name": "project_environment"
            },
            "condaDependenciesFile": null,
            "interpreterPath": "python",
            "userManagedDependencies": false
        },
        "version": "1"
    }
}

Salvare il file con il nome dummyinferenceconfig.json.

Vedere questo articolo per una descrizione più approfondita delle configurazioni di inferenza.

Definire una configurazione di distribuzione

Una configurazione di distribuzione specifica la quantità di memoria e core necessari per l'esecuzione del servizio Web. Fornisce anche i dettagli di configurazione del servizio Web sottostante. Ad esempio, una configurazione di distribuzione consente di specificare che il servizio necessita di 2 gigabyte di memoria, 2 core CPU, 1 core GPU e che si vuole abilitare la scalabilità automatica.

Le opzioni disponibili per una configurazione di distribuzione variano a seconda della destinazione di calcolo scelta. In una distribuzione locale è possibile specificare solo la porta in cui verrà gestito il servizio Web.

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

Le voci del documento deploymentconfig.json vengono associate ai parametri di LocalWebservice.deploy_configuration. La tabella seguente descrive il mapping tra le entità nel documento JSON e i parametri per il metodo:

Entità JSON Parametro per il metodo Descrizione
computeType ND La destinazione di calcolo. Per le destinazioni locali, il valore deve essere local.
port port La porta locale su cui esporre l'endpoint HTTP del servizio.

Il codice JSON seguente è un esempio di configurazione della distribuzione da usare con l'interfaccia della riga di comando:

{
    "computeType": "local",
    "port": 32267
}

Salvare questo codice JSON come file denominato deploymentconfig.json.

Per altre informazioni, vedere lo schema di distribuzione.

Distribuire il modello di Machine Learning

È ora possibile distribuire il modello.

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

Sostituire bidaf_onnx:1 con il nome del modello e il relativo numero di versione.

az ml model deploy -n myservice \
    -m bidaf_onnx:1 \
    --overwrite \
    --ic dummyinferenceconfig.json \
    --dc deploymentconfig.json \
    -g <resource-group> \
    -w <workspace-name>

Chiamare il modello

Verificare che il modello echo sia stato distribuito correttamente. Dovrebbe essere possibile eseguire una semplice richiesta di attività, nonché una richiesta di assegnazione dei punteggi:

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

curl -v http://localhost:32267
curl -v -X POST -H "content-type:application/json" \
    -d '{"query": "What color is the fox", "context": "The quick brown fox jumped over the lazy dog."}' \
    http://localhost:32267/score

Definire uno script di immissione

È ora possibile caricare effettivamente il modello. Prima di tutto, modificare lo script di immissione:

import json
import numpy as np
import os
import onnxruntime
from nltk import word_tokenize
import nltk


def init():
    nltk.download("punkt")
    global sess
    sess = onnxruntime.InferenceSession(
        os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model.onnx")
    )


def run(request):
    print(request)
    text = json.loads(request)
    qw, qc = preprocess(text["query"])
    cw, cc = preprocess(text["context"])

    # Run inference
    test = sess.run(
        None,
        {"query_word": qw, "query_char": qc, "context_word": cw, "context_char": cc},
    )
    start = np.asscalar(test[0])
    end = np.asscalar(test[1])
    ans = [w for w in cw[start : end + 1].reshape(-1)]
    print(ans)
    return ans


def preprocess(word):
    tokens = word_tokenize(word)

    # split into lower-case word tokens, in numpy array with shape of (seq, 1)
    words = np.asarray([w.lower() for w in tokens]).reshape(-1, 1)

    # split words into chars, in numpy array with shape of (seq, 1, 1, 16)
    chars = [[c for c in t][:16] for t in tokens]
    chars = [cs + [""] * (16 - len(cs)) for cs in chars]
    chars = np.asarray(chars).reshape(-1, 1, 1, 16)
    return words, chars

Salvare il file come score.py all'interno di source_dir.

Si noti l'uso della AZUREML_MODEL_DIR variabile di ambiente per individuare il modello registrato. Ora che sono stati aggiunti alcuni pacchetti pip.

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

{
    "entryScript": "score.py",
    "sourceDirectory": "./source_dir",
    "environment": {
        "docker": {
            "arguments": [],
            "baseDockerfile": null,
            "baseImage": "mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04",
            "enabled": false,
            "sharedVolumes": true,
            "shmSize": null
        },
        "environmentVariables": {
            "EXAMPLE_ENV_VAR": "EXAMPLE_VALUE"
        },
        "name": "my-deploy-env",
        "python": {
            "baseCondaEnvironment": null,
            "condaDependencies": {
                "channels": [],
                "dependencies": [
                    "python=3.6.2",
                    {
                        "pip": [
                            "azureml-defaults",
                            "nltk",
                            "numpy",
                            "onnxruntime"
                        ]
                    }
                ],
                "name": "project_environment"
            },
            "condaDependenciesFile": null,
            "interpreterPath": "python",
            "userManagedDependencies": false
        },
        "version": "2"
    }
}

Salvare il file con nome inferenceconfig.json

Distribuire di nuovo e chiamare il servizio

Distribuire di nuovo il servizio:

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

Sostituire bidaf_onnx:1 con il nome del modello e il relativo numero di versione.

az ml model deploy -n myservice \
    -m bidaf_onnx:1 \
    --overwrite \
    --ic inferenceconfig.json \
    --dc deploymentconfig.json \
    -g <resource-group> \
    -w <workspace-name>

Assicurarsi quindi di poter inviare una richiesta post al servizio:

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

curl -v -X POST -H "content-type:application/json" \
    -d '{"query": "What color is the fox", "context": "The quick brown fox jumped over the lazy dog."}' \
    http://localhost:32267/score

Scegliere una destinazione di calcolo

La destinazione di calcolo usata per ospitare il modello influirà sul costo e sulla disponibilità dell'endpoint distribuito. Usare questa tabella per scegliere una destinazione di calcolo appropriata.

Destinazione del calcolo Utilizzo Supporto GPU Descrizione
Servizio Web locale Test/debug   Usare per attività limitate di test e risoluzione dei problemi. L'accelerazione hardware dipende dall'uso di librerie nel sistema locale.
Endpoint di Azure Machine Learning (solo SDK/interfaccia della riga di comando v2) Inferenza in tempo reale

Inferenza batch		 Sì Calcolo completamente gestito per gli endpoint online gestiti e il punteggio batch (endpoint batch) nel calcolo serverless.
Azure Machine Learning Kubernetes Inferenza in tempo reale

Inferenza batch		 Sì Eseguire carichi di lavoro di inferenza in cluster Kubernetes locali, cloud e perimetrali.
Istanze di Azure Container (solo SDK/CLI v1) Inferenza in tempo reale

Consigliato solo per scopi di sviluppo/test.		   Usare per carichi di lavoro basati su CPU su scala ridotta che richiedono meno di 48 GB di RAM. Non è necessario gestire un cluster.

Supportato nella finestra di progettazione.

Nota

Per la scelta dello SKU di un cluster, aumentare prima le risorse dei sistemi esistenti e poi il numero di sistemi. Iniziare con un computer dotato del 150% della RAM richiesta dal modello, profilare il risultato e trovare un computer con le prestazioni necessarie. Dopo aver appreso questo, aumentare il numero di computer in base all'esigenza di inferenza simultanea.

Nota

Le istanze del contenitore richiedono l'SDK o l'interfaccia della riga di comando v1 e sono adatte solo per i modelli di piccole dimensioni inferiori a 1 GB.

Distribuire nel cloud

Dopo aver confermato che il servizio funziona in locale e ha scelto una destinazione di calcolo remota, è possibile distribuire nel cloud.

Modificare la configurazione di distribuzione in modo che corrisponda alla destinazione di calcolo scelta, in questo caso Istanze di Azure Container:

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

Le opzioni disponibili per una configurazione di distribuzione differiscono a seconda della destinazione di calcolo scelta.

{
    "computeType": "aci",
    "containerResourceRequirements":
    {
        "cpu": 0.5,
        "memoryInGB": 1.0
    },
    "authEnabled": true,
    "sslEnabled": false,
    "appInsightsEnabled": false
}

Salvare questo file come re-deploymentconfig.json.

Per altre informazioni, vedere questo riferimento.

Distribuire di nuovo il servizio:

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

Sostituire bidaf_onnx:1 con il nome del modello e il relativo numero di versione.

az ml model deploy -n myservice \
    -m bidaf_onnx:1 \
    --overwrite \
    --ic inferenceconfig.json \
    --dc re-deploymentconfig.json \
    -g <resource-group> \
    -w <workspace-name>

Per visualizzare i log del servizio, usare il comando seguente:

az ml service get-logs -n myservice \
    -g <resource-group> \
    -w <workspace-name>

Chiamare il servizio Web remoto

Quando si distribuisce in remoto, potrebbe essere abilitata l'autenticazione delle chiavi. Nell'esempio seguente viene illustrato come ottenere la chiave del servizio con Python per effettuare una richiesta di inferenza.

import requests
import json
from azureml.core import Webservice

service = Webservice(workspace=ws, name="myservice")
scoring_uri = service.scoring_uri

# If the service is authenticated, set the key or token
key, _ = service.get_keys()

# Set the appropriate headers
headers = {"Content-Type": "application/json"}
headers["Authorization"] = f"Bearer {key}"

# Make the request and display the response and logs
data = {
    "query": "What color is the fox",
    "context": "The quick brown fox jumped over the lazy dog.",
}
data = json.dumps(data)
resp = requests.post(scoring_uri, data=data, headers=headers)
print(resp.text)
print(service.get_logs())

Vedere l'articolo sulle applicazioni client per l'utilizzo di servizi Web per altri client di esempio in altre lingue.

Come configurare i messaggi di posta elettronica nello studio

Per iniziare a ricevere messaggi di posta elettronica quando il processo, l'endpoint online o l'endpoint batch è stato completato o se si verifica un problema (non riuscito, annullato), seguire questa procedura:

  1. In Azure ML Studio passare alle impostazioni selezionando l'icona a forma di ingranaggio.
  2. Selezionare la scheda notifiche Email.
  3. Attivare o disabilitare le notifiche di posta elettronica per un evento specifico.

Screenshot delle impostazioni di Azure ML Studio nella scheda Notifiche tramite posta elettronica.

Informazioni sullo stato del servizio

Durante la distribuzione del modello, è possibile che lo stato del servizio venga modificato durante la distribuzione completa.

La tabella seguente descrive i diversi stati del servizio:

Stato del servizio Web Descrizione Stato finale?
Transizione Il servizio si trova nel processo di distribuzione. No
Unhealthy Il servizio è stato distribuito ma attualmente non è raggiungibile. No
Non programmabile Il servizio non può essere distribuito in questo momento a causa della mancanza di risorse. No
Non riuscito Il servizio non è riuscito a distribuire a causa di un errore o un arresto anomalo. Sì
Healthy Il servizio è integro e l'endpoint è disponibile. Sì

Suggerimento

Durante la distribuzione, le immagini Docker per le destinazioni di calcolo vengono compilate e caricate da Registro Azure Container (ACR). Per impostazione predefinita, Azure Machine Learning crea un Registro Azure Machine Learning che usa il livello di servizio di base . La modifica del Registro Azure Container per l'area di lavoro a livello standard o Premium può ridurre il tempo necessario per compilare e distribuire immagini nelle destinazioni di calcolo. Per altre informazioni, vedere Livelli di servizio di Registro Azure Container.

Nota

Se si distribuisce un modello nel servizio Azure Kubernetes, è consigliabile abilitare Monitoraggio di Azure per il cluster. Ciò consente di comprendere l'integrità complessiva del cluster e l'utilizzo delle risorse. Potrebbero essere utili anche le risorse seguenti:

Se si sta tentando di distribuire un modello in un cluster non integro o sovraccarico, è prevedibile che si verifichino problemi. Per risolvere i problemi del cluster del servizio Azure Kubernetes, contattare il supporto del servizio Azure Kubernetes.

Eliminare le risorse

SI APPLICA A:Estensione ml dell'interfaccia della riga di comando di Azure v1

# Get the current model id
import os

stream = os.popen(
    'az ml model list --model-name=bidaf_onnx --latest --query "[0].id" -o tsv'
)
MODEL_ID = stream.read()[0:-1]
MODEL_ID
az ml service delete -n myservice
az ml service delete -n myaciservice
az ml model delete --model-id=<MODEL_ID>

Per eliminare un servizio Web distribuito, usare az ml service delete <name of webservice>.

Per eliminare un modello registrato dall'area di lavoro, usare az ml model delete <model id>

Altre informazioni sull'eliminazione di un servizio Web ed eliminazione di un modello.

Passaggi successivi