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

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

Informazioni su come uno scienziato dei dati usa Azure Machine Learning per eseguire il training di un modello. In questo esempio si usa un set di dati con carta di credito per comprendere come usare Azure Machine Learning per un problema di classificazione. L'obiettivo è prevedere se un cliente ha una probabilità elevata di insolvenza per un pagamento con carta di credito. Lo script di training gestisce la preparazione dei dati. Lo script esegue quindi 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.

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

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/train-model.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)

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 viene arrestata, selezionare Avviare ambiente di calcolo e attendere fino a quando non è in esecuzione.

   

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

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

5. È 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.

   

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. 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. Questo processo 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.

Questa esercitazione è incentrata sull'uso di un processo di comando per creare un processo di training personalizzato 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

Questa esercitazione fornisce 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 all'area di lavoro

Prima di passare ai dettagli del codice, è necessario un modo per fare riferimento all'area di lavoro. Creare ml_client per un handle nell'area di lavoro. ml_client Usare 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:

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. È 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,
)

# 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 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 da installare nel calcolo in cui eseguire il training. È simile all'ambiente Python nel computer locale. Per altre informazioni, vedere Che cosa sono gli ambienti di Azure Machine Learning?

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

In questo esempio viene creato un ambiente conda personalizzato per i processi usando un file yaml conda.

Per prima cosa, creare una directory in cui archiviare il file.

import os

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

La cella successiva usa IPython magic per scrivere il file conda nella directory 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 usati nel processo, ad esempio numpy e pip.

Fare riferimento a questo file YAML per creare e registrare l'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 previsione di insolvenza 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. Creare quindi lo script di training. In questo caso, si sta eseguendo 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 suddivide il set di dati in dati di test e training. In questa esercitazione viene creato uno script di training Python.

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

Creare lo script di training

Per iniziare, creare lo script di training: 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 pre-elabora i dati, suddividerli in dati di test ed eseguirne il training. Usa quindi i 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 questo processo. Il pacchetto MLFlow consente di tenere traccia delle metriche e dei risultati per ogni modello di Azure train. Usare MLFlow per ottenere il modello migliore per i dati. Visualizzare quindi le metriche del modello in Azure Studio. Per altre informazioni, vedere MLflow e Azure Machine Learning.

%%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, dopo il training del modello, il file del modello viene salvato e registrato nell'area di lavoro. La registrazione del modello consente di archiviare i modelli e creare le relative versioni nel cloud di Azure, all'interno della propria 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 i modelli sottoposti a training e tenerne traccia.

Configurare il comando

Ora che è disponibile uno script in grado di eseguire l'attività di classificazione, usare il 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.

Creare variabili di input per specificare i dati di input, il rapporto di divisione, la frequenza di apprendimento e il nome del modello registrato. Script di comando:

• Usa l'ambiente creato in precedenza. Usare la @latest notazione per indicare la versione più recente dell'ambiente quando viene eseguito il comando.
• Configura l'azione della riga di comando stessa, python main.py in questo caso. È possibile accedere agli input e agli output nel comando usando ${{ ... }} la notazione .
• Poiché non è stata specificata una risorsa di calcolo, lo script viene 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

Inviare il processo da eseguire in studio di Azure Machine Learning. Questa volta, usare 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

Per visualizzare il processo in studio di Azure Machine Learning, selezionare 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 vari dettagli, ad esempio metriche, output e così via. Al termine del processo, registra un modello nell'area di lavoro in seguito al training.

Quando si esegue la cella, l'output del notebook mostra un collegamento alla pagina dei dettagli del processo in Machine Learning Studio. In alternativa, è anche possibile selezionare Processi nel menu di spostamento a sinistra.

Un processo è un raggruppamento di più esecuzioni da uno script o da un frammento di codice specificato. 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, la creazione e altre informazioni. La pagina include anche schede per altre informazioni sul processo, ad esempio metriche, output e log e codice. Ecco le schede disponibili nella pagina dei dettagli del processo:

• Panoramica: informazioni di base sul processo, inclusi lo stato, l'ora di inizio e di fine e il tipo di processo eseguito
• Input: dati e 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: 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: metriche delle prestazioni chiave del modello, ad esempio punteggio di training, punteggio f1 e punteggio di precisione.

Pulire le risorse

Se si prevede di continuare ora ad altre esercitazioni, passare a Contenuto correlato.

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 superiori selezionare Istanze 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

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

1. Nella casella di ricerca della portale di Azure immettere Gruppi di risorse e selezionarlo nei risultati.

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

3. Nella pagina Panoramica selezionare Elimina gruppo di risorse.

   

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

Contenuto correlato

Informazioni sulla distribuzione di 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.

Machine Learning automatizzato è uno strumento supplementare per ridurre la quantità di tempo impiegata da uno scienziato dei dati per trovare il modello che garantisce le prestazioni ottimali con i propri dati. Per altre informazioni, vedere Informazioni sull'apprendimento automatico.

Per altri esempi simili a questa esercitazione, vedere Learn from sample notebooks (Apprendere da notebook di esempio). Questi 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 gli script esistenti dagli esempi, che contengono vari scenari, tra cui classificazione, elaborazione del linguaggio naturale e rilevamento anomalie.