Nastavení AutoML pro trénování modelu prognózování časových řad pomocí sady SDK a rozhraní příkazového řádku
PLATÍ PRO:
Rozšíření Azure CLI ml v2 (aktuální)Python SDK azure-ai-ml v2 (aktuální)
Automatizované strojové učení (AutoML) ve službě Azure Machine Learning používá standardní modely strojového učení spolu s dobře známými modely časových řad k vytváření prognóz. Tento přístup zahrnuje historické informace o cílové proměnné s funkcemi poskytovanými uživatelem do vstupních dat a automaticky navrženými funkcemi. Algoritmy vyhledávání modelů pomáhají identifikovat modely s nejlepší prediktivní přesností. Další informace najdete v části Metodologie prognózování a úklidu a výběru modelu.
Tento článek popisuje, jak nastavit AutoML pro prognózování časových řad pomocí machine learningu pomocí sady Azure Machine Learning Python SDK](/python/api/overview/azure/ai-ml-readme). Proces zahrnuje přípravu dat pro trénování a konfiguraci parametrů časové řady v úloze prognózování (referenční dokumentace třídy). Pak trénujete, odvozujete a vyhodnocujete modely pomocí komponent a kanálů.
Informace o prostředí s nízkým kódem najdete v tématu Kurz: Prognóza poptávky pomocí automatizovaného strojového učení. Tento prostředek je příkladem prognózování časových řad, který používá AutoML v studio Azure Machine Learning.
Požadavky
- Pracovní prostor služby Azure Machine Learning. Pokud chcete vytvořit pracovní prostor, přečtěte si téma Vytvoření prostředků pracovního prostoru.
- Možnost spouštění trénovacích úloh AutoML Další informace najdete v tématu Nastavení trénování AutoML pro tabulková data pomocí azure Machine Learning CLI a sady Python SDK.
Příprava trénovacích a ověřovacích dat
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 pro množství, které se má předpovídat. Ostatní sloupce můžou sloužit jako prediktory. Další informace najdete v tématu Jak AutoML používá vaše data.
Důležité
Když vytrénujete model pro prognózování budoucích hodnot, ujistěte se, že se všechny funkce použité v trénování dají použít také při spouštění předpovědí pro zamýšlený horizont.
Zvažte funkci pro aktuální cenu akcií, která může výrazně zvýšit přesnost trénování. Pokud prognózujete s dlouhým horizontem, možná nebudete moct přesně předpovědět budoucí hodnoty akcií, které odpovídají budoucím bodům časových řad. Tento přístup může snížit přesnost modelu.
Úlohy prognózování AutoML vyžadují, aby trénovací data byla reprezentována jako MLTable objekt. Objekt MLTable určuje zdroj dat a kroky pro načtení dat. Další informace a případy použití najdete v tématu [Práce s tabulkami(how-to-mltable.md).
Předpokládejme, že v následujícím příkladu jsou trénovací data obsažená v souboru CSV v místním adresáři . /train_data/timeseries_train.csv.
Objekt můžete vytvořit MLTable pomocí sady SDK pro mltable Python , 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/MLTable, který obsahuje formát souboru a pokyny k načtení.
Pokud chcete spustit trénovací úlohu, definujte vstupní datový objekt pomocí sady 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. Vytvořte MLTable objekt a zadejte 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ší informace naleznete v následujících zdrojích:
- Výběr modelů prognózování
- Nastavení požadavků na délku trénovacích dat
- Zabránění přeurčení pomocí křížového ověření
Vytvoření výpočetních prostředků pro spuštění experimentu
AutoML ke spuštění trénovací úlohy používá výpočetní prostředky Azure Machine Learning, což je plně spravovaný výpočetní prostředek. Následující příklad 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
Následující příklad ukazuje, jak nakonfigurovat experiment.
Funkce továrny AutoML slouží ke konfiguraci úloh 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
# 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,
)
Nastavení úlohy prognózy
Ú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 povinné nastavení. Horizont prognózy byste měli obecně nastavit 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. Když jsou tyto sloupce seskupené, definují jednotlivé řady. Předpokládejme například, že máte data, která se skládají z hodinového prodeje 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 pojmenované úložiště a značku:
# 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 není zadán žádný.
Další nastavení jsou volitelná a kontrolovaná v následující čá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.
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, jak je znázorněno v následujícím příkladu:
# Only search ExponentialSmoothing and ElasticNet models
forecasting_job.set_training(
allowed_training_algorithms=["ExponentialSmoothing", "ElasticNet"]
)
V tomto scénáři úloha prognózování prohledá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 sadu, jak je znázorněno v následujícím příkladu:
# Search over all model classes except Prophet
forecasting_job.set_training(
blocked_training_algorithms=["Prophet"]
)
Ú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_algorithmsviz vlastnosti trénování. Můžete použít buď buď, ale ne obojí allowed_training_algorithms i blocked_training_algorithms pro trénovací běh.
Povolení učení pro hluboké neurální sítě
AutoML se dodává s vlastním modelem hluboké neurální sítě (DNN) s názvem TCNForecaster. Tento model je dočasná konvoluční síť (TCN), která používá běžné metody úloh vytváření obrázků na modelování časových řad. Jednorozměrné "kauzální" konvoluce tvoří páteř sítě a umožňují modelu učit se složité vzory v průběhu dlouhých dob v historii trénování. Další informace naleznete v tématu Úvod do TCNForecaster.
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 distribuovaném trénování.
Pokud chcete povolit DNN pro experiment AutoML vytvořený v studio Azure Machine Learning, podívejte se na nastavení typu úlohy v uživatelském rozhraní studia.
Poznámka:
- Když povolíte síť DNN pro experimenty vytvořené pomocí sady SDK, nejlepší vysvětlení modelů se zakáže.
- Podpora DNN pro prognózování v automatizovaném strojovém učení není podporovaná pro spuštění zahájená v Azure Databricks.
- Doporučeným přístupem je použití výpočetních typů GPU při povoleném 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 se vypočítá maximální, minimální a součtové hodnoty pomocí hodnot poptávky za 8. září 2017 1:00–3:00. Toto okno se třemi hodinami posune a naplní data pro zbývající řádky. Další informace a příklady najdete v tématu Funkce prodlevy pro prognózování časových řad v AutoML.
Pro cíl můžete povolit agregační funkce prodlevy a průběžného intervalu tak, že nastavíte velikost posuvné okno a pořadí prodlev, které chcete vytvořit. Velikost okna byla v předchozím příkladu tři. U funkcí s nastavením feature_lags můžete také povolit prodlevy. V následujícím příkladu jsou všechna tato nastavení nastavená tak, aby auto autoML instruoval, aby automaticky určil nastavení analýzou struktury korelace 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
AutoML 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ší informace 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 | Notes |
|---|---|---|
auto |
Výchozí hodnota pro zpracování krátkých řad. | - Pokud jsou všechny řady krátké, vložte data. - Pokud nejsou všechny řady krátké, vypusťte krátkou řadu. |
pad |
Pokud se short_series_handling_config = pad toto nastavení použije, AutoML přidá náhodné hodnoty do každé nalezené krátké řady. AutoML vycpe cílový sloupec bílým šumem. |
Můžete použít následující typy sloupců se zadaným odsazením: - Sloupce objektů, pad s NaN- Číselné sloupce, pad s 0 (nula) - Logické/logické sloupce, pad s False |
drop |
short_series_handling_config = drop Pokud se toto nastavení použije, AutoML krátkou řadu zahodí a nepoužívá se k trénování ani predikci. |
Předpovědi pro tyto řady vrátí NaN. |
None |
Žádná řada není vycpaná nebo vyhozena. |
Následující příklad nastaví 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'
)
Upozornění
Odsazení může ovlivnit přesnost výsledného modelu, protože zavádí umělá data, aby se zabránilo 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.
Frekvence a agregace cílových 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 scénářích může AutoML agregovat 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. Následující tabulka uvádí podporované hodnoty pro agregační funkci:
| 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 |
AutoML použije agregaci pro následující sloupce:
| Column | Metoda agregace |
|---|---|
| Numerické prediktory | AutoML používá funkce sum, mean, mina max . Vygeneruje nové sloupce, kde každý název sloupce obsahuje příponu, která identifikuje název agregační funkce použité u hodnot sloupců. |
| Kategorické prediktory | AutoML používá hodnotu parametru forecast_mode k agregaci dat. Je to nejvýraznější kategorie v okně. Další informace najdete v popisech parametru v oddílech Kanálu N modelů a kanálu HTS. |
| Prediktory dat | AutoML používá k agregaci dat minimální cílovou hodnotu (min), maximální cílovou hodnotu (max) a forecast_mode nastavení parametrů. |
| Cíl | AutoML agreguje hodnoty podle zadané operace. sum Funkce je obvykle vhodná pro většinu scénářů. |
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ózování. Upravte počet přeložení pomocí parametru n_cross_validations a nakonfigurujte parametr cv_step_size tak, aby definoval časový posun mezi přeložením. Další informace najdete v tématu prognózování výběru modelu.
AutoML ve výchozím nastavení nastavuje obě nastavení automaticky na základě charakteristik vašich dat. 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 nastavit tyto hodnoty:
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 tématu automatizovaného inženýrství funkcí. Některé kroky předběžného zpracování je možné přizpůsobit pomocí konfigurace featurizace úlohy prognózy.
Následující tabulka obsahuje seznam podporovaných přizpůsobení pro prognózování:
| Vlastní nastavení | Popis | Možnosti |
|---|---|---|
| Aktualizace účelu sloupce | Přepište typ funkce automatického rozpoznávání pro zadaný sloupec. | categorical, , dateTimenumeric |
| 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, on sale příznak a typ produktu. Následující příklad 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 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 pro experiment používáte studio Azure Machine Learning, přečtěte si téma Konfigurace nastavení featurizace v sadě Studio.
Odeslání úlohy prognózování
Jakmile nakonfigurujete všechna nastavení, můžete spustit úlohu prognózování. Následující příklad ukazuje tento proces.
# 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
Jakmile úlohu odešlete, AutoML zřídí výpočetní prostředky, použije na vstupní data featurizaci a další přípravné kroky a začne přemístit modely prognózování. Další informace najdete v části Metodologie prognózování v autoML a úklidu modelů a výběru pro prognózování v AutoML.
Orchestrace trénování, odvozování a hodnocení pomocí komponent a kanálů
Pracovní postup strojového učení pravděpodobně vyžaduje více než jen trénování. Odvozování nebo načítání predikcí modelu na novějších datech a vyhodnocení přesnosti modelu na testovací sadě se známými cílovými hodnotami jsou další běžné úlohy, které můžete orchestrovat ve službě Azure Machine Learning spolu s trénovacími úlohami. Pro podporu odvozování a vyhodnocování úloh poskytuje Azure Machine Learning komponenty, které jsou samostatné části kódu, které provádějí jeden krok v kanálu Azure Machine Learning.
V následujícím příkladu načtěte kód komponenty z registru klienta:
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"
)
Dále definujte funkci továrny, která vytvoří kanály, které orchestrují trénování, odvozování a výpočty metrik. Další informace najdete v tématu Konfigurace experimentu.
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
}
Definujte vstupy trénování a testování dat obsažených 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řte kanál, nastavte jeho výchozí výpočetní prostředky a odešlete ú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 pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
pipeline_job,
experiment_name=experiment_name
)
returned_pipeline_job
Po odeslání žádosti o spuštění kanál spustí trénování AutoML, postupné vyhodnocení odvozování a výpočtu metrik v sekvenci. Spuštění můžete monitorovat a kontrolovat v uživatelském rozhraní studia. Po dokončení spuštění si můžete stáhnout průběžné prognózy a metriky vyhodnocení do místního pracovního adresáře:
# 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')
Výstup můžete zkontrolovat v následujících umístěních:
- Metriky: ./named-outputs/metrics_results/evaluationResult/metrics.json
- Prognózy: ./named-outputs/rolling_fcst_result/inference_output_file (formát řádků JSON)
Další informace o průběžném vyhodnocování najdete v tématu Odvozování a hodnocení modelů prognóz.
Prognóza ve velkém měřítku: Mnoho modelů
Mnoho komponent modelů v AutoML umožňuje trénovat a spravovat miliony modelů paralelně. Další informace o mnoha konceptech modelů najdete v tématu Mnoho modelů.
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. Soubor YAML má stejnou specifikaci jako úloha příkazu Prognózování a partition_column_names allow_multi_partitions parametry.
| 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í příklad obsahuje ukázkovou konfiguraci YAML:
$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 je konfigurace uložena v cestě ./automl_settings_mm.yml'.
Kanál mnoha modelů
Dále definujte funkci továrny, která vytváří kanály pro orchestraci mnoha modelů trénování, odvozování a výpočtů metrik. Následující tabulka popisuje parametry této funkce továrny:
| Parametr | Popis |
|---|---|
max_nodes |
Počet výpočetníchuzlůch |
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 natrénování pro neúspěšné modely Tato hodnota je užitečná, pokud jste v některých datových oddílech provedli předchozí řadu spuštění modelů, jejichž výsledkem byly neúspěšné úlohy AutoML. Když tento příznak povolíte, mnoho modelů spouští 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 (výchozí) a rolling. Další informace naleznete v tématu Odvozování a vyhodnocení prognózování modelů a Reference třídy ManyModelsInferenceParameters . |
step |
Velikost kroku pro průběžnou prognózu (výchozí hodnota je 1). Další informace naleznete v tématu Odvozování a vyhodnocení prognózování modelů a Reference třídy ManyModelsInferenceParameters . |
Následující příklad ukazuje metodu továrny pro vytvoření mnoha modelů trénování a kanálů vyhodnocení modelu:
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
}
Vytvořte kanál pomocí funkce továrny. Trénovací a testovací data jsou v místních složkách ./data/train a ./data/test. Nakonec nastavte výchozí výpočetní prostředky a odešlete úlohu, jak je znázorněno v následujícím příkladu:
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 můžete metriky vyhodnocení stáhnout místně pomocí stejného postupu jako v kanálu jednoho trénovacího spuštění.
Podrobnější příklad najdete v prognózování poptávky s mnoha poznámkovými bloky modelů.
Důležité informace o trénování pro mnoho modelů
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á. Před spuštěním mnoha modelů trénování nebo odvozování doporučujeme data rozdělit ručně.
Poznámka:
Výchozí limit paralelismu pro mnoho modelů spuštěných v rámci předplatného je nastavený na 320. Pokud vaše úloha vyžaduje vyšší limit, můžete kontaktovat podporu Microsoftu.
Prognóza ve velkém měřítku: Hierarchická časová řada
Komponenty hierarchických časových řad (HTS) v AutoML umožňují trénovat velký počet modelů na datech s hierarchickou strukturou. Další informace naleznete v tématu Hierarchické časové řady prognózování.
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 příkazu 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 list nebo nejvíce členěnou úroveň hierarchie. |
hierarchy_training_level |
Úroveň hierarchie, která se má použít pro trénování modelu prognózy. |
Následující příklad obsahuje ukázkovou konfiguraci YAML:
$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 je konfigurace uložena v cestě ./automl_settings_hts.yml.
Kanál HTS
Dále definujte funkci továrny, která vytváří kanály pro orchestraci trénování, odvozování a výpočtů metrik HTS. Následující tabulka popisuje parametry této funkce továrny:
| Parametr | Popis |
|---|---|
forecast_level |
Úroveň hierarchie, pro kterou se mají načítat prognózy. |
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íchuzlůch |
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 naleznete v tématu Odvozování a hodnocení modelů prognózování a HTSInferenceParameters – referenční dokumentace třídy . |
step |
Velikost kroku pro průběžnou prognózu (výchozí hodnota je 1). Další informace naleznete v tématu Odvozování a hodnocení modelů prognózování a HTSInferenceParameters – referenční dokumentace třídy . |
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
}
Vytvořte kanál pomocí funkce továrny. Trénovací a testovací data jsou v místních složkách ./data/train a ./data/test. Nakonec nastavte výchozí výpočetní prostředky a odešlete úlohu, jak je znázorněno v následujícím příkladu:
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 v prognózování poptávky pomocí poznámkového bloku hierarchické časové řady.
Důležité informace o trénování pro spuštění HTS
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á. Doporučeným přístupem je ruční dělení dat před spuštěním trénování nebo odvozování HTS.
Poznámka:
Výchozí limit paralelismu pro spuštění HTS v rámci předplatného je nastavený na 320. Pokud vaše úloha vyžaduje vyšší limit, můžete kontaktovat podporu Microsoftu.
Prognóza ve velkém měřítku: Distribuované trénování DNN
Jak je popsáno výše v tomto článku, můžete povolit učení pro hluboké neurální sítě (DNN). Informace o tom, jak distribuované trénování funguje pro úlohy prognózování DNN, najdete v tématu Trénování distribuované hluboké neurální sítě (Preview).
Pro scénáře s velkými požadavky na data je distribuované trénování pomocí AutoML k dispozici pro omezenou sadu modelů. Další informace a ukázky kódu najdete ve službě AutoML ve velkém měřítku: Distribuované trénování.
Prozkoumání ukázkových poznámkových bloků
Podrobné ukázky kódu, které demonstrují pokročilé konfigurace prognózování, jsou k dispozici v úložišti GitHubu s ukázkovými poznámkovými bloky pro prognózování AutoML. Tady jsou některé z ukázkových poznámkových bloků:
- Vytvoření kanálu prognózování poptávky (HTS a mnoho modelů)
- TCNForecaster (DNN) model trénování na datové sadě GitHubu
- Prognóza s detekcí svátků a featurizací (datová sada pro sdílení kol)
- Ruční konfigurace prodlev a agregace posuvných oken