Configurare il training AutoML per i dati tabulari con l'interfaccia della riga di comando di Azure Machine Learning e Python SDK

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 configurare un processo di training di Machine Learning automatizzato (AutoML) con Azure Machine Learning Python SDK v2. Machine Learning automatizzato seleziona automaticamente un algoritmo e iperparametri, e genera un modello pronto per la distribuzione. Questo articolo fornisce informazioni dettagliate sulle varie opzioni che è possibile usare per configurare esperimenti di Machine Learning automatizzati.

Se si preferisce un'esperienza senza codice, è anche possibile configurare il training automatico di Machine Learning senza codice per i dati tabulari con l'interfaccia utente di Studio.

Prerequisiti

• Una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning.
• Un'area di lavoro di Azure Machine Learning. Se non è disponibile, vedere Creare risorse per iniziare.

Configurare l'area di lavoro

Per connettersi a un'area di lavoro, è necessario fornire una sottoscrizione, un gruppo di risorse e un'area di lavoro.

from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient

credential = DefaultAzureCredential()
ml_client = None
try:
    ml_client = MLClient.from_config(credential)
except Exception as ex:
    print(ex)
    # Enter details of your Azure Machine Learning workspace
    subscription_id = "<SUBSCRIPTION_ID>"
    resource_group = "<RESOURCE_GROUP>"
    workspace = "<AZUREML_WORKSPACE_NAME>"
    ml_client = MLClient(credential, subscription_id, resource_group, workspace)

az login

az configure --defaults group=<RESOURCE_GROUP> workspace=<AZUREML_WORKSPACE_NAME> location=<LOCATION>

Specificare l'origine dati e il formato

Per fornire i dati di training in SDK v2, è necessario caricarli nel cloud tramite mlTable.

Requisiti per il caricamento dei dati in un oggetto MLTable:

• I dati devono essere in formato tabulare.
• Il valore da stimare, la colonna di destinazione, deve essere nei dati.

I dati di training devono essere accessibili dal calcolo remoto. ML v2 automatizzato (Python SDK e CLI/YAML) accetta asset di dati MLTable (v2). Per la compatibilità con le versioni precedenti, supporta anche set di dati tabulari v1 dalla versione 1, un set di dati tabulare registrato, tramite le stesse proprietà del set di dati di input. È consigliabile usare MLTable, disponibile nella versione 2. In questo esempio i dati vengono archiviati nel percorso locale, ./train_data/bank_marketing_train_data.csv.

import mltable

paths = [
    {'file': './train_data/bank_marketing_train_data.csv'}
]

train_table = mltable.from_delimited_files(paths)
train_table.save('./train_data')

$schema: https://azuremlschemas.azureedge.net/latest/MLTable.schema.json

paths:
  - file: ./bank_marketing_train_data.csv
transformations:
  - read_delimited:
        delimiter: ','
        encoding: 'ascii'

La cartella ./train_data include ora il file di definizione MLTable più il file di dati bank_marketing_train_data.csv.

Per altre informazioni su MLTable, vedere Uso delle tabelle in Azure Machine Learning.

Training, convalida e test dei dati

È possibile specificare set di dati di training e di convalida separati. I dati di training devono essere forniti al training_data parametro nella funzione factory del processo di Machine Learning automatizzato.

Se non si specifica in modo esplicito un validation_data parametro o n_cross_validation , Machine Learning automatizzato applica tecniche predefinite per determinare come viene eseguita la convalida. Questa determinazione dipende dal numero di righe nel set di dati assegnato al parametro training_data.

Calcolo per eseguire l'esperimento

I processi di Machine Learning automatizzati con Python SDK v2 (o l'interfaccia della riga di comando v2) sono attualmente supportati solo nel cluster di calcolo remoto di Azure Machine Learning o nell'istanza di calcolo. Per altre informazioni sulla creazione di risorse di calcolo con Python SDKv2 o CLIv2, vedere Eseguire il training di modelli con l'interfaccia della riga di comando di Azure Machine Learning, l'SDK e l'API REST.

Configurare le impostazioni di esperimento

Per configurare l'esperimento di Machine Learning automatizzato sono disponibili varie opzioni. Questi parametri di configurazione vengono impostati nel metodo dell'attività. È anche possibile impostare le impostazioni di training del processo e i criteri di uscita con le impostazioni training e limits.

L'esempio seguente mostra i parametri obbligatori per un'attività di classificazione che specifica l'accuratezza come metrica primaria e cinque riduzioni di convalida incrociata .

from azure.ai.ml.constants import AssetTypes
from azure.ai.ml import automl, Input

# note that this is a code snippet -- you might have to modify the variable values to run it successfully

# make an Input object for the training data
my_training_data_input = Input(
    type=AssetTypes.MLTABLE, path="./data/training-mltable-folder"
)

# configure the classification job
classification_job = automl.classification(
    compute=my_compute_name,
    experiment_name=my_exp_name,
    training_data=my_training_data_input,
    target_column_name="y",
    primary_metric="accuracy",
    n_cross_validations=5,
    enable_model_explainability=True,
    tags={"my_custom_tag": "My custom value"}
)

# Limits are all optional
classification_job.set_limits(
    timeout_minutes=600, 
    trial_timeout_minutes=20, 
    max_trials=5,
    enable_early_termination=True,
)

# Training properties are optional
classification_job.set_training(
    blocked_training_algorithms=["logistic_regression"], 
    enable_onnx_compatible_models=True
)

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: <my_exp_name>
description: A classification AutoML job
task: classification

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:<my_compute_name>
primary_metric: accuracy  
target_column_name: y
n_cross_validations: 5
enable_model_explainability: True

tags:
    <my_custom_tag>: <My custom value>

limits:
    timeout_minutes: 600 
    trial_timeout_minutes: 20 
    max_trials: 5
    enable_early_termination: True

training:
    blocked_training_algorithms: ["logistic_regression"] 
    enable_onnx_compatible_models: True

Selezionare il tipo di attività di Machine Learning

Prima di poter inviare il processo di Machine Learning automatizzato, determinare il tipo di problema di Machine Learning che si vuole risolvere. Questo problema determina la funzione usata dal processo e gli algoritmi del modello applicati.

Machine Learning automatizzato supporta diversi tipi di attività:

• Attività basate sui dati tabulari

  • classificazione
  • Regressione
  • previsione

• Attività di visione artificiale, tra cui

  • Classificazione immagini
  • Rilevamento oggetti

• Attività di elaborazione del linguaggio naturale, tra cui

  • Classificazione testo
  • Riconoscimento delle entità

Per altre informazioni, vedere Tipi di attività. Per altre informazioni sulla configurazione dei processi di previsione, vedere Configurare AutoML per eseguire il training di un modello di previsione di serie temporali.

Algoritmi supportati

Il Machine Learning automatizzato prova modelli e algoritmi diversi durante il processo di automazione e ottimizzazione. Gli utenti non devono specificare l'algoritmo.

Il metodo task determina l'elenco di algoritmi o modelli da applicare. Per modificare ulteriormente le iterazioni con i modelli disponibili da includere o escludere, usare i allowed_training_algorithms parametri o blocked_training_algorithms nella training configurazione del processo.

Nella tabella seguente esplorare gli algoritmi supportati per ogni attività di Machine Learning.

Con altri algoritmi:

• Algoritmi multi-classe di classificazione immagini
• Algoritmi con più etichette di classificazione delle immagini
• Algoritmi di rilevamento oggetti immagine
• Algoritmi con più etichette di classificazione di testo con elaborazione del linguaggio naturale
• Algoritmi di riconoscimento entità denominata (NER) di testi con elaborazione del linguaggio naturale

Ad esempio, i notebook di ogni tipo di attività, vedere automl-standalone-jobs.

Primary metric (Metrica principale)

Il parametro primary_metric determina la metrica da usare durante il training del modello per l'ottimizzazione. Il tipo di attività scelto determina le metriche che è possibile selezionare.

La scelta di una metrica primaria per l'apprendimento automatico da ottimizzare dipende da molti fattori. È consigliabile scegliere una metrica che rappresenti al meglio le esigenze aziendali. Valutare quindi se la metrica è adatta per il profilo del set di dati, incluse le dimensioni dei dati, l'intervallo e la distribuzione di classi. Le sezioni seguenti riepilogano le metriche principali consigliate in base al tipo di attività e allo scenario aziendale.

Per informazioni sulle definizioni specifiche di queste metriche, vedere Valutare i risultati dell'esperimento di Machine Learning automatizzato.

Metriche per gli scenari di classificazione multi-classe

Queste metriche si applicano a tutti gli scenari di classificazione, inclusi dati tabulari, immagini o visione artificiale e testo di elaborazione del linguaggio naturale (NLP-Text).

Le metriche dipendenti dalla soglia, ad esempio accuracy, recall_score_weighted, norm_macro_recalle precision_score_weighted potrebbero non essere ottimizzate anche per i set di dati di piccole dimensioni, hanno un'asimmetria di classe di grandi dimensioni (squilibrio di classe) o quando il valore della metrica previsto è molto vicino a 0,0 o 1,0. In questi casi, AUC_weighted può essere una scelta migliore per la metrica primaria. Al termine dell'apprendimento automatico, è possibile scegliere il modello vincente in base alla metrica più adatta alle esigenze aziendali.

Metriche per scenari di classificazione con più etichette

Per la classificazione del testo con più etichette, attualmente "Accuratezza" è l'unica metrica primaria supportata.

Per Classificazione immagini con più etichette, le metriche principali supportate sono definite nell'enumerazione ClassificationMultilabelPrimaryMetrics .

Metriche per scenari di riconoscimento di entità denominate testo NLP

Per NLP Text Named Entity Recognition (NER), attualmente 'Accuracy' è l'unica metrica primaria supportata.

Metriche per i modelli di regressione

r2_score, normalized_mean_absolute_errore normalized_root_mean_squared_error stanno tentando di ridurre al minimo gli errori di stima. r2_score e normalized_root_mean_squared_error riducono al minimo gli errori quadratici medi mentre normalized_mean_absolute_error riduce al minimo il valore assoluto medio degli errori. Il valore assoluto tratta gli errori in tutte le dimensioni e gli errori quadrati hanno una penalità molto maggiore per gli errori con valori assoluti più grandi. A seconda che gli errori più grandi debbano essere puniti più o meno, è possibile scegliere di ottimizzare l'errore quadrato o l'errore assoluto.

La differenza principale tra r2_score e normalized_root_mean_squared_error è il modo in cui vengono normalizzati e i loro significati. normalized_root_mean_squared_error è la radice errore quadratico medio normalizzata per intervallo e può essere interpretata come la grandezza dell'errore medio per la stima. r2_score è un errore quadratico medio normalizzato da una stima della varianza dei dati. È la proporzione di variazione che il modello può acquisire.

Se la classificazione, anziché il valore esatto, è di interesse, spearman_correlation può essere una scelta migliore. Misura la correlazione di rango tra valori reali e stime.

Machine Learning automatizzato attualmente non supporta metriche primarie che misurano la differenza relativa tra stime e osservazioni. Le metriche r2_score, normalized_mean_absolute_errore normalized_root_mean_squared_error sono tutte misure di differenza assoluta. Ad esempio, se una stima è diversa da un'osservazione di 10 unità, queste metriche calcolano lo stesso valore se l'osservazione è di 20 unità o 20.000 unità. Al contrario, una differenza percentuale, che è una misura relativa, restituisce gli errori rispettivamente del 50% e dello 0,05%. Per ottimizzare la differenza relativa, è possibile eseguire Machine Learning automatizzato con una metrica primaria supportata e quindi selezionare il modello con il valore migliore mean_absolute_percentage_error o root_mean_squared_log_error. Queste metriche sono indefinite quando i valori di osservazione sono zero, quindi potrebbero non essere sempre scelte valide.

Metriche per gli scenari di previsione delle serie temporali

Le raccomandazioni sono simili alle raccomandazioni per gli scenari di regressione.

Metriche per scenari di rilevamento oggetti immagine

Per Rilevamento oggetti immagine, le metriche principali supportate sono definite nell'enumerazione ObjectDetectionPrimaryMetrics .

Metriche per scenari di segmentazione istanze immagine

Per gli scenari di segmentazione dell'istanza di immagine, le metriche principali supportate sono definite nell'enumerazione InstanceSegmentationPrimaryMetrics .

Definizione delle funzionalità dei dati

In ogni esperimento di Machine Learning automatizzato i dati vengono trasformati automaticamente in numeri e vettori di numeri. I dati vengono anche ridimensionati e normalizzati per aiutare gli algoritmi sensibili alle funzionalità su scale diverse. Queste trasformazioni dei dati sono denominate definizione delle funzionalità.

Quando si configurano processi di Machine Learning automatizzati, è possibile abilitare o disabilitare le featurization impostazioni.

La tabella seguente illustra le impostazioni accettate per la definizione delle funzionalità.

Il codice seguente illustra come fornire la definizione delle funzionalità personalizzata in questo caso per un processo di regressione.

from azure.ai.ml.automl import ColumnTransformer

transformer_params = {
    "imputer": [
        ColumnTransformer(fields=["CACH"], parameters={"strategy": "most_frequent"}),
        ColumnTransformer(fields=["PRP"], parameters={"strategy": "most_frequent"}),
    ],
}
regression_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    blocked_transformers=["LabelEncoding"],
    column_name_and_types={"CHMIN": "Categorical"},
)

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: <my_exp_name>
description: A classification AutoML job
task: classification

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:<my_compute_name>
primary_metric: accuracy  
target_column_name: y
n_cross_validations: 5
enable_model_explainability: True

featurization:
    mode: custom
    column_name_and_types:
        CHMIN: Categorical
    blocked_transformers: ["label_encoder"]
    transformer_params:
        imputer:
            - fields: ["CACH", "PRP"]
            parameters:
                strategy: most_frequent

limits:
    # limit settings

training:
    # training settings

Criteri di uscita

Sono disponibili alcune opzioni che è possibile definire nella set_limits() funzione per terminare l'esperimento prima del completamento del processo.

Eseguire esperimento

Avviare l'esperimento per eseguire e generare un modello.

Dopo aver creato MLClient nei prerequisiti, è possibile eseguire il comando seguente nell'area di lavoro.

# Submit the AutoML job
returned_job = ml_client.jobs.create_or_update(
    classification_job
)  # submit the job to the backend

print(f"Created job: {returned_job}")

# Get a URL for the status of the job
returned_job.services["Studio"].endpoint

run_id=$(az ml job create --file automl-classification-job.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>)

az ml job show -n $run_id --web

Più esecuzioni figlio nei cluster

Le esecuzioni figlio dell'esperimento di Machine Learning automatizzato possono essere eseguite in un cluster che esegue già un altro esperimento. Tuttavia, la tempistica dipende dal numero di nodi del cluster e se tali nodi sono disponibili per eseguire un esperimento diverso.

Ogni nodo del cluster funge da singola macchina virtuale (VM) che può eseguire una singola esecuzione di training. Per Machine Learning automatizzato, questo significa infatti un'esecuzione figlio. Se tutti i nodi sono occupati, viene accodato un nuovo esperimento. Se sono presenti nodi liberi, il nuovo esperimento esegue l'esecuzione figlio in parallelo nei nodi o nelle macchine virtuali disponibili.

Per gestire le esecuzioni figlio e quando possono essere eseguite, è consigliabile creare un cluster dedicato per esperimento e associare il numero di max_concurrent_iterations esperimenti al numero di nodi nel cluster. In questo modo, si usano tutti i nodi del cluster contemporaneamente con il numero di esecuzioni figlio simultanee e iterazioni desiderate.

Configurare max_concurrent_iterations nella configurazione limits. Se non è configurata, per impostazione predefinita è consentita una sola esecuzione/iterazione figlio simultanea per esperimento. Per un'istanza di calcolo, max_concurrent_trials può essere impostato come uguale al numero di core nella macchina virtuale dell'istanza di calcolo.

Esplorare modelli e metriche

Il Machine Learning automatizzato offre opzioni per monitorare e valutare i risultati del training.

• Per definizioni ed esempi dei grafici delle prestazioni e delle metriche fornite per ogni esecuzione, vedere Valutare i risultati dell'esperimento di Machine Learning automatizzato.

• Per ottenere un riepilogo delle caratteristiche e comprendere quali funzionalità sono state aggiunte a un modello specifico, vedere Trasparenza delle funzionalità.

Dall'interfaccia utente di Azure Machine Learning nella pagina del modello, è anche possibile visualizzare i parametri hyper-parameter usati quando si esegue il training di un modello specifico e anche visualizzare e personalizzare il codice di training del modello interno usato.

Registrare e distribuire modelli

Dopo aver testato un modello e aver confermato di voler usarlo nell'ambiente di produzione, è possibile registrarlo per usarlo in un secondo momento.

Usare AutoML nelle pipeline

Per usare Machine Learning automatizzato nei flussi di lavoro delle operazioni di Machine Learning, è possibile aggiungere i passaggi del processo AutoML alle pipeline di Azure Machine Learning. Questo approccio consente di automatizzare l'intero flusso di lavoro associando gli script di preparazione dei dati a Machine Learning automatizzato. Registrare e convalidare quindi il modello migliore risultante.

Questo codice è una pipeline di esempio con un componente di classificazione di Machine Learning automatizzato e un componente di comando che mostra l'output risultante. Il codice fa riferimento agli input (dati di training e convalida) e agli output (modello migliore) in passaggi diversi.

# Define pipeline
@pipeline(
    description="AutoML Classification Pipeline",
    )
def automl_classification(
    classification_train_data,
    classification_validation_data
):
    # define the automl classification task with automl function
    classification_node = classification(
        training_data=classification_train_data,
        validation_data=classification_validation_data,
        target_column_name="y",
        primary_metric="accuracy",
        # currently need to specify outputs "mlflow_model" explictly to reference it in following nodes 
        outputs={"best_model": Output(type="mlflow_model")},
    )
    # set limits and training
    classification_node.set_limits(max_trials=1)
    classification_node.set_training(
        enable_stack_ensemble=False,
        enable_vote_ensemble=False
    )

    command_func = command(
        inputs=dict(
            automl_output=Input(type="mlflow_model")
        ),
        command="ls ${{inputs.automl_output}}",
        environment="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:latest"
    )
    show_output = command_func(automl_output=classification_node.outputs.best_model)


pipeline_job = automl_classification(
    classification_train_data=Input(path="./training-mltable-folder/", type="mltable"),
    classification_validation_data=Input(path="./validation-mltable-folder/", type="mltable"),
)

# set pipeline level compute
pipeline_job.settings.default_compute = compute_name

# submit the pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

# ...
# Note that this is a snippet from the bankmarketing example you can find in our examples repo -> https://github.com/Azure/azureml-examples/tree/main/sdk/python/jobs/pipelines/1h_automl_in_pipeline/automl-classification-bankmarketing-in-pipeline

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

description: AutoML Classification Pipeline
experiment_name: <exp_name>

# set the default compute for the pipeline steps
settings:
    default_compute: azureml:<my_compute>

# pipeline inputs
inputs:
    classification_train_data:
        type: mltable
        path: "./train_data"
    classification_validation_data:
        type: mltable
        path: "./valid_data"

jobs:
    # Configure the automl training node of the pipeline 
    classification_node:
        type: automl
        task: classification
        primary_metric: accuracy
        target_column_name: y
        training_data: ${{parent.inputs.classification_train_data}}
        validation_data: ${{parent.inputs.classification_validation_data}}
        training:
            max_trials: 1
        limits:
            enable_stack_ensemble: False
            enable_vote_ensemble: False
        outputs:
            best_model:
                type: mlflow_model

    show_output:
        type: command
        inputs:
            automl_output: ${{parent.jobs.classification_node.outputs.best_model}}
        environment: "AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:latest"
        command: >-
            ls ${{inputs.automl_output}}
        

> run_id=$(az ml job create --file automl-classification-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>)
> az ml job show -n $run_id --web

Usare AutoML su larga scala: training distribuito

Per scenari di dati di grandi dimensioni, Machine Learning automatizzato supporta il training distribuito per un set limitato di modelli:

Gli algoritmi di training distribuiti partizionano e distribuiscono automaticamente i dati tra più nodi di calcolo per il training del modello.

Training distribuito per la classificazione e la regressione

Per usare il training distribuito per la classificazione o la regressione, impostare le training_mode proprietà e max_nodes dell'oggetto processo.

L'esempio di codice seguente illustra un esempio di queste impostazioni per un processo di classificazione:

from azure.ai.ml.constants import TabularTrainingMode

# Set the training mode to distributed
classification_job.set_training(
    allowed_training_algorithms=["LightGBM"],
    training_mode=TabularTrainingMode.DISTRIBUTED
)

# Distribute training across 4 nodes for each trial
classification_job.set_limits(
    max_nodes=4,
    # other limit settings
)

# Set the training mode to distributed
training:
    allowed_training_algorithms: ["LightGBM"]
    training_mode: distributed

# Distribute training across 4 nodes for each trial
limits:
    max_nodes: 4

Training distribuito per la previsione

Per informazioni sul funzionamento del training distribuito per le attività di previsione, vedere Previsione su larga scala. Per usare il training distribuito per la previsione, è necessario impostare le proprietà training_mode, enable_dnn_training, max_nodes e facoltativamente max_concurrent_trials dell'oggetto processo.

L'esempio di codice seguente illustra un esempio di queste impostazioni per un processo di previsione:

from azure.ai.ml.constants import TabularTrainingMode

# Set the training mode to distributed
forecasting_job.set_training(
    enable_dnn_training=True,
    allowed_training_algorithms=["TCNForecaster"],
    training_mode=TabularTrainingMode.DISTRIBUTED
)

# Distribute training across 4 nodes
# Train 2 trial models in parallel => 2 nodes per trial
forecasting_job.set_limits(
    max_concurrent_trials=2,
    max_nodes=4,
    # other limit settings
)

# Set the training mode to distributed
training:
    allowed_training_algorithms: ["TCNForecaster"]
    training_mode: distributed

# Distribute training across 4 nodes
# Train 2 trial models in parallel => 2 nodes per trial
limits:
    max_concurrent_trials: 2
    max_nodes: 4

Per esempi di codice di configurazione completo, vedere le sezioni precedenti relative alla configurazione e all'invio di processi.

Contenuto correlato

• Altre informazioni su come e dove distribuire un modello.
• Altre informazioni su come configurare AutoML per eseguire il training di un modello di previsione di serie temporali.