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 guiden får du lära dig hur du konfigurerar ett automatiserat maskininlärningsjobb, AutoML, träningsjobb 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 guiden innehåller information om de olika alternativ som du kan använda för att konfigurera automatiserade ML-experiment.

Om du föredrar en upplevelse utan kod kan du även konfigurera autoML-träning utan kod i Azure Machine Learning-studio.

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

Konfigurera din arbetsyta

Om du vill ansluta till en arbetsyta måste du ange ett prenumerations-, resursgrupps- och arbetsytenamn.

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 tillsammans med standardkonfigurationen för arbetsytan eller från en config.json fil som du kan ha kopierat till mappstrukturen. Om inget config.json hittas måste du manuellt introducera subscription_id, resource_group och arbetsytan 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)

Datakällor och format

För att kunna tillhandahålla träningsdata till AutoML 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), men för bakåtkompatibilitet stöder det även v1 Tabelldatauppsättningar från v1 (en registrerad tabelldatauppsättning) via samma egenskaper för indatauppsättningen. Rekommendationen är dock att använda MLTable tillgängligt i v2. I det här exemplet förutsätter vi att data lagras 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.

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

Mer information om MLTable finns i artikeln mltable how-to

Tränings-, validerings- och testdata

Du kan ange separata träningsdata och valideringsdatauppsättningar, men träningsdata måste anges för parametern training_data i fabriksfunktionen för ditt automatiserade ML-jobb.

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-/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 10 vikningar.
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 ML-jobb med Python SDK v2 (eller CLI v2) stöds för närvarande endast på Fjärrberäkning i Azure Machine Learning (kluster eller beräkningsinstans).

Läs mer om att skapa beräkning med Python SDKv2 (eller CLIv2)..

Konfigurera dina experimentinställningar

Det finns flera alternativ som du kan använda för att konfigurera ditt automatiserade ML-experiment. 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 klassificeringsaktivitet som anger noggrannhet som primärt mått och 5 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 maskininlärningsaktivitetstyp (ML-problem)

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

Automatiserad ML stöder tabelldatabaserade uppgifter (klassificering, regression, prognostisering), uppgifter för visuellt innehåll (till exempel bildklassificering och objektidentifiering) och bearbetningsuppgifter för naturligt språk (till exempel textklassificering och uppgifter för entitetsigenkänning). Mer information finns i vår artikel om uppgiftstyper . Mer information om hur du konfigurerar prognosjobb finns i vår prognosguide 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/modeller som ska tillämpas. Använd parametrarna allowed_training_algorithms eller blocked_training_algorithms i konfigurationen training av AutoML-jobbet för att ytterligare ändra iterationer med de tillgängliga modeller som ska inkluderas eller exkluderas.

I följande lista med länkar kan du utforska de algoritmer som stöds per maskininlärningsuppgift som anges nedan.

Klassificering Regression Prognostisering för tidsserier
Logistisk regression* Elastiskt nät* AutoARIMA
Ljus GBM* Ljus GBM* Profeten
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
Genomsnitt
Naiv
SeasonalAverage

Med ytterligare algoritmer nedan.

Följ den här länken om du vill ha exempel på anteckningsböcker av varje aktivitetstyp.

Primärt mått

Parametern primary_metric avgör vilket mått som ska användas under modellträningen för optimering. De tillgängliga mått som du kan välja bestäms av den aktivitetstyp du väljer.

Att välja ett primärt mått för automatiserad ML 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 (datastorlek, intervall, klassdistribution osv.). I följande avsnitt sammanfattas de rekommenderade primära måtten baserat på aktivitetstyp och affärsscenario.

Lär dig mer om de specifika definitionerna av dessa mått i Förstå automatiserade maskininlärningsresultat.

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

Dessa mått gäller för alla klassificeringsscenarier, inklusive tabelldata, bilder/visuellt innehåll och 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 ML har slutförts kan du välja den vinnande modellen baserat på måttet som passar bäst för dina affärsbehov.

Metric Exempel på användningsfall
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 textklassificering är multietiketter 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 Enum

Mått för NLP Text NER-scenarier (namngiven entitetsigenkänning)

  • För NLP Text NER (namngiven entitetsigenkänning) ä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_error och 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 får 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 man 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 andelen variation som kan fångas upp av modellen.

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, spearman_correlation kan vara ett bättre val eftersom den mäter rangrelationen mellan verkliga värden och förutsägelser.

AutoML 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 %! Om du vill optimera för relativ skillnad kan du köra AutoML med ett primärt mått som stöds och sedan välja den modell som har bäst mean_absolute_percentage_error eller root_mean_squared_log_error. Observera att dessa mått är odefinierade när eventuella observationsvärden är noll, så de kanske inte alltid är bra val.

Metric Exempel på användningsfall
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 dem som anges för regressionsscenarier.

Metric Exempel på användningsfall
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 Enum

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 Enum

Funktionalisering av data

I varje automatiserat ML-experiment omvandlas dina data automatiskt till tal och vektorer av tal och skalas och normaliseras också 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 (funktionsnormalisering, hantering av saknade data, konvertering av text till numeriska osv.) 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 dina automatiserade ML-jobb kan du aktivera/inaktivera featurization inställningarna.

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

Funktionaliseringskonfiguration beskrivning
"mode": 'auto' Anger att som en del av förbearbetningen utförs dataskyddsmekanismer och funktionaliseringssteg automatiskt. Standardinställning.
"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 har slutförts.

Villkor description
Inga villkor Om du inte definierar några slutparametrar fortsätter experimentet tills inga ytterligare framsteg görs för ditt primära mått.
timeout Definierar hur länge experimentet i minuter ska fortsätta att köras. Om det inte anges är standardjobbets totala tidsgräns 6 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 konfigurations-, 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 slutfö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 AutoML-jobb. Om det inte anges är standardvärdet 1 000 utvärderingsversioner. Om du använder enable_early_termination antalet utvärderingsversioner kan det 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

Kommentar

Om du kör ett experiment med samma konfigurationsinställningar och primärt mått flera gånger ser du förmodligen variation i varje experiments slutliga måttpoäng och genererade modeller. De algoritmer som automatiserad ML 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 kommer förmodligen också att se resultat med samma modellnamn, men olika hyperparametrar används.

Varning

Om du har angett regler i brandväggen och/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.

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

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 detta en underordnad körning. Om alla noder är upptagna placeras ett nytt experiment i kö. Men om det finns kostnadsfria noder kommer det nya experimentet att köra automatiserade ML-underordnade körningar parallellt på tillgängliga noder/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 det antal samtidiga underordnade körningar/iterationer som du vill använda.

Konfigurera max_concurrent_iterations i konfigurationen limits . Om den inte har konfigurerats tillåts som standard endast en samtidig underordnad körning/iteration per experiment. När det gäller beräkningsinstanser 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 är distribution med ett klick tillgängligt via Azure Machine Learning-studio. Se hur du distribuerar registrerade modeller från studion.

AutoML i pipelines

Om du vill använda AutoML i dina MLOps-arbetsflöden kan du lägga till AutoML-jobbsteg i dina Azure Machine Learning-pipelines. På så sätt kan du automatisera hela arbetsflödet genom att ansluta dina dataförberedelseskript till AutoML och sedan registrera och validera den resulterande bästa modellen.

Nedan visas en exempelpipeline med en AutoML-klassificeringskomponent och en kommandokomponent som visar resulterande AutoML-utdata. Observera hur indata (tränings- och valideringsdata) och utdata (bästa modell) refereras 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 AutoML i dina pipelines finns i vår lagringsplats för exempel.

AutoML i stor skala: distribuerad träning

För stora datascenarier stöder AutoML 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. AutoML 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 utbildning för klassificering eller regression måste du ange 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 AutoML-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

Mer information om hur distribuerad utbildning fungerar för prognostiseringsuppgifter finns i vår artikel om 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 ä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
)

Se föregående avsnitt om konfiguration och jobböverföring för exempel på fullständig konfigurationskod.

Nästa steg