Esercitazione: Azure Machine Learning in un giorno

Articolo
03/06/2023
13 minuti per la lettura

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

Informazioni su come un data scientist usa Azure Machine Learning per eseguire il training di un modello, quindi usare il modello per la stima. Questa esercitazione consente di acquisire familiarità con i concetti di base di Azure Machine Learning e l'utilizzo più comune.

Si apprenderà come inviare un processo di comando per eseguire lo script di training in una risorsa di calcolo specificata, configurata con l'ambiente di processo necessario per eseguire lo script.

Lo script di training gestisce la preparazione dei dati, quindi esegue il training e registra un modello. Dopo aver creato il modello, verrà distribuito come endpoint, quindi chiamare l'endpoint per l'inferenza.

I passaggi da eseguire sono:

Connettersi all'area di lavoro di Azure Machine Learning
Creare la risorsa di calcolo e l'ambiente del processo
Creare lo script di training
Creare ed eseguire il processo di comando per eseguire lo script di training nella risorsa di calcolo, 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

Prerequisiti

Completare l'avvio rapido: Introduzione ad Azure Machine Learning :
- Creare un'area di lavoro.
- Creare un'istanza di calcolo basata sul cloud da usare per l'ambiente di sviluppo.
Creare un nuovo notebook o copiare il notebook.
- Seguire la guida introduttiva: Eseguire juypter notebook in studio di Azure Machine Learning passaggi per creare un nuovo notebook.
- In alternativa, usare la procedura descritta nella guida introduttiva per clonare la cartella esercitazioni v2, quindi aprire il notebook dalle esercitazioni/azureml-in-a-day/azureml-in-a-day.ipynb nella sezione File .

Eseguire il notebook

Nella barra superiore selezionare l'istanza di calcolo creata durante l'avvio rapido: Introduzione ad Azure Machine Learning da usare per l'esecuzione del notebook.
Assicurarsi 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.

Screenshot: Impostare il kernel.

Importante

Il resto di questa esercitazione contiene celle del notebook dell'esercitazione. Copiare/incollarli nel nuovo notebook o passare al notebook ora se è stato clonato.

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.

Connettersi all'area di lavoro

Prima di esaminare il codice, è necessario connettersi all'area di lavoro di Azure Machine Learning. 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.

Si usa DefaultAzureCredential per ottenere l'accesso all'area di lavoro. DefaultAzureCredential viene usato per gestire la maggior parte degli scenari di autenticazione di Azure SDK.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

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

Nella barra degli strumenti superiore studio di Azure Machine Learning destra selezionare il nome dell'area di lavoro.
Copiare il valore per l'area di lavoro, il gruppo di risorse e l'ID sottoscrizione nel codice.
Sarà necessario copiare un valore, chiudere l'area e incollare, quindi tornare per quello successivo.

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

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

Il risultato è un gestore dell'area di lavoro che si userà per gestire altre risorse e processi.

Importante

La creazione di MLClient non si connetterà all'area di lavoro. L'inizializzazione client è lazy, attende la prima volta che deve eseguire una chiamata (nel notebook seguente, che si verificherà durante la creazione di calcolo).

Creare una risorsa di calcolo per eseguire il processo

È necessaria una risorsa di calcolo per l'esecuzione di un processo. Può essere un computer singolo o multi-nodo con il sistema operativo Linux o Windows o un'infrastruttura di calcolo specifica come Spark.

Si eseguirà il provisioning di un cluster di calcolo Linux. Vedere l'elenco completo delle dimensioni e dei prezzi delle macchine virtuali .

Per questo esempio, è necessario solo un cluster di base, quindi si userà un modello di Standard_DS3_v2 con 2 core vCPU, 7 GB di RAM e si creerà un calcolo di Azure Machine Learning.

from azure.ai.ml.entities import AmlCompute

# Name assigned to the compute cluster
cpu_compute_target = "cpu-cluster"

try:
    # let's see if the compute target already exists
    cpu_cluster = ml_client.compute.get(cpu_compute_target)
    print(
        f"You already have a cluster named {cpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new cpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    cpu_cluster = AmlCompute(
        name=cpu_compute_target,
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_DS3_V2",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )
    print(
        f"AMLCompute with name {cpu_cluster.name} will be created, with compute size {cpu_cluster.size}"
    )
    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster)

Creare un ambiente del processo

Per eseguire il processo di Azure Machine Learning nella risorsa di calcolo, è necessario un ambiente. Un ambiente elenca il runtime software e le librerie che si desidera installare nel calcolo in cui si esegue il training. È simile all'ambiente Python nel computer locale.

Azure Machine Learning offre molti ambienti pronti o curati, utili per scenari di training e inferenza comuni. È anche possibile creare ambienti personalizzati usando un'immagine docker o una configurazione conda.

In questo esempio si creerà un ambiente conda personalizzato per i processi usando un file yaml conda.

Creare prima di tutto una directory in cui archiviare il file.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Creare ora il file nella directory delle dipendenze. La cella seguente usa IPython magic per scrivere il file nella directory appena creata.

%%writefile {dependencies_dir}/conda.yml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 1.26.1
    - azureml-mlflow==1.42.0
    - psutil>=5.8,<5.9
    - tqdm>=4.59,<4.60
    - ipykernel~=6.0
    - matplotlib

La specifica contiene alcuni pacchetti consueti che verranno usati nel processo (numpy, pip).

Fare riferimento a questo file yaml per creare e registrare questo ambiente personalizzato nell'area di lavoro:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yml"),
    image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

print(
    f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)

Che cos'è un processo di comando?

Si creerà un processo di comando di Azure Machine Learning per eseguire il training di un modello per la stima predefinita del credito. Il processo di comando viene usato per eseguire uno script di training in un ambiente specificato in una risorsa di calcolo specificata. È già stato creato l'ambiente e la risorsa di calcolo. Successivamente si creerà lo script di training.

Lo script di training gestisce la preparazione dei dati, il training e la registrazione del modello sottoposto a training. In questa esercitazione verrà creato uno script di training Python.

I processi di comando possono essere eseguiti dall'interfaccia dell'interfaccia della riga di comando, Python SDK o studio. In questa esercitazione si userà Azure Machine Learning Python SDK v2 per creare ed eseguire il processo di comando.

Dopo aver eseguito il processo di training, si distribuirà il modello, quindi usarlo per produrre una stima.

Creare uno script di training

Iniziamo creando lo script di training: il file Python main.py .

Creare prima una cartella di origine per lo script:

import os

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

Questo script gestisce il pre-elaborazione dei dati, suddividendolo in dati di test e di training. Utilizza quindi questi dati per eseguire il training di un modello basato su albero e restituire il modello di output.

MLFlow verrà usato per registrare i parametri e le metriche durante l'esecuzione della pipeline.

La cella seguente usa IPython magic 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_excel(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ò vedere in questo 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.

Configurare il comando

Ora che si dispone di uno script che può eseguire le attività desiderate, si userà il comando per utilizzo generico che può eseguire azioni della riga di comando . Questa azione della riga di comando può essere chiamata direttamente ai comandi di sistema o eseguendo uno script.

In questo caso verranno create variabili di input per specificare i dati di input, il rapporto di suddivisione, la frequenza di apprendimento e il nome del modello registrato. Lo script di comando:

Usare il calcolo creato in precedenza per eseguire questo comando.
Usare l'ambiente creato in precedenza: è possibile usare la @latest notazione per indicare la versione più recente dell'ambiente quando viene eseguito il comando.
Configurare alcuni metadati come il nome visualizzato, il nome dell'esperimento e così via. Un esperimento è un contenitore per tutte le iterazioni eseguite in un determinato progetto. Tutti i processi inviati con lo stesso nome dell'esperimento verranno elencati tra loro in studio di Azure Machine Learning.
Configurare l'azione della riga di comando stessa, python main.py in questo caso. Gli input/output sono accessibili nel comando tramite la ${{ ... }} notazione.

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://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls",
        ),
        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="aml-scikit-learn@latest",
    compute="cpu-cluster",
    experiment_name="train_model_credit_default_prediction",
    display_name="credit_default_prediction",
)

Inviare il processo

È ora possibile inviare il processo da eseguire in Azure Machine Learning. Questa volta si userà create_or_update su ml_client.jobs.

ml_client.create_or_update(job)

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

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

L'output di questo processo sarà simile al seguente nel studio di Azure Machine Learning. Esplorare le schede per vari dettagli, ad esempio metriche, output e così via. Al termine, il processo registrerà un modello nell'area di lavoro in seguito al training.

Screenshot che mostra la panoramica del processo

Importante

Attendere il completamento dello stato del processo prima di tornare a questo 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 calcolo è 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 di Azure, un .online endpoint

Per distribuire un servizio di Machine Learning, è in genere necessario:

Asset del modello (file, metadati) da distribuire. Questi asset sono già stati registrati nel processo di training.
Codice da eseguire come servizio. Il codice esegue il modello in una determinata richiesta di input. Questo script di immissione riceve i dati inviati a un servizio Web distribuito e lo passa al modello, quindi restituisce la risposta del modello al client. Lo script è specifico del modello. Lo script di immissione deve comprendere i dati previsti e restituiti dal modello. Con un modello MLFlow, come in questa esercitazione, questo script viene creato automaticamente. Gli esempi di script di assegnazione dei punteggi sono disponibili qui.

Creare un nuovo endpoint online

Dopo aver creato un modello registrato e uno script di inferenza, è possibile creare l'endpoint online. Il nome dell'endpoint deve essere univoco nell'intera 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]

Nota

La creazione dell'endpoint richiederà da circa 6 a 8 minuti.

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}")

Dopo aver creato un 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

Dopo aver creato l'endpoint, distribuire il modello con lo script di immissione. Ogni endpoint può avere più distribuzioni. È possibile specificare il traffico diretto a queste distribuzioni usando le regole. Verrà creata una singola distribuzione che gestisce il 100% del traffico in ingresso. È stato scelto un nome di colore per la distribuzione, ad esempio blu, verde, distribuzioni rosse , che è arbitrario.

È possibile controllare la pagina Modelli nel studio di Azure Machine Learning per identificare la versione più recente del modello registrato. In alternativa, il codice seguente recupererà 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)]
)

Distribuire la versione più recente del modello.

Nota

Si prevede che questa distribuzione richiederà da circa 6 a 8 minuti.

# 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)


# create an online deployment.
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()

Eseguire test con una query di esempio

Ora che il modello viene distribuito nell'endpoint, è possibile eseguirne l'inferenza.

Creare un file di richiesta di esempio seguendo la progettazione prevista nel metodo run nello script del 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 intende usare l'endpoint, eliminarlo per interrompere l'uso della risorsa. Assicurarsi che nessun'altra distribuzione usi un endpoint prima di eliminarla.

Nota

Si prevede che questo passaggio impieva da circa 6 a 8 minuti.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

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 non si prevede di usare alcuna risorsa creata, eliminarle in modo da non sostenere alcun addebito:

Nel portale di Azure fare clic su Gruppi di risorse all'estrema sinistra.
Nell'elenco selezionare il gruppo di risorse creato.
Selezionare Elimina gruppo di risorse.
Immettere il nome del gruppo di risorse. Selezionare Elimina.

Passaggi successivi

Convertire questa esercitazione in una pipeline pronta per la produzione con componenti riutilizzabili.
Informazioni su tutte le opzioni di distribuzione per Azure Machine Learning.
Informazioni su come eseguire l'autenticazione al modello distribuito.

Esercitazione: Azure Machine Learning in un giorno

Prerequisiti

Eseguire il notebook

Connettersi all'area di lavoro

Creare una risorsa di calcolo per eseguire il processo

Creare un ambiente del processo

Che cos'è un processo di comando?

Creare uno 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

Eliminare tutto

Passaggi successivi

Risorse aggiuntive

Risorse aggiuntive