Esercitazione: Eseguire il training di un modello di classificazione immagini e distribuirlo con un notebook Jupyter di esempio

Articolo
10/16/2024

In questa esercitazione si eseguirà il training di un modello di Machine Learning su risorse di calcolo remote. Si usa il flusso di lavoro per il training e la distribuzione di Azure Machine Learning in un notebook di Jupyter per Python. È quindi possibile usare il notebook come modello per eseguire il training di un modello di Machine Learning con i propri dati di training.

Questa esercitazione esegue il training di una semplice regressione logistica usando il set di dati MNIST e scikit-learn con Azure Machine Learning. MNIST è un set di dati noto costituito da 70.000 immagini in scala di grigi. Ogni immagine è una cifra in stile scrittura a mano di 28x28 pixel, che rappresenta un numero compreso tra zero e nove. L'obiettivo è creare un classificatore multiclasse per identificare la cifra rappresentata da una determinata immagine.

Si apprenderà a eseguire le operazioni seguenti:

Scaricare un set di dati ed esaminare i dati.
Eseguire il training di un modello di classificazione immagini e registrare le metriche con MLflow.
Distribuire il modello per eseguire l'inferenza in tempo reale.

Prerequisiti

Completare Avvio rapido: Iniziare a usare il servizio Azure Machine Learning per:
- Creare un'area di lavoro.
- Creare un'istanza di ambiente di calcolo basata sul cloud da usare per l'ambiente di sviluppo.

Eseguire un notebook dall'area di lavoro

Azure Machine Learning include un server notebook cloud nell'area di lavoro per un'esperienza preconfigurata senza installazioni. Se si preferisce avere il controllo sull'ambiente, sui pacchetti e sulle dipendenze, usare il proprio ambiente.

Clonare una cartella del notebook

Completare la configurazione dell'esperimento seguente ed eseguire i passaggi in Azure Machine Learning Studio. Questa interfaccia consolidata include gli strumenti di Machine Learning per eseguire scenari di data science per professionisti con tutti i livelli di competenze.

Accedere ad Azure Machine Learning Studio.
Selezionare la sottoscrizione e l'area di lavoro create.
Selezionare Notebook a sinistra.
Selezionare la scheda Esempi in alto.
Aprire la cartella SDK v1.
Selezionare il pulsante ... a destra della cartella tutorials e quindi scegliere Clone (Clona).
Viene visualizzato un elenco di cartelle che mostra ogni utente che accede all'area di lavoro. Selezionare la propria cartella per clonare la cartella tutorials al suo interno.

Aprire il notebook clonato

Aprire la cartella tutorials clonata nella sezione File utente.
Selezionare il file quickstart-azureml-in-10mins.ipynb dalla cartella tutorials/compute-instance-quickstarts/quickstart-azureml-in-10mins.

Installare i pacchetti

Quando l'istanza di ambiente di calcolo è in esecuzione e viene visualizzato il kernel, aggiungere una nuova cella di codice per installare i pacchetti necessari per questa esercitazione.

Nella parte superiore del notebook aggiungere una cella di codice.
Aggiungere quanto segue nella cella e quindi eseguire la cella usando lo strumento Esegui o premendo MAIUSC+INVIO.
```
%pip install scikit-learn==0.22.1
%pip install scipy==1.5.2
```

Potrebbero essere visualizzati alcuni avvisi di installazione. Tali errori possono essere ignorati.

Eseguire il notebook

Questa esercitazione e il file utils.py associato sono disponibili in GitHub se si vuole usarli nel proprio ambiente locale. Se non si usa l'istanza di ambiente di calcolo, aggiungere %pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib all'installazione precedente.

Importante

Il resto di questo articolo contiene lo stesso contenuto visualizzato nel notebook.

Passare ora al notebook Jupyter se si vuole eseguire il codice durante la lettura. Per eseguire una singola cella di codice in un notebook, fare clic sulla cella di codice e premere MAIUSC + INVIO. In alternativa, eseguire l'intero notebook scegliendo Esegui tutto dalla barra degli strumenti superiore.

Importare i dati

Prima di eseguire il training di un modello, è necessario conoscere i dati usati per il training. In questa sezione si apprenderà come:

Scaricare il set di dati MNIST
Visualizzare alcune immagini di esempio

Usare set di dati aperti di Azure per ottenere i file di dati MNIST non elaborati. I set di dati aperti di Azure sono set di dati pubblici curati che è possibile usare per aggiungere funzionalità specifiche dello scenario alle soluzioni di Machine Learning e ottenere modelli migliori. Per ogni set di dati è disponibile una classe corrispondente, in questo caso MNIST, per recuperare i dati in modi diversi.

import os
from azureml.opendatasets import MNIST

data_folder = os.path.join(os.getcwd(), "/tmp/qs_data")
os.makedirs(data_folder, exist_ok=True)

mnist_file_dataset = MNIST.get_file_dataset()
mnist_file_dataset.download(data_folder, overwrite=True)

Esaminare i dati

Caricare i file compressi in matrici numpy. Usare quindi matplotlib per tracciare 30 immagini casuali dal set di dati con le etichette al di sopra.

Per questo passaggio è necessaria una funzione load_data inclusa in un file utils.py. Questo file viene inserito nella stessa cartella del notebook. La funzione load_data si limita ad analizzare i file compressi in matrici numpy.

from utils import load_data
import matplotlib.pyplot as plt
import numpy as np
import glob


# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the model converge faster.
X_train = (
    load_data(
        glob.glob(
            os.path.join(data_folder, "**/train-images-idx3-ubyte.gz"), recursive=True
        )[0],
        False,
    )
    / 255.0
)
X_test = (
    load_data(
        glob.glob(
            os.path.join(data_folder, "**/t10k-images-idx3-ubyte.gz"), recursive=True
        )[0],
        False,
    )
    / 255.0
)
y_train = load_data(
    glob.glob(
        os.path.join(data_folder, "**/train-labels-idx1-ubyte.gz"), recursive=True
    )[0],
    True,
).reshape(-1)
y_test = load_data(
    glob.glob(
        os.path.join(data_folder, "**/t10k-labels-idx1-ubyte.gz"), recursive=True
    )[0],
    True,
).reshape(-1)


# now let's show some randomly chosen images from the traininng set.
count = 0
sample_size = 30
plt.figure(figsize=(16, 6))
for i in np.random.permutation(X_train.shape[0])[:sample_size]:
    count = count + 1
    plt.subplot(1, sample_size, count)
    plt.axhline("")
    plt.axvline("")
    plt.text(x=10, y=-10, s=y_train[i], fontsize=18)
    plt.imshow(X_train[i].reshape(28, 28), cmap=plt.cm.Greys)
plt.show()

Il codice consente di visualizzare un set casuale di immagini con le relative etichette, simile al seguente:

Immagini di esempio con le relative etichette.

Eseguire il training del modello e registrare le metriche con MLflow

Eseguire il training del modello usando il codice seguente. Questo codice usa l'assegnazione automatica di MLflow per tenere traccia delle metriche e degli artefatti del modello di log.

Per classificare i dati, si userà il classificatore LogisticRegression del framework scikit-learn.

Nota

Il training del modello richiede circa due minuti.

# create the model
import mlflow
import numpy as np
from sklearn.linear_model import LogisticRegression
from azureml.core import Workspace

# connect to your workspace
ws = Workspace.from_config()

# create experiment and start logging to a new run in the experiment
experiment_name = "azure-ml-in10-mins-tutorial"

# set up MLflow to track the metrics
mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())
mlflow.set_experiment(experiment_name)
mlflow.autolog()

# set up the Logistic regression model
reg = 0.5
clf = LogisticRegression(
    C=1.0 / reg, solver="liblinear", multi_class="auto", random_state=42
)

# train the model
with mlflow.start_run() as run:
    clf.fit(X_train, y_train)

Visualizzare l'esperimento

Nel menu a sinistra nello studio di Azure Machine Learning selezionare Processi e quindi selezionare il processo (azure-ml-in10-mins-tutorial). Un processo è un raggruppamento di più esecuzioni da uno script o da codice specificato. È possibile raggruppare più processi in un esperimento.

Le informazioni per l'esecuzione vengono archiviate in tale processo. Se il nome non esiste quando si invia un processo, quando si seleziona l'esecuzione verranno visualizzate varie schede contenenti metriche, log, spiegazioni e così via.

Implementare il controllo della versione per i modelli con il registro dei modelli

È possibile usare la registrazione dei modelli per archiviare i modelli e crearne le relative versioni nell'area di lavoro. I modelli registrati sono identificati dal nome e dalla versione. Ogni volta che si registra un modello con lo stesso nome di uno esistente, il registro incrementa la versione. Il codice seguente consente di registrare e creare una versione per il modello sottoposto a training in precedenza. Dopo aver eseguito la cella di codice seguente, il modello verrà visualizzato nel Registro di sistema selezionando Modelli nel menu a sinistra in Azure Machine Learning Studio.

# register the model
model_uri = "runs:/{}/model".format(run.info.run_id)
model = mlflow.register_model(model_uri, "sklearn_mnist_model")

Distribuire il modello per l'inferenza in tempo reale

In questa sezione viene illustrato come distribuire un modello in modo che un'applicazione possa utilizzare (tramite inferenza) il modello in REST.

Creare la configurazione della distribuzione

La cella di codice ottiene un ambiente curato, che specifica tutte le dipendenze necessarie per ospitare il modello, ad esempio i pacchetti come scikit-learn. Viene creata anche una configurazione di distribuzione, che specifica la quantità di ambiente di calcolo necessaria per ospitare il modello. In questo caso, il calcolo ha 1CPU e 1 GB di memoria.

# create environment for the deploy
from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.webservice import AciWebservice

# get a curated environment
env = Environment.get(
    workspace=ws, 
    name="AzureML-sklearn-1.0"
)
env.inferencing_stack_version='latest'

# create deployment config i.e. compute resources
aciconfig = AciWebservice.deploy_configuration(
    cpu_cores=1,
    memory_gb=1,
    tags={"data": "MNIST", "method": "sklearn"},
    description="Predict MNIST with sklearn",
)

Distribuire un modello

Questa cella di codice successiva consente di distribuire il modello nell'istanza di Azure Container.

Nota

La distribuzione richiede circa tre minuti. Ma potrebbe essere più lungo fino a quando non è disponibile per l'uso, ad esempio fino a 15 minuti.**

%%time
import uuid
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment
from azureml.core.model import Model

# get the registered model
model = Model(ws, "sklearn_mnist_model")

# create an inference config i.e. the scoring script and environment
inference_config = InferenceConfig(entry_script="score.py", environment=env)

# deploy the service
service_name = "sklearn-mnist-svc-" + str(uuid.uuid4())[:4]
service = Model.deploy(
    workspace=ws,
    name=service_name,
    models=[model],
    inference_config=inference_config,
    deployment_config=aciconfig,
)

service.wait_for_deployment(show_output=True)

Il file di script di assegnazione dei punteggi a cui si fa riferimento nel codice precedente è disponibile nella stessa cartella del notebook e include due funzioni:

Funzione init eseguita una volta all'avvio del servizio. In questa funzione si ottiene in genere il modello dal registro e si impostano le variabili globali
Funzione run(data) eseguita ogni volta che viene effettuata una chiamata al servizio. In questa funzione si formattano in genere i dati di input, si esegue una previsione e si restituisce il risultato previsto.

Visualizzare l'endpoint

Dopo aver distribuito correttamente il modello, è possibile visualizzare l'endpoint passando a Endpoint nel menu a sinistra nello studio di Azure Machine Learning. Si visualizzerà lo stato dell'endpoint (integro/non integro), i log e l'utilizzo (informazioni sull'utilizzo del modello da parte delle applicazioni).

Testare il servizio modello

È possibile testare il modello inviando una richiesta HTTP non elaborata per testare il servizio Web.

# send raw HTTP request to test the web service.
import requests

# send a random row from the test set to score
random_index = np.random.randint(0, len(X_test) - 1)
input_data = '{"data": [' + str(list(X_test[random_index])) + "]}"

headers = {"Content-Type": "application/json"}

resp = requests.post(service.scoring_uri, input_data, headers=headers)

print("POST to url", service.scoring_uri)
print("label:", y_test[random_index])
print("prediction:", resp.text)

Pulire le risorse

Se non si intende continuare a usare questo modello, eliminare il servizio modello usando:

# if you want to keep workspace and only delete endpoint (it will incur cost while running)
service.delete()

Se si intende controllare ulteriormente i costi, arrestare l'istanza di ambiente di calcolo selezionando il pulsante "Arresta ambiente di calcolo" accanto all'elenco a discesa Calcolo. Sarà quindi possibile avviare di nuovo l'istanza di ambiente di calcolo quando necessario.

Eliminare tutto

Usare questa procedura per eliminare l'area di lavoro di Azure Machine Learning e tutte le risorse di calcolo.

Importante

Le risorse create possono essere usate come prerequisiti per altre esercitazioni e procedure dettagliate per Azure Machine Learning.

Se le risorse create non servono più, eliminarle per evitare addebiti:

Nella casella di ricerca della portale di Azure immettere Gruppi di risorse e selezionarlo nei risultati.
Nell'elenco selezionare il gruppo di risorse creato.
Nella pagina Panoramica selezionare Elimina gruppo di risorse.
Immettere il nome del gruppo di risorse. Quindi seleziona Elimina.

Informazioni su tutte le opzioni di distribuzione di Azure Machine Learning.
Informazioni su come eseguire l'autenticazione al modello distribuito.
Eseguire stime su grandi quantità di dati in modo asincrono.
Monitorare i modelli di Azure Machine Learning con Application Insights.

Condividi tramite

Esercitazione: Eseguire il training di un modello di classificazione immagini e distribuirlo con un notebook Jupyter di esempio

Prerequisiti

Eseguire un notebook dall'area di lavoro

Clonare una cartella del notebook

Aprire il notebook clonato

Installare i pacchetti

Eseguire il notebook

Importare i dati

Esaminare i dati

Eseguire il training del modello e registrare le metriche con MLflow

Visualizzare l'esperimento

Implementare il controllo della versione per i modelli con il registro dei modelli

Distribuire il modello per l'inferenza in tempo reale

Creare la configurazione della distribuzione

Distribuire un modello

Visualizzare l'endpoint

Testare il servizio modello

Pulire le risorse

Eliminare tutto

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Esercitazione: Eseguire il training di un modello di classificazione immagini e distribuirlo con un notebook Jupyter di esempio

Prerequisiti

Eseguire un notebook dall'area di lavoro

Clonare una cartella del notebook

Aprire il notebook clonato

Installare i pacchetti

Eseguire il notebook

Importare i dati

Esaminare i dati

Eseguire il training del modello e registrare le metriche con MLflow

Visualizzare l'esperimento

Implementare il controllo della versione per i modelli con il registro dei modelli

Distribuire il modello per l'inferenza in tempo reale

Creare la configurazione della distribuzione

Distribuire un modello

Visualizzare l'endpoint

Testare il servizio modello

Pulire le risorse

Eliminare tutto

Risorse correlate

Commenti e suggerimenti

Risorse aggiuntive