Konfigurera AutoML-träning för tabelldata med Azure Mašinsko učenje 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 guiden får du lära dig hur du konfigurerar ett automatiserat maskininlärningsjobb, AutoML, träningsjobb med Azure Mašinsko učenje 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 Mašinsko učenje Studio.
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 Mašinsko učenje.
- En Azure Machine Learning-arbetsyta. Om du inte har någon kan du använda stegen i artikeln Skapa resurser för att komma igång .
Om du vill använda SDK-informationen installerar du Azure Mašinsko učenje SDK v2 för Python.
Om du vill installera SDK:et kan du antingen
- Skapa en beräkningsinstans som redan har installerat den senaste Azure Mašinsko učenje Python SDK och är förkonfigurerad för ML-arbetsflöden. Mer information finns i Skapa en Azure Mašinsko učenje beräkningsinstans.
- Installera SDK:et på den lokala datorn
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-Mašinsko učenje-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å Azure Mašinsko učenje fjärrberäkning (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* | 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 | ||
Genomsnitt | ||
Naiv | ||
SeasonalAverage |
Med ytterligare algoritmer nedan.
- 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)
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_recall
och 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_error
och 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.
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 Mašinsko učenje-användargränssnittet på modellens sida kan du också visa hyperparametrarna 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 Mašinsko učenje 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 Azure Mašinsko učenje 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_mode
egenskaperna , 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
- 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.
Feedback
https://aka.ms/ContentUserFeedback.
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i:Skicka och visa feedback för