Esercitazione: Eseguire il training di un modello in Azure Machine Learning

Articolo
11/15/2023

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. In questo esempio viene usato il set di dati della carta di credito associato per illustrare come usare Azure Machine Learning per un problema di classificazione. L'obiettivo è prevedere se un cliente ha una probabilità elevata di impostazione predefinita per un pagamento con carta di credito.

Lo script di training gestisce la preparazione dei dati, quindi esegue il training e registra un modello. Questa esercitazione illustra i passaggi per inviare un processo di training basato sul cloud (processo di comando). Per altre informazioni su come caricare i dati in Azure, vedere Esercitazione: Caricare, accedere ed esplorare i dati in Azure Machine Learning. I passaggi sono:

Ottenere un handle per l'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 e l'origine dati
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

Questo video illustra come iniziare a usare studio di Azure Machine Learning in modo da poter seguire i passaggi dell'esercitazione. Il video illustra come creare un notebook, creare un'istanza di calcolo e clonare il notebook. I passaggi sono descritti anche nelle sezioni seguenti.

Prerequisiti

Per usare Azure Machine Learning, è prima necessaria un'area di lavoro. Se non è disponibile, completare Creare risorse necessarie per iniziare a creare un'area di lavoro e altre informazioni sull'uso.
Accedere allo studio e selezionare l'area di lavoro se non è già aperta.
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/train-model.ipynb dalla sezione Esempi di Studio. Selezionare quindi Clona per aggiungere il notebook ai file. Vedere dove trovare esempi.

Impostare il kernel

Nella barra superiore sopra il notebook aperto creare un'istanza di calcolo se non ne è già disponibile una.
Se l'istanza di calcolo viene arrestata, selezionare Avvia calcolo e attendere fino a quando non è in esecuzione.
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.
Se viene visualizzato un banner che indica che è necessario eseguire l'autenticazione, selezionare Autentica.

Importante

Il resto di questa esercitazione contiene celle del notebook dell'esercitazione. Copia/incollali nel nuovo notebook o passa ora al notebook se è stato clonato.

Usare un processo di comando per eseguire il training di un modello in Azure Machine Learning

Per eseguire il training di un modello, è necessario inviare un processo. Il tipo di processo che verrà inviato in questa esercitazione è un processo di comando. Azure Machine Learning offre diversi tipi di processi per il training dei modelli. Gli utenti possono selezionare il metodo di training in base alla complessità del modello, delle dimensioni dei dati e dei requisiti di velocità di training. In questa esercitazione si apprenderà come inviare un processo di comando per eseguire uno script di training.

Un processo di comando è una funzione che consente di inviare uno script di training personalizzato per eseguire il training del modello. Può anche essere definito come processo di training personalizzato. Un processo di comando in Azure Machine Learning è un tipo di processo che esegue uno script o un comando in un ambiente specificato. È possibile usare i processi di comando per eseguire il training di modelli, elaborare i dati o qualsiasi altro codice personalizzato da eseguire nel cloud.

In questa esercitazione verrà illustrato l'uso di un processo di comando per creare un processo di training personalizzato che verrà usato per eseguire il training di un modello. Per qualsiasi processo di training personalizzato, sono necessari gli elementi seguenti:

dell'ambiente di
data
processo di comando
script di training

In questa esercitazione verranno forniti tutti questi elementi per l'esempio: creazione di un classificatore per stimare i clienti che hanno una probabilità elevata di impostazione predefinita nei pagamenti con carta di credito.

Creare un handle nell'area di lavoro

Prima di approfondire il codice, è necessario un modo per fare riferimento all'area di lavoro. Si creerà ml_client un handle per l'area di lavoro. Si userà ml_client quindi per gestire risorse e 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:

Nella barra degli strumenti in alto a destra studio di Azure Machine Learning 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 incollarlo, quindi tornare 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 si connetterà all'area di lavoro. L'inizializzazione del client è differita e attende per la prima volta che deve 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 un ambiente di 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 da installare nel calcolo in cui verrà eseguito il training. È simile all'ambiente Python nel computer locale.

Azure Machine Learning offre molti ambienti curati o pronti, utili per scenari di training e inferenza comuni.

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)

La cella seguente usa IPython magic per scrivere il file conda nella directory appena creata.

%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=1.0.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - mlflow==2.8.0
    - mlflow-skinny==2.8.0
    - azureml-mlflow==1.51.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"

custom_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults job",
    tags={"scikit-learn": "1.0.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
custom_job_env = ml_client.environments.create_or_update(custom_job_env)

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

Configurare un processo di training usando la funzione di comando

Si crea 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 esegue uno script di training in un ambiente specificato in una risorsa di calcolo specificata. L'ambiente e il cluster di calcolo sono già stati creati. Successivamente si creerà lo script di training. In questo caso specifico, viene eseguito il training del set di dati per produrre un classificatore usando il GradientBoostingClassifier modello.

Lo script di training gestisce la preparazione, il training e la registrazione dei dati del modello sottoposto a training. Il metodo train_test_split gestisce la suddivisione del set di dati in dati di test e training. In questa esercitazione si creerà uno script di training Python.

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

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

Questo script gestisce la pre-elaborazione dei dati, suddividendoli in dati di test ed eseguirne il training. Usa quindi questi dati per eseguire il training di un modello basato su albero e restituire il modello di output.

MLFlow viene usato per registrare i parametri e le metriche durante il processo. Il pacchetto MLFlow consente di tenere traccia delle metriche e dei risultati per ogni modello di Azure train. Si userà MLFlow per ottenere prima di tutto il modello migliore per i dati, quindi si visualizzeranno le metriche del modello in Azure Studio.

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

    #Split train and test datasets
    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()

In questo script, una volta eseguito il training del modello, il file del modello viene salvato e registrato nell'area di lavoro. La registrazione del modello consente di archiviare e aggiornare i modelli nel cloud di Azure nell'area di lavoro. Dopo aver registrato un modello, è possibile trovare tutti gli altri modelli registrati in un'unica posizione in Azure Studio denominata registro dei modelli. Il Registro modelli consente di organizzare e tenere traccia dei modelli sottoposti a training.

Configurare il comando

Ora che si dispone di uno script in grado di eseguire l'attività di classificazione, usare il comando per utilizzo generico che può eseguire azioni della riga di comando. Questa azione della riga di comando può chiamare direttamente i comandi di sistema o eseguendo uno script.

In questo caso, creare variabili di input per specificare i dati di input, il rapporto di divisione, la frequenza di apprendimento e il nome del modello registrato. Lo script di 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 l'azione della riga di comando stessa python main.py , in questo caso. Gli input/output sono accessibili nel comando tramite la ${{ ... }} notazione .
Poiché non è stata specificata una risorsa di calcolo, lo script verrà eseguito in un cluster di calcolo 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="aml-scikit-learn@latest",
    display_name="credit_default_prediction",
)

Inviare il processo

È ora possibile inviare il processo da eseguire in studio di Azure Machine Learning. Questa volta si userà create_or_update in ml_client. ml_client è una classe client che consente di connettersi alla sottoscrizione di Azure usando Python e interagire con i servizi di Azure Machine Learning. ml_client consente di inviare i processi usando Python.

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 shows the overview page for the job.

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. Potrebbero essere necessari 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.

Quando si esegue la cella, l'output del notebook mostra un collegamento alla pagina dei dettagli del processo in Azure Studio. In alternativa, è anche possibile selezionare Processi nel menu di spostamento a sinistra. Un processo è un raggruppamento di molte esecuzioni da uno script o da una parte di codice specificata. Le informazioni per l'esecuzione vengono archiviate in tale processo. La pagina dei dettagli offre una panoramica del processo, il tempo necessario per l'esecuzione, quando è stato creato e così via. La pagina include anche schede per altre informazioni sul processo, ad esempio metriche, output e log e codice. Di seguito sono elencate le schede disponibili nella pagina dei dettagli del processo:

Panoramica: la sezione panoramica fornisce informazioni di base sul processo, inclusi lo stato, l'ora di inizio e di fine e il tipo di processo eseguito
Input: la sezione input elenca i dati e il codice usati come input per il processo. Questa sezione può includere set di dati, script, configurazioni dell'ambiente e altre risorse usate durante il training.
Output e log: la scheda Output e log contiene i log generati durante l'esecuzione del processo. Questa scheda consente di risolvere i problemi in caso di problemi con lo script di training o la creazione del modello.
Metriche: la scheda Metriche mostra le metriche principali del modello, ad esempio il punteggio di training, il punteggio f1 e il punteggio di precisione.

Pulire le risorse

Se si prevede di continuare ora ad altre esercitazioni, passare a Passaggi successivi.

Arrestare l'istanza di calcolo

Se non si intende usarlo ora, arrestare l'istanza di calcolo:

Nello studio, nell'area di spostamento a sinistra selezionare Calcolo.
Nelle schede superiori selezionare Istanze di calcolo
Selezionare l'istanza di calcolo nell'elenco.
Sulla barra degli strumenti superiore 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 non si prevede di usare alcuna delle risorse create, 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. Quindi seleziona Elimina.

Passaggi successivi

Informazioni sulla distribuzione di un modello

Distribuire un modello.

In questa esercitazione è stato usato un file di dati online. Per altre informazioni su altri modi per accedere ai dati, vedere Esercitazione: Caricare, accedere ed esplorare i dati in Azure Machine Learning.

Per altre informazioni sui diversi modi per eseguire il training dei modelli in Azure Machine Learning, vedere Che cos'è l'apprendimento automatico (AutoML)?. Machine Learning automatizzato è uno strumento supplementare per ridurre la quantità di tempo che un data scientist impiega per trovare un modello che funzioni meglio con i propri dati.

Per altri esempi simili a questa esercitazione, vedere la sezione Esempi di Studio. Questi stessi esempi sono disponibili nella pagina degli esempi di GitHub. Gli esempi includono notebook Python completi che è possibile eseguire il codice e imparare a eseguire il training di un modello. È possibile modificare ed eseguire script esistenti dagli esempi, contenenti scenari, tra cui classificazione, elaborazione del linguaggio naturale e rilevamento anomalie.

Condividi tramite

Esercitazione: Eseguire il training di un modello in Azure Machine Learning

Prerequisiti

Impostare il kernel

Usare un processo di comando per eseguire il training di un modello in Azure Machine Learning

Creare un handle nell'area di lavoro

Creare un ambiente di processo

Configurare un processo di training usando la funzione di comando

Creare uno script di training

Configurare il comando

Inviare il processo

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

Pulire le risorse

Arrestare l'istanza di calcolo

Eliminare tutte le risorse

Passaggi successivi

Risorse aggiuntive