Condividi tramite

Come rendere operativa una pipeline di training con endpoint batch

  • Articolo

SI APPLICA A:Estensione ML dell'interfaccia della riga di comando di Azure v2 (corrente)Python SDK azure-ai-ml v2 (corrente)

Questo articolo illustra come rendere operativa una pipeline di training in un endpoint batch. La pipeline usa più componenti (o passaggi) che includono il training del modello, la pre-elaborazione dei dati e la valutazione del modello.

Si apprenderà come:

  • Creare e testare una pipeline di training
  • Distribuire la pipeline in un endpoint batch
  • Modificare la pipeline e creare una nuova distribuzione nello stesso endpoint
  • Testare la nuova distribuzione e impostarla come distribuzione predefinita

Informazioni su questo esempio

Questo esempio distribuisce una pipeline di training che accetta i dati di training di input (etichettati) e produce un modello predittivo, insieme ai risultati della valutazione e alle trasformazioni applicate durante la pre-elaborazione. La pipeline userà i dati tabulari del Set di dati UCI Heart Disease per eseguire il training di un modello XGBoost. Si usa un componente di pre-elaborazione dei dati per pre-elaborare i dati prima che vengano inviati al componente di training per adattarsi e valutare il modello.

Di seguito è riportata una visualizzazione della pipeline:

Screenshot della pipeline che mostra i componenti di pre-elaborazione e training.

L'esempio contenuto in questo articolo si basa sugli esempi di codice contenuti nel repository azureml-examples. Per eseguire i comandi in locale senza dover copiare o incollare YAML e altri file, usare i comandi seguenti per clonare il repository e passare alla cartella per il linguaggio di codifica:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

I file per questo esempio si trovano in:

cd endpoints/batch/deploy-pipelines/training-with-components

Seguire la procedura nei Jupyter Notebook

È possibile seguire la versione di Python SDK di questo esempio aprendo il notebook sdk-deploy-and-test.ipynb nel repository clonato.

Prerequisiti

  • Una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

  • Un'area di lavoro di Azure Machine Learning. Per creare un'area di lavoro, vedere Gestire le aree di lavoro di Azure Machine Learning.

  • Le autorizzazioni seguenti nell'area di lavoro di Azure Machine Learning:

    • Per la creazione o la gestione di endpoint e distribuzioni batch: usare un ruolo proprietario, collaboratore o personalizzato a cui sono state assegnate le Microsoft.MachineLearningServices/workspaces/batchEndpoints/* autorizzazioni.
    • Per la creazione di distribuzioni di Azure Resource Manager nel gruppo di risorse dell'area di lavoro: usare un ruolo proprietario, collaboratore o personalizzato a cui è stata assegnata l'autorizzazione Microsoft.Resources/deployments/write nel gruppo di risorse in cui viene distribuita l'area di lavoro.

  • Interfaccia della riga di comando di Azure Machine Learning o Azure Machine Learning SDK per Python:

    Eseguire il comando seguente per installare l'interfaccia della riga di comando di Azure e l'mlestensione per Azure Machine Learning:

    az extension add -n ml

    Le distribuzioni dei componenti della pipeline per gli endpoint batch vengono introdotte nella versione 2.7 dell'estensione per l'interfaccia ml della riga di comando di Azure. Usare il comando az extension update --name ml per ottenere la versione più recente.

Connettersi all'area di lavoro

L'area di lavoro è la risorsa di primo livello per Azure Machine Learning. Offre una posizione centralizzata per lavorare con tutti gli artefatti creati quando si usa Azure Machine Learning. In questa sezione ci si connette all'area di lavoro in cui verranno eseguite le attività di distribuzione.

Nel comando seguente immettere l'ID sottoscrizione, il nome dell'area di lavoro, il nome del gruppo di risorse e il percorso:

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Creare il componente della pipeline di training

In questa sezione verranno creati tutti gli asset necessari per la pipeline di training. Si inizierà creando un ambiente che include le librerie necessarie per eseguire il training del modello. Si creerà quindi un cluster di elaborazione in cui verrà eseguita la distribuzione batch e infine si registreranno i dati di input come asset di dati.

Creare l'ambiente

I componenti di questo esempio useranno un ambiente con le librerie XGBoost e scikit-learn. Il file environment/conda.yml contiene la configurazione dell'ambiente:

environment/conda.yml

channels:
- conda-forge
dependencies:
- python=3.8.5
- pip
- pip:
  - mlflow
  - azureml-mlflow
  - datasets
  - jobtools
  - cloudpickle==1.6.0
  - dask==2023.2.0
  - scikit-learn==1.1.2
  - xgboost==1.3.3
  - pandas==1.4
name: mlflow-env

Creare l'ambiente nel modo seguente:

  1. Definire l'ambiente:

    environment/xgboost-sklearn-py38.yml

    $schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
name: xgboost-sklearn-py38
image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
conda_file: conda.yml
description: An environment for models built with XGBoost and Scikit-learn.

  2. Creare l'ambiente:

    az ml environment create -f environment/xgboost-sklearn-py38.yml

Creare un cluster di elaborazione

Gli endpoint e le distribuzioni batch vengono eseguiti nei cluster di elaborazione. Possono essere eseguiti in qualsiasi cluster di elaborazione di Azure Machine Learning già esistente nell'area di lavoro. Di conseguenza, più distribuzioni batch possono condividere la stessa infrastruttura di calcolo. In questo esempio si utilizzerà un cluster di elaborazione di Azure Machine Learning denominato batch-cluster. Verificare che il calcolo esista nell'area di lavoro o, in caso contrario, crearlo.

az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5

Registrare i dati di training come asset di dati

I dati di training sono rappresentati nei file CSV. Per simulare un carico di lavoro a livello di produzione, verranno registrati i dati di training nel file heart.csv come un asset di dati nell'area di lavoro. Questo asset di dati verrà indicato successivamente come input per l'endpoint.

az ml data create --name heart-classifier-train --type uri_folder --path data/train

Creare la pipeline

La pipeline da rendere operativa accetta un input, i dati di training e produce tre output: il modello sottoposto a training, i risultati della valutazione e le trasformazioni dei dati applicate come pre-elaborazione. La pipeline è costituita da due componenti:

  • preprocess_job: questo passaggio legge i dati di input e restituisce i dati preparati e le trasformazioni applicate. Il passaggio riceve tre input:
    • data: cartella contenente i dati di input da trasformare e a cui assegnare un punteggio
    • transformations: (facoltativo) percorso delle trasformazioni che verranno applicate, se disponibili. Se il percorso non viene specificato, le trasformazioni verranno apprese dai dati di input. Poiché l'input transformations è facoltativo, il componente preprocess_job può essere usato durante il training e l'assegnazione dei punteggi.
    • categorical_encoding: la strategia di codifica per le funzionalità categoriche (ordinal o onehot).
  • train_job: questo passaggio eseguirà il training di un modello XGBoost in base ai dati preparati e restituirà i risultati della valutazione e il modello sottoposto a training. Il passaggio riceve tre input:
    • data: i dati pre-elaborati.
    • target_column: colonna che verrà stimata.
    • eval_size: indica la proporzione dei dati di input usati per la valutazione.

La configurazione della pipeline è definita nel file deployment-ordinal/pipeline.yml:

deployment-ordinal/pipeline.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
type: pipeline

name: uci-heart-train-pipeline
display_name: uci-heart-train
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

inputs:
  input_data:
    type: uri_folder

outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    type: uri_folder
    mode: upload

jobs:
  preprocess_job:
    type: command
    component: ../components/prepare/prepare.yml
    inputs:
      data: ${{parent.inputs.input_data}}
      categorical_encoding: ordinal
    outputs:
      prepared_data:
      transformations_output: ${{parent.outputs.prepare_transformations}}
  
  train_job:
    type: command
    component: ../components/train_xgb/train_xgb.yml
    inputs:
      data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
      target_column: target
      register_best_model: false
      eval_size: 0.3
    outputs:
      model: 
        mode: upload
        type: mlflow_model
        path: ${{parent.outputs.model}}
      evaluation_results:
        mode: upload
        type: uri_folder
        path: ${{parent.outputs.evaluation_results}}

Nota

Nel file pipeline.yml l'input transformations non è presente in preprocess_job, pertanto lo script apprenderà i parametri di trasformazione dai dati di input.

Di seguito è riportata una visualizzazione della pipeline:

Immagine della pipeline che mostra l'input del processo, i componenti della pipeline e gli output in ogni passaggio della pipeline.

Testare la pipeline

Verrà ora testata la pipeline con alcuni dati campione. A tale scopo, verrà creato un processo usando la pipeline e il cluster di elaborazione batch-cluster creato in precedenza.

Il file pipeline-job.yml seguente contiene la configurazione per il processo della pipeline:

deployment-ordinal/pipeline-job.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

experiment_name: uci-heart-train-pipeline
display_name: uci-heart-train-job
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

compute: batch-cluster
component: pipeline.yml
inputs:
  input_data:
    type: uri_folder
outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    mode: upload

Creare il processo di test:

az ml job create -f deployment-ordinal/pipeline-job.yml --set inputs.input_data.path=azureml:heart-classifier-train@latest

Creare un endpoint batch

  1. Immettere un nome per l'endpoint. Il nome di un endpoint batch deve essere univoco in ogni area poiché viene usato per costruire l'URI di chiamata. Per garantirne l'univocità, aggiungere tutti i caratteri finali al nome specificato nel codice seguente.

    ENDPOINT_NAME="uci-classifier-train"

  2. Configurare l'endpoint:

    Il file endpoint.yml contiene la configurazione dell'endpoint.

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: uci-classifier-train
description: An endpoint to perform training of the Heart Disease Data Set prediction task.
auth_mode: aad_token

  3. Creare l'endpoint:

    az ml batch-endpoint create --name $ENDPOINT_NAME -f endpoint.yml

  4. Eseguire una query sull'URI dell'endpoint:

    az ml batch-endpoint show --name $ENDPOINT_NAME

Distribuire il componente della pipeline

Per distribuire il componente della pipeline, è necessario creare una distribuzione batch. Per distribuzione si intende un set di risorse necessarie per ospitare l'asset che esegue il lavoro effettivo.

  1. Configurare la distribuzione:

    Il file deployment-ordinal/deployment.yml contiene la configurazione della distribuzione. È possibile controllare lo schema YAML dell'endpoint batch completo per ottenere proprietà aggiuntive.

    deployment-ordinal/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
name: uci-classifier-train-xgb
description: A sample deployment that trains an XGBoost model for the UCI dataset.
endpoint_name: uci-classifier-train
type: pipeline
component: pipeline.yml
settings:
    continue_on_step_failure: false
    default_compute: batch-cluster

  2. Creare la distribuzione:

    Eseguire il codice seguente per creare una distribuzione batch nell'endpoint batch e impostarla come distribuzione predefinita.

    az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-ordinal/deployment.yml --set-default

    Suggerimento

    Si noti che l'uso del flag --set-default sta ad indicare che ora questa nuova distribuzione è la distribuzione predefinita.

  3. La distribuzione è pronta per l'uso.

Testare la distribuzione

Dopo aver creato la distribuzione, questa è pronta per ricevere i processi. Per testarlo, attenersi a questa procedura:

  1. Per la distribuzione è necessario indicare un input di dati.

    Il file inputs.yml contiene la definizione per l'asset di dati di input:

    inputs.yml

    inputs:
  input_data:
    type: uri_folder
    path: azureml:heart-classifier-train@latest

    Suggerimento

    Per altre informazioni su come indicare gli input, vedere Creare processi e dati di input per gli endpoint batch.

  2. È possibile richiamare la distribuzione predefinita nel modo seguente:

    JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)

  3. È possibile monitorare lo stato di avanzamento del contenuto e trasmettere i log usando:

    az ml job stream -n $JOB_NAME

È opportuno ricordare che solo gli input della pipeline vengono pubblicati come input nell'endpoint batch. Ad esempio, categorical_encoding è un input di un passaggio della pipeline, ma non un input nella pipeline stessa. Considerare questo aspetto per gestire quali input si intende esporre e quali nascondere ai client.

Accedere agli output dei processi

Una volta completato il processo, è possibile accedere ad alcuni output. Questa pipeline produce gli output seguenti per i relativi componenti:

  • preprocess job: l'output è transformations_output
  • train job: gli output sono model e evaluation_results

È possibile scaricare i risultati associati usando:

az ml job download --name $JOB_NAME --output-name transformations
az ml job download --name $JOB_NAME --output-name model
az ml job download --name $JOB_NAME --output-name evaluation_results

Creare una nuova distribuzione nell'endpoint

Gli endpoint possono ospitare più distribuzioni contemporaneamente, mantenendo una sola distribuzione come predefinita. Pertanto è possibile eseguire l'iterazione sui diversi modelli, distribuire i diversi modelli nell'endpoint e testarli e infine passare la distribuzione predefinita alla distribuzione del modello più adatta.

A questo punto verrà descritto come modificare il modo in cui viene eseguita la pre-elaborazione nella pipeline per verificare se si ottiene un modello che offre prestazioni migliori.

Modificare un parametro nel componente di pre-elaborazione della pipeline

Il componente di pre-elaborazione ha un input denominato categorical_encoding, che può avere valori ordinal o onehot. Questi valori corrispondono a due modi diversi per codificare le funzionalità categoriche.

  • ordinal: codifica i valori di funzionalità con valori numerici (ordinali) da [1:n], dove n è il numero di categorie nella funzionalità. La codifica ordinale implica che esiste un ordine di classificazione naturale tra le categorie di funzionalità.
  • onehot: non implica una relazione ordinata in base a una classificazione naturale, ma introduce un problema di dimensionalità se il numero di categorie è elevato.

Per impostazione predefinita, è stato usato ordinal in precedenza. A questo punto è possibile modificare la codifica categorica per usare onehot in modo da vedere come viene eseguito il modello.

Suggerimento

In alternativa, potrebbe essere stato esposto l'input categorial_encoding ai client come input per il processo della pipeline stesso. Tuttavia, è stato scelto di modificare il valore del parametro nel passaggio di pre-elaborazione in modo che sia possibile nascondere e controllare il parametro all'interno della distribuzione e sfruttare l'opportunità di avere più distribuzioni nello stesso endpoint.

  1. Modificare la pipeline. L'aspetto è il seguente:

    La configurazione della pipeline è definita nel file deployment-onehot/pipeline.yml:

    deployment-onehot/pipeline.yml

    $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
type: pipeline

name: uci-heart-train-pipeline
display_name: uci-heart-train
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

inputs:
  input_data:
    type: uri_folder

outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    type: uri_folder
    mode: upload

jobs:
  preprocess_job:
    type: command
    component: ../components/prepare/prepare.yml
    inputs:
      data: ${{parent.inputs.input_data}}
      categorical_encoding: onehot
    outputs:
      prepared_data:
      transformations_output: ${{parent.outputs.prepare_transformations}}
  
  train_job:
    type: command
    component: ../components/train_xgb/train_xgb.yml
    inputs:
      data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
      target_column: target
      eval_size: 0.3
    outputs:
      model: 
        type: mlflow_model
        path: ${{parent.outputs.model}}
      evaluation_results:
        type: uri_folder
        path: ${{parent.outputs.evaluation_results}}

  2. Configurare la distribuzione:

    Il file deployment-onehot/deployment.yml contiene la configurazione della distribuzione. È possibile controllare lo schema YAML dell'endpoint batch completo per ottenere proprietà aggiuntive.

    deployment-onehot/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
name: uci-classifier-train-onehot
description: A sample deployment that trains an XGBoost model for the UCI dataset using onehot encoding for variables.
endpoint_name: uci-classifier-train
type: pipeline
component: pipeline.yml
settings:
    continue_on_step_failure: false
    default_compute: batch-cluster

  3. Creare la distribuzione:

    Eseguire il codice seguente per creare una distribuzione batch nell'endpoint batch e impostarla come distribuzione predefinita.

    az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-onehot/deployment.yml

    La distribuzione è pronta per l'uso.

  4. La distribuzione è pronta per l'uso.

Testare una distribuzione non predefinita

Dopo aver creato la distribuzione, questa è pronta per ricevere i processi. È possibile testarlo nello stesso modo in cui è stato fatto in precedenza, ma ora verrà richiamata una distribuzione specifica:

  1. Richiamare la distribuzione come indicato di seguito, specificando il parametro di distribuzione per attivare la distribuzione specifica uci-classifier-train-onehot:

    DEPLOYMENT_NAME="uci-classifier-train-onehot"
JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME -d $DEPLOYMENT_NAME --f inputs.yml --query name -o tsv)

  2. È possibile monitorare lo stato di avanzamento del contenuto e trasmettere i log usando:

    az ml job stream -n $JOB_NAME

Configurare la nuova distribuzione come predefinita

Dopo aver soddisfatto le prestazioni della nuova distribuzione, è possibile impostare la nuova distribuzione come predefinita:

az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

Eliminare la distribuzione precedente

Al termine, è possibile eliminare la distribuzione precedente se non è più necessaria:

az ml batch-deployment delete --name uci-classifier-train-xgb --endpoint-name $ENDPOINT_NAME --yes

Pulire le risorse

Al termine, eliminare le risorse associate dall'area di lavoro:

Eseguire il codice seguente per eliminare l'endpoint batch e la relativa distribuzione sottostante. --yes viene usato per confermare l'eliminazione.

az ml batch-endpoint delete -n $ENDPOINT_NAME --yes

(Facoltativo) Eliminare le risorse di calcolo, a meno che non si preveda di riutilizzare il cluster di elaborazione con distribuzioni successive.

az ml compute delete -n batch-cluster

Passaggi successivi