Udostępnij za pośrednictwem


Konfigurowanie rozwiązania AutoML do trenowania modelu prognozowania szeregów czasowych przy użyciu zestawu SDK i interfejsu wiersza polecenia

DOTYCZY: Rozszerzenie interfejsu wiersza polecenia platformy Azure w wersji 2 (current)Zestaw PYTHON SDK azure-ai-ml v2 (bieżąca)

Zautomatyzowane uczenie maszynowe (AutoML) w usłudze Azure Machine Learning używa standardowych modeli uczenia maszynowego wraz z dobrze znanymi modelami szeregów czasowych do tworzenia prognoz. Takie podejście obejmuje historyczne informacje o zmiennej docelowej z funkcjami udostępnianymi przez użytkownika w danych wejściowych i automatycznie zaprojektowanymi funkcjami. Algorytmy wyszukiwania modelu pomagają identyfikować modele z najlepszą dokładnością predykcyjną. Aby uzyskać więcej informacji, zobacz metodologię prognozowania i zamiatanie modeli i wybór.

W tym artykule opisano sposób konfigurowania automatycznego uczenia maszynowego na potrzeby prognozowania szeregów czasowych przy użyciu zestawu SDK języka Python usługi Azure Machine Learning](/python/api/overview/azure/ai-ml-readme). Proces obejmuje przygotowywanie danych do trenowania i konfigurowania parametrów szeregów czasowych w zadaniu prognozowania (odwołanie do klasy). Następnie trenujesz, wnioskowanie i oceniasz modele przy użyciu składników i potoków.

Aby uzyskać informacje o niskim kodzie, zobacz Samouczek: prognozowanie zapotrzebowania za pomocą zautomatyzowanego uczenia maszynowego. Ten zasób jest przykładem prognozowania szeregów czasowych, który używa rozwiązania AutoML w usłudze Azure Machine Learning Studio.

Wymagania wstępne

Przygotowywanie danych trenowania i walidacji

Dane wejściowe prognozowania automatycznego uczenia maszynowego muszą zawierać prawidłowy szereg czasowy 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 czasu reprezentującej oś czasu i kolumnę docelową dla prognozowanej ilości. Inne kolumny mogą służyć jako predyktory. Aby uzyskać więcej informacji, zobacz How AutoML uses your data (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ć również używane podczas uruchamiania przewidywań dla zamierzonego horyzontu.

Rozważ funkcję bieżącej ceny akcji, która może znacznie zwiększyć dokładność trenowania. Jeśli prognozujesz za pomocą długiego horyzontu, możesz nie być w stanie dokładnie przewidzieć przyszłych wartości akcji odpowiadających przyszłym punktom szeregów czasowych. Takie podejście może zmniejszyć dokładność modelu.

Zadania prognozowania automatycznego uczenia maszynowego wymagają, aby dane szkoleniowe były reprezentowane jako MLTable obiekt. Obiekt MLTable określa źródło danych i kroki ładowania danych. Aby uzyskać więcej informacji i przypadków użycia, zobacz [Praca z tabelami (how-to-mltable.md).

W poniższym przykładzie załóżmy, że dane szkoleniowe znajdują się w pliku CSV w katalogu lokalnym ./train_data/timeseries_train.csv.

Obiekt można utworzyć MLTable 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/MLTable, który zawiera format pliku i instrukcje ładowania.

Aby rozpocząć zadanie trenowania, zdefiniuj obiekt danych wejściowych przy użyciu zestawu SDK języka Python 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. MLTable Utwórz obiekt i określ dane wejściowe danych walidacji. Alternatywnie, jeśli nie podasz danych walidacji, rozwiązanie AutoML automatycznie tworzy podziały krzyżowe weryfikacji z danych treningowych do użycia na potrzeby wyboru modelu. Aby uzyskać więcej informacji, zobacz następujące zasoby:

Tworzenie zasobów obliczeniowych do uruchamiania eksperymentu

Rozwiązanie AutoML używa usługi Azure Machine Learning Compute, czyli w pełni zarządzanego zasobu obliczeniowego, aby uruchomić zadanie trenowania. Poniższy przykład tworzy 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

W poniższym przykładzie pokazano, jak skonfigurować eksperyment.

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 metrykę podstawową i ustawiając limity w przebiegu trenowania:

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

Ustawienia zadania prognozy

Zadania prognozowania mają wiele ustawień specyficznych dla prognozowania. Najbardziej podstawowe z tych ustawień są nazwa kolumny czasu 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. 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. Po zgrupowaniu tych kolumn definiują pojedynczą serię. 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 żadne nie zostanie określone.

Inne ustawienia są opcjonalne i przeglądane w poniższej 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 referencyjnej.

Ustawienia wyszukiwania modelu

Istnieją dwa opcjonalne ustawienia kontrolujące przestrzeń modelu, w której rozwiązanie AutoML wyszukuje najlepszy model: allowed_training_algorithms i blocked_training_algorithms. Aby ograniczyć przestrzeń wyszukiwania do danego zestawu klas modelu, użyj parametru allowed_training_algorithms , jak pokazano w poniższym przykładzie:

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

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

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

Zadanie wyszukuje wszystkie klasy modeli z wyjątkiem Proroka. Aby uzyskać listę nazw modeli prognozowania akceptowanych w allowed_training_algorithms systemach i blocked_training_algorithms, zobacz właściwości trenowania. Możesz zastosować zarówno, jak allowed_training_algorithms i blocked_training_algorithms do przebiegu treningowego.

Włączanie uczenia dla głębokich sieci neuronowych

Rozwiązanie AutoML jest dostarczane z niestandardowym modelem głębokiej sieci neuronowej (DNN) o nazwie TCNForecaster. Ten model to tymczasowa sieć konwolucyjna (TCN), która stosuje typowe metody zadań obrazowania do modelowania szeregów czasowych. Jednowymiarowe "przyczynowe" sploty tworzą szkielet sieci i umożliwiają modelowi uczenie się złożonych wzorców przez długi czas w historii trenowania. Aby uzyskać więcej informacji, zobacz Wprowadzenie do TCNForecaster.

Diagram przedstawiający główne składniki modelu 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.

Funkcję TCNForecaster można włączyć 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ępny, na wersję próbną modelu. W przypadku scenariuszy dużych danych zaleca się dystrybucję każdej wersji próbnej TCNForecaster na wiele rdzeni/procesorów GPU i węzłów. Aby uzyskać więcej informacji i przykładów kodu, zobacz trenowanie rozproszone.

Aby włączyć nazwę sieci rozproszonej dla eksperymentu automatycznego uczenia maszynowego utworzonego w usłudze Azure Machine Learning Studio, zobacz ustawienia typu zadań 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 sieci rozproszonej na potrzeby prognozowania w zautomatyzowanym uczeniu maszynowym nie jest obsługiwana w przypadku przebiegów zainicjowanych w usłudze Azure Databricks.
  • Zalecaną metodą jest użycie typów obliczeniowych procesora GPU w przypadku włączenia trenowania sieci rozproszonej.

Funkcje opóźnień i okien kroczenia

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 kroczenia, aby potencjalnie zwiększyć dokładność modelu.

Rozważmy scenariusz prognozowania zapotrzebowania na energię, w którym są dostępne dane pogodowe i historyczne zapotrzebowanie. W tabeli przedstawiono wynikowe inżynierii cech, które występują, 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 4:00, wartości maksymalne, minimalne i sum są obliczane przy użyciu wartości zapotrzebowania dla 8 września 2017 r. 1:00–3:00. To okno z trzema godzinami zmienia się, aby wypełnić dane pozostałych wierszy. Aby uzyskać więcej informacji i przykładów, zobacz funkcje opóźnienie dla prognozowania szeregów czasowych w rozwiązaniu AutoML.

Diagram tabeli z danymi, które pokazują docelowe okno stopniowe i wartości w wyróżnionej kolumnie Żądanie.

Funkcje agregacji opóźnień i okien kroczenia dla elementu docelowego można włączyć, ustawiając rozmiar okna kroczącego i zamówienia opóźnienia, które chcesz utworzyć. Rozmiar okna był trzy w poprzednim przykładzie. Można również włączyć opóźnienia dla funkcji za pomocą feature_lags ustawienia . W poniższym przykładzie wszystkie te ustawienia są ustawione tak, aby auto system AutoML automatycznie określał 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

Rozwiązanie AutoML uwzględnia szeregi czasowe serii krótkiej, jeśli nie ma wystarczającej liczby punktów danych, aby przeprowadzić fazy trenowania i walidacji tworzenia modelu. Aby uzyskać więcej informacji, zobacz wymagania dotyczące długości danych treningowych.

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

Ustawienie opis Uwagi
auto Wartość domyślna obsługi serii krótkich. — Jeśli wszystkie serie są krótkie, wypełnij dane.
- Jeśli nie wszystkie serie są krótkie, upuść krótką serię.
pad short_series_handling_config = pad Jeśli to ustawienie jest używane, rozwiązanie AutoML dodaje losowe wartości do każdej znalezionej serii krótkiej. AutoML dopełnia kolumnę docelową białym szumem. Można użyć następujących typów kolumn z określonym wypełnieniem:
- Kolumny obiektów, dopełniaj za pomocą NaNs
- Kolumny liczbowe, pad z 0 (zero)
- Kolumny logiczne/logiczne, pad z False
drop short_series_handling_config = drop Jeśli to ustawienie jest używane, rozwiązanie AutoML przerywa serię krótką i nie jest używane do trenowania ani przewidywania. Przewidywania dla tych serii zwracają wartość NaN.
None Żadna seria nie jest dopełniona ani porzucona.

W poniższym przykładzie ustawiono obsługę serii krótkiej, więc wszystkie serie krótkie są dopełniane do minimalnej długości:

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

Uwaga

Wypełnienie może mieć wpływ na dokładność wynikowego modelu, ponieważ wprowadza 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.

Częstotliwość i docelowa agregacja danych

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 określonym okresem czasu, na przykład godzinowo lub codziennie. Dane dotyczące punktów sprzedaży są dobrym przykładem nieregularnych danych. W tych scenariuszach 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. W poniższej tabeli przedstawiono obsługiwane wartości dla funkcji agregacji:

Function opis
sum  Suma wartości docelowych
mean  Średnia lub średnia wartości docelowych
min Minimalna wartość elementu docelowego
max Maksymalna wartość elementu docelowego

Rozwiązanie AutoML stosuje agregację dla następujących kolumn:

Kolumna Metoda agregacji
Predyktory liczbowe Rozwiązanie AutoML używa sumfunkcji , mean, mini max . Generuje nowe kolumny, w których każda nazwa kolumny zawiera sufiks, który identyfikuje nazwę funkcji agregacji zastosowanej do wartości kolumn.
Predyktory podzielone na kategorie Rozwiązanie AutoML używa wartości parametru forecast_mode do agregowania danych. Jest to najbardziej widoczna kategoria w oknie. Aby uzyskać więcej informacji, zobacz opisy parametru w sekcjach potoku Wiele modeli i potoku HTS.
Predyktory danych Rozwiązanie AutoML używa minimalnej wartości docelowej (), maksymalnej wartości docelowej (minmax) i forecast_mode ustawień parametrów w celu agregowania danych.
Obiekt docelowy Rozwiązanie AutoML agreguje wartości zgodnie z określoną operacją. sum Zazwyczaj funkcja jest odpowiednia dla większości scenariuszy.

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. Dostosuj liczbę składań przy użyciu parametru n_cross_validations i skonfiguruj parametr cv_step_size w celu zdefiniowania przesunięcia czasu między fałdami. Aby uzyskać więcej informacji, zobacz prognozowanie wyboru modelu.

Domyślnie rozwiązanie AutoML automatycznie ustawia oba ustawienia na podstawie cech danych. Użytkownicy zaawansowani mogą chcieć ustawić je ręcznie. Załóżmy na przykład, że masz dzienne dane sprzedaży i chcesz, aby konfiguracja walidacji składała się z pięciu składa się z siedmiodniowego przesunięcia między sąsiednimi fałdami. Poniższy przykładowy kod pokazuje, jak ustawić następujące wartości:

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 szkoleniowe o funkcje zaprojektowane w celu zwiększenia dokładności modeli. Aby uzyskać więcej informacji, zobacz zautomatyzowane inżynierii cech. Niektóre kroki przetwarzania wstępnego można dostosować przy użyciu konfiguracji cech zadania prognozowania.

W poniższej tabeli wymieniono obsługiwane dostosowania prognozowania:

Dostosowanie opis Opcje
Aktualizacja celu kolumny Zastąpij automatycznie wykryty typ funkcji dla określonej kolumny. categorical, , dateTimenumeric
Aktualizacja parametrów transformatora 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ę on sale i typ produktu. W poniższym przykładzie pokazano, jak ustawić dostosowane 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 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 usługi Azure Machine Learning Studio na potrzeby eksperymentu, zobacz Konfigurowanie ustawień cechowania w programie Studio.

Przesyłanie zadania prognozowania

Po skonfigurowaniu wszystkich ustawień możesz uruchomić zadanie prognozowania. W poniższym przykładzie pokazano ten 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

Po przesłaniu zadania rozwiązanie AutoML aprowizuje zasoby obliczeniowe, stosuje cechowanie i inne kroki przygotowywania do danych wejściowych i rozpoczyna zamiatanie modeli prognozowania. Aby uzyskać więcej informacji, zobacz metodologię prognozowania w rozwiązaniu AutoML i zamiatanie modeli oraz wybór prognozowania w rozwiązaniu AutoML.

Organizowanie trenowania, wnioskowania i oceny przy użyciu składników i potoków

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 Azure Machine Learning wraz z zadaniami szkoleniowymi. Aby obsługiwać zadania wnioskowania i oceny, usługa Azure Machine Learning udostępnia składniki, które są samodzielnymi fragmentami kodu, które wykonują jeden krok w potoku usługi Azure Machine Learning.

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

Następnie zdefiniuj funkcję fabryki, która tworzy potoki organizujące trenowanie, wnioskowanie i obliczanie metryk. Aby uzyskać więcej informacji, zobacz Konfigurowanie eksperymentu.

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
    }

Zdefiniuj dane wejściowe trenowania i testowania zawarte w folderach lokalnych ./train_data 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 skonstruuj potok, ustaw jego domyślne obliczenia i prześlij 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 pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

Po przesłaniu żądania uruchomienia potok uruchamia trenowanie automatycznego 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 można pobrać prognozy stopniowe i metryki oceny do lokalnego katalogu roboczego:

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

Dane wyjściowe można przejrzeć w następujących lokalizacjach:

  • Metryki: ./named-outputs/metrics_results/evaluationResult/metrics.json
  • Prognozy: ./named-outputs/rolling_fcst_result/inference_output_file (format wierszy JSON)

Aby uzyskać więcej informacji na temat oceny stopniowej, zobacz Wnioskowanie i ocena modeli prognozowania.

Prognoza na dużą skalę: wiele modeli

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 Wiele modeli.

Konfiguracja trenowania wielu modeli

Składnik trenowania wielu modeli akceptuje plik konfiguracji formatu YAML ustawień trenowania rozwiązania AutoML. Składnik stosuje te ustawienia do każdego uruchomionego wystąpienia rozwiązania AutoML. Plik YAML ma taką samą specyfikację jak zadanie polecenia Prognozowanie oraz partition_column_names parametry i allow_multi_partitions .

Parametr Opis
partition_column_names Nazwy kolumn w danych, które po zgrupowaniu definiują partycje danych. Składnik trenowania wielu modeli uruchamia niezależne zadanie szkoleniowe 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. Domyślna wartość to false.

W poniższym przykładzie przedstawiono przykładową konfigurację 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

W kolejnych przykładach konfiguracja jest przechowywana w ścieżce ./automl_settings_mm.yml".

Potok wielu modeli

Następnie zdefiniuj funkcję fabryki, która tworzy potoki do orkiestracji wielu modeli trenowania, wnioskowania i obliczeń metryk. W poniższej tabeli opisano parametry tej funkcji fabryki:

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 całkowita współbieżność wielu zadań modeli to max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Limit czasu składników wielu modeli określony w liczbie sekund.
retrain_failed_models Flaga umożliwiająca ponowne trenowanie dla modeli, które zakończyły się niepowodzeniem. Ta wartość jest przydatna, jeśli poprzednio wiele przebiegów modeli spowodowało niepowodzenie zadań automatycznego uczenia maszynowego na niektórych partycjach danych. Po włączeniu tej flagi wiele modeli uruchamia tylko zadania szkoleniowe dla wcześniej nieudanych partycji.
forecast_mode Tryb wnioskowania na potrzeby oceny modelu. Prawidłowe wartości to recursive (wartość domyślna) i rolling. Aby uzyskać więcej informacji, zobacz Wnioskowanie i ocena modeli prognozowania oraz Dokumentacja klasy ManyModelsInferenceParameters.
step Rozmiar kroku dla prognozy stopniowej (wartość domyślna to 1). Aby uzyskać więcej informacji, zobacz Wnioskowanie i ocena modeli prognozowania oraz Dokumentacja klasy ManyModelsInferenceParameters.

W poniższym przykładzie pokazano metodę fabryki, aby utworzyć wiele modeli trenowania i potoków oceny 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
    }

Skonstruuj potok za pomocą funkcji factory. Dane treningowe i testowe znajdują się odpowiednio w folderach lokalnych ./data/train i ./data/test. Na koniec ustaw domyślne obliczenia i prześlij zadanie, jak pokazano 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 można pobrać metryki oceny lokalnie przy użyciu tej samej procedury co w jednym potoku przebiegu trenowania.

Aby uzyskać bardziej szczegółowy przykład, zobacz prognozowanie zapotrzebowania za pomocą wielu notesów modeli.

Zagadnienia dotyczące trenowania dla wielu uruchomionych modeli

Wiele modeli trenowania i wnioskowania składników warunkowo partycjonuje dane zgodnie z ustawieniem partition_column_names , dzięki czemu każda partycja znajduje się we własnym pliku. Ten proces może być bardzo powolny lub ulegać awarii, gdy dane są bardzo duże. Zaleceniem jest ręczne partycjonowanie danych przed uruchomieniem wielu modeli trenowania lub wnioskowania.

Uwaga

Domyślny limit równoległości dla wielu modeli uruchamianych w ramach subskrypcji wynosi 320. Jeśli obciążenie wymaga wyższego limitu, możesz skontaktować się z pomocą techniczną firmy Microsoft.

Prognoza na dużą skalę: hierarchiczne szeregi czasowe

Składniki hierarchicznych 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 Hierarchiczne prognozowanie szeregów czasowych.

Konfiguracja trenowania HTS

Składnik trenowania HTS akceptuje plik konfiguracji formatu YAML ustawień trenowania 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 polecenia Prognozowanie oraz inne 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 liść lub większość rozagregowanych poziom hierarchii.
hierarchy_training_level Poziom hierarchii do użycia na potrzeby trenowania modelu prognozy.

W poniższym przykładzie przedstawiono przykładową konfigurację 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"

W kolejnych przykładach konfiguracja jest przechowywana w ścieżce ./automl_settings_hts.yml.

Potok HTS

Następnie zdefiniuj funkcję fabryki, która tworzy potoki do orkiestracji trenowania, wnioskowania i obliczeń metryk HTS. W poniższej tabeli opisano parametry tej funkcji fabryki:

Parametr Opis
forecast_level Poziom hierarchii, dla której mają być pobierane prognozy.
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 określony w liczbie sekund.
forecast_mode Tryb wnioskowania na potrzeby oceny modelu. Prawidłowe wartości to recursive i rolling. Aby uzyskać więcej informacji, zobacz Wnioskowanie i ocena modeli prognozowania oraz dokumentacja klasy HTSInferenceParameters.
step Rozmiar kroku dla prognozy stopniowej (wartość domyślna to 1). Aby uzyskać więcej informacji, zobacz Wnioskowanie i ocena modeli prognozowania oraz dokumentacja klasy HTSInferenceParameters.
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
    }

Konstruowanie potoku przy użyciu funkcji factory. Dane treningowe i testowe znajdują się odpowiednio w folderach lokalnych ./data/train i ./data/test. Na koniec ustaw domyślne obliczenia i prześlij zadanie, jak pokazano 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 przebiegu trenowania.

Aby uzyskać bardziej szczegółowy przykład, zobacz prognozowanie zapotrzebowania za pomocą hierarchicznego notesu szeregów czasowych.

Zagadnienia dotyczące trenowania przebiegu HTS

Składniki trenowania i wnioskowania HTS warunkowo partycjonować dane zgodnie z ustawieniem hierarchy_column_names , aby każda partycja znajduje się we własnym pliku. Ten proces może być bardzo powolny lub ulegać awarii, gdy dane są bardzo duże. Zalecaną metodą jest ręczne partycjonowanie danych przed uruchomieniem trenowania lub wnioskowania HTS.

Uwaga

Domyślny limit równoległości dla uruchamiania HTS w ramach subskrypcji wynosi 320. Jeśli obciążenie wymaga wyższego limitu, możesz skontaktować się z pomocą techniczną firmy Microsoft.

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

Jak opisano wcześniej w tym artykule, możesz włączyć uczenie dla głębokich sieci neuronowych (DNN). Aby dowiedzieć się, jak działa trenowanie rozproszone dla zadań prognozowania sieci rozproszonej, zobacz Rozproszone trenowanie głębokiej sieci neuronowej (wersja zapoznawcza).

W przypadku scenariuszy z dużymi wymaganiami dotyczącymi danych trenowanie rozproszone za pomocą rozwiązania AutoML jest dostępne dla ograniczonego zestawu modeli. Więcej informacji i przykładów kodu można znaleźć w rozwiązaniu AutoML na dużą skalę: trenowanie rozproszone.

Eksplorowanie przykładowych notesów

Szczegółowe przykłady kodu pokazujące zaawansowane konfiguracje prognozowania są dostępne w repozytorium GitHub przykładowych notesów prognozowania automatycznego uczenia maszynowego. Oto niektóre z przykładowych notesów: