Avvio rapido: Iniziare a usare il servizio Azure Machine Learning

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

Questa esercitazione fornisce un'introduzione ad alcune delle funzionalità più usate del servizio Azure Machine Learning. Verrà creato, registrato e distribuito un modello. Questa esercitazione consente di acquisire familiarità con i concetti di base di Azure Machine Learning e i metodi di utilizzo più comuni.

Si apprenderà come eseguire un processo di training in una risorsa di calcolo scalabile, quindi distribuirlo e infine testare la distribuzione.

Verrà creato uno script di training per gestire la preparazione dei dati, eseguire il training di un modello e registrarlo. Dopo aver eseguito il training del modello, lo si distribuirà come endpoint e quindi si chiamerà l'endpoint per l'inferenza.

Ecco i passaggi da eseguire:

• Configurare un handle all'area di lavoro di Azure Machine Learning
• Creare lo script di training
• Creare una risorsa di calcolo scalabile, un cluster di elaborazione
• Creare ed eseguire un processo di comando che eseguirà lo script di training nel cluster di elaborazione, configurato con l'ambiente di processo appropriato
• Visualizzare l'output dello script di training
• Distribuire il modello appena sottoposto a training come endpoint
• Chiamare l'endpoint di Azure Machine Learning per l'inferenza

Per una panoramica dei passaggi di questo argomento di avvio rapido, guardare questo video.

Prerequisiti

1. Per usare Azure Machine Learning, è prima di tutto necessaria un'area di lavoro. Se non è disponibile, completare Creare le risorse necessarie per iniziare creare un'area di lavoro e ottenere maggiori informazioni su come usarla.

2. Accedere allo studio e selezionare l'area di lavoro se non è già aperta.

3. Aprire o creare un notebook nell'area di lavoro:

   • Creare un nuovo notebook, se si vuole copiare/incollare il codice nelle celle.
   • In alternativa, aprire tutorials/get-started-notebooks/quickstart.ipynb dalla sezione Esempi dello studio. Selezionare quindi Clona per aggiungere il notebook in File. Vedere dove trovare gli esempi.

Impostare il kernel

1. Nella barra superiore sopra il notebook aperto creare un'istanza di ambiente di calcolo, se non ne è già disponibile una.

   

2. Se l'istanza di ambiente di calcolo è arrestata, selezionare Avviare ambiente di calcolo e attendere fino a quando non è in esecuzione.

   

3. Assicurarsi che il kernel, visualizzato in alto a destra, sia Python 3.10 - SDK v2. In caso contrario, usare l'elenco a discesa per selezionare questo kernel.

   

4. Se viene visualizzato un banner che indica che è necessario eseguire l'autenticazione, selezionare Autentica.

Importante

La parte rimanente di questa esercitazione contiene le celle del notebook dell'esercitazione. Copiarle e incollarle nel nuovo notebook oppure passare al notebook, se è stato clonato.

Creare un handle all'area di lavoro

Prima di approfondire il codice, è necessario un modo per fare riferimento all'area di lavoro. L'area di lavoro è la risorsa di primo livello per Azure Machine Learning, che fornisce una posizione centralizzata da cui gestire tutti gli artefatti creati quando si usa Azure Machine Learning.

Verrà creato un oggetto ml_client per un handle all'area di lavoro. Sarà quindi possibile usare ml_client per gestire le risorse e i processi.

Nella cella successiva immettere l'ID sottoscrizione, il nome del gruppo di risorse e il nome dell'area di lavoro. Per trovare questi valori:

1. In alto a destra nella barra degli strumenti dello studio di Azure Machine Learning selezionare il nome dell'area di lavoro.
2. Copiare i valori per l'area di lavoro, il gruppo di risorse e l'ID sottoscrizione nel codice.
3. Sarà necessario copiare un valore, chiudere l'area e incollarlo, quindi tornare indietro per quello successivo.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

SUBSCRIPTION="<SUBSCRIPTION_ID>"
RESOURCE_GROUP="<RESOURCE_GROUP>"
WS_NAME="<AML_WORKSPACE_NAME>"
# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id=SUBSCRIPTION,
    resource_group_name=RESOURCE_GROUP,
    workspace_name=WS_NAME,
)

Nota

La creazione di MLClient non comporta la connessione all'area di lavoro. L'inizializzazione del client avviene in modo differito e viene attesa la prima volta in cui è necessario effettuare una chiamata (questa operazione verrà eseguita nella cella di codice successiva).

# Verify that the handle works correctly.  
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location,":", ws.resource_group)

Creare lo script di training

Per iniziare, creare lo script di training, ovvero il file Python main.py.

Creare prima di tutto una cartella di origine per lo script:

import os

train_src_dir = "./src"
os.makedirs(train_src_dir, exist_ok=True)

Lo script gestisce la pre-elaborazione dei dati, suddividendoli in dati di test e di training. Usa quindi i dati per eseguire il training di un modello basato su albero e restituisce il modello di output.

Si userà MLflow per registrare i parametri e le metriche durante l'esecuzione della pipeline.

La cella seguente usa un magic IPython per scrivere lo script di training nella directory appena creata.

%%writefile {train_src_dir}/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)
    
    credit_df = pd.read_csv(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

    ##################
    #<train the model>
    ##################
    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))
    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Come si può notare nello script, una volta eseguito il training del modello, il file del modello viene salvato e registrato nell'area di lavoro. È ora possibile usare il modello registrato negli endpoint di inferenza.

Potrebbe essere necessario selezionare Aggiorna per visualizzare la nuova cartella e lo script in File.

Configurare il comando

Ora che si dispone di uno script in grado di eseguire le attività desiderate e di un cluster di elaborazione per eseguire lo script, si userà un comando per utilizzo generico in grado di eseguire le azioni della riga di comando. Questa azione della riga di comando può chiamare direttamente i comandi di sistema o eseguire uno script.

In questo caso si creeranno variabili di input per specificare i dati di input, il rapporto di suddivisione, la velocità di apprendimento e il nome del modello registrato. Lo script di comando eseguirà le operazioni seguenti:

• Utilizzo di un ambiente che definisce le librerie software e di runtime necessarie per lo script di training. Azure Machine Learning fornisce molti ambienti curati o pronti, utili per scenari di training e inferenza comuni. In questo caso si userà uno di questi ambienti. In Esercitazione: Eseguire il training di un modello in Azure Machine Learning si apprenderà come creare un ambiente personalizzato.
• Configurazione dell'azione della riga di comando, in questo caso python main.py. Gli input/output sono accessibili nel comando tramite la notazione ${{ ... }}.
• In questo esempio si accede ai dati da un file in Internet.
• Poiché non è stata specificata una risorsa di calcolo, lo script verrà eseguito in un cluster di elaborazione serverless creato automaticamente.

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

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    display_name="credit_default_prediction",
)

Inviare il processo

È ora possibile inviare il processo per l'esecuzione in Azure Machine Learning. Questa volta si userà create_or_update in ml_client.

ml_client.create_or_update(job)

Visualizzare l'output del processo e attendere il completamento del processo

Visualizzare il processo nello studio di Azure Machine Learning selezionando il collegamento nell'output della cella precedente.

L'output di questo processo sarà simile al seguente nello studio di Azure Machine Learning. Esplorare le schede per visualizzare diversi dettagli, ad esempio metriche, output e così via. Al termine, il processo registrerà un modello nell'area di lavoro come risultato del training.

Importante

Attendere fino a quando lo stato del processo non risulta completato prima di tornare al notebook per continuare. L'esecuzione del processo richiederà da 2 a 3 minuti. Potrebbe essere necessario più tempo (fino a 10 minuti) se il cluster di elaborazione è stato ridotto a zero nodi e l'ambiente personalizzato è ancora in fase di compilazione.

Distribuire il modello come endpoint online

Distribuire ora il modello di Machine Learning come servizio Web nel cloud Azure, come oggetto online endpoint.

Per distribuire un servizio di Machine Learning, si userà il modello registrato.

Creare un nuovo endpoint online

Ora che si dispone di un modello registrato, è possibile creare l'endpoint online. Il nome dell'endpoint deve essere univoco all'interno dell'area di Azure. Per questa esercitazione si creerà un nome univoco usando UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]

Creare l'endpoint:

# Expect the endpoint creation to take a few minutes
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

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

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

Nota

La creazione dell'endpoint richiederà alcuni minuti.

Dopo aver creato l'endpoint, è possibile recuperarlo come indicato di seguito:

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

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

Distribuire il modello nell'endpoint

Una volta creato l'endpoint, distribuire il modello con lo script di immissione. Un endpoint batch può avere più distribuzioni. È possibile specificare che il traffico venga diretto a queste distribuzioni usando le regole. In questo caso verrà creata una singola distribuzione che gestisce tutto il traffico in ingresso. Per le distribuzioni sono stati usati nomi di colori, ad esempio blue, green, red, ma si tratta di una scelta arbitraria.

È possibile esaminare la pagina Modelli nello studio di Azure Machine Learning per identificare la versione più recente del modello registrato. In alternativa, il codice seguente consente di recuperare il numero di versione più recente da usare.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)
print(f'Latest model is version "{latest_model_version}" ')

Distribuire la versione più recente del modello.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)

# Expect this deployment to take approximately 6 to 8 minutes.
# create an online deployment.
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.
# Learn more on https://azure.microsoft.com/pricing/details/machine-learning/.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

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

Nota

La distribuzione richiederà circa da 6 a 8 minuti.

Al termine della distribuzione, sarà possibile testarla.

Eseguire test con una query di esempio

Dopo aver distribuito il modello nell'endpoint, è possibile eseguire l'inferenza.

Creare un file di richiesta di esempio seguendo la progettazione prevista nel metodo run nello script di punteggio.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)

%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Pulire le risorse

Se non si prevede di usare l'endpoint, eliminarlo per interrompere l'uso della risorsa. Prima di eliminare l'endpoint, assicurarsi che nessun'altra distribuzione lo stia usando.

Nota

L'eliminazione completa può richiedere circa 20 minuti.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Arrestare l'istanza di ambiente di calcolo

Se non si prevede di usare subito l'istanza di ambiente di calcolo, arrestarla:

1. Nell'area di spostamento a sinistra nello studio selezionare Ambiente di calcolo.
2. Nelle schede in alto selezionare Istanze di ambiente di calcolo
3. Selezionare l'istanza di ambiente di calcolo nell'elenco.
4. Sulla barra degli strumenti in alto selezionare Arresta.

Eliminare tutte le risorse

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:

1. Nel portale di Azure fare clic su Gruppi di risorse all'estrema sinistra.

2. Nell'elenco selezionare il gruppo di risorse creato.

3. Selezionare Elimina gruppo di risorse.

   

4. Immettere il nome del gruppo di risorse. Quindi seleziona Elimina.

Passaggi successivi

Ora che si ha un'idea delle operazioni associate al training e alla distribuzione di un modello, è possibile eseguire queste esercitazioni per altre informazioni sul processo:

Esercitazione	Descrizione
Caricare i dati, accedervi ed esplorarli in Azure Machine Learning	Archiviare dati di grandi dimensioni nel cloud e recuperarli da notebook e script
Sviluppo di modelli in una workstation cloud	Iniziare a creare prototipi e sviluppare modelli di Machine Learning
Eseguire il training di un modello in Azure Machine Learning	Approfondire i dettagli del training di un modello
Distribuire un modello come endpoint online	Approfondire i dettagli della distribuzione di un modello
Creare pipeline di Machine Learning di produzione	Suddividere un'attività di Machine Learning completa in un flusso di lavoro in più passaggi.