Konfigurowanie rozwiązania AutoML do trenowania modelu prognozowania szeregów czasowych za pomocą zestawu SDK i interfejsu wiersza polecenia

  • Artykuł

DOTYCZY:Rozszerzenie uczenia maszynowego platformy Azure w wersji 2 (bieżąca)Zestaw SDK języka Python azure-ai-ml w wersji 2 (bieżąca)

W tym artykule dowiesz się, jak skonfigurować rozwiązanie AutoML na potrzeby prognozowania szeregów czasowych za pomocą zautomatyzowanego uczenia maszynowego usługi Azure Machine Learning w zestawie SDK języka Python usługi Azure Machine Learning.

W tym celu wykonasz następujące czynności:

  • Przygotowywanie danych do trenowania.
  • Skonfiguruj określone parametry szeregów czasowych w zadaniu prognozowania.
  • Organizowanie trenowania, wnioskowania i oceny modelu przy użyciu składników i potoków.

Aby uzyskać małe środowisko kodu, zobacz Samouczek: prognozowanie zapotrzebowania na zautomatyzowane uczenie maszynowe na przykład prognozowania szeregów czasowych przy użyciu zautomatyzowanego uczenia maszynowego w Azure Machine Learning studio.

Rozwiązanie AutoML używa standardowych modeli uczenia maszynowego wraz z dobrze znanymi modelami szeregów czasowych do tworzenia prognoz. Nasze podejście obejmuje historyczne informacje o zmiennej docelowej, funkcjach udostępnianych przez użytkownika w danych wejściowych i automatycznie zaprojektowanych funkcjach. Następnie algorytmy wyszukiwania modelu działają, aby znaleźć model z najlepszą dokładnością predykcyjną. Aby uzyskać więcej informacji, zobacz nasze artykuły dotyczące metodologii prognozowania i wyszukiwania modeli.

Wymagania wstępne

W przypadku tego artykułu potrzebne są następujące elementy:

Trenowanie i walidacja danych

Dane wejściowe prognozowania automatycznego uczenia maszynowego muszą zawierać prawidłowe szeregi czasowe w formacie tabelarycznym. Każda zmienna musi mieć własną odpowiednią kolumnę w tabeli danych. Rozwiązanie AutoML wymaga co najmniej dwóch kolumn: kolumny czasowej reprezentującej oś czasu i kolumnę docelową , która jest ilością do prognozowania. Inne kolumny mogą służyć jako predyktory. Aby uzyskać więcej informacji, zobacz, jak rozwiązanie AutoML używa danych.

Ważne

Podczas trenowania modelu prognozowania przyszłych wartości upewnij się, że wszystkie funkcje używane w trenowaniu mogą być używane podczas uruchamiania przewidywań dla zamierzonego horyzontu.

Na przykład funkcja bieżącej ceny akcji może znacznie zwiększyć dokładność trenowania. Jeśli jednak zamierzasz prognozować długi horyzont, może nie być w stanie dokładnie przewidzieć przyszłych wartości zapasów odpowiadających przyszłym punktom szeregów czasowych, a dokładność modelu może cierpieć.

Zadania prognozowania automatycznego uczenia maszynowego wymagają, aby dane treningowe są reprezentowane jako obiekt MLTable . Tabela MLTable określa źródło danych i kroki ładowania danych. Aby uzyskać więcej informacji i przypadków użycia, zobacz przewodnik z instrukcjami w tabeli MLTable. W prostym przykładzie załóżmy, że dane szkoleniowe znajdują się w pliku CSV w katalogu lokalnym . ./train_data/timeseries_train.csv

Tabelę MLTable można utworzyć przy użyciu zestawu MLtable Python SDK , jak pokazano w poniższym przykładzie:

import mltable

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

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

Ten kod tworzy nowy plik, ./train_data/MLTablektóry zawiera format pliku i instrukcje ładowania.

Teraz zdefiniujesz obiekt danych wejściowych, który jest wymagany do uruchomienia zadania szkoleniowego przy użyciu zestawu SDK języka Python usługi Azure Machine Learning w następujący sposób:

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

Dane weryfikacji można określić w podobny sposób, tworząc tabelę MLTable i określając dane wejściowe danych weryfikacji. Alternatywnie, jeśli nie podasz danych weryfikacji, rozwiązanie AutoML automatycznie tworzy podziały krzyżowe weryfikacji z danych treningowych do użycia do wyboru modelu. Aby uzyskać więcej informacji, zobacz nasz artykuł dotyczący wyboru modelu prognozowania . Zobacz również wymagania dotyczące długości danych treningowych , aby uzyskać szczegółowe informacje na temat tego, ile danych szkoleniowych należy pomyślnie wytrenować model prognozowania.

Dowiedz się więcej o tym, jak rozwiązanie AutoML stosuje krzyżową walidację, aby zapobiec nadmiernemu dopasowaniu.

Obliczenia w celu uruchomienia eksperymentu

Rozwiązanie AutoML używa usługi Azure Machine Learning Compute, czyli w pełni zarządzanego zasobu obliczeniowego do uruchamiania zadania trenowania. W poniższym przykładzie tworzony jest klaster obliczeniowy o nazwie 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()

Konfigurowanie eksperymentu

Funkcje fabryki automatycznego uczenia maszynowego służą do konfigurowania zadań prognozowania w zestawie SDK języka Python. W poniższym przykładzie pokazano, jak utworzyć zadanie prognozowania , ustawiając podstawową metrykę i ustawiając limity w przebiegu trenowania:

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

Ustawienia zadania prognozowania

Zadania prognozowania mają wiele ustawień specyficznych dla prognozowania. Najbardziej podstawowe z tych ustawień są nazwa kolumny czasowej w danych treningowych i horyzoncie prognozy.

Użyj metod ForecastingJob , aby skonfigurować następujące ustawienia:

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

Nazwa kolumny czasowej jest wymaganym ustawieniem i zazwyczaj należy ustawić horyzont prognozy zgodnie ze scenariuszem przewidywania. Jeśli dane zawierają wiele szeregów czasowych, możesz określić nazwy kolumn identyfikatorów szeregów czasowych. Te kolumny, po zgrupowaniu, definiują poszczególne serie. Załóżmy na przykład, że masz dane składające się z godzinowej sprzedaży z różnych sklepów i marek. W poniższym przykładzie pokazano, jak ustawić kolumny identyfikatorów szeregów czasowych przy założeniu, że dane zawierają kolumny o nazwie "store" i "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']
)

Rozwiązanie AutoML próbuje automatycznie wykryć kolumny identyfikatorów szeregów czasowych w danych, jeśli nie zostaną określone żadne.

Inne ustawienia są opcjonalne i przeglądane w następnej sekcji.

Opcjonalne ustawienia zadania prognozowania

Opcjonalne konfiguracje są dostępne dla zadań prognozowania, takich jak włączanie uczenia głębokiego i określanie docelowej agregacji okien kroczących. Pełna lista parametrów jest dostępna w dokumentacji dokumentacji referencyjnej prognozowania.

Ustawienia wyszukiwania modelu

Istnieją dwa opcjonalne ustawienia kontrolujące miejsce modelu, w którym rozwiązanie AutoML wyszukuje najlepszy model i allowed_training_algorithmsblocked_training_algorithms. Aby ograniczyć miejsce wyszukiwania do danego zestawu klas modelu, użyj parametru allowed_training_algorithms w następujący przykład:

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

W tym przypadku zadanie prognozowania wyszukuje tylko klasy modeli Exponential Smoothing i Elastic Net. Aby usunąć dany zestaw klas modelu z obszaru wyszukiwania, użyj blocked_training_algorithms jak w poniższym przykładzie:

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

Teraz zadanie wyszukuje wszystkie klasy modeli z wyjątkiem Proroka. Aby zapoznać się z listą nazw modeli prognozowania akceptowanych w allowed_training_algorithms systemach i blocked_training_algorithms, zobacz dokumentację referencyjną właściwości trenowania . Albo, ale nie oba, allowed_training_algorithms i blocked_training_algorithms można zastosować do przebiegu trenowania.

Włączanie uczenia głębokiego

Rozwiązanie AutoML jest dostarczane z niestandardowym modelem głębokiej sieci neuronowej (DNN) o nazwie TCNForecaster. Ten model jest tymczasową siecią konwolucyjną lub TCN, która stosuje typowe metody zadań obrazowania do modelowania szeregów czasowych. Mianowicie jednowymiarowe "przyczynowe" sploty tworzą szkielet sieci i umożliwiają modelowi uczenie się złożonych wzorców w długich okresach trwania w historii trenowania. Aby uzyskać więcej informacji, zobacz nasz artykuł TCNForecaster.

Diagram przedstawiający główne składniki TCNForecaster rozwiązania AutoML.

TCNForecaster często osiąga większą dokładność niż standardowe modele szeregów czasowych, gdy istnieje tysiące lub więcej obserwacji w historii trenowania. Jednak trenowanie i zamiatanie modeli TCNForecaster z powodu ich wyższej pojemności trwa dłużej.

Możesz włączyć funkcję TCNForecaster w rozwiązaniu AutoML, ustawiając flagę enable_dnn_training w konfiguracji trenowania w następujący sposób:

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

Domyślnie trenowanie TCNForecaster jest ograniczone do jednego węzła obliczeniowego i pojedynczego procesora GPU, jeśli jest dostępne, na wersję próbną modelu. W przypadku dużych scenariuszy danych zalecamy dystrybucję każdej wersji próbnej TCNForecaster na wiele rdzeni/procesorów GPU i węzłów. Aby uzyskać więcej informacji i przykłady kodu, zobacz sekcję artykułu dotyczącego trenowania rozproszonego .

Aby włączyć nazwę sieci rozproszonej dla eksperymentu automatycznego uczenia maszynowego utworzonego w Azure Machine Learning studio, zobacz ustawienia typu zadania w interfejsie użytkownika programu Studio.

Uwaga

  • Po włączeniu nazwy sieci rozproszonej dla eksperymentów utworzonych za pomocą zestawu SDK najlepsze wyjaśnienia modelu są wyłączone.
  • Obsługa nazwy sieci rozproszonej na potrzeby prognozowania w zautomatyzowanym uczeniu maszynowym nie jest obsługiwana w przypadku przebiegów zainicjowanych w usłudze Databricks.
  • Typy obliczeniowe procesora GPU są zalecane w przypadku włączenia trenowania nazwy sieci rozproszonej

Funkcje opóźnień i okien kroczących

Ostatnie wartości celu często mają wpływ na funkcje w modelu prognozowania. W związku z tym rozwiązanie AutoML może tworzyć funkcje agregacji okien czasowych i kroczących, aby potencjalnie zwiększyć dokładność modelu.

Rozważmy scenariusz prognozowania zapotrzebowania na energię, w którym dostępne są dane pogodowe i historyczne zapotrzebowanie. W tabeli przedstawiono wynikowe inżynierii cech, które mają miejsce, gdy agregacja okien jest stosowana w ciągu ostatnich trzech godzin. Kolumny dla wartości minimalnej, maksymalnej i sumy są generowane w oknie przewijania wynoszącym trzy godziny na podstawie zdefiniowanych ustawień. Na przykład dla obserwacji ważnej 8 września 2017 r. 4:00 maksymalna, minimalna i suma wartości są obliczane przy użyciu wartości zapotrzebowania dla 8 września 2017 r. 1:00–3:00. To okno z trzema godzinami przesuwa się w celu wypełnienia danych pozostałych wierszy. Aby uzyskać więcej szczegółów i przykładów, zobacz artykuł dotyczący funkcji opóźnienia.

okno stopniowe elementu docelowego

Funkcje agregacji opóźnień i okien kroczących dla elementu docelowego można włączyć, ustawiając rozmiar okna kroczącego, który był trzy w poprzednim przykładzie, oraz zamówienia opóźnień, które chcesz utworzyć. Możesz również włączyć opóźnienia dla funkcji za pomocą feature_lags ustawienia . W poniższym przykładzie ustawimy wszystkie te ustawienia tak auto , aby rozwiązanie AutoML automatycznie określało ustawienia, analizując strukturę korelacji danych:

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

Obsługa serii krótkiej

Zautomatyzowane uczenie maszynowe uwzględnia szereg czasowy w krótkiej serii , jeśli nie ma wystarczającej liczby punktów danych do przeprowadzenia fazy trenowania i walidacji opracowywania modeli. Zobacz wymagania dotyczące długości danych treningowych , aby uzyskać więcej informacji na temat wymagań dotyczących długości.

Rozwiązanie AutoML ma kilka akcji, które można wykonać w krótkiej serii. Te akcje można konfigurować za short_series_handling_config pomocą ustawienia . Wartość domyślna to "auto". W poniższej tabeli opisano ustawienia:

Ustawienie Opis
auto Wartość domyślna obsługi serii krótkiej.
- Jeśli wszystkie serie są krótkie, dodaj dane.
- Jeśli nie wszystkie serie są krótkie, upuść krótką serię.
pad Jeśli short_series_handling_config = padwartość , zautomatyzowane uczenie maszynowe dodaje losowe wartości do każdej znalezionej serii krótkiej. Poniżej wymieniono typy kolumn i ich zawartość:
- Kolumny obiektów z siecią NaN
- Kolumny liczbowe z 0
- Kolumny logiczne/logiczne z fałszem
- Kolumna docelowa jest dopełniona białym szumem.
drop Jeśli short_series_handling_config = drop, zautomatyzowane uczenie maszynowe pominie serię krótką i nie będzie używane do trenowania ani przewidywania. Przewidywania dla tych serii będą zwracać wartości NaN.
None Żadna seria nie jest dopełniona ani porzucona

W poniższym przykładzie ustawiliśmy obsługę serii krótkiej tak, aby wszystkie krótkie serie zostały dopełnione do minimalnej długości:

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

Ostrzeżenie

Wypełnienie może mieć wpływ na dokładność wynikowego modelu, ponieważ wprowadzamy sztuczne dane, aby uniknąć niepowodzeń trenowania. Jeśli wiele serii jest krótkich, może być również widoczny wpływ na wyniki objaśnienia

Agregacja danych docelowych częstotliwości &

Użyj opcji częstotliwości i agregacji danych, aby uniknąć błędów spowodowanych nieregularnymi danymi. Dane są nieregularne, jeśli nie są zgodne z ustawionym okresem w czasie, na przykład co godzinę lub codziennie. Dane dotyczące punktów sprzedaży są dobrym przykładem nieregularnych danych. W takich przypadkach rozwiązanie AutoML może agregować dane do żądanej częstotliwości, a następnie utworzyć model prognozowania na podstawie agregacji.

Należy ustawić frequency ustawienia i target_aggregate_function , aby obsługiwać nieregularne dane. Ustawienie częstotliwości akceptuje ciągi DateOffset biblioteki Pandas jako dane wejściowe. Obsługiwane wartości funkcji agregacji to:

Funkcja Opis
sum  Suma wartości docelowych
mean  Średnia lub średnia wartości docelowych
min Minimalna wartość elementu docelowego
max Maksymalna wartość elementu docelowego
  • Wartości kolumny docelowej są agregowane zgodnie z określoną operacją. Zazwyczaj suma jest odpowiednia dla większości scenariuszy.
  • Kolumny predyktora liczbowego w danych są agregowane według sumy, średniej, wartości minimalnej i wartości maksymalnej. W związku z tym zautomatyzowane uczenie maszynowe generuje nowe kolumny z sufiksem nazwy funkcji agregacji i stosuje wybraną operację agregacji.
  • W przypadku kolumn predyktora kategorii dane są agregowane według trybu, czyli najbardziej widocznej kategorii w oknie.
  • Kolumny predyktora dat są agregowane według wartości minimalnej, wartości maksymalnej i trybu.

W poniższym przykładzie ustawiono częstotliwość na wartość godzinową, a funkcja agregacji na sumację:

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

Niestandardowe ustawienia krzyżowego sprawdzania poprawności

Istnieją dwa dostosowywalne ustawienia, które kontrolują krzyżową walidację zadań prognozowania: liczbę składań, n_cross_validationsi rozmiar kroku definiujący przesunięcie czasu między fałdami, cv_step_size. Aby uzyskać więcej informacji na temat znaczenia tych parametrów, zobacz prognozowanie wyboru modelu . Domyślnie rozwiązanie AutoML automatycznie ustawia oba ustawienia na podstawie właściwości danych, ale zaawansowani użytkownicy mogą chcieć ustawić je ręcznie. Załóżmy na przykład, że masz dane dziennej sprzedaży i chcesz, aby konfiguracja walidacji składała się z pięciu krotności z siedmiodniowym przesunięciem między sąsiednimi fałdami. Poniższy przykład kodu przedstawia sposób ustawiania następujących elementów:

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
)

Cechowanie niestandardowe

Domyślnie rozwiązanie AutoML rozszerza dane treningowe o funkcje zaprojektowane w celu zwiększenia dokładności modeli. Aby uzyskać więcej informacji, zobacz zautomatyzowaną inżynierię cech . Niektóre kroki przetwarzania wstępnego można dostosować przy użyciu konfiguracji cech zadania prognozowania.

Obsługiwane dostosowania do prognozowania znajdują się w poniższej tabeli:

Dostosowywanie Opis Opcje
Aktualizacja celu kolumny Zastąpij automatycznie wykryty typ funkcji dla określonej kolumny. "Kategorialne", "DateTime", "Numeryczne"
Aktualizacja parametru funkcji Transformer Zaktualizuj parametry dla określonego imputera. {"strategy": "constant", "fill_value": <value>}, {"strategy": "median"}, {"strategy": "ffill"}

Załóżmy na przykład, że masz scenariusz popytu detalicznego, w którym dane obejmują ceny, flagę "sprzedaży" i typ produktu. W poniższym przykładzie pokazano, jak ustawić niestandardowe typy i imputery dla tych funkcji:

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

Jeśli używasz Azure Machine Learning studio do eksperymentu, zobacz, jak dostosować cechowanie w studio.

Przesyłanie zadania prognozowania

Po skonfigurowaniu wszystkich ustawień uruchamiasz zadanie prognozowania w następujący sposób:

# 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

Po przesłaniu zadania rozwiązanie AutoML będzie aprowizować zasoby obliczeniowe, zastosować cechowanie i inne kroki przygotowania do danych wejściowych, a następnie rozpocząć zamiatanie modeli prognozowania. Aby uzyskać więcej informacji, zobacz nasze artykuły dotyczące metodologii prognozowania i wyszukiwania modeli.

Organizowanie trenowania, wnioskowania i oceny za pomocą składników i potoków

Ważne

Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone.

Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Przepływ pracy uczenia maszynowego prawdopodobnie wymaga więcej niż tylko trenowania. Wnioskowanie lub pobieranie przewidywań modelu na nowszych danych oraz ocena dokładności modelu w zestawie testowym ze znanymi wartościami docelowymi to inne typowe zadania, które można organizować w usłudze AzureML wraz z zadaniami trenowania. Aby obsługiwać zadania wnioskowania i oceny, usługa AzureML udostępnia składniki, które są samodzielnymi fragmentami kodu, które wykonują jeden krok w potoku usługi AzureML.

W poniższym przykładzie pobieramy kod składnika z rejestru 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"
)

Następnie zdefiniujemy funkcję fabryki, która tworzy potoki organizujące trenowanie, wnioskowanie i obliczanie metryk. Aby uzyskać więcej informacji na temat ustawień trenowania, zobacz sekcję konfiguracja trenowania .

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
    }

Teraz definiujemy dane wejściowe trenowania i testowania przy założeniu, że są one zawarte w folderach ./train_data lokalnych i ./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',
)

Na koniec skonstruujemy potok, ustawimy jego domyślne obliczenia i prześlemy zadanie:

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 przesłaniu potok uruchamia trenowanie zautomatyzowanego uczenia maszynowego, wnioskowanie oceny stopniowej i obliczanie metryk w sekwencji. Możesz monitorować i sprawdzać przebieg w interfejsie użytkownika programu Studio. Po zakończeniu przebiegu prognozy stopniowe i metryki oceny można pobrać do lokalnego katalogu roboczego:

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

Następnie można znaleźć wyniki metryk i ./named-outputs/metrics_results/evaluationResult/metrics.json prognozy w formacie wierszy JSON w pliku ./named-outputs/rolling_fcst_result/inference_output_file.

Aby uzyskać więcej informacji na temat oceny stopniowej, zobacz nasz artykuł dotyczący oceny modelu prognozowania.

Prognozowanie na dużą skalę: wiele modeli

Ważne

Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone.

Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Wiele składników modeli w rozwiązaniu AutoML umożliwia równoległe trenowanie milionów modeli i zarządzanie nimi. Aby uzyskać więcej informacji na temat wielu pojęć dotyczących modeli, zobacz sekcję z wieloma modelami.

Konfiguracja trenowania wielu modeli

Składnik trenowania wielu modeli akceptuje plik konfiguracji formatu YAML ustawień trenowania zautomatyzowanego uczenia maszynowego. Składnik stosuje te ustawienia do każdego uruchamianych wystąpień rozwiązania AutoML. Ten plik YAML ma taką samą specyfikację jak zadanie prognozowania oraz dodatkowe parametry partition_column_names i allow_multi_partitions.

Parametr Opis
partition_column_names Nazwy kolumn w danych, które podczas grupowania definiują partycje danych. Wiele modeli składnik trenowania uruchamia niezależne zadanie trenowania na każdej partycji.
allow_multi_partitions Opcjonalna flaga umożliwiająca trenowanie jednego modelu na partycję, gdy każda partycja zawiera więcej niż jeden unikatowy szereg czasowy. Wartość domyślna to False.

Poniższy przykład zawiera szablon konfiguracji:

$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

W kolejnych przykładach przyjęto założenie, że konfiguracja jest przechowywana w ścieżce ./automl_settings_mm.yml.

Potok wielu modeli

Następnie zdefiniujemy funkcję fabryki, która tworzy potoki do organizowania wielu modeli trenowania, wnioskowania i obliczeń metryk. Parametry tej funkcji fabryki zostały szczegółowo opisane w poniższej tabeli:

Parametr Opis
max_nodes Liczba węzłów obliczeniowych do użycia w zadaniu trenowania
max_concurrency_per_node Liczba procesów automatycznego uczenia maszynowego do uruchomienia w każdym węźle. W związku z tym łączna współbieżność wielu zadań modeli to max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Wiele modeli limitu czasu składników podane w liczbie sekund.
retrain_failed_models Flaga umożliwiająca ponowne trenowanie modeli, które zakończyły się niepowodzeniem. Jest to przydatne, jeśli wykonano poprzednie wiele przebiegów modeli, które spowodowały niepowodzenie zadań automatycznego uczenia maszynowego na niektórych partycjach danych. Po włączeniu tej flagi wiele modeli uruchamia zadania szkoleniowe tylko dla wcześniej nieudanych partycji.
forecast_mode Tryb wnioskowania na potrzeby oceny modelu. Prawidłowe wartości to "recursive" i "rolling". Aby uzyskać więcej informacji, zobacz artykuł dotyczący oceny modelu .
forecast_step Rozmiar kroku dla prognozy stopniowej. Aby uzyskać więcej informacji, zobacz artykuł dotyczący oceny modelu .

Poniższy przykład ilustruje metodę fabryki do konstruowania wielu modeli trenowania i ewaluacji modeli:

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
    }

Teraz skonstruujemy potok za pomocą funkcji fabryki, zakładając, że dane treningowe i testowe znajdują się odpowiednio w folderach ./data/train lokalnych i ./data/test. Na koniec ustawimy domyślne obliczenia i prześlemy zadanie, tak jak w poniższym przykładzie:

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 zakończeniu zadania metryki oceny można pobrać lokalnie przy użyciu tej samej procedury co w jednym potoku przebiegu trenowania.

Aby uzyskać bardziej szczegółowy przykład, zobacz również prognozowanie zapotrzebowania przy użyciu wielu modeli notesu.

Uwaga

Wiele modeli trenowania i wnioskowania składników warunkowo partycjonuje dane zgodnie z ustawieniem partition_column_names , tak aby każda partycja znajduje się we własnym pliku. Ten proces może być bardzo powolny lub kończy się niepowodzeniem, gdy dane są bardzo duże. W takim przypadku zalecamy ręczne partycjonowanie danych przed uruchomieniem wielu modeli trenowania lub wnioskowania.

Prognozowanie na dużą skalę: hierarchiczne szeregi czasowe

Ważne

Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone.

Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Hierarchiczne składniki szeregów czasowych (HTS) w rozwiązaniu AutoML umożliwiają trenowanie dużej liczby modeli na danych przy użyciu struktury hierarchicznej. Aby uzyskać więcej informacji, zobacz sekcję artykułu HTS.

Konfiguracja trenowania HTS

Składnik trenowania HTS akceptuje plik konfiguracji formatu YAML ustawień uczenia automatycznego uczenia maszynowego. Składnik stosuje te ustawienia do każdego uruchomionego wystąpienia rozwiązania AutoML. Ten plik YAML ma taką samą specyfikację jak zadanie prognozowania oraz dodatkowe parametry związane z informacjami o hierarchii:

Parametr Opis
hierarchy_column_names Lista nazw kolumn w danych definiujących hierarchiczną strukturę danych. Kolejność kolumn na tej liście określa poziomy hierarchii; stopień agregacji zmniejsza się wraz z indeksem listy. Oznacza to, że ostatnia kolumna na liście definiuje poziom liścia (najbardziej rozagregowany) hierarchii.
hierarchy_training_level Poziom hierarchii używany do trenowania modelu prognozy.

Poniżej przedstawiono przykładową konfigurację:

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

W kolejnych przykładach przyjęto założenie, że konfiguracja jest przechowywana w ścieżce ./automl_settings_hts.yml.

Potok HTS

Następnie zdefiniujemy funkcję fabryki, która tworzy potoki do orkiestracji trenowania, wnioskowania i obliczeń metryk HTS. Parametry tej funkcji fabryki zostały szczegółowo opisane w poniższej tabeli:

Parametr Opis
forecast_level Poziom hierarchii do pobierania prognoz dla
allocation_method Metoda alokacji do użycia, gdy prognozy są rozagregowane. Prawidłowe wartości to "proportions_of_historical_average" i "average_historical_proportions".
max_nodes Liczba węzłów obliczeniowych do użycia w zadaniu trenowania
max_concurrency_per_node Liczba procesów automatycznego uczenia maszynowego do uruchomienia w każdym węźle. W związku z tym łączna współbieżność zadania HTS to max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Limit czasu składników wielu modeli jest podawany w ciągu kilku sekund.
forecast_mode Tryb wnioskowania na potrzeby oceny modelu. Prawidłowe wartości to "recursive" i "rolling". Aby uzyskać więcej informacji, zobacz artykuł dotyczący oceny modelu .
forecast_step Rozmiar kroku dla prognozy stopniowej. Aby uzyskać więcej informacji, zobacz artykuł dotyczący oceny 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
    }

Teraz skonstruujemy potok za pomocą funkcji factory, zakładając, że dane trenowania i testowania znajdują się odpowiednio w folderach lokalnych i ./data/test. ./data/train Na koniec ustawiliśmy domyślne obliczenia i przesyłamy zadanie tak, jak w poniższym przykładzie:

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 zakończeniu zadania metryki oceny można pobrać lokalnie przy użyciu tej samej procedury co w potoku pojedynczego uruchomienia trenowania.

Zobacz również prognozowanie zapotrzebowania z hierarchicznym notesem szeregów czasowych , aby uzyskać bardziej szczegółowy przykład.

Uwaga

Składniki trenowania i wnioskowania HTS warunkowo partycjonować dane zgodnie z hierarchy_column_names ustawieniem, tak aby każda partycja znajduje się we własnym pliku. Ten proces może być bardzo powolny lub kończy się niepowodzeniem, gdy dane są bardzo duże. W takim przypadku zalecamy ręczne partycjonowanie danych przed uruchomieniem trenowania lub wnioskowania HTS.

Prognozowanie na dużą skalę: trenowanie rozproszonej sieci rozproszone

Przykładowe notesy

Zobacz przykładowe notesy prognozowania, aby uzyskać szczegółowe przykłady kodu zaawansowanej konfiguracji prognozowania obejmujące następujące elementy:

Następne kroki