Nastavení AutoML pro trénování modelu prognózování časových řad pomocí sady SDK a rozhraní příkazového řádku

  • Článek

PLATÍ PRO:Rozšíření Azure CLI ml v2 (aktuální)Python SDK azure-ai-ml v2 (aktuální)

V tomto článku se dozvíte, jak nastavit AutoML pro prognózování časových řad pomocí služby Azure Machine Učení automatizovaného strojového učení v sadě Azure Machine Učení Python SDK.

Uděláte to takto:

  • Příprava dat na trénování
  • Nakonfigurujte konkrétní parametry časové řady v úloze prognózování.
  • Orchestrace trénování, odvozování a vyhodnocování modelů pomocí komponent a kanálů

Informace o nízkém prostředí kódu najdete v kurzu: Prognóza poptávky pomocí automatizovaného strojového učení pro příklad prognózování časových řad pomocí automatizovaného strojového učení v studio Azure Machine Learning.

AutoML používá standardní modely strojového učení spolu s dobře známými modely časových řad k vytváření prognóz. Náš přístup zahrnuje historické informace o cílové proměnné, funkcích poskytovaných uživatelem ve vstupních datech a automaticky navržených funkcích. Vyhledávací algoritmy modelu pak pracují na nalezení modelu s nejlepší prediktivní přesností. Další podrobnosti najdete v našich článcích o metodologii prognózování a vyhledávání modelů.

Požadavky

Pro tento článek potřebujete:

Trénovací a ověřovací data

Vstupní data pro prognózování AutoML musí obsahovat platnou časovou řadu v tabulkovém formátu. Každá proměnná musí mít v tabulce dat svůj vlastní odpovídající sloupec. AutoML vyžaduje alespoň dva sloupce: časový sloupec představující časovou osu a cílový sloupec , což je množství pro prognózu. Ostatní sloupce můžou sloužit jako prediktory. Další podrobnosti najdete v tom , jak AutoML používá vaše data.

Důležité

Při trénování modelu pro prognózování budoucích hodnot se ujistěte, že se všechny funkce použité v trénování dají použít při spouštění předpovědí pro zamýšlený horizont.

Například funkce pro aktuální cenu akcií by mohla výrazně zvýšit přesnost trénování. Pokud ale máte v úmyslu předpovídat s dlouhým horizontem, možná nebudete moct přesně předpovědět budoucí hodnoty akcií odpovídající budoucím bodům časové řady a přesnost modelu by mohla trpět.

Úlohy prognózování AutoML vyžadují, aby trénovací data byla reprezentována jako objekt MLTable . Tabulka MLTable určuje zdroj dat a kroky pro načtení dat. Další informace a případy použití najdete v průvodci postupy tabulky MLTable. Předpokládejme jako jednoduchý příklad, že trénovací data jsou obsažena v souboru CSV v místním adresáři. ./train_data/timeseries_train.csv

Tabulku MLTable můžete vytvořit pomocí sady MLtable Python SDK , jak je znázorněno v následujícím příkladu:

import mltable

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

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

Tento kód vytvoří nový soubor, ./train_data/MLTablekterý obsahuje formát souboru a pokyny k načtení.

Teď definujete vstupní datový objekt, který je nutný ke spuštění trénovací úlohy pomocí sady Azure Machine Učení Python SDK následujícím způsobem:

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

Ověřovací data zadáte podobným způsobem tak, že vytvoříte tabulku MLTable a zadáte vstup ověřovacích dat. Případně pokud nezadáte ověřovací data, AutoML automaticky vytvoří rozdělení křížového ověření z trénovacích dat, která se použijí pro výběr modelu. Další podrobnosti najdete v našem článku o výběru modelu prognózy. Podrobnosti o tom, kolik trénovacích dat potřebujete k úspěšnému trénování modelu prognózy, najdete také v požadavcích na délku trénovacích dat.

Přečtěte si další informace o tom, jak AutoML používá křížové ověřování, aby se zabránilo přizpůsobení.

Výpočetní prostředí pro spuštění experimentu

AutoML ke spuštění trénovací úlohy používá službu Azure Machine Učení Compute, což je plně spravovaný výpočetní prostředek. V následujícím příkladu se vytvoří výpočetní cluster s názvem cpu-compute :

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()

Konfigurace experimentu

Pomocí funkcí automl factory nakonfigurujete úlohy prognózování v sadě Python SDK. Následující příklad ukazuje, jak vytvořit úlohu prognózování nastavením primární metriky a nastavením limitů pro spuštění trénování:

from azure.ai.ml import automl

# note that the below is a code snippet -- you might have to modify the variable values to run it 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",
)

# Limits are all optional
forecasting_job.set_limits(
    timeout_minutes=120,
    trial_timeout_minutes=30,
    max_concurrent_trials=4,
)

Nastavení úlohy prognózování

Úlohy prognózování mají mnoho nastavení, která jsou specifická pro prognózování. Nejzásadnější z těchto nastavení je název sloupce času v trénovacích datech a horizont prognózy.

Ke konfiguraci těchto nastavení použijte metody ForecastingJob:

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

Název časového sloupce je požadované nastavení a měli byste obecně nastavit horizont prognózy podle scénáře předpovědi. Pokud vaše data obsahují více časových řad, můžete zadat názvy sloupců ID časové řady. Tyto sloupce při seskupení definují jednotlivé řady. Předpokládejme například, že máte data skládající se z hodinových prodejen z různých obchodů a značek. Následující ukázka ukazuje, jak nastavit sloupce ID časové řady za předpokladu, že data obsahují sloupce s názvem "store" a "brand":

# 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']
)

AutoML se pokusí automaticky rozpoznat sloupce ID časové řady ve vašich datech, pokud nejsou zadány žádné.

Další nastavení jsou volitelná a kontrolovaná v další části.

Volitelná nastavení úlohy prognózování

Volitelné konfigurace jsou k dispozici pro úlohy prognózy, jako je povolení hlubokého učení a určení cílové agregace posuvných oken. Úplný seznam parametrů je k dispozici v referenční dokumentaci k prognózování.

Nastavení hledání modelu

Existují dvě volitelná nastavení, která řídí prostor modelu, ve kterém AutoML hledá nejlepší model allowed_training_algorithms , a blocked_training_algorithms. Pokud chcete omezit vyhledávací prostor na danou sadu tříd modelu, použijte allowed_training_algorithms parametr jako v následující ukázce:

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

V tomto případě úloha prognózování vyhledává pouze třídy modelů Exponential Smoothing a Elastic Net. Pokud chcete odebrat danou sadu tříd modelů z vyhledávacího prostoru, použijte blocked_training_algorithms jako v následující ukázce:

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

Teď úloha hledá ve všech třídách modelů s výjimkou Proroka. Seznam názvů modelů prognóz, které jsou přijímány allowed_training_algorithms , a blocked_training_algorithmsnaleznete v referenční dokumentaci k vlastnostem trénování. Buď, ale ne obojí, allowed_training_algorithms a blocked_training_algorithms lze je použít na trénovací běh.

Povolení hlubokého učení

AutoML se dodává s vlastním modelem hluboké neurální sítě (DNN), který se nazývá TCNForecaster. Tento model je dočasná konvoluční síť neboli TCN, která používá běžné metody úloh vytváření obrázků na modelování časových řad. Konkrétně jednorozměrné "kauzální" konvoluce tvoří páteřní síť a umožňují modelu učit se složité vzory v průběhu dlouhých dob v historii trénování. Další podrobnosti najdete v našem článku TCNForecaster.

Diagram znázorňující hlavní komponenty TCNForecasteru AutoML

TCNForecaster často dosahuje vyšší přesnosti než standardní modely časových řad, pokud v historii trénování existují tisíce nebo více pozorování. TCNForecaster modely však kvůli vyšší kapacitě trvá déle.

TCNForecaster v AutoML můžete povolit nastavením enable_dnn_training příznaku v konfiguraci trénování následujícím způsobem:

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

Ve výchozím nastavení je trénování TCNForecaster omezené na jeden výpočetní uzel a jeden GPU, pokud je k dispozici, na zkušební verzi modelu. V případě velkých datových scénářů doporučujeme distribuovat každou zkušební verzi TCNForecasteru do více jader nebo gpu a uzlů. Další informace a ukázky kódu najdete v naší části s distribuovaným školicím článkem.

Pokud chcete povolit síť DNN pro experiment AutoML vytvořený v studio Azure Machine Learning, podívejte se na nastavení typu úlohy v návodu k uživatelskému rozhraní studia.

Poznámka:

  • Když povolíte síť DNN pro experimenty vytvořené pomocí sady SDK, nejlepší vysvětlení modelů se zakáže.
  • Podpora sítě DNN pro prognózování v Učení automatizovaného počítače není podporována pro spuštění zahájená v Databricks.
  • Výpočetní typy GPU se doporučují, když je povolené trénování DNN.

Lag and rolling window features

Nedávné hodnoty cíle jsou často ovlivněné funkcemi modelu prognózování. AutoML proto může vytvářet časově opožděné a průběžné agregační funkce, aby se potenciálně zlepšila přesnost modelu.

Představte si scénář prognózování poptávky po energii, ve kterém jsou k dispozici data o počasí a historická poptávka. Tabulka ukazuje výslednou přípravu funkcí, ke které dochází při použití agregace oken za poslední tři hodiny. Sloupce pro minimum, maximum a součet se generují v posuvném okně se třemi hodinami na základě definovaných nastavení. Například pro pozorování platné 8. září 2017 4:00, maximální, minimální a součet hodnoty se počítají pomocí hodnot poptávky pro 8. září 2017 1:00–3:00. Toto okno se třemi hodinami posune a naplní data pro zbývající řádky. Další podrobnosti a příklady najdete v článku o funkci prodlevy.

cílové posuvné okno

Agregační funkce prodlevy a průběžného intervalu pro cíl můžete povolit nastavením velikosti posuvné sady, která byla v předchozím příkladu tři a pořadí prodlev, které chcete vytvořit. U funkcí s nastavením feature_lags můžete také povolit prodlevy. V následující ukázce nastavíme všechna tato nastavení tak auto , aby AutoML automaticky určilo nastavení analýzou struktury korelace vašich dat:

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

Zpracování krátkých řad

Automatizované strojové učení považuje časovou řadu za krátkou řadu , pokud není dostatek datových bodů k provedení fází trénování a ověřování vývoje modelu. Další podrobnosti o požadavcích na délku najdete v požadavcích na délku trénovacích dat.

AutoML má několik akcí, které může provést pro krátkou řadu. Tyto akce se dají konfigurovat pomocí short_series_handling_config tohoto nastavení. Výchozí hodnota je "auto". Následující tabulka popisuje nastavení:

Nastavení Popis
auto Výchozí hodnota pro zpracování krátkých řad.
- Pokud jsou všechny řady krátké, vložte data.
- Pokud ne všechny řady jsou krátké, zahoďte krátkou řadu.
pad Pokud short_series_handling_config = padpak automatizované strojové učení přidá náhodné hodnoty do každé krátké nalezené řady. Následující seznam uvádí typy sloupců a jejich vkládání:
– Objektové sloupce s názvy NaN
- Číselné sloupce s 0
– logické sloupce nebo sloupce logiky s hodnotou False
- Cílový sloupec je vycpaný bílým šumem.
drop Pokud short_series_handling_config = droppak automatizované strojové učení krátké řady poklesne a nepoužije se pro trénování nebo predikci. Předpovědi pro tyto řady vrátí hodnoty NaN.
None Žádná řada není vycpaná nebo zahozená

V následujícím příkladu nastavíme zpracování krátkých řad tak, aby všechny krátké řady byly vycpané na minimální délku:

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

Upozorňující

Odsazení může mít vliv na přesnost výsledného modelu, protože zavádíme umělá data, abychom se vyhnuli selháním trénování. Pokud je řada řad krátká, může se také zobrazit nějaký dopad na výsledky vysvětlovatelnosti.

Agregace četnosti a cíle dat

Pomocí možností četnosti a agregace dat se vyhnete selháním způsobeným nepravidelnými daty. Vaše data jsou nepravidelná, pokud nedodržují nastavené tempo v čase, jako je hodinová nebo denní doba. Dobrým příkladem nepravidelných dat jsou data typu point-of-sales. V těchto případech může AutoML agregovat vaše data do požadované frekvence a pak vytvořit model prognózování z agregací.

Musíte nastavit a target_aggregate_function nastavit frequency pro zpracování nepravidelných dat. Nastavení frekvence přijímá jako vstup řetězce Pandas DateOffset. Podporované hodnoty agregační funkce jsou:

Function Popis
sum  Součet cílových hodnot
mean  Střední nebo průměr cílových hodnot
min Minimální hodnota cíle
max Maximální hodnota cíle
  • Hodnoty cílového sloupce se agregují podle zadané operace. Součet je obvykle vhodný pro většinu scénářů.
  • Číselné prediktorové sloupce v datech se agregují podle součtu, střední hodnoty, minimální hodnoty a maximální hodnoty. V důsledku toho automatizované strojové učení generuje nové sloupce s příponou názvu agregační funkce a použije vybranou agregační operaci.
  • U sloupců prediktoru kategorií jsou data agregována podle režimu, nejvýraznější kategorie v okně.
  • Sloupce prediktoru data se agregují podle minimální hodnoty, maximální hodnoty a režimu.

Následující příklad nastaví frekvenci na každou hodinu a agregační funkci na sumaci:

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

Vlastní nastavení křížového ověřování

Existují dvě přizpůsobitelná nastavení, která řídí křížové ověřování pro úlohy prognózy: počet záhybů n_cross_validationsa velikost kroku definující časový posun mezi přeložením, cv_step_size. Další informace o významu těchto parametrů najdete v části výběr modelu prognózování. AutoML ve výchozím nastavení nastavuje obě nastavení automaticky na základě charakteristik vašich dat, ale pokročilí uživatelé je můžou chtít nastavit ručně. Předpokládejme například, že máte data o denním prodeji a chcete, aby nastavení ověření obsahovalo pět záhybů se sedmidenním posunem mezi sousedními složenými záhyby. Následující ukázka kódu ukazuje, jak tyto možnosti nastavit:

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
)

Vlastní funkce

AutoML ve výchozím nastavení rozšiřuje trénovací data pomocí inženýrovaných funkcí, aby se zvýšila přesnost modelů. Další informace najdete v analýze automatizovaných funkcí . Některé kroky předběžného zpracování je možné přizpůsobit pomocí konfigurace featurizace úlohy prognózy.

Podporovaná přizpůsobení prognózování najdete v následující tabulce:

Vlastní nastavení Popis Možnosti
Aktualizace účelu sloupce Přepište typ automaticky rozpoznané funkce pro zadaný sloupec. "Categorical", "DateTime", "Numeric"
Aktualizace parametrů Transformátoru Aktualizujte parametry pro zadaný imputer. {"strategy": "constant", "fill_value": <value>}, , {"strategy": "median"}{"strategy": "ffill"}

Předpokládejme například, že máte scénář maloobchodní poptávky, ve kterém data zahrnují ceny, příznak "při prodeji" a typ produktu. Následující ukázka ukazuje, jak můžete pro tyto funkce nastavit přizpůsobené typy a imputery:

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 that product_type feature is interpreted as categorical
forecasting_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    column_name_and_types={"product_type": "Categorical"},
)

Pokud používáte studio Azure Machine Learning pro experiment, podívejte se, jak přizpůsobit featurizaci v sadě Studio.

Odeslání úlohy prognózování

Po nakonfigurování všech nastavení spustíte úlohu prognózování následujícím způsobem:

# 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 AML studio user interface
returned_job.services["Studio"].endpoint

Jakmile se úloha odešle, AutoML zřídí výpočetní prostředky, použije na vstupní data featurizaci a další přípravné kroky a pak začne uklidit modely prognóz. Další podrobnosti najdete v našich článcích o metodologii prognózování a vyhledávání modelů.

Orchestrace trénování, odvozování a hodnocení pomocí komponent a kanálů

Důležité

Tato funkce je v současné době ve verzi Public Preview. Tato verze Preview je poskytována bez smlouvy o úrovni služeb a nedoporučujeme ji pro produkční úlohy. Některé funkce se nemusí podporovat nebo mohou mít omezené možnosti.

Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

Pracovní postup ML pravděpodobně vyžaduje více než jen trénování. Odvozování nebo načítání předpovědí modelu na novějších datech a vyhodnocení přesnosti modelu v testovací sadě se známými cílovými hodnotami jsou další běžné úlohy, které můžete orchestrovat v AzureML spolu s trénovacími úlohami. Pro podporu odvozování a vyhodnocování úloh poskytuje AzureML komponenty, které jsou samostatné části kódu, které provádějí jeden krok v kanálu AzureML.

V následujícím příkladu načteme kód komponenty z registru klienta:

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

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

# Create a client for accessing assets in the AzureML preview registry
ml_client_registry = MLClient(
    credential=credential,
    registry_name="azureml-preview"
)

# Create a client for accessing assets in the AzureML preview registry
ml_client_metrics_registry = MLClient(
    credential=credential,
    registry_name="azureml"
)

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

# Get a component for computing evaluation metrics from the registry
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

Dále definujeme funkci továrny, která vytvoří kanály, které orchestrují trénování, odvozování a výpočty metrik. Další podrobnosti o nastavení trénování najdete v části konfigurace trénování.

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 the training node of the 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 the inference node to make rolling forecasts on the 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',
        forecast_step=1
    )

    # Configure the 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 a dictionary with the evaluation metrics and the raw test set forecasts
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result,
        "rolling_fcst_result": inference_node.outputs.inference_output_file
    }

Teď definujeme vstupy trénování a testování dat za předpokladu, že jsou obsaženy v místních složkách, ./train_data a ./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',
)

Nakonec vytvoříme kanál, nastavíme výchozí výpočetní prostředky a odešleme úlohu:

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 the pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

Po odeslání kanál spustí trénování AutoML, postupné vyhodnocení odvozování a výpočet metriky v sekvenci. Spuštění můžete monitorovat a kontrolovat v uživatelském rozhraní studia. Po dokončení spuštění je možné průběžné prognózy a metriky vyhodnocení stáhnout do místního pracovního adresáře:

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

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

Výsledky metrik ./named-outputs/metrics_results/evaluationResult/metrics.json a prognózy pak najdete ve formátu řádků JSON v ./named-outputs/rolling_fcst_result/inference_output_filesouboru .

Další podrobnosti o průběžném vyhodnocení najdete v našem článku o vyhodnocení modelu prognózy.

Prognózování ve velkém měřítku: mnoho modelů

Důležité

Tato funkce je v současné době ve verzi Public Preview. Tato verze Preview je poskytována bez smlouvy o úrovni služeb a nedoporučujeme ji pro produkční úlohy. Některé funkce se nemusí podporovat nebo mohou mít omezené možnosti.

Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

Mnoho komponent modelů v AutoML umožňuje trénovat a spravovat miliony modelů paralelně. Další informace o mnoha konceptech modelů najdete v části věnované mnoha modelům.

Konfigurace trénování mnoha modelů

Komponenta trénování mnoha modelů přijímá konfigurační soubor formátu YAML nastavení trénování AutoML. Tato nastavení se použijí pro každou spuštěnou instanci AutoML. Tento soubor YAML má stejnou specifikaci jako forecasting Job plus další parametry partition_column_names a allow_multi_partitions.

Parametr Popis
partition_column_names Názvy sloupců v datech, která při seskupení definují datové oddíly. Komponenta trénování mnoha modelů spouští nezávislou trénovací úlohu v každém oddílu.
allow_multi_partitions Volitelný příznak, který umožňuje trénování jednoho modelu na oddíl, pokud každý oddíl obsahuje více než jednu jedinečnou časovou řadu. Výchozí hodnota je False.

Následující ukázka obsahuje šablonu konfigurace:

$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

V dalších příkladech předpokládáme, že konfigurace je uložena v cestě, ./automl_settings_mm.yml.

Kanál mnoha modelů

Dále definujeme funkci továrny, která vytváří kanály pro orchestraci mnoha modelů trénování, odvozování a výpočtů metrik. Parametry této funkce továrny jsou podrobně popsány v následující tabulce:

Parametr Popis
max_nodes Počet výpočetních uzlů, které se mají použít v trénovací úloze
max_concurrency_per_node Početprocesůch Proto je celková souběžnost mnoha úloh max_nodes * max_concurrency_per_nodemodelů .
parallel_step_timeout_in_seconds Časový limit řady komponent modelů zadaný v počtu sekund
retrain_failed_models Příznak pro povolení opětovného trénování pro neúspěšné modely To je užitečné, pokud jste provedli předchozí řadu spuštění modelů, jejichž výsledkem byly neúspěšné úlohy AutoML v některých datových oddílech. Pokud je tento příznak povolený, mnoho modelů spustí pouze trénovací úlohy pro dříve neúspěšné oddíly.
forecast_mode Režim odvozování pro vyhodnocení modelu Platné hodnoty jsou "recursive" a "rolling". Další informace najdete v článku o vyhodnocení modelu.
forecast_step Velikost kroku pro průběžnou prognózu Další informace najdete v článku o vyhodnocení modelu.

Následující ukázka znázorňuje metodu továrny pro vytváření mnoha trénovacích a testovacích kanálů modelů:

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

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

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

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

# Get a component for computing 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,
        forecast_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 the metrics results from the rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Teď kanál vytvoříme prostřednictvím funkce továrny za předpokladu, že trénovací a testovací data jsou v místních složkách, ./data/train a ./data/testv uvedeném pořadí. Nakonec nastavíme výchozí výpočetní prostředky a úlohu odešleme jako v následující ukázce:

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)

Po dokončení úlohy je možné metriky vyhodnocení stáhnout místně stejným postupem jako v kanálu s jedním trénovacím spuštěním.

Podrobnější příklad najdete také v prognózování poptávky s mnoha modely v poznámkovém bloku .

Poznámka:

Mnoho modelů trénování a odvozování komponent podmíněně rozděluje vaše data podle partition_column_names nastavení tak, aby každý oddíl byl ve vlastním souboru. Tento proces může být velmi pomalý nebo může selhat, pokud jsou data velmi velká. V takovém případě doporučujeme data rozdělit ručně, než spustíte trénování nebo odvozování mnoha modelů.

Prognózování ve velkém měřítku: hierarchická časová řada

Důležité

Tato funkce je v současné době ve verzi Public Preview. Tato verze Preview je poskytována bez smlouvy o úrovni služeb a nedoporučujeme ji pro produkční úlohy. Některé funkce se nemusí podporovat nebo mohou mít omezené možnosti.

Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

Komponenty hierarchických časových řad (HTS) v AutoML umožňují trénovat velký počet modelů na datech s hierarchickou strukturou. Další informace najdete v části věnované HTS.

Konfigurace trénování HTS

Trénovací komponenta HTS přijímá konfigurační soubor formátu YAML nastavení trénování AutoML. Tato nastavení se použijí pro každou spuštěnou instanci AutoML. Tento soubor YAML má stejnou specifikaci jako úloha prognózování a další parametry související s informacemi o hierarchii:

Parametr Popis
hierarchy_column_names Seznam názvů sloupců v datech, která definují hierarchickou strukturu dat. Pořadí sloupců v tomto seznamu určuje úrovně hierarchie; stupeň agregace se snižuje s indexem seznamu. To znamená, že poslední sloupec v seznamu definuje úroveň listu (nejvíce členěná) hierarchie.
hierarchy_training_level Úroveň hierarchie, která se má použít pro trénování modelu prognózy.

Následující příklad ukazuje ukázkovou konfiguraci:

$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"

V dalších příkladech předpokládáme, že konfigurace je uložena v cestě, ./automl_settings_hts.yml.

Kanál HTS

Dále definujeme funkci továrny, která vytvoří kanály pro orchestraci trénování, odvozování a výpočtu metrik HTS. Parametry této funkce továrny jsou podrobně popsány v následující tabulce:

Parametr Popis
forecast_level Úroveň hierarchie pro načtení prognóz pro
allocation_method Metoda přidělování, která se má použít, když jsou prognózy členěné. Platné hodnoty jsou "proportions_of_historical_average" a "average_historical_proportions".
max_nodes Počet výpočetních uzlů, které se mají použít v trénovací úloze
max_concurrency_per_node Početprocesůch Proto je celková souběžnost úlohy max_nodes * max_concurrency_per_nodeHTS .
parallel_step_timeout_in_seconds Časový limit řady komponent modelů zadaný v počtu sekund
forecast_mode Režim odvozování pro vyhodnocení modelu Platné hodnoty jsou "recursive" a "rolling". Další informace najdete v článku o vyhodnocení modelu.
forecast_step Velikost kroku pro průběžnou prognózu Další informace najdete v článku o vyhodnocení modelu. 
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

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

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

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

# Get a component for computing 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,
        forecast_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 the metrics results from the rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Teď kanál vytvoříme prostřednictvím funkce továrny za předpokladu, že trénovací a testovací data jsou v místních složkách, ./data/train a ./data/testv uvedeném pořadí. Nakonec nastavíme výchozí výpočetní prostředky a úlohu odešleme jako v následující ukázce:

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)

Po dokončení úlohy je možné metriky vyhodnocení stáhnout místně stejným postupem jako v kanálu s jedním trénovacím spuštěním.

Podrobnější příklad najdete také v prognózování poptávky s hierarchickým poznámkovým blokem časových řad.

Poznámka:

Komponenty TTS pro trénování a odvozování podmíněně rozdělují vaše data podle hierarchy_column_names nastavení tak, aby každý oddíl byl ve vlastním souboru. Tento proces může být velmi pomalý nebo může selhat, pokud jsou data velmi velká. V takovém případě doporučujeme data rozdělit ručně před spuštěním trénování nebo odvozování HTS.

Prognózování ve velkém měřítku: distribuované trénování DNN

Příklady poznámkových bloků

V ukázkových poznámkových blocích pro prognózování najdete podrobné příklady kódu rozšířené konfigurace prognózování, mezi které patří:

Další kroky