AutoML-training instellen voor tabelgegevens met de Azure Machine Learning CLI en Python SDK

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

In dit artikel leert u hoe u een AutoML-trainingstaak instelt met de Azure Machine Learning Python SDK v2. AutoML kiest een algoritme en hyperparameters voor u en genereert een model dat gereed is voor implementatie. Dit artikel bevat informatie over de verschillende opties die u kunt gebruiken om AutoML-experimenten te configureren.

Als u liever geen code gebruikt, kunt u ook AutoML-training zonder code instellen voor tabellaire gegevens met de gebruikersinterface van studio.

Vereisten

• Een Azure-abonnement. Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint. Probeer de gratis of betaalde versie van Azure Machine Learning.
• Een Azure Machine Learning-werkruimte. Als u er nog geen hebt, raadpleegt u Resources maken om aan de slag te gaan.

Uw werkruimte instellen

Als u verbinding wilt maken met een werkruimte, moet u een abonnement, resourcegroep en werkruimte opgeven.

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>

Gegevensbron en -indeling opgeven

Als u trainingsgegevens in SDK v2 wilt leveren, moet u deze uploaden naar de cloud via een MLTable.

Vereisten voor het laden van gegevens in een MLTable:

• Gegevens moeten in tabelvorm zijn.
• De waarde die moet worden voorspeld, de doelkolom, moet in de gegevens staan.

Trainingsgegevens moeten toegankelijk zijn vanaf de externe berekening. AutoML v2 (Python SDK en CLI/YAML) accepteert MLTable-gegevensassets (v2). Voor compatibiliteit met eerdere versies ondersteunt het ook v1 Tabellaire gegevenssets van v1, een geregistreerde tabelgegevensset, via dezelfde eigenschappen van de invoergegevensset. U wordt aangeraden MLTable te gebruiken, beschikbaar in v2. In dit voorbeeld worden de gegevens opgeslagen op het lokale pad. /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'

De map ./train_data bevat nu het MLTable-definitiebestand plus het gegevensbestand, bank_marketing_train_data.csv.

Zie Werken met tabellen in Azure Machine Learning voor meer informatie over MLTable.

Trainings-, validatie- en testgegevens

U kunt afzonderlijke trainingsgegevens en validatiegegevenssets opgeven. U moet trainingsgegevens opgeven voor de training_data parameter in de fabrieksfunctie van uw AutoML-taak.

Als u niet expliciet een validation_data of n_cross_validation parameter opgeeft, past AutoML standaardtechnieken toe om te bepalen hoe validatie moet worden uitgevoerd. Deze bepaling is afhankelijk van het aantal rijen in de gegevensset die is toegewezen aan uw training_data parameter.

Compute en uitvoering van het experiment instellen

AutoML-taken met de Python SDK v2 (of CLI v2) worden momenteel alleen ondersteund in een extern rekencluster of rekenproces van Azure Machine Learning. Zie modellen trainen met Azure Machine Learning CLI, SDK en REST API voor meer informatie over het maken van berekeningen met python SDKv2 of CLIv2.

Uw experimentinstellingen configureren

U kunt verschillende opties gebruiken om uw AutoML-experiment te configureren. Deze configuratieparameters worden ingesteld in uw taakmethode. U kunt ook instellingen voor taaktraining instellen en criteria afsluiten met de training en limits instellingen.

In het volgende voorbeeld ziet u de vereiste parameters voor een classificatietaak waarmee de nauwkeurigheid wordt opgegeven als primaire metrische gegevens en vijf kruisvalidatievouws.

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

Het type machine learning-taak selecteren

Voordat u uw AutoML-taak kunt indienen, bepaalt u het soort machine learning-probleem dat u wilt oplossen. Dit probleem bepaalt welke functie uw taak gebruikt en welke modelalgoritmen worden toegepast.

AutoML ondersteunt verschillende taaktypen:

• Taken op basis van gegevens in tabelvorm

  • classificatie
  • regressie
  • Vooruitzichten

• Computer Vision-taken, waaronder

  • Classificatie van afbeeldingen
  • Objectdetectie

• Taken voor verwerking van natuurlijke taal, waaronder

  • Tekstclassificatie
  • Herkenning van entiteiten

Zie taaktypen voor meer informatie. Zie AutoML instellen voor het trainen van een tijdreeksprognosemodel voor meer informatie over het instellen van prognosetaken.

Ondersteunde algoritmen

AutoML probeert verschillende modellen en algoritmen tijdens het automatiserings- en afstemmingsproces. Als gebruiker hoeft u het algoritme niet op te geven.

De taakmethode bepaalt de lijst met algoritmen of modellen die moeten worden toegepast. Als u iteraties verder wilt wijzigen met de beschikbare modellen die u wilt opnemen of uitsluiten, gebruikt u de allowed_training_algorithms of blocked_training_algorithms parameters in de training configuratie van de taak.

In de volgende tabel verkent u de ondersteunde algoritmen per machine learning-taak.

Met andere algoritmen:

• Algoritmen voor afbeeldingsclassificatie met meerdere klassen
• Algoritmen voor afbeeldingsclassificatie met meerdere labels
• Algoritmen voor objectdetectie van afbeeldingen
• Algoritmen voor NLP-tekstclassificatie met meerdere labels
• Algoritmen voor NLP Text Named Entity Recognition (NER)

Zie bijvoorbeeld notebooks van elk taaktype, automl-standalone-jobs.

Primaire metrische gegevens

De primary_metric parameter bepaalt de metrische waarde die moet worden gebruikt tijdens de modeltraining voor optimalisatie. Het taaktype dat u kiest, bepaalt de metrische gegevens die u kunt selecteren.

Het kiezen van een primaire metriek voor AutoML om te optimaliseren, is afhankelijk van veel factoren. We raden u aan om een metrische waarde te kiezen die het beste bij uw zakelijke behoeften past. Overweeg vervolgens of de metrische waarde geschikt is voor uw gegevenssetprofiel, inclusief gegevensgrootte, bereik en klassedistributie. In de volgende secties worden de aanbevolen primaire metrische gegevens samengevat op basis van het taaktype en het bedrijfsscenario.

Zie AutoML-experimentresultaten evalueren voor meer informatie over de specifieke definities van deze metrische gegevens.

Metrische gegevens voor classificatiescenario's met meerdere klassen

Deze metrische gegevens zijn van toepassing op alle classificatiescenario's, waaronder tabelgegevens, afbeeldingen of computervisie en tekst voor natuurlijke taalverwerking (NLP-Text).

Drempelwaardeafhankelijke metrische gegevens, zoals accuracy, recall_score_weighted, norm_macro_recallen precision_score_weighted kunnen niet zo goed worden geoptimaliseerd voor gegevenssets die klein zijn, grote klasseverschil hebben (onevenwichtige klasse) of wanneer de verwachte metrische waarde zeer dicht bij 0,0 of 1,0 ligt. In die gevallen AUC_weighted kan dit een betere keuze zijn voor de primaire metrische gegevens. Nadat AutoML is voltooid, kunt u het winnende model kiezen op basis van de metrische gegevens die het meest geschikt zijn voor uw bedrijfsbehoeften.

Metrische gegevens voor classificatiescenario's met meerdere labels

Voor tekstclassificatie met meerdere labels is 'Nauwkeurigheid' momenteel de enige primaire metriek die wordt ondersteund.

Voor afbeeldingsclassificatie met meerdere labels worden de ondersteunde primaire metrische gegevens gedefinieerd in de ClassificationMultilabelPrimaryMetrics enum.

Metrische gegevens voor NLP Text Named Entity Recognition-scenario's

Voor NLP-tekst Herkenning van entiteiten (NER) is momenteel 'Nauwkeurigheid' de enige primaire metriek die wordt ondersteund.

Metrische gegevens voor regressiescenario's

r2_score, normalized_mean_absolute_erroren normalized_root_mean_squared_error alle proberen voorspellingsfouten te minimaliseren. r2_score en normalized_root_mean_squared_error minimaliseer zowel gemiddelde kwadratische fouten terwijl normalized_mean_absolute_error de gemiddelde absolute waarde van fouten wordt geminimaliseerd. Absolute waarde behandelt fouten op alle grootten en kwadratische fouten hebben een veel grotere boete voor fouten met grotere absolute waarden. Afhankelijk van of grotere fouten meer of niet moeten worden gestraft, kunt u ervoor kiezen om kwadratische fouten of absolute fouten te optimaliseren.

Het belangrijkste verschil tussen r2_score en normalized_root_mean_squared_error is hoe ze worden genormaliseerd en hun betekenissen. normalized_root_mean_squared_error is wortelgemiddelde kwadratische fout genormaliseerd per bereik en kan worden geïnterpreteerd als de gemiddelde grootte van de fout voor voorspelling. r2_score is gemiddelde kwadratische fout genormaliseerd door een schatting van de variantie van gegevens. Het is het aandeel variatie dat door het model kan worden vastgelegd.

Als de rang, in plaats van de exacte waarde, van belang is, spearman_correlation kan een betere keuze zijn. Het meet de rangcorrelatie tussen reële waarden en voorspellingen.

AutoML biedt momenteel geen ondersteuning voor primaire metrische gegevens die het relatieve verschil tussen voorspellingen en waarnemingen meten. De metrische gegevens, r2_scoreen normalized_mean_absolute_error zijn alle metingen normalized_root_mean_squared_errorvan absoluut verschil. Als een voorspelling bijvoorbeeld verschilt van een observatie met 10 eenheden, berekenen deze metrische gegevens dezelfde waarde als de observatie 20 eenheden of 20.000 eenheden is. Een percentageverschil, een relatieve meting, geeft daarentegen fouten van respectievelijk 50% en 0,05%. Als u wilt optimaliseren voor relatief verschil, kunt u AutoML uitvoeren met een ondersteunde primaire metriek en vervolgens het model selecteren met het beste mean_absolute_percentage_error of root_mean_squared_log_error. Deze metrische gegevens zijn niet gedefinieerd wanneer waarnemingswaarden nul zijn, zodat ze mogelijk niet altijd goede keuzes zijn.

Metrische gegevens voor time series-prognosescenario's

De aanbevelingen zijn vergelijkbaar met de aanbevelingen voor regressiescenario's.

Metrische gegevens voor scenario's voor objectdetectie van afbeeldingen

Voor objectdetectie van afbeeldingen worden de ondersteunde primaire metrische gegevens gedefinieerd in de ObjectDetectionPrimaryMetrics enum.

Metrische gegevens voor segmentatiescenario's van het exemplaar van installatiekopieën

Voor scenario's met segmentatie van installatiekopieën worden de ondersteunde primaire metrische gegevens gedefinieerd in de InstanceSegmentationPrimaryMetrics enum.

Gegevensmetrisatie

In elk AutoML-experiment worden uw gegevens automatisch omgezet in getallen en vectoren van getallen. De gegevens worden ook geschaald en genormaliseerd om algoritmen te helpen die gevoelig zijn voor functies die zich op verschillende schalen bevinden. Deze gegevenstransformaties worden featurization genoemd.

Wanneer u AutoML-taken configureert, kunt u de featurization instellingen in- of uitschakelen.

In de volgende tabel ziet u de geaccepteerde instellingen voor featurization.

De volgende code laat zien hoe u in dit geval aangepaste featurization kunt bieden voor een regressietaak.

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

Criteria voor afsluiten

U kunt een aantal opties definiëren in de set_limits() functie om het experiment te beëindigen voordat de taak is voltooid.

Experiment uitvoeren

Dien het experiment in om een model uit te voeren en te genereren.

Nu de MLClient vereisten zijn gemaakt, kunt u de volgende opdracht uitvoeren in de werkruimte.

# 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

Meerdere onderliggende uitvoeringen op clusters

U kunt onderliggende AutoML-experimenten uitvoeren op een cluster waarop al een ander experiment wordt uitgevoerd. De timing is afhankelijk van het aantal knooppunten dat het cluster heeft en of deze knooppunten beschikbaar zijn om een ander experiment uit te voeren.

Elk knooppunt in het cluster fungeert als een afzonderlijke virtuele machine (VM) die één trainingsuitvoering kan uitvoeren. Voor AutoML betekent dit dat een onderliggende uitvoering wordt uitgevoerd. Als alle knooppunten bezet zijn, wordt met AutoML een nieuw experiment in de wachtrij geplaatst. Als er gratis knooppunten beschikbaar zijn, wordt in het nieuwe experiment onderliggende uitvoeringen parallel uitgevoerd in de beschikbare knooppunten of virtuele machines.

Voor het beheren van onderliggende uitvoeringen en wanneer ze kunnen worden uitgevoerd, raden we u aan een toegewezen cluster per experiment te maken en het aantal van max_concurrent_iterations uw experiment te koppelen aan het aantal knooppunten in het cluster. Op deze manier gebruikt u alle knooppunten van het cluster tegelijkertijd met het aantal gelijktijdige onderliggende uitvoeringen en iteraties dat u wilt.

Configureer max_concurrent_iterations deze in de limits configuratie. Als deze niet is geconfigureerd, is standaard slechts één gelijktijdige onderliggende uitvoering/iteratie toegestaan per experiment. Voor een rekenproces kunt u instellen max_concurrent_trials dat dit hetzelfde is als het aantal kernen op de virtuele machine van het rekenproces.

Modellen en metrische gegevens verkennen

AutoML biedt opties voor het bewaken en evalueren van uw trainingsresultaten.

• Zie AutoML-experimentresultaten evalueren voor definities en voorbeelden van de prestatiegrafieken en metrische gegevens voor elke uitvoering.

• Als u een overzicht van featurization wilt krijgen en wilt weten welke functies aan een bepaald model zijn toegevoegd, raadpleegt u de transparantie van de functie.

Vanuit de Azure Machine Learning-gebruikersinterface op de pagina van het model kunt u ook de hyperparameters bekijken die worden gebruikt bij het trainen van een bepaald model en ook de trainingscode van het interne model weergeven en aanpassen.

Modellen registreren en implementeren

Nadat u een model hebt getest en hebt bevestigd dat u het in productie wilt gebruiken, kunt u het voor later gebruik registreren.

AutoML gebruiken in pijplijnen

Als u AutoML wilt gebruiken in uw werkstromen voor machine learning-bewerkingen, kunt u AutoML-taakstappen toevoegen aan uw Azure Machine Learning-pijplijnen. Met deze methode kunt u uw hele werkstroom automatiseren door uw scripts voor gegevensvoorbereiding aan AutoML te koppelen. Registreer en valideer vervolgens het resulterende beste model.

Deze code is een voorbeeldpijplijn met een AutoML-classificatieonderdeel en een opdrachtonderdeel dat de resulterende uitvoer weergeeft. De code verwijst naar de invoer (trainings- en validatiegegevens) en de uitvoer (beste model) in verschillende stappen.

# 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

AutoML op schaal gebruiken: gedistribueerde training

Voor scenario's met grote gegevens ondersteunt AutoML gedistribueerde training voor een beperkte set modellen:

Gedistribueerde trainingsalgoritmen partitioneren en distribueren uw gegevens automatisch over meerdere rekenknooppunten voor modeltraining.

Gedistribueerde training voor classificatie en regressie

Als u gedistribueerde training wilt gebruiken voor classificatie of regressie, stelt u de training_mode en max_nodes eigenschappen van het taakobject in.

In het volgende codevoorbeeld ziet u een voorbeeld van deze instellingen voor een classificatietaak:

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

Gedistribueerde training voor prognose

Zie Prognose op schaal voor meer informatie over hoe gedistribueerde training werkt voor het voorspellen van taken. Als u gedistribueerde training wilt gebruiken voor prognoses, moet u de training_mode, enable_dnn_trainingen max_nodeseventueel de max_concurrent_trials eigenschappen van het taakobject instellen.

In het volgende codevoorbeeld ziet u een voorbeeld van deze instellingen voor een prognosetaak:

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

Zie de vorige secties over het indienen van configuraties en taken voor voorbeelden van volledige configuratiecode.

Gerelateerde inhoud

• Meer informatie over hoe en waar u een model kunt implementeren.
• Meer informatie over het instellen van AutoML voor het trainen van een tijdreeksprognosemodel.