Avvio rapido: Iniziare a usare il servizio Azure Machine Learning

Articolo
10/16/2024

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. Viene 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.

Viene creato uno script di training per gestire la preparazione dei dati, eseguire il training e registrare un modello. Dopo aver eseguito il training, il modello viene distribuito in un endpoint, quindi viene chiamato l'endpoint per l'inferenza.

I passaggi da eseguire sono:

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

Per usare Azure Machine Learning, è 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.
Accedere allo studio e selezionare l'area di lavoro, se non è già aperta.
Aprire o creare un notebook nell'area di lavoro:
- Se si vuole copiare e incollare il codice nelle celle, creare un nuovo notebook.
- In alternativa, aprire tutorials/get-started-notebooks/quickstart.ipynb dalla sezione Esempi dello studio. Selezionare quindi Clona per aggiungere il notebook in File. Per trovare notebook di esempio, vedere Learn from sample notebooks (Informazioni sui notebook di esempio).

Impostare il kernel e aprirlo in Visual Studio Code (VS Code)

Nella barra superiore sopra il notebook aperto creare un'istanza di ambiente di calcolo, se non ne è già disponibile una.
Se l'istanza di ambiente di calcolo viene arrestata, selezionare Avviare ambiente di calcolo e attendere fino a quando non è in esecuzione.
Attendere che l'istanza di calcolo sia in esecuzione. Assicurarsi quindi che il kernel, trovato in alto a destra, sia Python 3.10 - SDK v2. In caso contrario, usare l'elenco a discesa per selezionare questo kernel.

Se questo kernel non viene visualizzato, verificare che l'istanza di calcolo sia in esecuzione. In caso affermativo, selezionare il pulsante Aggiorna in alto a destra del notebook.
Se viene visualizzato un banner che indica che è necessario eseguire l'autenticazione, selezionare Autentica.
È possibile eseguire il notebook qui o aprirlo in VS Code per usare un ambiente di sviluppo integrato (IDE) completo con la potenza delle risorse di Azure Machine Learning. Selezionare Apri in VS Code, quindi selezionare l'opzione Web o desktop. Quando viene avviato in questo modo, VS Code viene collegato all'istanza di ambiente di calcolo, al kernel e al file system dell'area di lavoro.

Importante

La parte rimanente di questa esercitazione contiene le celle del notebook dell'esercitazione. Copiarli e incollarli nel nuovo notebook oppure passare ora 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 ml_client per un handle nell'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:

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

Screenshot: trovare le credenziali per il codice in alto a destra della barra degli strumenti.

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 restituire il modello di output.

Viene usato 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.

Screenshot che mostra l'icona di aggiornamento.

Configurare il comando

Ora che è disponibile uno script che può eseguire le attività desiderate e di un cluster di elaborazione per eseguire lo script, viene usato un comando per utilizzo generico che può eseguire le azioni della riga di comando. Questa azione della riga di comando può chiamare direttamente comandi di sistema o eseguire uno script.

In questo caso vengono create 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. Nell'Esercitazione: Eseguire il training di un modello in Azure Machine Learning si apprenderà come creare un ambiente personalizzato.
Configurerà l'azione della riga di comando stessa, 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://registries/azureml/environments/sklearn-1.5/labels/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 in Azure Machine Learning Studio. Esplorare le schede per visualizzare diversi dettagli, ad esempio metriche, output e così via. Al termine, la processo registra un modello nell'area di lavoro come risultato del training.

Screenshot che mostra la pagina di panoramica per il processo.

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 Machine Learning, viene usato 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, viene creato 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 viene creata una singola distribuzione che gestisce il 100% del traffico in ingresso. È stato scelto un nome colore per la distribuzione, ad esempio distribuzioni blu, verde, rossa, arbitrariamente.

È 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 dell'ultima versione 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:

Nell'area di spostamento a sinistra nello studio selezionare Ambiente di calcolo.
Nelle schede in alto selezionare Istanze di ambiente di calcolo
Selezionare l'istanza di ambiente di calcolo nell'elenco.
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:

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.

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.

Condividi tramite

Avvio rapido: Iniziare a usare il servizio Azure Machine Learning

Prerequisiti

Impostare il kernel e aprirlo in Visual Studio Code (VS Code)

Creare un handle all'area di lavoro

Creare lo script di training

Configurare il comando

Inviare il processo

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

Distribuire il modello come endpoint online

Creare un nuovo endpoint online

Distribuire il modello nell'endpoint

Eseguire test con una query di esempio

Pulire le risorse

Arrestare l'istanza di ambiente di calcolo

Eliminare tutte le risorse

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive