Konfigurera AutoML för att träna en prognosmodell för tidsserier med SDK och CLI

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

Automatisk maskininlärning (AutoML) i Azure Machine Learning använder standardmodeller för maskininlärning tillsammans med välkända tidsseriemodeller för att skapa prognoser. Den här metoden innehåller historisk information om målvariabeln med funktioner som tillhandahålls av användaren i indata och automatiskt utformade funktioner. Modellsökningsalgoritmer hjälper till att identifiera modeller med bästa förutsägelsenoggrannhet. Mer information finns i prognostiseringsmetodik och modellsanering och urval.

Den här artikeln beskriver hur du konfigurerar AutoML för tidsserieprognoser med Machine Learning med hjälp av Azure Machine Learning Python SDK](/python/api/overview/azure/ai-ml-readme). Processen omfattar förberedelse av data för träning och konfiguration av tidsserieparametrar i ett prognostiseringsjobb (klassreferens).. Sedan tränar, härleder och utvärderar du modeller med hjälp av komponenter och pipelines.

En lågkodsupplevelse finns i Självstudie: Prognostisera efterfrågan med automatiserad maskininlärning. Den här resursen är ett exempel på tidsserieprognoser som använder AutoML i Azure Machine Learning-studio.

Förutsättningar

• En Azure Machine Learning-arbetsyta. Information om hur du skapar en arbetsyta finns i Skapa arbetsyteresurser.
• Möjligheten att starta AutoML-träningsjobb. Mer information finns i Konfigurera AutoML-träning för tabelldata med Azure Machine Learning CLI och Python SDK.

Förbereda tränings- och valideringsdata

Indata för AutoML-prognostisering måste innehålla en giltig tidsserie i tabellformat. Varje variabel måste ha en egen motsvarande kolumn i datatabellen. AutoML kräver minst två kolumner: en tidskolumn för att representera tidsaxeln och en målkolumn för den kvantitet som ska prognostiseras. Andra kolumner kan fungera som prediktorer. Mer information finns i Hur AutoML använder dina data.

Viktigt!

När du tränar en modell för prognostisering av framtida värden ska du se till att alla funktioner som används i träning också kan användas när du kör förutsägelser för din avsedda horisont.

Överväg en funktion för aktuell aktiekurs, vilket kan öka träningsnoggrannheten kraftigt. Om du förutspår med en lång horisont kanske du inte kan förutsäga framtida aktievärden som motsvarar framtida tidsseriepunkter. Den här metoden kan minska modellens noggrannhet.

AutoML-prognosjobb kräver att dina träningsdata representeras som ett MLTable objekt. Ett MLTable objekt anger en datakälla och steg för att läsa in data. Mer information och användningsfall finns i [Arbeta med tabeller(how-to-mltable.md).

Anta i följande exempel att dina träningsdata finns i en CSV-fil i en lokal katalog, ./train_data/timeseries_train.csv.

Python SDK

Du kan skapa ett MLTable objekt med hjälp av mltable Python SDK enligt följande exempel:

import mltable

paths = [
    {'file': './train_data/timeseries_train.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.

Om du vill starta träningsjobbet definierar du ett indataobjekt med hjälp av Python SDK enligt följande:

from azure.ai.ml.constants import AssetTypes
from azure.ai.ml import Input

# Training MLTable defined locally, with local data to be uploaded
my_training_data_input = Input(
    type=AssetTypes.MLTABLE, path="./train_data"
)

Azure CLI

Du kan definiera ett nytt MLTable objekt genom att kopiera följande YAML-kodfragment till en ny fil, ./train_data/MLTable:

$schema: https://azuremlschemas.azureedge.net/latest/MLTable.schema.json

type: mltable
paths:
    - file: ./timeseries_train.csv

transformations:
    - read_delimited:
        delimiter: ','
        encoding: ascii

Börja skapa YAML-konfigurationen för AutoML-jobbet med de träningsdata som anges enligt följande exempel:

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

# Training data MLTable for the AutoML job
training_data:
    path: "./train_data"
    type: mltable

validation_data:
    # Optional validation data

compute: # Compute for training job
primary_metric: # Primary metric  

target_column_name: # Target column name
n_cross_validations: # Cross validation setting

limits:
    # Limit settings

forecasting:
    # Forecasting specific settings

training:
    # Training settings 

Lägg till mer information i den här konfigurationen i efterföljande avsnitt i den här artikeln. I det här exemplet är platsen ./automl-forecasting-job.yml.

Du anger valideringsdata på ett liknande sätt. Skapa ett MLTable objekt och ange indata för valideringsdata. Om du inte anger valideringsdata skapar AutoML automatiskt korsvalideringsdelningar från dina träningsdata som ska användas för modellval. Mer information finns i följande resurser:

• Välj prognosmodeller
• Ange krav för träningsdatalängd
• Förhindra överanpassning med korsvalidering

Skapa beräkning för att köra experiment

AutoML använder Azure Machine Learning Compute, som är en fullständigt hanterad beräkningsresurs, för att köra träningsjobbet. I följande exempel skapas ett beräkningskluster med namnet cpu-compute.

Python SDK

from azure.ai.ml.entities import AmlCompute

# specify aml compute name.
cpu_compute_target = "cpu-cluster"

try:
    ml_client.compute.get(cpu_compute_target)
except Exception:
    print("Creating a new cpu compute target...")
    compute = AmlCompute(
        name=cpu_compute_target, size="STANDARD_D2_V2", min_instances=0, max_instances=4
    )
    ml_client.compute.begin_create_or_update(compute).result()

Azure CLI

Du kan skapa en ny beräkning med namnet cpu-compute med följande Azure CLI-kommando:

az ml compute create -n cpu-compute --type amlcompute --min-instances 0 --max-instances 4

Referera till beräkningen i jobbdefinitionen på följande sätt:

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

# Set training data MLTable for the AutoML job
training_data:
    path: "./train_data"
    type: mltable

# Set compute for the training job to use 
compute: azureml:cpu-compute

primary_metric: # Primary metric  

target_column_name: # Target column name
n_cross_validations: # Cross validation setting

limits:
    # Limit settings

forecasting:
    # Forecasting specific settings

training:
    # Training settings

Konfigurera experiment

I följande exempel visas hur du konfigurerar experimentet.

Python SDK

Du använder AutoML-fabriksfunktionerna för att konfigurera prognostiseringsjobb i Python SDK. I följande exempel visas hur du skapar ett prognostiseringsjobb genom att ange det primära måttet och ange gränser för träningskörningen:

from azure.ai.ml import automl

# Set forecasting variables
# As needed, modify the variable values to run the snippet successfully
forecasting_job = automl.forecasting(
    compute="cpu-compute",
    experiment_name="sdk-v2-automl-forecasting-job",
    training_data=my_training_data_input,
    target_column_name=target_column_name,
    primary_metric="normalized_root_mean_squared_error",
    n_cross_validations="auto",
)

# Set optional limits
forecasting_job.set_limits(
    timeout_minutes=120,
    trial_timeout_minutes=30,
    max_concurrent_trials=4,
)

Azure CLI

Konfigurera allmänna egenskaper för AutoML-jobbet, inklusive:

• Det primära måttet
• Namnet på målkolumnen i träningsdata
• Inställningarna för korsvalidering
• Resursbegränsningar för jobbet

Mer information finns i yaml-schemat för prognostiseringskommandot, träningsparametrar och gränser.

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:cpu-compute

# Settings for primary metric, target/label column name, cross validation
primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Settings for training job limits on time, concurrency, and others
limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

forecasting:
    # Forecasting specific settings

training:
    # Training settings

Prognostisera jobbinställningar

Prognostiseringsaktiviteter har många inställningar som är specifika för prognostisering. Den mest grundläggande av dessa inställningar är namnet på tidskolumnen i träningsdata och prognoshorisonten.

Python SDK

Använd metoderna ForecastingJob för att konfigurera de här inställningarna:

# Forecasting specific configuration
forecasting_job.set_forecast_settings(
    time_column_name=time_column_name,
    forecast_horizon=24
)

Azure CLI

De här inställningarna konfigureras i forecasting avsnittet i jobbets YAML-konfiguration:

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

# Forecasting specific settings
# Set the horizon to 24 for this example, the horizon generally depends on the business scenario
forecasting:
    time_column_name: <time_column_name>
    forecast_horizon: 24

training:
    # Training settings

Tidskolumnnamnet är en obligatorisk inställning. Du bör vanligtvis ange prognoshorisonten enligt ditt förutsägelsescenario. Om dina data innehåller flera tidsserier kan du ange namnen på tidsserie-ID-kolumnerna . När dessa kolumner grupperas definierar de den enskilda serien. Anta till exempel att du har data som består av timförsäljning från olika butiker och varumärken. Följande exempel visar hur du anger kolumner för tidsserie-ID förutsatt att data innehåller kolumner med namnet store och varumärke:

Python SDK

# Forecasting specific configuration
# Add time series IDs for store and brand
forecasting_job.set_forecast_settings(
    ...,  # Other settings
    time_series_id_column_names=['store', 'brand']
)

Azure CLI

# Forecasting specific settings
# Add time series IDs for store and brand
forecasting:
    # Other settings
    time_series_id_column_names: ["store", "brand"]

AutoML försöker automatiskt identifiera tidsserie-ID-kolumner i dina data om ingen anges.

Andra inställningar är valfria och granskas i följande avsnitt.

Valfria inställningar för prognostiseringsjobb

Valfria konfigurationer är tillgängliga för prognostiseringsuppgifter, till exempel att aktivera djupinlärning och ange en målsammanfattning för rullande fönster. En fullständig lista över parametrar finns i referensdokumentationen.

Inställningar för modellsökning

Det finns två valfria inställningar som styr modellutrymmet där AutoML söker efter den bästa modellen: allowed_training_algorithms och blocked_training_algorithms. Om du vill begränsa sökutrymmet till en viss uppsättning modellklasser använder du parametern allowed_training_algorithms enligt följande exempel:

Python SDK

# Only search ExponentialSmoothing and ElasticNet models
forecasting_job.set_training(
    allowed_training_algorithms=["ExponentialSmoothing", "ElasticNet"]
)

Azure CLI

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

forecasting:
    time_column_name: <time_column_name>
    forecast_horizon: 24

# Training settings
# Only search ExponentialSmoothing and ElasticNet models
training:
    allowed_training_algorithms: ["ExponentialSmoothing", "ElasticNet"]
    # Other training settings

I det här scenariot söker prognosjobbet endast över modellklasserna Exponential Smoothing och Elastic Net. Om du vill ta bort en viss uppsättning modellklasser från sökutrymmet blocked_training_algorithms använder du det som visas i följande exempel:

Python SDK

# Search over all model classes except Prophet
forecasting_job.set_training(
    blocked_training_algorithms=["Prophet"]
)

Azure CLI

# Training settings
# Search over all model classes except Prophet
training:
    blocked_training_algorithms: ["Prophet"]
    # other training settings

Jobbet söker igenom alla modellklasser utom Prophet. En lista över prognosmodellnamn som accepteras i och blocked_training_algorithmsfinns i allowed_training_algorithms träningsegenskaper. Du kan använda antingen men inte både allowed_training_algorithms och blocked_training_algorithms på en träningskörning.

Aktivera inlärning för djupa neurala nätverk

AutoML levereras med en anpassad DNN-modell (Deep Neural Network) med namnet TCNForecaster. Den här modellen är ett tidsmässigt konvolutional nätverk (TCN), som tillämpar vanliga metoder för avbildningsaktiviteter för tidsseriemodellering. Endimensionella "kausala" faltningar utgör nätverkets stamnät och gör det möjligt för modellen att lära sig komplexa mönster under långa perioder i träningshistoriken. Mer information finns i Introduktion till TCNForecaster.

TCNForecaster uppnår ofta högre noggrannhet än standardtidsseriemodeller när det finns tusentals eller fler observationer i träningshistoriken. Men det tar också längre tid att träna och sopa över TCNForecaster-modeller på grund av deras högre kapacitet.

Du kan aktivera TCNForecaster i AutoML genom att ange enable_dnn_training flaggan i träningskonfigurationen på följande sätt:

Python SDK

# Include TCNForecaster models in the model search
forecasting_job.set_training(
    enable_dnn_training=True
)

Azure CLI

# Training settings
# Include TCNForecaster models in the model search
training:
    enable_dnn_training: true
    # Other training settings

Som standard är TCNForecaster-träning begränsad till en enda beräkningsnod och en enda GPU, om tillgängligt, per modellutvärdering. För stora datascenarier rekommenderar vi att du distribuerar varje TCNForecaster-utvärderingsversion över flera kärnor/GPU:er och noder. Mer information och kodexempel finns i distribuerad utbildning.

Information om hur du aktiverar DNN för ett AutoML-experiment som skapats i Azure Machine Learning-studio finns i inställningarna för aktivitetstyp i studiogränssnittet.

Kommentar

• När du aktiverar DNN för experiment som skapats med SDK inaktiveras de bästa modellförklaringarna .
• DNN-stöd för prognostisering i Automatiserad maskininlärning stöds inte för körningar som initieras i Azure Databricks.
• Den rekommenderade metoden är att använda GPU-beräkningstyper när DNN-träning är aktiverad.

Funktioner för fördröjning och rullande fönster

De senaste värdena för målet är ofta effektfulla funktioner i en prognosmodell. Därför kan AutoML skapa tidsfördröjnings- och rullande fönsteraggregeringsfunktioner för att potentiellt förbättra modellens noggrannhet.

Tänk dig ett scenario för prognostisering av energiefterfrågan där väderdata och historisk efterfrågan är tillgängliga. Tabellen visar resulterande funktionsframställning som inträffar när fönsteraggregering tillämpas under de senaste tre timmarna. Kolumner för minimum, maximum och sum genereras i ett skjutfönster på tre timmar baserat på de definierade inställningarna. För observationen som är giltig den 8 september 2017 04:00 beräknas till exempel de högsta, lägsta och totala värdena med hjälp av efterfrågevärdena för 8 september 2017 01:00–03:00. Det här fönstret med tre timmar skiftar för att fylla i data för de återstående raderna. Mer information och exempel finns i Lag-funktionerna för tidsserieprognoser i AutoML.

Du kan aktivera aggregeringsfunktioner för fördröjning och rullande fönster för målet genom att ange storleken på rullande fönster och de fördröjningsbeställningar som du vill skapa. Fönsterstorleken var tre i föregående exempel. Du kan också aktivera fördröjningar för funktioner med inställningen feature_lags . I följande exempel är alla dessa inställningar inställda på att auto instruera AutoML att automatiskt fastställa inställningar genom att analysera korrelationsstrukturen för dina data:

Python SDK

forecasting_job.set_forecast_settings(
    ...,  # Other settings
    target_lags='auto', 
    target_rolling_window_size='auto',
    feature_lags='auto'
)

Azure CLI

# Forecasting specific settings
# Auto configure lags and rolling window features
forecasting:
    target_lags: auto
    target_rolling_window_size: auto
    feature_lags: auto
    # Other settings

Kort seriehantering

AutoML betraktar en tidsserie som en kort serie om det inte finns tillräckligt med datapunkter för att genomföra tränings- och valideringsfaserna för modellutveckling. Mer information finns i krav på datalängd för träning.

AutoML har flera åtgärder som kan utföras för korta serier. Dessa åtgärder kan konfigureras med inställningen short_series_handling_config . Standardvärdet är auto. Inställningarna beskrivs i följande tabell:

Inställning	beskrivning	Kommentar
auto	Standardvärdet för kort seriehantering.	– Om alla serier är korta kan du fylla på data. - Om inte alla serier är korta, släpp den korta serien.
pad	Om inställningen short_series_handling_config = pad används lägger AutoML till slumpmässiga värden i varje kort serie som hittas. AutoML fyller ut målkolumnen med vitt brus.	Du kan använda följande kolumntyper med angiven utfyllnad: - Objektkolumner, kudde med NaNs - Numeriska kolumner, kudde med 0 (noll) - Booleska/logiska kolumner, kudde med False
drop	Om inställningen short_series_handling_config = drop används släpper AutoML den korta serien och används inte för träning eller förutsägelse.	Förutsägelser för dessa serier returnerar NaN.
None	Ingen serie är vadderad eller tappad.

I följande exempel anges kortseriehanteringen så att alla korta serier är vadderade till den minsta längden:

Python SDK

forecasting_job.set_forecast_settings(
    ...,  # Other settings
    short_series_handling_config='pad'
)

Azure CLI

# Forecasting specific settings
# Auto configure lags and rolling window features
forecasting:
    short_series_handling_config: pad
    # Other settings

Varning

Utfyllnad kan påverka den resulterande modellens noggrannhet eftersom den introducerar artificiella data för att undvika träningsfel. Om många av serierna är korta kan du också se en viss inverkan på förklaringsresultaten.

Sammansättning av frekvens- och måldata

Använd alternativen frekvens och dataaggregering för att undvika fel som orsakas av oregelbundna data. Dina data är oregelbundna om de inte följer en angiven takt i tiden, till exempel varje timme eller varje dag. Point-of-sales-data är ett bra exempel på oregelbundna data. I dessa scenarier kan AutoML aggregera dina data till önskad frekvens och sedan skapa en prognosmodell från aggregeringarna.

Du måste ange frequency inställningarna och target_aggregate_function för att hantera oregelbundna data. Frekvensinställningen accepterar Pandas DateOffset-strängar som indata. I följande tabell visas värden som stöds för aggregeringsfunktionen:

Function	beskrivning
sum	Summan av målvärden
mean	Medelvärde eller medelvärde för målvärden
min	Minimivärde för ett mål
max	Maximalt värde för ett mål

AutoML tillämpar aggregering för följande kolumner:

Column	Sammansättningsmetod
Numeriska prediktorer	AutoML använder sumfunktionerna , mean, minoch max . Den genererar nya kolumner, där varje kolumnnamn innehåller ett suffix som identifierar namnet på sammansättningsfunktionen som tillämpas på kolumnvärdena.
Kategoriska prediktorer	AutoML använder värdet för parametern forecast_mode för att aggregera data. Det är den mest framträdande kategorin i fönstret. Mer information finns i beskrivningarna av parametern i pipelinen Många modeller och HTS-pipelineavsnitten .
Data förutsägare	AutoML använder det lägsta målvärdet (min), det maximala målvärdet (max) och forecast_mode parameterinställningarna för att aggregera data.
Mål	AutoML aggregerar värdena enligt den angivna åtgärden. Vanligtvis är funktionen sum lämplig för de flesta scenarier.

I följande exempel anges frekvensen till varje timme och aggregeringsfunktionen till sammanfattning:

Python SDK

# Aggregate the data to hourly frequency
forecasting_job.set_forecast_settings(
    ...,  # Other settings
    frequency='H',
    target_aggregate_function='sum'
)

Azure CLI

# Forecasting specific settings
# Auto configure lags and rolling window features
forecasting:
    frequency: H
    target_aggregate_function: sum
    # Other settings

Anpassade inställningar för korsvalidering

Det finns två anpassningsbara inställningar som styr korsvalidering för prognostiseringsjobb. Anpassa antalet vikningar med parametern n_cross_validations och konfigurera parametern cv_step_size för att definiera tidsförskjutningen mellan vikningar. Mer information finns i val av prognosmodell.

Som standard anger AutoML båda inställningarna automatiskt baserat på dina datas egenskaper. Avancerade användare kanske vill ange dem manuellt. Anta till exempel att du har dagliga försäljningsdata och att du vill att valideringskonfigurationen ska bestå av fem gånger med en sjudagars förskjutning mellan intilliggande veck. Följande kodexempel visar hur du anger dessa värden:

Python SDK

from azure.ai.ml import automl

# Create a job with five CV folds
forecasting_job = automl.forecasting(
    ...,  # Other training parameters
    n_cross_validations=5,
)

# Set the step size between folds to seven days
forecasting_job.set_forecast_settings(
    ...,  # Other settings
    cv_step_size=7
)

Azure CLI

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Use five CV folds
n_cross_validations: 5

# Set the step size between folds to seven days
forecasting:
    cv_step_size: 7
    # Other settings

limits:
    # Limit settings

training:
    # Training settings

Anpassad funktionalisering

Som standard utökar AutoML träningsdata med konstruerade funktioner för att öka modellernas noggrannhet. Mer information finns i automatiserad funktionsutveckling. Vissa av förbearbetningsstegen kan anpassas med hjälp av konfigurationen av prognostiseringsjobbet.

I följande tabell visas de anpassningar som stöds för prognostisering:

Anpassning	beskrivning	Alternativ
Uppdatering av kolumnsyfte	Åsidosätt den automatiskt identifierade funktionstypen för den angivna kolumnen.	categorical, , dateTimenumeric
Uppdatering av transformeringsparameter	Uppdatera parametrarna för den angivna imputern.	{"strategy": "constant", "fill_value": <value>}, , {"strategy": "median"}{"strategy": "ffill"}

Anta till exempel att du har ett scenario för detaljhandelsefterfrågan där data innehåller priser, en on sale flagga och en produkttyp. I följande exempel visas hur du kan ange anpassade typer och imputer för dessa funktioner:

Python SDK

from azure.ai.ml.automl import ColumnTransformer

# Customize imputation methods for price and is_on_sale features
# Median value imputation for price, constant value of zero for is_on_sale
transformer_params = {
    "imputer": [
        ColumnTransformer(fields=["price"], parameters={"strategy": "median"}),
        ColumnTransformer(fields=["is_on_sale"], parameters={"strategy": "constant", "fill_value": 0}),
    ],
}

# Set the featurization
# Ensure product_type feature is interpreted as categorical
forecasting_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    column_name_and_types={"product_type": "Categorical"},
)

Azure CLI

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Customize imputation methods for price and is_on_sale features
# Median value imputation for price, constant value of zero for is_on_sale
featurization:
    mode: custom
    column_name_and_types:
        product_type: Categorical
    transformer_params:
        imputer:
            - fields: ["price"]
            parameters:
                strategy: median
            - fields: ["is_on_sale"]
            parameters:
                strategy: constant
                fill_value: 0

forecasting:
    # Forecasting specific settings

limits:
    # Limit settings

training:
    # Training settings

Om du använder Azure Machine Learning-studio för experimentet kan du läsa Konfigurera inställningar för funktionalisering i studion.

Skicka prognostiseringsjobb

När du har konfigurerat alla inställningar är du redo att köra prognostiseringsjobbet. I följande exempel visas den här processen.

Python SDK

# Submit the AutoML job
returned_job = ml_client.jobs.create_or_update(
    forecasting_job
)

print(f"Created job: {returned_job}")

# Get a URL for the job in the studio UI
returned_job.services["Studio"].endpoint

Azure CLI

I följande Azure CLI-kommando finns jobbets YAML-konfiguration i den aktuella arbetskatalogen på sökvägen . /automl-forecasting-job.yml. Om du kör kommandot från en annan katalog måste du ändra sökvägen i enlighet med detta.

run_id=$(az ml job create --file automl-forecasting-job.yml)

Du kan använda det lagrade körnings-ID:t för att returnera information om jobbet. Parametern --web öppnar Azure Machine Learning-studio webbgränssnitt där du kan se information om jobbet:

az ml job show -n $run_id --web

När du har skickat jobbet etablerar AutoML beräkningsresurser, tillämpar funktionalisering och andra förberedelsesteg på indata och börjar sopa över prognosmodeller. Mer information finns i prognostiseringsmetodik i AutoML och Modellsanering och val för prognostisering i AutoML.

Samordna utbildning, slutsatsdragning och utvärdering med komponenter och pipelines

Ditt arbetsflöde för maskininlärning kräver troligen mer än bara träning. Slutsatsdragning eller hämtning av modellförutsägelser på nyare data och utvärdering av modellnoggrannhet på en testuppsättning med kända målvärden är andra vanliga uppgifter som du kan samordna i Azure Machine Learning tillsammans med träningsjobb. För att stödja slutsatsdragnings- och utvärderingsuppgifter tillhandahåller Azure Machine Learning komponenter, som är fristående koddelar som utför ett steg i en Azure Machine Learning-pipeline.

Python SDK

I följande exempel hämtar du komponentkod från ett klientregister:

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Get credential to access AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if token can be obtained successfully
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Create client to access assets in AzureML preview registry
ml_client_registry = MLClient(
    credential=credential,
    registry_name="azureml-preview"
)

# Create client to access assets in AzureML registry
ml_client_metrics_registry = MLClient(
    credential=credential,
    registry_name="azureml"
)

# Get inference component from registry
inference_component = ml_client_registry.components.get(
    name="automl_forecasting_inference",
    label="latest"
)

# Get component to compute evaluation metrics from registry
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

Definiera sedan en fabriksfunktion som skapar pipelines som orkestrerar träning, slutsatsdragning och måttberäkning. Mer information finns i Konfigurera experiment.

from azure.ai.ml import automl
from azure.ai.ml.constants import AssetTypes
from azure.ai.ml.dsl import pipeline

@pipeline(description="AutoML Forecasting Pipeline")
def forecasting_train_and_evaluate_factory(
    train_data_input,
    test_data_input,
    target_column_name,
    time_column_name,
    forecast_horizon,
    primary_metric='normalized_root_mean_squared_error',
    cv_folds='auto'
):
    # Configure training node of pipeline
    training_node = automl.forecasting(
        training_data=train_data_input,
        target_column_name=target_column_name,
        primary_metric=primary_metric,
        n_cross_validations=cv_folds,
        outputs={"best_model": Output(type=AssetTypes.MLFLOW_MODEL)},
    )

    training_node.set_forecasting_settings(
        time_column_name=time_column_name,
        forecast_horizon=max_horizon,
        frequency=frequency,
        # Other settings
        ... 
    )
    
    training_node.set_training(
        # Training parameters
        ...
    )
    
    training_node.set_limits(
        # Limit settings
        ...
    )

    # Configure inference node to make rolling forecasts on test set
    inference_node = inference_component(
        test_data=test_data_input,
        model_path=training_node.outputs.best_model,
        target_column_name=target_column_name,
        forecast_mode='rolling',
        step=1
    )

    # Configure metrics calculation node
    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        ground_truth=inference_node.outputs.inference_output_file,
        prediction=inference_node.outputs.inference_output_file,
        evaluation_config=inference_node.outputs.evaluation_config_output_file
    )

    # Return dictionary with evaluation metrics and raw test set forecasts
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result,
        "rolling_fcst_result": inference_node.outputs.inference_output_file
    }

Definiera tränings- och testdataindata som finns i lokala mappar ./train_data och ./test_data.

my_train_data_input = Input(
    type=AssetTypes.MLTABLE,
    path="./train_data"
)

my_test_data_input = Input(
    type=AssetTypes.URI_FOLDER,
    path='./test_data',
)

Slutligen skapar du pipelinen, anger dess standardberäkning och skickar jobbet:

pipeline_job = forecasting_train_and_evaluate_factory(
    my_train_data_input,
    my_test_data_input,
    target_column_name,
    time_column_name,
    forecast_horizon
)

# Set pipeline level compute
pipeline_job.settings.default_compute = compute_name

# Submit pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

Azure CLI

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

description: AutoML Forecasting Pipeline
experiment_name: cli-v2-automl-forecasting-pipeline

# Set default compute for pipeline steps
settings:
    default_compute: cpu-compute

# Pipeline inputs
inputs:
    train_data_input:
        type: mltable
        path: "./train_data"
    test_data_input:
        type: uri_folder
        path: "./test_data"
    target_column_name: <target column name>
    time_column_name: <time column name>
    forecast_horizon: <forecast horizon>
    primary_metric: normalized_root_mean_squared_error
    cv_folds: auto

# Set pipeline outputs
# Output the evaluation metrics and raw test set rolling forecasts
outputs: 
    metrics_result:
        type: uri_file
        mode: upload
    rolling_fcst_result:
        type: uri_file
        mode: upload

jobs:
  # Configure automl training node of pipeline 
    training_node:
        type: automl
        task: forecasting
        primary_metric: ${{parent.inputs.primary_metric}}
        target_column_name: ${{parent.inputs.target_column_name}}
        training_data: ${{parent.inputs.train_data_input}}
        n_cross_validations: ${{parent.inputs.cv_folds}}
        training:
            # Training settings
        forecasting:
            time_column_name: ${{parent.inputs.time_column_name}}
            forecast_horizon: ${{parent.inputs.forecast_horizon}}
            # Other forecasting specific settings
        limits:
            # Limit settings
        outputs:
            best_model:
                type: mlflow_model

    # Configure inference node to make rolling forecasts on test set
    inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_forecasting_inference
        inputs:
            target_column_name: ${{parent.inputs.target_column_name}}
            forecast_mode: rolling
            step: 1
            test_data: ${{parent.inputs.test_data_input}}
            model_path: ${{parent.jobs.training_node.outputs.best_model}}
        outputs:
            inference_output_file: ${{parent.outputs.rolling_fcst_result}}
            evaluation_config_output_file:
                type: uri_file

    # Configure metrics calculation node
    compute_metrics:
        type: command
        component: azureml://registries/azureml/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.inference_node.outputs.inference_output_file}}
            prediction: ${{parent.jobs.inference_node.outputs.inference_output_file}}
            evaluation_config: ${{parent.jobs.inference_node.outputs.evaluation_config_output_file}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

AutoML kräver träningsdata i MLTable-format för AutoML.

Starta pipelinekörningen med hjälp av följande kommando. Pipelinekonfigurationen finns på sökvägen ./automl-forecasting-pipeline.yml:

run_id=$(az ml job create --file automl-forecasting-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>)

När du har skickat körningsbegäran kör pipelinen AutoML-träning, löpande utvärderingsslutsats och måttberäkning i följd. Du kan övervaka och inspektera körningen i studiogränssnittet. När körningen är klar kan du ladda ned de löpande prognoserna och utvärderingsmåtten till den lokala arbetskatalogen:

Python SDK

# Download metrics JSON
ml_client.jobs.download(returned_pipeline_job.name, download_path=".", output_name='metrics_result')

# Download rolling forecasts
ml_client.jobs.download(returned_pipeline_job.name, download_path=".", output_name='rolling_fcst_result')

Azure CLI

az ml job download --name $run_id --download-path . --output-name metrics_result
az ml job download --name $run_id --download-path . --output-name rolling_fcst_result

Du kan granska utdata på följande platser:

• Mått: ./named-outputs/metrics_results/evaluationResult/metrics.json
• Prognoser: ./named-outputs/rolling_fcst_result/inference_output_file (JSON-linjeformat)

Mer information om löpande utvärdering finns i Slutsatsdragning och utvärdering av prognosmodeller.

Prognos i stor skala: Många modeller

Med de många modellkomponenterna i AutoML kan du träna och hantera miljontals modeller parallellt. Mer information om många modeller finns i Många modeller.

Träningskonfiguration för många modeller

Träningskomponenten för många modeller accepterar en YAML-formatkonfigurationsfil med AutoML-träningsinställningar. Komponenten tillämpar dessa inställningar på varje AutoML-instans som startas. YAML-filen har samma specifikation som kommandojobbet Prognostisering plus parametrarna partition_column_names ochallow_multi_partitions.

Parameter	Description
partition_column_names	Kolumnnamn i data som, när de grupperas, definierar datapartitionerna. Träningskomponenten många modeller startar ett oberoende träningsjobb på varje partition.
allow_multi_partitions	En valfri flagga som tillåter träning av en modell per partition när varje partition innehåller mer än en unik tidsserie. Standardvärdet är false.

I följande exempel finns en YAML-exempelkonfiguration:

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

description: A time-series forecasting job config
compute: azureml:<cluster-name>
task: forecasting
primary_metric: normalized_root_mean_squared_error
target_column_name: sales
n_cross_validations: 3

forecasting:
  time_column_name: date
  time_series_id_column_names: ["state", "store"]
  forecast_horizon: 28

training:
  blocked_training_algorithms: ["ExtremeRandomTrees"]

limits:
  timeout_minutes: 15
  max_trials: 10
  max_concurrent_trials: 4
  max_cores_per_trial: -1
  trial_timeout_minutes: 15
  enable_early_termination: true
  
partition_column_names: ["state", "store"]
allow_multi_partitions: false

I efterföljande exempel lagras konfigurationen på sökvägen . /automl_settings_mm.yml.

Pipeline för många modeller

Definiera sedan en fabriksfunktion som skapar pipelines för orkestrering av många modellers träning, slutsatsdragning och måttberäkning. I följande tabell beskrivs parametrarna för den här fabriksfunktionen:

Parameter	Description
max_nodes	Antal beräkningsnoder som ska användas i träningsjobbet.
max_concurrency_per_node	Antal AutoML-processer som ska köras på varje nod. Därför är max_nodes * max_concurrency_per_nodeden totala samtidigheten för många modelljobb .
parallel_step_timeout_in_seconds	Tidsgränsen för många modellers komponent har angetts i antal sekunder.
retrain_failed_models	Flagga för att aktivera omträning för misslyckade modeller. Det här värdet är användbart om du gjorde tidigare många modeller som resulterade i misslyckade AutoML-jobb på vissa datapartitioner. När du aktiverar den här flaggan startar många modeller endast träningsjobb för tidigare misslyckade partitioner.
forecast_mode	Slutsatsdragningsläge för modellutvärdering. Giltiga värden är recursive (standard) och rolling. Mer information finns i Slutsatsdragning och utvärdering av prognosmodeller och klassreferensen ManyModelsInferenceParameters .
step	Stegstorlek för rullande prognos (standardvärdet är 1). Mer information finns i Slutsatsdragning och utvärdering av prognosmodeller och klassreferensen ManyModelsInferenceParameters .

I följande exempel visas en fabriksmetod för att konstruera många modellers tränings- och modellutvärderingspipelines:

Python SDK

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Get credential to access AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if token can be obtained successfully
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Get many models training component
mm_train_component = ml_client_registry.components.get(
    name='automl_many_models_training',
    version='latest'
)

# Get many models inference component
mm_inference_component = ml_client_registry.components.get(
    name='automl_many_models_inference',
    version='latest'
)

# Get component to compute evaluation metrics
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

@pipeline(description="AutoML Many Models Forecasting Pipeline")
def many_models_train_evaluate_factory(
    train_data_input,
    test_data_input,
    automl_config_input,
    compute_name,
    max_concurrency_per_node=4,
    parallel_step_timeout_in_seconds=3700,
    max_nodes=4,
    retrain_failed_model=False,
    forecast_mode="rolling",
    forecast_step=1
):
    mm_train_node = mm_train_component(
        raw_data=train_data_input,
        automl_config=automl_config_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        retrain_failed_model=retrain_failed_model,
        compute_name=compute_name
    )

    mm_inference_node = mm_inference_component(
        raw_data=test_data_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        optional_train_metadata=mm_train_node.outputs.run_output,
        forecast_mode=forecast_mode,
        step=forecast_step,
        compute_name=compute_name
    )

    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        prediction=mm_inference_node.outputs.evaluation_data,
        ground_truth=mm_inference_node.outputs.evaluation_data,
        evaluation_config=mm_inference_node.outputs.evaluation_configs
    )

    # Return metrics results from rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Konstruera pipelinen med fabriksfunktionen. Tränings- och testdata finns i de lokala mapparna ./data/train respektive ./data/test. Ange slutligen standardberäkningen och skicka jobbet enligt följande exempel:

pipeline_job = many_models_train_evaluate_factory(
    train_data_input=Input(
        type="uri_folder",
        path="./data/train"
    ),
    test_data_input=Input(
        type="uri_folder",
        path="./data/test"
    ),
    automl_config=Input(
        type="uri_file",
        path="./automl_settings_mm.yml"
    ),
    compute_name="<cluster name>"
)
pipeline_job.settings.default_compute = "<cluster name>"

returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name,
)
ml_client.jobs.stream(returned_pipeline_job.name)

Azure CLI

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

description: AutoML Many Models Forecasting Pipeline
experiment_name: cli-v2-automl-mm-forecasting-pipeline

# Set default compute for pipeline steps
settings:
    default_compute: azureml:cpu-compute

# Set pipeline inputs
inputs:
    train_data_input:
        type: uri_folder
        path: "./train_data"
        mode: direct
    test_data_input:
        type: uri_folder
        path: "./test_data"
    automl_config_input:
        type: uri_file
        path: "./automl_settings_mm.yml"
    max_nodes: 4
    max_concurrency_per_node: 4
    parallel_step_timeout_in_seconds: 3700
    forecast_mode: rolling
    step: 1
    retrain_failed_model: False

# Set pipeline outputs
# Output the evaluation metrics and raw test set rolling forecasts
outputs: 
    metrics_result:
        type: uri_file
        mode: upload

jobs:
    # Configure AutoML many models training component
    mm_train_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_many_models_training
        inputs:
            raw_data: ${{parent.inputs.train_data_input}}
            automl_config: ${{parent.inputs.automl_config_input}}
            max_nodes: ${{parent.inputs.max_nodes}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            retrain_failed_model: ${{parent.inputs.retrain_failed_model}}
        outputs:
            run_output:
                type: uri_folder

    # Configure inference node to make rolling forecasts on test set
    mm_inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_many_models_inference
        inputs:
            raw_data: ${{parent.inputs.test_data_input}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            forecast_mode: ${{parent.inputs.forecast_mode}}
            step: ${{parent.inputs.step}}
            max_nodes: ${{parent.inputs.max_nodes}}
            optional_train_metadata: ${{parent.jobs.mm_train_node.outputs.run_output}}
        outputs:
            run_output:
                type: uri_folder
            evaluation_configs:
                type: uri_file
            evaluation_data:
                type: uri_file

    # Configure metrics calculation node
    compute_metrics:
        type: command
        component: azureml://registries/azureml/components/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.mm_inference_node.outputs.evaluation_data}}
            prediction: ${{parent.jobs.mm_inference_node.outputs.evaluation_data}}
            evaluation_config: ${{parent.jobs.mm_inference_node.outputs.evaluation_configs}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

Du startar pipelinejobbet med följande kommando. Pipelinekonfigurationen för många modeller finns på sökvägen ./automl-mm-forecasting-pipeline.yml:

az ml job create --file automl-mm-forecasting-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>

När jobbet är klart kan du ladda ned utvärderingsmåtten lokalt med samma procedur som i pipelinen för en träningskörning.

Ett mer detaljerat exempel finns i efterfrågeprognoser med många notebook-modeller.

Träningsöverväganden för många modeller körs

De många modellernas tränings- och slutsatsdragningskomponenter partitionerade villkorligt dina data enligt inställningen så att partition_column_names varje partition finns i sin egen fil. Den här processen kan vara mycket långsam eller misslyckas när data är mycket stora. Rekommendationen är att partitionera dina data manuellt innan du kör många modellers träning eller slutsatsdragning.

Kommentar

Standardparallellitetsgränsen för många modeller som körs i en prenumeration är inställd på 320. Om din arbetsbelastning kräver en högre gräns kan du kontakta Microsofts support.

Prognos i stor skala: Hierarkisk tidsserie

Med HTS-komponenter (hierarkisk tidsserie) i AutoML kan du träna ett stort antal modeller på data med hierarkisk struktur. Mer information finns i Hierarkisk tidsserieprognos.

HTS-träningskonfiguration

HTS-träningskomponenten accepterar en YAML-formatkonfigurationsfil med AutoML-träningsinställningar. Komponenten tillämpar dessa inställningar på varje AutoML-instans som startas. Den här YAML-filen har samma specifikation som kommandojobbet Prognostisering plus andra parametrar som är relaterade till hierarkiinformationen:

Parameter	Description
hierarchy_column_names	En lista med kolumnnamn i data som definierar datans hierarkiska struktur. Ordningen på kolumnerna i den här listan avgör hierarkinivåerna. Aggregeringsgraden minskar med listindexet. Den sista kolumnen i listan definierar alltså hierarkins lövnivå, eller den mest disaggregerade nivån.
hierarchy_training_level	Hierarkinivån som ska användas för träning av prognosmodeller.

I följande exempel finns en YAML-exempelkonfiguration:

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

description: A time-series forecasting job config
compute: azureml:cluster-name
task: forecasting
primary_metric: normalized_root_mean_squared_error
log_verbosity: info
target_column_name: sales
n_cross_validations: 3

forecasting:
  time_column_name: "date"
  time_series_id_column_names: ["state", "store", "SKU"]
  forecast_horizon: 28

training:
  blocked_training_algorithms: ["ExtremeRandomTrees"]

limits:
  timeout_minutes: 15
  max_trials: 10
  max_concurrent_trials: 4
  max_cores_per_trial: -1
  trial_timeout_minutes: 15
  enable_early_termination: true
  
hierarchy_column_names: ["state", "store", "SKU"]
hierarchy_training_level: "store"

I efterföljande exempel lagras konfigurationen på sökvägen . /automl_settings_hts.yml.

HTS-pipeline

Definiera sedan en fabriksfunktion som skapar pipelines för orkestrering av HTS-träning, slutsatsdragning och måttberäkning. I följande tabell beskrivs parametrarna för den här fabriksfunktionen:

Parameter	Description
forecast_level	Nivån på hierarkin för vilken prognoser ska hämtas.
allocation_method	Allokeringsmetod som ska användas när prognoser delas upp. Giltiga värden är proportions_of_historical_average och average_historical_proportions.
max_nodes	Antal beräkningsnoder som ska användas i träningsjobbet.
max_concurrency_per_node	Antal AutoML-processer som ska köras på varje nod. Därför är max_nodes * max_concurrency_per_nodeden totala samtidigheten för ett HTS-jobb .
parallel_step_timeout_in_seconds	Tidsgränsen för många modellers komponent har angetts i antal sekunder.
forecast_mode	Slutsatsdragningsläge för modellutvärdering. Giltiga värden är recursive och rolling. Mer information finns i Slutsatsdragning och utvärdering av prognosmodeller och klassreferensen HTSInferenceParameters .
step	Stegstorlek för rullande prognos (standardvärdet är 1). Mer information finns i Slutsatsdragning och utvärdering av prognosmodeller och klassreferensen HTSInferenceParameters .

Python SDK

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Get credential to access AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if token can be obtained successfully
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Get HTS training component
hts_train_component = ml_client_registry.components.get(
    name='automl_hts_training',
    version='latest'
)

# Get HTS inference component
hts_inference_component = ml_client_registry.components.get(
    name='automl_hts_inference',
    version='latest'
)

# Get component to compute evaluation metrics
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

@pipeline(description="AutoML HTS Forecasting Pipeline")
def hts_train_evaluate_factory(
    train_data_input,
    test_data_input,
    automl_config_input,
    max_concurrency_per_node=4,
    parallel_step_timeout_in_seconds=3700,
    max_nodes=4,
    forecast_mode="rolling",
    forecast_step=1,
    forecast_level="SKU",
    allocation_method='proportions_of_historical_average'
):
    hts_train = hts_train_component(
        raw_data=train_data_input,
        automl_config=automl_config_input,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        max_nodes=max_nodes
    )
    hts_inference = hts_inference_component(
        raw_data=test_data_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        optional_train_metadata=hts_train.outputs.run_output,
        forecast_level=forecast_level,
        allocation_method=allocation_method,
        forecast_mode=forecast_mode,
        step=forecast_step
    )
    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        prediction=hts_inference.outputs.evaluation_data,
        ground_truth=hts_inference.outputs.evaluation_data,
        evaluation_config=hts_inference.outputs.evaluation_configs
    )

    # Return metrics results from rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Konstruera pipelinen med hjälp av fabriksfunktionen. Tränings- och testdata finns i de lokala mapparna ./data/train respektive ./data/test. Ange slutligen standardberäkningen och skicka jobbet enligt följande exempel:

pipeline_job = hts_train_evaluate_factory(
    train_data_input=Input(
        type="uri_folder",
        path="./data/train"
    ),
    test_data_input=Input(
        type="uri_folder",
        path="./data/test"
    ),
    automl_config=Input(
        type="uri_file",
        path="./automl_settings_hts.yml"
    )
)
pipeline_job.settings.default_compute = "cluster-name"

returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name,
)
ml_client.jobs.stream(returned_pipeline_job.name)

Azure CLI

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

description: AutoML Many Models Forecasting Pipeline
experiment_name: cli-v2-automl-mm-forecasting-pipeline

# Set the default compute for pipeline steps
settings:
    default_compute: cpu-compute

# Set pipeline inputs
inputs:
    train_data_input:
        type: uri_folder
        path: "./train_data"
        mode: direct
    test_data_input:
        type: uri_folder
        path: "./test_data"
    automl_config_input:
        type: uri_file
        path: "./automl_settings_hts.yml"
    max_concurrency_per_node: 4
    parallel_step_timeout_in_seconds: 3700
    max_nodes: 4
    forecast_mode: rolling
    step: 1
    allocation_method: proportions_of_historical_average
    forecast_level: # forecast level

# Set pipeline outputs
# Output evaluation metrics and raw test set rolling forecasts
outputs: 
    metrics_result:
        type: uri_file
        mode: upload

jobs:
    # Configure AutoML many models training component
    hts_train_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_hts_training
        inputs:
            raw_data: ${{parent.inputs.train_data_input}}
            automl_config: ${{parent.inputs.automl_config_input}}
            max_nodes: ${{parent.inputs.max_nodes}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
        outputs:
            run_output:
                type: uri_folder


    # Configure inference node to make rolling forecasts on test set
    hts_inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_hts_inference
        inputs:
            raw_data: ${{parent.inputs.test_data_input}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            forecast_mode: ${{parent.inputs.forecast_mode}}
            step: ${{parent.inputs.step}}
            max_nodes: ${{parent.inputs.max_nodes}}
            optional_train_metadata: ${{parent.jobs.hts_train_node.outputs.run_output}}
            forecast_level: ${{parent.inputs.forecast_level}}
            allocation_method: ${{parent.inputs.allocation_method}}
        outputs:
            run_output:
                type: uri_folder
            evaluation_configs:
                type: uri_file
            evaluation_data:
                type: uri_file

    # Configure metrics calculation node
    compute_metrics:
        type: command
        component: azureml://registries/azureml/components/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.hts_inference_node.outputs.evaluation_data}}
            prediction: ${{parent.jobs.hts_inference_node.outputs.evaluation_data}}
            evaluation_config: ${{parent.jobs.hts_inference_node.outputs.evaluation_configs}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

Du startar pipelinejobbet med följande kommando. Pipelinekonfigurationen för många modeller finns på sökvägen ./automl-hts-forecasting-pipeline.yml:

az ml job create --file automl-hts-forecasting-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>

När jobbet är klart kan utvärderingsmåtten laddas ned lokalt med samma procedur som i pipelinen för en träningskörning.

Ett mer detaljerat exempel finns i efterfrågeprognoser med notebook-filen för hierarkisk tidsserie.

Träningsöverväganden för en HTS-körning

HTS-tränings- och slutsatsdragningskomponenterna partitioneras villkorligt dina data enligt inställningen så att hierarchy_column_names varje partition finns i sin egen fil. Den här processen kan vara mycket långsam eller misslyckas när data är mycket stora. Den rekommenderade metoden är att partitionera dina data manuellt innan du kör HTS-träning eller slutsatsdragning.

Kommentar

Standardparallellitetsgränsen för en HTS-körning i en prenumeration är inställd på 320. Om din arbetsbelastning kräver en högre gräns kan du kontakta Microsofts support.

Prognos i stor skala: Distribuerad DNN-utbildning

Som beskrivs tidigare i den här artikeln kan du aktivera inlärning för djupa neurala nätverk (DNN). Information om hur distribuerad träning fungerar för DNN-prognosuppgifter finns i Distribuerad djup neural nätverksträning (förhandsversion).

För scenarier med stora datakrav är distribuerad träning med AutoML tillgänglig för en begränsad uppsättning modeller. Mer information och kodexempel finns i AutoML i stor skala: Distribuerad träning.

Utforska exempel på notebook-filer

Detaljerade kodexempel som visar avancerade prognoskonfigurationer finns på GitHub-lagringsplatsen AutoML Forecasting Sample Notebooks . Här är några av exempelanteckningsböckerna:

• Skapa pipeline för prognostisering av efterfrågan (HTS och många modeller)
• Träna TCNForecaster-modell (DNN) på GitHub-datauppsättning
• Prognos med semesteridentifiering och funktionalisering (cykeldelningsdatauppsättning)
• Konfigurera fördröjningar och löpande fönsteraggregering manuellt

Relaterat innehåll

• Distribuera en AutoML-modell till en onlineslutpunkt
• Hämta AutoML-modellförklaringar med Python SDK
• Välj en modelleringskonfiguration