Dela via

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

  • Artikel

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

Om du vill använda SDK-informationen installerar du Azure Machine Learning SDK v2 för Python.

Om du vill installera SDK:et kan du antingen:

  • Skapa en beräkningsinstans som redan har den senaste Azure Machine Learning Python SDK och som har konfigurerats för ML-arbetsflöden. Mer information finns i Skapa en Azure Machine Learning-beräkningsinstans.
  • Installera SDK:et på den lokala datorn.

Konfigurera din arbetsyta

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

Informationen om arbetsytan används i MLClient från azure.ai.ml för att få ett handtag till den nödvändiga Azure Machine Learning-arbetsytan.

I följande exempel används azure-standardautentisering med standardkonfigurationen eller konfigurationen av arbetsytan från en config.json fil i mappstrukturen. Om den inte hittar någon config.jsonmåste du manuellt introducera prenumerations-ID, resursgrupp och arbetsyta när du skapar MLClient.

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)

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.

Du kan skapa en MLTable med hjälp av mltable Python SDK som i följande exempel:

import mltable

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

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

Den här koden skapar en ny fil, ./train_data/MLTable, som innehåller filformatet och inläsningsinstruktionerna.

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 .

Träningsdatastorlek Valideringsteknik
Större än 20 000 rader Delning av tränings- och valideringsdata tillämpas. Standardvärdet är att ta 10 % av den inledande träningsdatauppsättningen som verifieringsuppsättning. Verifieringsuppsättningen används i sin tur för måttberäkning.
Mindre än eller lika med 20 000 rader Metoden för korsvalidering tillämpas. Standardantalet vikningar beror på antalet rader.
Om datamängden är färre än 1 000 rader används tio gånger.
Om raderna är lika med eller mellan 1 000 och 20 000 används tre veck.

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
)

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.

Klassificering Regression Prognostisering för tidsserier
Logistisk regression* Elastiskt nät* AutoARIMA
Ljus GBM* Ljus GBM* Profet
Toningshöjande* Toningshöjande* Elastiskt nät
Beslutsträd* Beslutsträd* Ljus GBM
K Närmaste grannar* K Närmaste grannar* Angränsande till K
Linjär SVC* LARS Lasso* Beslutsträd
Stödvektorklassificering (SVC)* Stochastic Gradient Descent (SGD)* Arimax
Slumpmässig skog* Slumpmässig skog LARS Lasso
Extremt randomiserade träd* Extremt randomiserade träd* Extremt randomiserade träd*
Xgboost* Xgboost* Slumpmässig skog
Naive Bayes* Xgboost TCNForecaster
Stochastic Gradient Descent (SGD)* Stochastic Gradient Descent (SGD) Toningshöjande
ExponentialSmoothing
SeasonalNaive
Medel
Naiv
SeasonalAverage

Med andra algoritmer:

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 Användningsexempel
accuracy Bildklassificering, Attitydanalys, Churn-förutsägelse
AUC_weighted Bedrägeriidentifiering, bildklassificering, avvikelseidentifiering/skräppostidentifiering
average_precision_score_weighted Attitydanalys
norm_macro_recall Förutsägelse av omsättning
precision_score_weighted

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.

Kommentar

r2_score och normalized_root_mean_squared_error fungerar också på samma sätt som primära mått. Om en fast valideringsuppsättning tillämpas optimerar dessa två mått samma mål, medelvärdet av kvadratfel och optimeras av samma modell. När endast en träningsuppsättning är tillgänglig och korsvalidering tillämpas skulle de vara något annorlunda eftersom normaliseraren för normalized_root_mean_squared_error är fast som träningsuppsättningens intervall, men normaliseraren för r2_score skulle variera för varje vik eftersom det är variansen för varje vik.

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 Användningsexempel
spearman_correlation
normalized_root_mean_squared_error Prisförutsägelse (hus/produkt/tips), Förutsägelse av granskningspoäng
r2_score Flygbolagsfördröjning, löneuppskattning, felmatchningstid
normalized_mean_absolute_error

Mått för scenarier med tidsserieprognoser

Rekommendationerna liknar rekommendationerna för regressionsscenarier.

Mått Användningsexempel
normalized_root_mean_squared_error Prisförutsägelse (prognostisering), lageroptimering, efterfrågeprognoser
r2_score Prisförutsägelse (prognostisering), lageroptimering, efterfrågeprognoser
normalized_mean_absolute_error

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.

Kommentar

Automatiserade maskininlärningssteg, till exempel funktionsnormalisering, hantering av data som saknas och konvertering av text till numeriska, blir en del av den underliggande modellen. När du använder modellen för förutsägelser tillämpas samma funktionaliseringssteg som tillämpas under träningen på dina indata automatiskt.

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.

Funktionaliseringskonfiguration beskrivning
"mode": 'auto' Anger att dataskyddsmekanismer och funktionaliseringssteg utförs automatiskt som en del av förbearbetningen. Det här värdet är standard.
"mode": 'off' Anger att funktionaliseringssteget inte ska utföras automatiskt.
"mode": 'custom' Anger att det anpassade funktionaliseringssteget ska användas.

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"},
)

Avsluta villkor

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

Villkor description
Inga villkor Om du inte definierar några slutparametrar fortsätter experimentet tills inga ytterligare framsteg görs för det primära måttet.
timeout Definierar hur länge experimentet i minuter ska fortsätta att köras. Om det inte anges är standardjobbets totala tidsgräns sex dagar (8 640 minuter). Om du vill ange en tidsgräns som är mindre än eller lika med 1 timme (60 minuter) kontrollerar du att datauppsättningens storlek inte är större än 10 000 000 (rader gånger kolumn) eller ett felresultat.

Den här tidsgränsen omfattar installations-, funktionaliserings- och träningskörningar, men inkluderar inte monterings- och modellförklarbarhetskörningar i slutet av processen eftersom dessa åtgärder måste utföras när alla utvärderingsversioner (underordnade jobb) har utförts.
trial_timeout_minutes Maximal tid i minuter som varje utvärderingsversion (underordnat jobb) kan köras för innan den avslutas. Om det inte anges används ett värde på 1 månad eller 4 3200 minuter.
enable_early_termination Om jobbet ska avslutas om poängen inte förbättras på kort sikt.
max_trials Det maximala antalet utvärderingsversioner/körningar var och en med en annan kombination av algoritmer och hyperparametrar att prova under ett jobb. Om det inte anges är standardvärdet 1 000 utvärderingsversioner. Om du använder enable_early_terminationkan antalet utvärderingsversioner vara mindre.
max_concurrent_trials Representerar det maximala antalet utvärderingsversioner (underordnade jobb) som skulle köras parallellt. Det är en bra idé att matcha det här talet med antalet noder i klustret.

Köra experiment

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

Kommentar

Om du kör ett experiment med samma konfigurationsinställningar och primärt mått flera gånger kan du se variation i varje experiments slutliga måttpoäng och genererade modeller. De algoritmer som automatiserad maskininlärning använder har inbyggd slumpmässighet som kan orsaka liten variation i modellernas utdata från experimentet och den rekommenderade modellens slutliga måttpoäng, till exempel noggrannhet. Du kan också se resultat med samma modellnamn, men olika hyperparametrar används.

Varning

Om du har angett regler i brandväggen eller nätverkssäkerhetsgruppen över din arbetsyta kontrollerar du att nödvändiga behörigheter ges till inkommande och utgående nätverkstrafik enligt definitionen i Konfigurera inkommande och utgående nätverkstrafik.

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

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.

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.

Dricks

För registrerade modeller kan du använda distribution med ett klick med hjälp av Azure Machine Learning-studio. Se Distribuera din modell.

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

Fler exempel på hur du inkluderar automatiserad ML i dina pipelines finns i exempellagringsplatsen.

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:

Distribuerad algoritm Uppgifter som stöds Datastorleksgräns (ungefärlig)
LightGBM Klassificering, regression 1 TB
TCNForecaster Prognostisering 200 GB

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

Kommentar

Korsvalidering, ensemblemodeller, ONNX-stöd och kodgenerering stöds för närvarande inte i det distribuerade träningsläget. Automatisk ML kan också göra val som att begränsa tillgängliga funktionaliserare och undersamplingsdata som används för validering, förklaring och modellutvärdering.

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 .

Property beskrivning
training_mode Anger träningsläge: distributed eller non_distributed. Standardvärdet är non_distributed.
max_nodes Antalet noder som ska användas för träning av varje utvärderingsversion. Den här inställningen måste vara större än eller lika med 4.

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
)

Kommentar

Distribuerad träning för klassificerings- och regressionsaktiviteter stöder för närvarande inte flera samtidiga utvärderingsversioner. Modellförsök körs sekventiellt med varje utvärderingsversion med hjälp av max_nodes noder. Gränsinställningen max_concurrent_trials ignoreras för närvarande.

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.

Property beskrivning
training_mode Anger träningsläge; distributed eller non_distributed. Standardvärdet är non_distributed.
enable_dnn_training Flagga för att aktivera djup neurala nätverksmodeller.
max_concurrent_trials Det här värdet är det maximala antalet utvärderingsmodeller som ska tränas parallellt. Standardvärdet är 1.
max_nodes Det totala antalet noder som ska användas för träning. Den här inställningen måste vara större än eller lika med 2. För prognostiseringsuppgifter tränas varje utvärderingsmodell med $\text{max}\left(2, \text{floor}( \text{max_nodes} / \text{max_concurrent_trials}) \right)$ noder.

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
)

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

Relaterat innehåll