Konfigurera AutoML-träning för tabelldata med Azure Machine Learning CLI och Python SDK

GÄLLER FÖR:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (aktuell)

I den här artikeln får du lära dig hur du konfigurerar ett autoML-träningsjobb (automatiserad maskininlärning) med Azure Machine Learning Python SDK v2. Automatiserad ML väljer en algoritm och hyperparametrar åt dig och genererar en modell som är redo för distribution. Den här artikeln innehåller information om de olika alternativ som du kan använda för att konfigurera automatiserade maskininlärningsexperiment.

Om du föredrar en upplevelse utan kod kan du även konfigurera automatisk ML-träning utan kod för tabelldata med studiogränssnittet.

Förutsättningar

• En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Machine Learning.
• En Azure Machine Learning-arbetsyta. Om du inte har någon läser du Skapa resurser för att komma igång.

Konfigurera din arbetsyta

Om du vill ansluta till en arbetsyta måste du ange en prenumeration, resursgrupp och arbetsyta.

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>

Ange datakälla och format

För att kunna tillhandahålla träningsdata i SDK v2 måste du ladda upp dem till molnet via en MLTable.

Krav för att läsa in data i en MLTable:

• Data måste vara i tabellform.
• Värdet som ska förutsägas, målkolumnen, måste finnas i data.

Träningsdata måste vara tillgängliga från fjärrberäkningen. Automatiserad ML v2 (Python SDK och CLI/YAML) accepterar MLTable-datatillgångar (v2). För bakåtkompatibilitet stöder den även v1 Tabelldatauppsättningar från v1, en registrerad tabelldatauppsättning, via samma indatauppsättningsegenskaper. Vi rekommenderar att du använder MLTable, som är tillgängligt i v2. I det här exemplet lagras data på den lokala sökvägen . /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'

Nu har mappen ./train_data MLTable-definitionsfilen plus datafilen bank_marketing_train_data.csv.

Mer information om MLTable finns i Arbeta med tabeller i Azure Machine Learning.

Tränings-, validerings- och testdata

Du kan ange separata träningsdata och valideringsdatauppsättningar. Träningsdata måste anges för parametern training_data i fabriksfunktionen för ditt automatiserade maskininlärningsjobb.

Om du inte uttryckligen anger en validation_data parameter eller n_cross_validation parameter använder automatiserad ML standardtekniker för att avgöra hur verifieringen utförs. Den här bestämningen beror på antalet rader i datauppsättningen som tilldelats parametern training_data .

Beräkning för att köra experiment

Automatiserade maskininlärningsjobb med Python SDK v2 (eller CLI v2) stöds för närvarande endast i Azure Machine Learning-fjärrberäkningskluster eller beräkningsinstanser. Mer information om hur du skapar beräkning med Python SDKv2 eller CLIv2 finns i Träna modeller med Azure Machine Learning CLI, SDK och REST API.

Konfigurera dina experimentinställningar

Det finns flera alternativ som du kan använda för att konfigurera ditt automatiserade maskininlärningsexperiment. Dessa konfigurationsparametrar anges i aktivitetsmetoden. Du kan också ange inställningar för jobbträning och avslutsvillkor med training inställningarna och limits .

I följande exempel visas de obligatoriska parametrarna för en klassificeringsuppgift som anger noggrannhet som primärt mått och fem korsvalideringsdelegeringar.

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

Välj din maskininlärningsaktivitetstyp

Innan du kan skicka in ditt automatiserade ML-jobb ska du fastställa vilken typ av maskininlärningsproblem du vill lösa. Det här problemet avgör vilken funktion ditt jobb använder och vilka modellalgoritmer det gäller.

Automatiserad ML har stöd för olika uppgiftstyper:

• Tabelldatabaserade uppgifter

  • klassificering
  • regression
  • prognostisering

• Uppgifter för visuellt innehåll, inklusive

  • Bildklassificering
  • Objektidentifiering

• Bearbetningsuppgifter för naturligt språk, inklusive

  • Textklassificering
  • Igenkänning av enhet

Mer information finns i uppgiftstyper. Mer information om hur du konfigurerar prognosjobb finns i Konfigurera AutoML för att träna en prognosmodell för tidsserier.

Algoritmer som stöds

Automatiserad maskininlärning provar olika modeller och algoritmer under automatiserings- och justeringsprocessen. Som användare behöver du inte ange algoritmen.

Aktivitetsmetoden avgör vilken lista med algoritmer eller modeller som ska tillämpas. Om du vill ändra iterationer ytterligare med tillgängliga modeller som ska inkluderas eller exkluderas använder du parametrarna allowed_training_algorithms eller blocked_training_algorithms i training jobbets konfiguration.

I följande tabell utforskar du de algoritmer som stöds per maskininlärningsuppgift.

Med andra algoritmer:

• Multiklassalgoritmer för bildklassificering
• Algoritmer för bildklassificering med flera etiketter
• Algoritmer för identifiering av bildobjekt
• NLP-textklassificering med flera etikettalgoritmer
• NLP-text med namn på algoritmer för entitetsigenkänning (NER)

Exempel på notebook-filer för varje aktivitetstyp finns i automl-standalone-jobs.

Primärt mått

Parametern primary_metric avgör vilket mått som ska användas under modellträningen för optimering. Vilken aktivitetstyp du väljer avgör vilka mått du kan välja.

Att välja ett primärt mått för automatiserad maskininlärning för att optimera beror på många faktorer. Vi rekommenderar att du främst överväger att välja ett mått som bäst motsvarar dina affärsbehov. Tänk sedan på om måttet är lämpligt för din datamängdsprofil, inklusive datastorlek, intervall och klassdistribution. I följande avsnitt sammanfattas de rekommenderade primära måtten baserat på aktivitetstyp och affärsscenario.

Mer information om de specifika definitionerna av dessa mått finns i Utvärdera automatiserade maskininlärningsexperimentresultat.

Mått för klassificering av scenarier med flera klasser

Dessa mått gäller för alla klassificeringsscenarier, inklusive tabelldata, bilder eller visuellt innehåll och textbearbetning av naturligt språk (NLP-Text).

Tröskelvärdesberoende mått, till exempel accuracy, recall_score_weighted, norm_macro_recalloch precision_score_weighted kanske inte optimeras lika bra för datauppsättningar som är små, har stor klassförskjutning (obalans i klassen) eller när det förväntade måttvärdet är mycket nära 0,0 eller 1,0. I dessa fall AUC_weighted kan vara ett bättre val för det primära måttet. När automatiserad maskininlärning har slutförts kan du välja den vinnande modellen baserat på måttet som passar bäst för dina affärsbehov.

Mått för klassificering av scenarier med flera etiketter

För fleretiketter för textklassificering är för närvarande "Noggrannhet" det enda primära mått som stöds.

För fleretiketter för bildklassificering definieras de primära mått som stöds i ClassificationMultilabelPrimaryMetrics uppräkningen.

Mått för scenarier med namngivn entitetsigenkänning i NLP-text

För NLP-text med namnet Entity Recognition (NER) är för närvarande "Noggrannhet" det enda primära mått som stöds.

Mått för regressionsscenarier

r2_score, normalized_mean_absolute_erroroch normalized_root_mean_squared_error försöker alla minimera förutsägelsefel. r2_score och normalized_root_mean_squared_error minimerar både genomsnittliga kvadratfel samtidigt normalized_mean_absolute_error som det genomsnittliga absoluta värdet för fel minimeras. Absolut värde behandlar fel i alla storleksklasser och kvadratfel har en mycket större straffavgift för fel med större absoluta värden. Beroende på om större fel ska straffas mer eller inte kan du välja att optimera kvadratfel eller absolut fel.

Den största skillnaden mellan r2_score och normalized_root_mean_squared_error är hur de normaliseras och deras betydelser. normalized_root_mean_squared_error är rotvärdet kvadratfel som normaliseras efter intervall och kan tolkas som den genomsnittliga felstorleken för förutsägelse. r2_score är ett genomsnittligt kvadratfel som normaliserats av en uppskattning av variansen för data. Det är den andel av variationen som modellen kan avbilda.

Om rangordningen i stället för det exakta värdet är av intresse kan spearman_correlation det vara ett bättre val. Den mäter rangrelationen mellan verkliga värden och förutsägelser.

Automatiserad ML stöder för närvarande inte några primära mått som mäter relativ skillnad mellan förutsägelser och observationer. Måtten r2_score, normalized_mean_absolute_erroroch normalized_root_mean_squared_error är alla mått på absolut skillnad. Om en förutsägelse till exempel skiljer sig från en observation med 10 enheter beräknar dessa mått samma värde om observationen är 20 enheter eller 20 000 enheter. Däremot ger en procentuell skillnad, som är ett relativt mått, fel på 50 % respektive 0,05 %. För att optimera för relativ skillnad kan du köra Automatiserad ML med ett primärt mått som stöds och sedan välja modellen med den bästa mean_absolute_percentage_error eller root_mean_squared_log_error. Dessa mått är odefinierade när eventuella observationsvärden är noll, så de kanske inte alltid är bra val.

Mått för scenarier med tidsserieprognoser

Rekommendationerna liknar rekommendationerna för regressionsscenarier.

Mått för scenarier för identifiering av bildobjekt

För identifiering av bildobjekt definieras de primära mått som stöds i ObjectDetectionPrimaryMetrics uppräkningen.

Mått för scenarier för segmentering av bildinstanser

För scenarier med segmentering av bildinstanser definieras de primära mått som stöds i InstanceSegmentationPrimaryMetrics uppräkningen.

Funktionalisering av data

I varje automatiserat maskininlärningsexperiment omvandlas dina data automatiskt till tal och talvektorer. Data skalas också och normaliseras för att hjälpa algoritmer som är känsliga för funktioner som finns i olika skalor. Dessa datatransformeringar kallas för funktionalisering.

När du konfigurerar automatiserade maskininlärningsjobb kan du aktivera eller inaktivera featurization inställningarna.

I följande tabell visas de godkända inställningarna för funktionalisering.

Följande kod visar hur anpassad funktionalisering kan tillhandahållas i det här fallet för ett regressionsjobb.

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

Avsluta villkor

Det finns några alternativ som du kan definiera i set_limits() funktionen för att avsluta experimentet innan jobbet är klart.

Köra experiment

Skicka experimentet för att köra och generera en modell.

Med det MLClient som skapas i förutsättningarna kan du köra följande kommando på arbetsytan.

# 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

Flera underordnade körningar i kluster

Automatiserade underordnade ML-experimentkörningar kan utföras på ett kluster som redan kör ett annat experiment. Tidpunkten beror dock på hur många noder klustret har och om dessa noder är tillgängliga för att köra ett annat experiment.

Varje nod i klustret fungerar som en enskild virtuell dator (VM) som kan utföra en enda träningskörning. För automatiserad ML innebär det här faktum en underordnad körning. Om alla noder är upptagna placeras ett nytt experiment i kö. Om det finns kostnadsfria noder kör det nya experimentet underordnade körningar parallellt på tillgängliga noder eller virtuella datorer.

För att hantera underordnade körningar och när de kan utföras rekommenderar vi att du skapar ett dedikerat kluster per experiment och matchar antalet max_concurrent_iterations experiment med antalet noder i klustret. På så sätt använder du alla noder i klustret samtidigt med antalet samtidiga underordnade körningar och iterationer som du vill använda.

Konfigurera max_concurrent_iterations i konfigurationen limits . Om den inte är konfigurerad tillåts som standard endast en samtidig underordnad körning/iteration per experiment. För en beräkningsinstans max_concurrent_trials kan ställas in på samma sätt som antalet kärnor på den virtuella datorn för beräkningsinstansen.

Utforska modeller och mått

Automatiserad ML erbjuder alternativ för att övervaka och utvärdera dina träningsresultat.

• Definitioner och exempel på prestandadiagram och mått som tillhandahålls för varje körning finns i Utvärdera automatiserade maskininlärningsexperimentresultat.

• Information om hur du får en funktionaliseringssammanfattning och förstår vilka funktioner som har lagts till i en viss modell finns i Funktionaliseringstransparens.

Från Azure Machine Learning-användargränssnittet på modellens sida kan du också visa de hyperparametrar som används när du tränar en viss modell och även visa och anpassa den interna modellens träningskod som används.

Registrera och distribuera modeller

När du har testat en modell och bekräftat att du vill använda den i produktion kan du registrera den för senare användning.

Använda AutoML i pipelines

Om du vill använda automatiserad ML i arbetsflöden för maskininlärningsåtgärder kan du lägga till AutoML-jobbsteg i dina Azure Machine Learning-pipelines. Med den här metoden kan du automatisera hela arbetsflödet genom att ansluta dina dataförberedelseskript till automatiserad ML. Registrera och verifiera sedan den resulterande bästa modellen.

Den här koden är en exempelpipeline med en automatiserad ML-klassificeringskomponent och en kommandokomponent som visar resultatet. Koden refererar till indata (tränings- och valideringsdata) och utdata (bästa modell) i olika steg.

# 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

Använda AutoML i stor skala: distribuerad träning

För stora datascenarier stöder automatiserad ML distribuerad träning för en begränsad uppsättning modeller:

Distribuerade träningsalgoritmer partitionerar och distribuerar automatiskt dina data över flera beräkningsnoder för modellträning.

Distribuerad utbildning för klassificering och regression

Om du vill använda distribuerad träning för klassificering eller regression anger du training_mode jobbobjektets egenskaper och max_nodes .

Följande kodexempel visar ett exempel på dessa inställningar för ett klassificeringsjobb:

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

Distribuerad träning för prognostisering

Information om hur distribuerad utbildning fungerar för prognostiseringsuppgifter finns i Prognostisering i stor skala. Om du vill använda distribuerad träning för prognostisering måste du ange training_modeegenskaperna , enable_dnn_training, max_nodes, och eventuellt max_concurrent_trials egenskaperna för jobbobjektet.

Följande kodexempel visar ett exempel på dessa inställningar för ett prognostiseringsjobb:

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

Exempel på fullständig konfigurationskod finns i föregående avsnitt om konfiguration och jobböverföring.

Relaterat innehåll

• Läs mer om hur och var du distribuerar en modell.
• Läs mer om hur du konfigurerar AutoML för att träna en prognosmodell för tidsserier.