Freigeben über

Einrichten von AutoML zum Trainieren eines Zeitreihenvorhersagemodells mit SDK und CLI

  • Artikel

GILT FÜR:Azure CLI ML-Erweiterung v2 (aktuell)Python SDK azure-ai-ml v2 (aktuell)

Automatisiertes maschinelles Lernen (automatisiertes ML) in Azure Machine Learning verwendet standardmäßige ML-Modelle zusammen mit bekannten Zeitreihenmodellen, um Vorhersagen zu erstellen. Bei diesem Ansatz werden historische Informationen zur Zielvariable mit vom Benutzer bereitgestellten Features in den Eingabedaten und automatisch erstellten Features kombiniert. Modellsuchalgorithmen helfen beim Ermitteln der Modelle mit der besten Vorhersagegenauigkeit. Weitere Informationen finden Sie unter Übersicht über Vorhersagemethoden in automatisiertem maschinellem Lernen und Modell-Sweeping und -Auswahl für Vorhersagen mit automatisiertem maschinellem Lernen.

In diesem Artikel wird beschrieben, wie Sie automatisiertes maschinelles Lernen für Zeitreihenvorhersagen mit Machine Learning mithilfe des Azure Machine Learning Python SDK (/python/api/overview/azure/ai-ml-readme) einrichten. Der Prozess umfasst das Vorbereiten von Daten für das Training und das Konfigurieren von Zeitreihenparametern in einem Vorhersageauftrag (Klassenreferenz). Anschließend verwenden Sie Komponenten und Pipelines, um Modelle zu trainieren, Rückschlüsse durchzuführen und Modelle auszuwerten.

Einen Low-Code-Ansatz finden Sie unter Tutorial: Vorhersage des Bedarfs mithilfe von automatisiertem maschinellem Lernen. Diese Ressource ist ein Beispiel für Zeitreihenvorhersagen mit automatisiertem maschinellem Lernen in Azure Machine Learning Studio.

Voraussetzungen

Vorbereiten der Trainings- und Validierungsdaten

Eingabedaten für AutoML-Vorhersagen müssen eine gültige Zeitreihe im tabellarischen Format enthalten. Jede Variable muss über eine eigene entsprechende Spalte in der Datentabelle verfügen. Automatisiertes maschinelles Lernen erfordert mindestens zwei Spalten: eine Zeitspalte, die die Zeitachse darstellt, und eine Zielspalte für die vorherzusagende Menge. Andere Spalten können als Prädiktoren dienen. Weitere Informationen finden Sie unter Verwendung Ihrer Daten durch das automatisierte maschinelle Lernen.

Wichtig

Stellen Sie beim Trainieren eines Modells für die Vorhersage zukünftiger Werte sicher, dass alle während des Trainings verwendeten Features auch beim Ausführen von Vorhersagen für Ihren gewünschten Vorhersagehorizont verwendet werden können.

Ein Feature für den aktuellen Aktienkurs kann die Trainingsgenauigkeit beispielsweise erheblich verbessern. Bei einem langen Vorhersagehorizont lassen sich zukünftige Aktienkurse, die in der Zukunft liegenden Zeitreihenpunkte entsprechen, möglicherweise nicht präzise vorhersagen. Dieser Ansatz kann die Modellgenauigkeit verringern.

Vorhersageaufträge mit automatisiertem maschinellem Lernen erfordern, dass Ihre Trainingsdaten als MLTable-Objekt dargestellt werden. Ein MLTable-Objekt gibt eine Datenquelle und Schritte zum Laden der Daten an. Weitere Informationen und Anwendungsfälle finden Sie unter „Arbeiten mit Tabellen“ (how-to-mltable.md).

Für das folgende Beispiel nehmen wir an, dass Ihre Trainingsdaten in einer CSV-Datei in einem lokalen Verzeichnis enthalten sind: ./train_data/timeseries_train.csv.

Sie können wie im folgenden Beispiel gezeigt ein MLTable-Objekt mit dem mltable-Python SDK erstellen:

import mltable

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

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

Mit diesem Code wird eine neue Datei, ./train_data/MLTable, erstellt, die das Dateiformat und die Ladeanweisungen enthält.

Definieren Sie zum Starten des Trainingsauftrags wie folgt ein Eingabedatenobjekt mit dem Python SDK:

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

Sie geben Überprüfungsdaten auf ähnliche Weise an. Erstellen Sie ein MLTable-Objekt, und geben Sie eine Validierungsdateneingabe an. Wenn Sie keine Validierungsdaten bereitstellen, erstellt AutoML automatisch Kreuzvalidierungsaufteilungen Ihrer Trainingsdaten, die für die Modellauswahl verwendet werden sollen. Weitere Informationen finden Sie in den folgenden Ressourcen:

Erstellen einer Computeressource zum Ausführen des Experiments

Automatisiertes ML verwendet Azure Machine Learning Compute, eine vollständig verwaltete Computeressource, um den Trainingsauftrag auszuführen. Im folgenden Beispielen wird ein Computecluster mit dem Namen cpu-compute erstellt.

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

Konfigurieren des Experiments

Im folgenden Beispiel wird gezeigt, wie Sie das Experiment konfigurieren.

Sie verwenden die Funktionen der AutoML-Factory, um Vorhersageaufträge im Python SDK zu konfigurieren. Das folgende Beispiel zeigt, wie Sie einen Vorhersageauftrag erstellen, indem Sie die primäre Metrik und Grenzwerte für die Trainingsausführung festlegen:

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

Einstellungen für Prognoseaufträge

Vorhersageaufgaben verfügen über viele Einstellungen, die spezifisch für die Vorhersage sind. Die grundlegendsten dieser Einstellungen sind der Name der Zeitspalte in den Trainingsdaten und der Vorhersagehorizont.

Verwenden Sie die ForecastingJob-Methoden, um diese Einstellungen zu konfigurieren:

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

Der Name der Zeitspalte muss angegeben werden. Sie sollten den Vorhersagezeitraum generell entsprechend Ihrem Vorhersageszenario festlegen. Wenn Ihre Daten mehrere Zeitreihen enthalten, können Sie die Namen der Zeitreihen-ID-Spalten angeben. Wenn diese Spalten gruppiert sind, definieren sie die einzelnen Datenreihen. Angenommen, Sie haben Daten, die aus stündlichen Verkäufen von verschiedenen Geschäften und Marken bestehen. Das folgende Beispiel zeigt, wie Sie die die Zeitreihen-ID-Spalten unter der Annahme festgelegen, dass die Daten Spalten mit den Namen store und brand enthalten:

# 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 versucht, Zeitreihen-ID-Spalten in Ihren Daten automatisch zu erkennen, wenn keine angegeben ist.

Andere Einstellungen sind optional und werden im folgenden Abschnitt erläutert.

Optionale Einstellungen für den Vorhersageauftrag

Für Vorhersageaufgaben sind optionale Konfigurationen verfügbar, z. B. das Aktivieren von Deep Learning und das Angeben einer rollierenden Zielfensteraggregation. Eine vollständige Liste der Parameter finden Sie in der Referenzdokumentation.

Modellsucheinstellungen

Es gibt zwei optionale Einstellungen, die den Modellbereich steuern, in dem AutoML nach dem besten Modell sucht: allowed_training_algorithms und blocked_training_algorithms. Um den Suchbereich auf eine bestimmte Gruppe von Modellklassen einzuschränken, verwenden Sie den Parameter allowed_training_algorithms wie im folgenden Beispiel gezeigt:

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

In diesem Szenario durchsucht der Vorhersageauftrag nur die Modellklassen „Exponentielle Glättung“ und „Elastisches Netz“. Um eine bestimmte Gruppe von Modellklassen aus dem Suchbereich zu entfernen, verwenden Sie blocked_training_algorithms wie im folgenden Beispiel gezeigt:

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

Der Auftrag durchsucht alle Modellklassen mit Ausnahme von Prophet. Eine Liste der Vorhersagemodellnamen, die in allowed_training_algorithms und blocked_training_algorithms akzeptiert werden, finden Sie in den Trainingseigenschaften. Sie können beides, aber nicht sowohl allowed_training_algorithms als auch blocked_training_algorithms auf einen Trainingslauf anwenden.

Aktivieren des Lernens für Deep Neural Networks

Im Lieferumfang von automatisiertem ML ist ein benutzerdefiniertes Deep Neural Network (DNN)-Modell namens TCNForecaster enthalten. Bei diesem Modell handelt es sich um ein temporales Faltungsnetzwerk (Temporal Convolutional Network, TCN), das gängige Methoden der Bildverarbeitung auf die Zeitreihenmodellierung anwendet. Eindimensionale „kausale“ Faltungen bilden das Rückgrat des Netzes und ermöglichen es dem Modell, komplexe Muster über lange Zeiträume im Trainingsverlauf zu lernen. Weitere Informationen finden Sie unter Einführung in TCNForecaster.

Diagramm: Hauptkomponenten des TCNForecaster-Modells des automatisierten maschinellen Lernens

TCNForecaster erreicht häufig eine höhere Genauigkeit als Standard-Zeitreihenmodelle, wenn Tausende oder mehr Beobachtungen im Trainingsverlauf vorhanden sind. Allerdings dauert es aufgrund der höheren Kapazität auch länger, um TCNForecaster-Modelle zu trainieren und auszuprobieren (Sweeping).

Sie können den TCNForecaster in AutoML aktivieren, indem Sie das Flag enable_dnn_training in der Trainingskonfiguration wie folgt festlegen:

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

Standardmäßig ist das Training von TCNForecaster auf einen einzelnen Computeknoten und eine einzelne GPU (falls verfügbar) pro Modelltest beschränkt. Für Szenarien mit umfangreichen Daten wird empfohlen, jeden TCNForecaster-Test auf mehrere Kerne/GPUs und Knoten zu verteilen. Weitere Informationen und Codebeispiele finden Sie unter Verteiltes Training.

Informationen zum Aktivieren des DNN-Trainings für ein Experiment mit automatisiertem maschinellem Lernen, das in Azure Machine Learning Studio erstellt wurde, finden Sie unter Einrichten des Trainings für Automated ML für Tabellendaten ohne Code über die Studio-Benutzeroberfläche.

Hinweis

  • Wenn Sie DNN für mit dem SDK erstellte Experimente aktivieren, sind Erläuterungen des besten Modells deaktiviert.
  • Die DNN-Unterstützung für Vorhersagen mit automatisiertem maschinellem Lernen wird für Ausführungen, die in Azure Databricks initiiert werden, nicht unterstützt.
  • Der empfohlene Ansatz besteht darin, GPU-Computetypen zu verwenden, wenn das DNN-Training aktiviert ist.

Features für verzögerte und rollierende Fenster

Aktuelle Werte des Ziels sind häufig wirkungsvolle Features in einem Vorhersagemodell. Dementsprechend kann AutoML Features für zeitverzögerte und rollierende Fensteraggregationen erstellen, um die Modellgenauigkeit zu verbessern.

Betrachten Sie ein Szenario zur Vorhersage des Energiebedarfs, in dem Wetterdaten und der historische Bedarf verfügbar sind. Die Tabelle zeigt die resultierende Featureentwicklung, die auftritt, wenn die Fensteraggregation über die letzten drei Stunden angewendet wird. Spalten für die Werte minimum, maximum und sum werden in einem gleitenden Fenster über drei Einträge basierend auf den definierten Einstellungen generiert. Für die Beobachtungen am 8. September 2017, 4:00 Uhr, werden die Höchst-, Mindest- und Summenwerte beispielsweise mithilfe der Bedarfswerte für den 8. September 2017, 1:00 Uhr bis 3:00 Uhr, berechnet. Dieses drei Stunden umfassende Fenster wird verschoben, um die verbleibenden Zeilen mit Daten aufzufüllen. Weitere Informationen und Beispiele finden Sie unter Verzögerte Features für Zeitreihenvorhersagen in AutoML.

Diagramm: Tabelle mit Daten, in der das rollierende Zielfenster und die Werte in der Spalte „Demand“ hervorgehoben sind

Sie können die Features für zeitverzögerte und rollierende Fensteraggregationen für das Ziel aktivieren, indem Sie die Größe des rollierenden Fensters und die zu erstellenden Verzögerungsordnungen festlegen. Die Fenstergröße im vorherigen Beispiel war drei. Sie können auch Verzögerungen für Features mit der feature_lags-Einstellung festlegen. Im folgenden Beispiel werden alle diese Einstellungen auf auto festgelegt, damit das automatisierte maschinelle Lernen die Einstellungen automatisch durch Analysieren der Korrelationsstruktur Ihrer Daten bestimmt:

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

Verarbeitung kurzer Reihen

Beim automatisierten maschinellen Lernen gilt eine Zeitreihe als kurze Reihe, wenn nicht genügend Datenpunkte vorhanden sind, um die Trainings- und Validierungsphasen der Modellentwicklung durchzuführen. Weitere Informationen finden Sie unter Anforderungen an die Länge von Trainingsdaten.

AutoML verfügt über mehrere Aktionen, die für kurze Serien ausgeführt werden können. Diese Aktionen können mit der Einstellung short_series_handling_config konfiguriert werden. Der Standardwert ist auto. Die Einstellungen werden in den folgenden Tabellen beschrieben:

Einstellung Beschreibung Hinweise
auto Der Standardwert für die Verarbeitung kurzer Reihen. - Wenn alle Reihen kurz sind, werden die Daten aufgefüllt.
- Wenn nicht alle Reihen kurz sind, werden die kurzen Reihen gelöscht.
pad Wenn die Einstellung short_series_handling_config = pad verwendet wird, fügt das automatisierte maschinelle Lernen allen gefundenen kurzen Reihen Zufallswerte hinzu. Das automatisierte maschinelle Lernen füllt die Zielspalte mit „weißem Rauschen“ (gleichmäßigen Zufallsdaten) auf. Sie können die folgenden Spaltentypen mit der angegebenen Auffüllung verwenden:
- Objektspalten werden mit NaN-Werten aufgefüllt.
- Numerische Spalten werden mit 0 (Null) aufgefüllt.
- Boolesche/logische Spalten werden mit False aufgefüllt.
drop Wenn die Einstellung short_series_handling_config = drop verwendet wird, werden die kurzen Reihen vom automatisierten maschinellen Lernen gelöscht und nicht für Trainings- oder Vorhersagezwecke verwendet. Bei Vorhersagen für diese Reihen werden NaN zurückgegeben.
None Es werden keine Reihen aufgefüllt oder gelöscht.

Im folgenden Beispiel wird die Behandlung kurzer Reihen so festgelegt, dass alle kurzen Reihen auf die Mindestlänge aufgefüllt werden:

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

Achtung

Die Auffüllung kann sich auf die Genauigkeit des resultierenden Modells auswirken, da künstliche Daten eingeführt werden, um Fehler beim Training zu vermeiden. Wenn viele der Reihen kurz sind, könnte sich dies auch auf die Erklärbarkeit der Ergebnisse auswirken.

Häufigkeit und Zieldatenaggregation

Verwenden Sie die Optionen für Häufigkeit und Datenaggregation, um Fehler zu vermeiden, die durch unregelmäßige Daten verursacht werden. Ihre Daten sind unregelmäßig, wenn sie nicht einem festgelegten Zeitrhythmus folgen, z. B. stündlich oder täglich. Point-of-Sales-Daten sind ein gutes Beispiel für unregelmäßige Daten. In diesen Szenarien kann das automatisierte maschinelle Lernen Ihre Daten bis zu einer gewünschten Häufigkeit aggregieren und dann ein Vorhersagemodell aus den Aggregaten erstellen.

Sie müssen die Einstellungen frequency und target_aggregate_function festlegen, um unregelmäßige Daten zu verarbeiten. Die Häufigkeitseinstellung akzeptiert Pandas DateOffset-Zeichenfolgen als Eingabe. In der folgenden Tabelle sind unterstützte Werte für die Aggregationsfunktion aufgeführt:

Funktion BESCHREIBUNG
sum  Summe der Zielwerte
mean  Mittelwert oder Durchschnitt der Zielwerte
min Minimalwert eines Ziels
max Maximalwert eines Ziels

Das automatisierte maschinelle Lernen wendet die Aggregation für die folgenden Spalten an:

Spalte Aggregationsmethode
Numerische Vorhersagen Automatisiertes maschinelles Lernen verwendet die Funktionen sum, mean, min und max. Es generiert neue Spalten, wobei jeder Spaltenname ein Suffix für den Namen der Aggregationsfunktion enthält, die auf die Spaltenwerte angewendet wird.
Kategorisierte Vorhersagen Automatisiertes maschinelles Lernen verwendet den Wert des Parameters forecast_mode, um die Daten zu aggregieren. Es ist die prominenteste Kategorie im Fenster. Weitere Informationen finden Sie in den Beschreibungen des Parameters in den Abschnitten Pipeline für viele Modelle und HTS-Pipeline.
Datenvorhersagen Automatisiertes maschinelles Lernen verwendet den minimalen Zielwert (min), den maximalen Zielwert (max) und die Einstellungen des Parameters forecast_mode, um die Daten zu aggregieren.
Ziel Automatisiertes maschinelles Lernen aggregiert die Werte entsprechend dem angegebenen Vorgang. Die sum-Funktion eignet sich in der Regel für die meisten Szenarien.

Im folgenden Beispiel wird die Häufigkeit auf stündlich und die Aggregationsfunktion auf Summierung festgelegt:

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

Benutzerdefinierte Einstellungen für die Kreuzvalidierung

Es gibt zwei anpassbare Einstellungen, die die Kreuzvalidierung für Vorhersageaufträge steuern. Passen Sie die Anzahl von Faltungen mit dem Parameter n_cross_validations an, und konfigurieren Sie den Parameter cv_step_size, um den Zeitversatz zwischen Faltungen zu definieren. Weitere Informationen finden Sie unter Auswahl eines Vorhersagemodells.

Standardmäßig legt AutoML beide Einstellungen automatisch basierend auf den Merkmalen Ihrer Daten fest. Fortgeschrittene Benutzer sollten sie möglicherweise manuell festlegen. Angenommen, Sie verfügen über tägliche Verkaufsdaten und möchten, dass Ihr Validierungssetup aus fünf Faltungen mit einem Sieben-Tage-Versatz zwischen benachbarten Faltungen bestehen soll. Der folgende Beispielcode zeigt, wie diese Werte festgelegt werden können:

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
)

Benutzerdefinierte Featurisierung

Standardmäßig erweitert AutoML Trainingsdaten mit technischen Features, um die Genauigkeit der Modelle zu erhöhen. Weitere Informationen finden Sie unter Automatisiertes Feature-Engineering. Einige der Vorverarbeitungsschritte können mithilfe der Konfiguration der Featurisierung für den Vorhersageauftrag angepasst werden.

In der folgenden Tabelle sind die unterstützten Anpassungen für Vorhersagen aufgeführt:

Anpassung BESCHREIBUNG Tastatur
Aktualisierung des Spaltenzwecks Außerkraftsetzen des automatisch erkannten Featuretyps für die angegebene Spalte. categorical, dateTime, numeric
Aktualisierung von Transformationsparametern Aktualisieren der Parameter für den angegebenen Imputer. {"strategy": "constant", "fill_value": <value>}, {"strategy": "median"}, {"strategy": "ffill"}

Nehmen Sie z. B. an, Sie haben ein Bedarfsszenario für den Einzelhandel, in dem die Daten Preise, ein on sale-Flag und einen Produkttyp enthalten. Das folgende Beispiel zeigt, wie Sie benutzerdefinierte Typen und Imputer für diese Features festlegen können:

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

Wenn Sie Azure Machine Learning Studio für Ihr Experiment verwenden, finden Sie im Abschnitt zum Konfigurieren von Featurisierungseinstellungen in Studio weitere Informationen.

Übermitteln eines Vorhersageauftrags

Nachdem Sie alle Einstellungen konfiguriert haben, können Sie den Vorhersageauftrag ausführen. Dieser Prozess wird im folgenden Beispiel veranschaulicht.

# 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

Nachdem Sie den Auftrag übermittelt haben, stellt das automatisierte maschinelle Lernen Computeressourcen bereit, wendet Featurisierung und andere Vorbereitungsschritte auf die Eingabedaten an und beginnt dann mit dem Sweeping (Durchsuchen) der Vorhersagemodelle. Weitere Informationen finden Sie unter Übersicht über Vorhersagemethoden in automatisiertem maschinellem Lernen und Modell-Sweeping und -Auswahl für Vorhersagen mit automatisiertem maschinellem Lernen.

Orchestrieren von Training, Rückschluss und Auswertung mit Komponenten und Pipelines

Ihr Machine Learning-Workflow erfordert wahrscheinlich mehr als nur Training. Rückschlüsse oder das Abrufen von Modellvorhersagen zu neueren Daten und die Auswertung der Modellgenauigkeit anhand eines Testsatzes mit bekannten Zielwerten sind weitere gängige Aufgaben, die Sie in Azure Machine Learning zusammen mit Trainingsaufträgen orchestrieren können. Zur Unterstützung von Rückschluss- und Auswertungsaufgaben bietet Azure Machine Learning Komponenten, die eigenständige Codesegmente sind, die einen Schritt in einer Azure Machine Learning-Pipeline ausführen.

Im folgenden Beispiel rufen Sie den Komponentencode aus einer Clientregistrierung ab:

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

Als nächstes definieren Sie eine Factoryfunktion, die Pipelines erstellt, die Training, Rückschlüsse und Metrikberechnungen orchestrieren. Weitere Informationen finden Sie unter Experiment konfigurieren.

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
    }

Definieren Sie Trainings- und Testdateneingaben in den lokalen Ordnern unter ./train_data und ./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',
)

Schließlich konstruieren Sie die Pipeline, legen Ihre standardmäßige Compute-Instanz fest und übermitteln den Auftrag:

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

Nachdem Sie die Ausführungsanforderung übermittelt haben, führt die Pipeline nacheinander das Training für automatisiertes maschinelles Lernen, Rückschlüsse für die rollierende Auswertung und die Berechnung von Metriken aus. Sie können die Ausführung in der Studio-Benutzeroberfläche überwachen und überprüfen. Wenn die Ausführung abgeschlossen ist, können Sie die rollierenden Vorhersagen und die Auswertungsmetriken in das lokale Arbeitsverzeichnis herunterladen:

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

Sie können die Ausgabe an den folgenden Speicherorten überprüfen:

  • Metriken: ./named-outputs/metrics_results/evaluationResult/metrics.json
  • Vorhersagen: ./named-outputs/rolling_fcst_result/inference_output_file (JSON-Zeilenformat)

Weitere Informationen zur rollierenden Auswertung finden Sie unter Rückschluss und Auswertung von Prognosemodellen.

Vorhersagen im großen Stil: Viele Modelle

Die vielen Modellkomponenten in AutoML ermöglichen es Ihnen, Millionen von Modellen parallel zu trainieren und zu verwalten. Weitere Informationen zu den Konzepten für viele Modelle finden Sie unter Viele Modelle.

Trainingskonfiguration für viele Modelle

Die Komponente für das Training von vielen Modellen akzeptiert eine Konfigurationsdatei im YAML-Format mit AutoML-Trainingseinstellungen. Die Komponente wendet diese Einstellungen auf jede AutoML-Instanz an, die sie startet. Die YAML-Datei enthält die gleiche Spezifikation wie der Befehlsauftrag für die Vorhersage sowie die Parameter partition_column_names und allow_multi_partitions.

Parameter Beschreibung
partition_column_names Spaltennamen in den Daten, die, wenn sie gruppiert sind, die Datenpartitionen definieren. Die Trainingskomponente für viele Modelle startet einen unabhängigen Trainingsauftrag in jeder Partition.
allow_multi_partitions Ein optionales Flag, das das Training eines Modells pro Partition ermöglicht, wenn jede Partition mehr als eine eindeutige Zeitreihe enthält. Der Standardwert ist false.

Das folgende Beispiel zeigte eine YAML-Beispielkonfiguration:

$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

In den folgenden Beispielen ist die Konfiguration im Pfad ./automl_settings_mm.yml` gespeichert ist.

Pipeline für viele Modelle

Als nächstes definieren Sie eine Factoryfunktion, die Pipelines für die Orchestrierung von Training, Rückschlüssen und Metrikberechnungen für viele Modelle erstellt. In der folgenden Tabelle werden die für diese Factory-Funktion verwendeten Parameter beschrieben:

Parameter Beschreibung
max_nodes Anzahl von Computeknoten, die für den Trainingsauftrag verwendet werden sollen.
max_concurrency_per_node Anzahl der AutoML-Prozesse, die auf jedem Knoten ausgeführt werden. Die Gesamtparallelität von Aufträgen für viele Modelle ist also max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Timeout der Komponente „Viele Modelle“ in Sekunden.
retrain_failed_models Flag zum Aktivieren des erneuten Trainings für fehlerhafte Modelle. Dieser Wert ist nützlich, wenn Sie zuvor Ausführungen für viele Modelle durchgeführt haben, die zu fehlerhaften AutoML-Aufträgen für einige Datenpartitionen geführt haben. Wenn Sie dieses Flag aktivieren, starten viele Modelle nur Trainingsaufträge für zuvor fehlerhafte Partitionen.
forecast_mode Rückschlussmodus für die Modellauswertung. Gültige Werte sind recursive (Standard) und rolling. Weitere Informationen finden Sie unter Rückschließen und Auswerten von Vorhersagemodellen und in der Referenz für die ManyModelsInferenceParameters-Klasse.
step Schrittgröße für rollierende Vorhersagen (Standardwert 1). Weitere Informationen finden Sie unter Rückschließen und Auswerten von Vorhersagemodellen und in der Referenz für die ManyModelsInferenceParameters-Klasse.

Das folgende Beispiel veranschaulicht eine Factorymethode zum Erstellen von Trainings- und Modellauswertungspipelines für viele Modelle:

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
    }

Erstellen Sie die Pipeline mit der Factoryfunktion. Die Trainings- und Testdaten befinden sich in den lokalen Ordnern ./data/train und ./data/test. Legen Sie zum Schluss die Einstellung für „Standardcompute“ fest, und übermitteln Sie den Auftrag wie im folgenden Beispiel:

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)

Nach Abschluss des Auftrags können Sie die Auswertungsmetriken wie unter Orchestrieren von Training, Rückschluss und Auswertung mit Komponenten und Pipelines für eine einzelne Trainingsausführung lokal herunterladen.

Ein ausführlicheres Beispiel finden Sie auch im Notebook zur Bedarfsvorhersage mit vielen Modellen.

Überlegungen zum Training für eine Ausführung mit vielen Modellen

Die Trainings- und Rückschlusskomponenten für viele Modelle partitionieren Ihre Daten entsprechend der partition_column_names-Einstellung, sodass sich jede Partition in einer eigenen Datei befindet. Dieser Prozess kann sehr langsam sein oder fehlschlagen, wenn die Daten sehr umfangreich sind. Es wird empfohlen, Ihre Daten manuell zu partitionieren, bevor Sie das Training oder Rückschlüsse für viele Modelle ausführen.

Hinweis

Die Standardparallelitätsgrenze für die Anzahl der Modelle, die innerhalb eines Abonnements ausgeführt werden, ist auf 320 festgelegt. Wenden Sie sich an den Microsoft-Support, falls Ihre Workload einen höheren Grenzwert erfordert.

Vorhersage im großen Stil: Hierarchische Zeitreihen

Mit den Komponenten für hierarchische Zeitreihen (Hierarchical Time Series, HTS) in AutoML können Sie eine große Anzahl von Modellen anhand von Daten mit hierarchischer Struktur trainieren. Weitere Informationen finden Sie unter Hierarchische Zeitreihenvorhersage.

HTS-Trainingskonfiguration

Die HTS-Trainingskomponente akzeptiert eine Konfigurationsdatei im YAML-Format mit AutoML-Trainingseinstellungen. Die Komponente wendet diese Einstellungen auf jede AutoML-Instanz an, die sie startet. Diese YAML-Datei weist dieselbe Spezifikation wie der Vorhersagebefehlsauftrag sowie andere Parameter in Zusammenhang mit den Hierarchieinformationen auf:

Parameter Beschreibung
hierarchy_column_names Eine Liste von Spaltennamen in den Daten, die die hierarchische Struktur der Daten definieren. Die Reihenfolge der Spalten in dieser Liste bestimmt die Hierarchieebenen. Der Grad der Aggregation nimmt mit dem Listenindex ab. Das heißt, die letzte Spalte in der Liste definiert die Blattebene, oder die am stärksten disaggregierte Ebene, der Hierarchie.
hierarchy_training_level Die Hierarchieebene, die für das Training des Vorhersagemodells verwendet werden soll.

Das folgende Beispiel zeigte eine YAML-Beispielkonfiguration:

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

In den folgenden Beispielen ist die Konfiguration im Pfad ./automl_settings_hts.yml gespeichert ist.

HTS-Pipeline

Als nächstes definieren Sie eine Factoryfunktion, die Pipelines für die Orchestrierung von Training, Rückschlüssen und Metrikberechnungen für HTS erstellt. In der folgenden Tabelle werden die für diese Factory-Funktion verwendeten Parameter beschrieben:

Parameter Beschreibung
forecast_level Hierarchieebene, für die Vorhersagen abgerufen werden sollen.
allocation_method Zuordnungsmethode, die beim Disaggregieren von Vorhersagen zu verwenden ist. Gültige Werte sind proportions_of_historical_average und average_historical_proportions.
max_nodes Anzahl von Computeknoten, die für den Trainingsauftrag verwendet werden sollen.
max_concurrency_per_node Anzahl der AutoML-Prozesse, die auf jedem Knoten ausgeführt werden. Die Gesamtparallelität eines HTS-Auftrags ist also max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Timeout der Komponente „Viele Modelle“ in Sekunden.
forecast_mode Rückschlussmodus für die Modellauswertung. Gültige Werte sind recursive und rolling. Weitere Informationen finden Sie unter Rückschließen und Auswerten von Vorhersagemodellen und in der Referenz für die HTSInferenceParameters Class-Klasse.
step Schrittgröße für rollierende Vorhersagen (Standardwert 1). Weitere Informationen finden Sie unter Rückschließen und Auswerten von Vorhersagemodellen und in der Referenz für die HTSInferenceParameters Class-Klasse. 
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
    }

Erstellen Sie die Pipeline über die Werksfunktion. Die Trainings- und Testdaten befinden sich in den lokalen Ordnern ./data/train und ./data/test. Legen Sie zum Schluss die Einstellung für „Standardcompute“ fest, und übermitteln Sie den Auftrag wie im folgenden Beispiel:

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)

Nach Abschluss des Auftrags können die Auswertungsmetriken mithilfe des gleichen Verfahrens wie unter Orchestrieren von Training, Rückschluss und Auswertung mit Komponenten und Pipelines für eine einzelne Trainingsausführung lokal herunterladen.

Ein ausführlicheres Beispiel finden Sie auch im Notebook zur Bedarfsvorhersage mit hierarchischen Zeitreihen.

Überlegungen zum Training für eine HTS-Ausführung

Die HTS-Trainings- und Rückschlusskomponenten (Hierarchical Times Series, hierarchische Zeitreihen) partitionieren Ihre Daten bedingt entsprechend der hierarchy_column_names-Einstellung, sodass sich jede Partition in einer eigenen Datei befindet. Dieser Prozess kann sehr langsam sein oder fehlschlagen, wenn die Daten sehr umfangreich sind. Es wird empfohlen, Ihre Daten manuell zu partitionieren, bevor Sie das HTS-Training oder HTS-Rückschlüsse ausführen.

Hinweis

Der standardmäßige Parallelitätsgrenzwert für HTS-Ausführungen in einem Abonnement ist 320. Wenden Sie sich an den Microsoft-Support, falls Ihre Workload einen höheren Grenzwert erfordert.

Vorhersagen im großen Stil: Verteiltes DNN-Training

Wie weiter oben in diesem Artikel beschrieben, können Sie das Lernen für Deep Neural Networks (DNN)aktivieren. Informationen dazu, wie verteiltes Training für DNN-Vorhersageaufgaben funktioniert, finden Sie unter Verteiltes Deep Neural Network-Training (Vorschau).

Für Szenarien mit hohen Datenanforderungen ist ein verteiltes Training mit automatisiertem maschinellem Lernen für eine begrenzte Gruppe von Modellen verfügbar. Weitere Informationen und Codebeispiele finden Sie unter AutoML im großen Stil: verteiltes Training.

Untersuchen von Beispiel-Notebooks

Detaillierte Codebeispiele mit erweiterten Vorhersagekonfigurationen sind im GitHub-Repository für Beispielnotebooks für Vorhersagen mit automatisiertem maschinellem Lernen verfügbar. Nachfolgend sind einige Beispielnotebooks aufgeführt:

Zugehöriger Inhalt