Partager via

Configurer AutoML pour entraîner un modèle de prévision de séries chronologiques avec SDK et CLI

  • Article

S’APPLIQUE À :Extension Azure CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (version actuelle)

Le Machine Learning automatisé (AutoML) dans Azure Machine Learning utilise des modèles de Machine Learning standard ainsi que des modèles de série chronologique connus pour créer des prévisions. Cette approche intègre des informations historiques sur la variable cible avec des caractéristiques fournies par les utilisateurs dans les données d’entrée et des caractéristiques conçues automatiquement. Les algorithmes de recherche de modèles permettent d’identifier les modèles avec la meilleure exactitude prédictive. Pour plus d’informations, consultez la méthodologie de prévision et le balayage et la sélection de modèles.

Cet article décrit comment configurer AutoML pour la prévision de série chronologique avec le Machine Learning à l’aide du Kit de développement logiciel (SDK) Python Azure Machine Learning](/python/api/overview/azure/ai-ml-readme). Le processus comprend la préparation des données pour l’entraînement et la configuration des paramètres de la série chronologique dans un travail de prévision (référence de classe). Vous effectuez ensuite l’entraînement, l’inférence et l’évaluation des modèles à l’aide de composants et de pipelines.

Pour une expérience low-code, consultez Tutoriel : Prévoir la demande avec le Machine Learning automatisé. Cette ressource est un exemple de prévision de série chronologique qui utilise AutoML dans Azure Machine Learning studio.

Prérequis

Préparer les données d’entraînement et de validation

Les données d’entrée pour les prévisions AutoML doivent contenir une série chronologique valide au format tabulaire. Chaque variable doit avoir sa propre colonne correspondante dans la table de données. AutoML nécessite au moins deux colonnes : une colonne de temps pour représenter l’axe temporel et une colonne cible pour la quantité à prévoir. D’autres colonnes peuvent servir de prédicteurs. Pour plus d’informations, consultez Comment AutoML utilise vos données.

Important

Quand vous entraînez un modèle pour prévoir des valeurs futures, vérifiez que toutes les caractéristiques utilisées dans l’entraînement peuvent également être utilisées lors de l’exécution de prédictions à l’horizon prévu.

Considérez une caractéristique du cours actuel d’une action, qui peut augmenter considérablement l’exactitude de l’entraînement. Si vous prévoyez à un horizon lointain, vous ne pourrez peut-être pas prévoir avec exactitude les cours futurs de l’action correspondant aux points futurs de la série chronologique. Cette approche peut réduire l’exactitude du modèle.

Les travaux de prévision AutoML nécessitent que vos données d’entraînement soient représentées sous la forme d’un objet MLTable. Un objet MLTable spécifie une source de données et les étapes de chargement des données. Pour obtenir plus d’informations et des cas d’utilisation, consultez [Utilisation de tables(how-to-mltable.md).

Pour l’exemple suivant, supposons que vos données d’entraînement soient contenues dans un fichier CSV nommé ./train_data/timeseries_train.csv dans un répertoire local.

Vous pouvez créer un objet MLTable à l’aide du SDK Python mltable, comme indiqué dans l’exemple suivant :

import mltable

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

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

Ce code crée un nouveau fichier, ./train_data/MLTable, qui contient le format de fichier et les instructions de chargement.

Pour démarrer le travail d’entraînement, définissez un objet de données d’entrée à l’aide du SDK Python, comme suit :

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

Vous spécifiez données de validation de manière similaire. Créez un objet MLTable et spécifiez une entrée de données de validation. Sinon, si vous ne fournissez pas de données de validation, AutoML crée automatiquement des fractionnements de validation croisée à partir de vos données de formation à utiliser pour la sélection du modèle. Pour plus d’informations, consultez les ressources suivantes :

Créez un calcul pour exécuter l’expérience

AutoML utilise la capacité de calcul Azure Machine Learning, qui est une ressource de calcul entièrement managée, pour exécuter le travail de formation. L’exemple suivant crée un cluster de calcul nommé 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()

Configurer une expérience

L’exemple suivant montre comment configurer l’expérience.

Vous utilisez les fonctions de fabrique AutoML pour configurer des travaux de prévision dans le SDK Python. L'exemple suivant montre comment créer une tâche de prévision en définissant l’indicateur de performance principale et en définissant des limites sur l'exécution de formation :

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

Prévoir les paramètres d’un travail

Les tâches de prévision ont de nombreux paramètres propres à la prévision. Les plus élémentaires de ces paramètres sont le nom de la colonne de temps dans les données de formation et l'horizon de prévision.

Utilisez les méthodes ForecastingJob pour configurer ces paramètres :

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

Le nom de la colonne de temps est un paramètre requis. Vous devez généralement définir l’horizon de prévision en fonction de votre scénario de prédiction. Si vos données contiennent plusieurs séries chronologiques, vous pouvez spécifier le nom des colonnes d’ID de série chronologique. Lorsque ces colonnes sont regroupées, elles définissent la série individuelle. Par exemple, supposons que vous disposiez de données composées des ventes horaires de différents magasins et marques. L’exemple suivant montre comment définir les colonnes d’ID de série chronologique en supposant que les données contiennent des colonnes nommées magasin et marque :

# 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 tente de détecter automatiquement les colonnes d’ID de série chronologique dans vos données si aucune n’est spécifiée.

Les autres paramètres sont facultatifs et sont décrits dans la section suivante.

Paramètres de tâche de prévision facultatifs

Des configurations facultatives sont disponibles pour les tâches de prévisions, telles que l’activation du Deep Learning et la spécification d’une agrégation de fenêtres dynamiques cibles. Une liste complète des paramètres est disponible dans la documentation de référence.

Paramètres de recherche de modèle

Il existe deux paramètres facultatifs qui contrôlent l’espace du modèle où AutoML recherche le meilleur modèle : allowed_training_algorithms et blocked_training_algorithms. Pour restreindre l’espace de recherche à un ensemble donné de classes de modèle, utilisez le paramètre allowed_training_algorithms comme indiqué dans l’exemple suivant :

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

Dans ce scénario, le travail de prévision recherche uniquement les classes de modèle ExponentialSmoothing et ElasticNet. Pour supprimer un ensemble donné de classes de modèle de l’espace de recherche, utilisez blocked_training_algorithms comme indiqué dans l’exemple suivant :

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

Le travail recherche toutes les classes de modèle sauf Prophet. Pour obtenir la liste des noms de modèles de prévision acceptés dans allowed_training_algorithms et blocked_training_algorithms, consultez la documentation de référence sur les propriétés de formation. Vous pouvez appliquer l’une ou l’autre des allowed_training_algorithms et des blocked_training_algorithms à une exécution de la formation.

Activer l’apprentissage pour les réseaux neuronaux profonds

AutoML est fourni avec un modèle de réseau neuronal profond (DNN, Deep Neural Network) personnalisé, nommé TCNForecaster. Ce modèle est un réseau convolutif temporel (TCN, Temporal Convolutional Network), qui applique des méthodes de tâche d’imagerie courantes à la modélisation de séries chronologiques. Les convolutions « causales » unidimensionnelles forment l’épine dorsale du réseau et permettent au modèle d’apprendre des modèles complexes sur de longues durées dans l’historique de formation. Pour plus d’informations, consultez Présentation de TCNForecaster.

Diagramme montrant les principaux composants du modèle AutoML TCNForecaster.

Le TCNForecaster obtient souvent une précision supérieure à celle des modèles de série chronologique standard lorsqu’il y a des milliers d’observations dans l’historique de formation. Toutefois, la formation et le nettoyage des modèles TCNForecaster prennent également plus de temps en raison de leur capacité plus élevée.

Vous pouvez activer le TCNForecaster dans AutoML en définissant l'indicateur enable_dnn_training dans la configuration de formation comme suit :

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

Par défaut, la formation TCNForecaster est limitée à un seul nœud de calcul et à un seul GPU, si disponible, par modèle d'essai. Pour les scénarios avec des données volumineuses, nous vous recommandons de distribuer chaque essai TCNForecaster sur plusieurs cœurs/GPU et nœuds. Pour plus d’informations et des exemples de code, voir la formation distribuée.

Pour activer DNN pour une expérience AutoML créée dans Azure Machine Learning studio, consultez les paramètres de type de tâche dans le guide pratique de l’interface utilisateur de studio.

Remarque

  • Lorsque vous activez DNN pour les expériences créées avec le Kit de développement logiciel (SDK), les meilleures explications des modèles sont désactivées.
  • L’utilisation de DNN pour la prévision dans le Machine Learning automatisé n’est pas prise en charge pour les exécutions lancées dans Azure Databricks.
  • L’approche recommandée consiste à utiliser les types de calcul GPU lorsque l’entraînement DNN est activé.

Fonctionnalités de décalage et de fenêtre glissante

Les valeurs récentes de la cible sont souvent des fonctionnalités impactantes dans un modèle de prévision. En conséquence, AutoML peut créer des fonctionnalités d'agrégation de fenêtres décalées et glissantes afin d'améliorer potentiellement la précision du modèle.

Envisagez un scénario de prévision de la demande d’énergie dans lequel des données météorologiques et une demande historique sont disponibles. Le tableau montre l’ingénierie de caractéristiques obtenue qui se produit lors de l’application de l’agrégation de fenêtres sur les trois dernières heures. Les colonnes pour minimum, maximum et somme sont générées sur une fenêtre glissante de trois heures en fonction des paramètres définis. Par exemple, pour l’observation valide le 8 septembre 2017 à 4 h 00, les valeurs maximale, minimale et de somme sont calculées à l’aide des valeurs de la demande du 8 septembre 2017 entre 1 h 00 et 3 h 00. Cette fenêtre de trois heures se déplace de façon à remplir les données des lignes restantes. Pour plus d’informations et d’exemples, consultez les caractéristiques de décalage pour la prévision de séries chronologiques dans AutoML.

Diagramme d’une table avec des données montrant la fenêtre mobile cible et les valeurs de la colonne Demand mises en évidence.

Vous pouvez activer les fonctionnalités d’agrégation de décalage et de fenêtre glissante pour la cible en définissant la taille de la fenêtre glissante, et les ordres de décalage que vous souhaitez créer. La taille de la fenêtre était trois dans l’exemple précédent. Vous pouvez également activer les décalages pour les fonctionnalités avec le paramètre feature_lags. Dans l’exemple suivant, tous ces paramètres sont définis sur auto pour indiquer à AutoML de déterminer automatiquement les paramètres en analysant la structure de corrélation de vos données :

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

Gestion des séries courtes

AutoML considère une série chronologique comme une série courte si le nombre de points de données est insuffisant pour mener les phases d’entraînement et de validation du développement du modèle. Pour plus d’informations, consultez Configuration requise pour la longueur des données d’apprentissage.

AutoML a plusieurs actions qu’il peut effectuer pour les séries courtes. Ces actions sont configurables avec le paramètre short_series_handling_config. La valeur par défaut est auto. La table suivante décrit les paramètres :

Setting Description Notes
auto Valeur par défaut pour la gestion des séries courtes. - Si toutes les séries sont courtes, remplissez les données.
- Si toutes les séries ne sont pas courtes, supprimez les séries courtes.
pad Si le paramètre short_series_handling_config = pad est utilisé, AutoML ajoute des valeurs aléatoires à chaque série courte trouvée. AutoML remplit la colonne cible avec du bruit blanc. Vous pouvez utiliser les types de colonnes suivants avec le remplissage spécifié :
- Colonnes d’objet, remplir avec des NaN
- Colonnes numériques, remplir avec 0 (zéro)
- Colonnes booléennes/logiques, remplir avec False
drop Si le paramètre short_series_handling_config = drop est utilisé, AutoML supprime la série courte. Celle-ci n’est donc pas utilisée pour l’entraînement ou la prédiction. Les prédictions de ces séries renvoient NaN.
None Aucune série n’est remplie ou supprimée.

L’exemple suivant définit la gestion des séries courtes afin qu’elles soient toutes remplies jusqu’à la longueur minimale :

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

Attention

Le remplissage peut avoir un impact sur l’exactitude du modèle résultant, car il introduit des données artificielles pour éviter les échecs d’entraînement. Si la plupart des séries sont courtes, vous pouvez constater un impact sur les résultats de l’explicabilité.

Fréquence et agrégation des données cibles

Utilisez les options de fréquence et d’agrégation de données pour éviter les défaillances causées par des données irrégulières. Vos données sont irrégulières si elles ne suivent pas une cadence définie dans le temps, par exemple toutes les heures ou tous les jours. Les données de point de vente sont un bon exemple de données irrégulières. Dans ces scénarios, AutoML peut agréger vos données à une fréquence souhaitée, puis générer un modèle de prévision à partir des agrégats.

Vous devez définir les paramètres frequency et target_aggregate_function pour gérer les données irrégulières. Le paramètre de fréquence accepte les chaînes Pandas DateOffset comme entrée. Le tableau suivant indique les valeurs prises en charge pour la fonction d’agrégation :

Fonction Description
sum  Somme des valeurs cibles
mean  Moyenne des valeurs cibles
min Valeur minimale d’une cible
max Valeur maximale d’une cible

AutoML applique l’agrégation pour les colonnes suivantes :

Colonne Méthode d’agrégation
Prédicteurs numériques AutoML utilise les fonctions sum, mean, min et max. Il génère de nouvelles colonnes, où chaque nom de colonne inclut un suffixe qui identifie le nom de la fonction d’agrégation appliquée aux valeurs de colonne.
Prédicteurs catégoriels AutoML utilise la valeur du paramètre forecast_mode pour agréger les données. C’est la catégorie la plus importante dans la fenêtre. Pour plus d’informations, consultez les descriptions du paramètre dans les sections Pipeline avec de nombreux modèles et Pipeline HTS.
Prédicteurs de données AutoML utilise la valeur cible minimale (min), la valeur cible maximale (max) et les paramètres forecast_mode pour agréger les données.
Cible AutoML agrège les valeurs en fonction de l’opération spécifiée. En général, la fonction sum convient à la plupart des scénarios.

L’exemple suivant définit la fréquence sur toutes les heures et la fonction d’agrégation sur la somme :

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

Paramètres de validation croisée personnalisés

Il existe deux paramètres personnalisables qui contrôlent la validation croisée pour les travaux de prévision. Personnalisez le nombre de replis avec le paramètre n_cross_validations, et configurez le paramètre cv_step_size pour définir le décalage horaire entre les replis. Pour plus d’informations, consultez Sélection des modèles de prévision.

Par défaut, AutoML définit les deux paramètres automatiquement en fonction des caractéristiques de vos données. Les utilisateurs avancés peuvent vouloir les définir manuellement. Par exemple, supposons que vous disposez de données de ventes quotidiennes et que votre configuration de validation se compose de cinq replis avec un décalage de sept jours entre les replis adjacents. L’exemple de code suivant montre comment définir ces valeurs :

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
)

Caractérisation personnalisée

Par défaut, AutoML augmente les données de formation avec des fonctionnalités développées pour augmenter la précision des modèles. Pour plus d’informations, consultez Ingénierie de caractéristiques automatisée. Vous pouvez personnaliser certaines étapes de prétraitement à l’aide de la configuration de caractérisation du travail de prévision.

Le tableau suivant liste les personnalisations prises en charge pour la prévision :

Personnalisation Description Options
Mise à jour de l’objectif de la colonne Remplacer le type de caractéristique détecté automatiquement pour la colonne spécifiée. categorical, dateTime, numeric
Mise à jour des paramètres du transformateur Mettez à jour les paramètres du processeur d’imputation spécifié. {"strategy": "constant", "fill_value": <value>}, {"strategy": "median"}, {"strategy": "ffill"}

Par exemple, supposons que vous ayez un scénario de demande de vente au détail dans lequel les données incluent des prix, un indicateur on sale et un type de produit. L’exemple suivant montre comment définir des types et des processus d’imputation personnalisés pour ces caractéristiques :

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

Si vous utilisez Azure Machine Learning studio pour votre expérience, consultez Configurer les paramètres de caractérisation dans le studio.

Envoyer un travail de prévision

Une fois tous les paramètres configurés, vous êtes prêt à exécuter le travail de prévision. L’exemple suivant illustre ce processus.

# 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

Une fois le travail envoyé, AutoML provisionne les ressources de calcul, applique la caractérisation et d’autres étapes de préparation aux données d’entrée, puis commence à balayer les modèles de prévision. Pour plus d’informations, consultez la méthodologie de prévision dans AutoML et Balayage et sélection des modèles pour la prévision dans AutoML.

Orchestrer la formation, l’inférence et l’évaluation avec des composants et des pipelines

Votre workflow de Machine Learning nécessite probablement plus qu’un simple entraînement. L’inférence ou la récupération des prédictions du modèle sur des données plus récentes et l’évaluation de la précision du modèle sur un ensemble de tests avec des valeurs cibles connues sont d’autres tâches courantes que vous pouvez orchestrer dans Azure Machine Learning avec les tâches de formation. Pour prendre en charge les tâches d’inférence et d’évaluation, Azure Machine Learning fournit des composants, qui sont des éléments de code autonomes qui effectuent une étape dans un pipeline Azure Machine Learning.

Dans l’exemple suivant, récupérez le code du composant à partir d’un registre client :

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

Ensuite, définissez une fonction d’usine qui crée des pipelines orchestrant la formation, l’inférence et le calcul des indicateurs de performance. Pour plus d’informations, consultez Configurer l’expérience.

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
    }

Définissez les entrées de données d’entraînement et de test contenues dans les dossiers locaux ./train_data et ./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',
)

Enfin, construisez le pipeline, définissons son calcul par défaut et soumettons la tâche :

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

Une fois la demande d’exécution envoyée, le pipeline exécute l’entraînement AutoML, l’inférence d’évaluation mobile et le calcul des métriques dans l’ordre. Vous pouvez surveiller et inspecter l'exécution dans l'interface utilisateur du studio. Une fois l’exécution terminée, vous pouvez télécharger les prévisions mobiles et les métriques d’évaluation dans le répertoire de travail local :

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

Vous pouvez passer en revue la sortie dans les emplacements suivants :

  • Métriques : ./named-outputs/metrics_results/evaluationResult/metrics.json
  • Prévisions : ./named-outputs/rolling_fcst_result/inference_output_file (format de lignes JSON)

Pour plus d’informations sur l’évaluation propagée, consultez inférence et évaluation des modèles de prévision.

Prévision à grande échelle : nombreux modèles

Les nombreux composants de modèles d'AutoML vous permettent d'entraîner et de gérer des millions de modèles en parallèle. Pour plus d’informations sur de nombreux concepts de modèles, consultez les nombreux modèles.

Configuration de formation de nombreux modèles

Le composant de formation de nombreux modèles accepte un fichier de configuration au format YAML des paramètres de formation AutoML. Le composant applique ces paramètres à chaque instance AutoML qu'il lance. Le fichier YAML a la même spécification que le travail de commande de prévision, plus les paramètres partition_column_names et allow_multi_partitions.

Paramètre Description
partition_column_names Noms de colonne dans les données qui, lorsqu'ils sont regroupés, définissent les partitions de données. Le composant de formation de nombreux modèles lance une tâche de formation indépendante sur chaque partition.
allow_multi_partitions Un indicateur facultatif qui permet de former un modèle par partition lorsque chaque partition contient plusieurs séries temporelles uniques. La valeur par défaut est false.

Voici un exemple de configuration 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

Dans les exemples suivants, la configuration est stockée dans le chemin ./automl_settings_mm.yml`.

Pipeline de nombreux modèles

Ensuite, définissons une fonction d’usine qui crée des pipelines pour l’orchestration de nombreux modèles de formation, d’inférence et de calcul de indicateurs de performance. Le tableau suivant décrit les paramètres de cette fonction de fabrique :

Paramètre Description
max_nodes Nombre de nœuds de calcul à utiliser dans le travail d’entraînement.
max_concurrency_per_node Nombre de processus AutoML à exécuter sur chaque nœud. Par conséquent, la simultanéité totale d'un grand nombre de travaux de modèles est max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Délai d’expiration des composants de nombreux modèles spécifié en secondes.
retrain_failed_models Indicateur pour activer la réformation des modèles défaillants. Cette valeur est utile si vous avez déjà effectué de nombreuses exécutions de modèles qui ont formé l’échec de tâches AutoML sur certaines partitions de données. Lorsque vous activez cet indicateur, de nombreux modèles lancent uniquement des travaux d’entraînement pour les partitions ayant précédemment échoué.
forecast_mode Mode d'inférence pour l'évaluation du modèle. Les valeurs valides sont recursive (valeur par défaut) et rolling. Pour plus d’informations, consultez Inférence et évaluation des modèles de prévision et la référence sur la classe ManyModelsInferenceParameters.
step Taille de pas pour la prévision mobile (la valeur par défaut est 1). Pour plus d’informations, consultez Inférence et évaluation des modèles de prévision et la référence sur la classe ManyModelsInferenceParameters.

L’exemple suivant illustre une méthode de fabrique permettant de construire des pipelines d’entraînement et d’évaluation de modèle avec de nombreux modèles :

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
    }

Construisez le pipeline avec la fonction de fabrique. Les données d’entraînement et de test se trouvent respectivement dans les dossiers locaux ./data/train et ./data/test. Enfin, définissez le calcul par défaut et envoyez le travail comme indiqué dans l’exemple suivant :

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)

Une fois le travail terminé, vous pouvez télécharger les métriques d’évaluation localement en utilisant la même procédure que dans le pipeline d’exécution d’entraînement unique.

Pour obtenir un exemple plus détaillé, consultez le notebook de prévision de la demande avec de nombreux modèles.

Considérations relatives à l’entraînement pour une exécution de plusieurs modèles

Les composants d’entraînement et d’inférence de nombreux modèles partitionnent conditionnellement vos données en fonction du paramètre partition_column_names afin que chaque partition se trouve dans son propre fichier. Ce processus peut être très lent ou échouer lorsque les données sont très volumineuses. Nous vous recommandons de partitionner vos données manuellement avant d’exécuter l’entraînement ou l’inférence de nombreux modèles.

Remarque

La limite de parallélisme par défaut pour un grand nombre de modèles exécutés dans un abonnement est définie sur 320. Si votre charge de travail nécessite une limite plus élevée, vous pouvez contacter le Support Microsoft.

Prévision à grande échelle : série chronologique hiérarchique

Les composants de séries chronologiques hiérarchiques (HTS) d'AutoML vous permettent d'entraîner un grand nombre de modèles sur des données à structure hiérarchique. Pour plus d’informations, consultez Prévision de séries chronologiques hiérarchiques.

Configuration de la formation HTS

Le composant de formation HTS accepte un fichier de configuration au format YAML des paramètres de formation AutoML. Le composant applique ces paramètres à chaque instance AutoML qu'il lance. Ce fichier YAML a la même spécification que le travail de commande de prévision, plus des paramètres liés aux informations de hiérarchie :

Paramètre Description
hierarchy_column_names Une liste de noms de colonnes dans les données qui définissent la structure hiérarchique des données. L’ordre des colonnes de cette liste détermine les niveaux de hiérarchie. Le degré d’agrégation diminue avec l’index de liste. Autrement dit, la dernière colonne de la liste définit le niveau feuille ou le plus désagrégé de la hiérarchie.
hierarchy_training_level Le niveau de hiérarchie à utiliser pour la formation du modèle de prévision.

Voici un exemple de configuration 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"

Dans les exemples suivants, la configuration est stockée dans le chemin ./automl_settings_hts.yml`.

Pipeline HTS

Ensuite, définissez une fonction d’usine qui crée des pipelines pour l’orchestration de la formation, de l’inférence et du calcul des indicateurs de performance HTS. Le tableau suivant décrit les paramètres de cette fonction de fabrique :

Paramètre Description
forecast_level Niveau de la hiérarchie pour lequel récupérer les prévisions.
allocation_method Méthode de répartition à utiliser lorsque les prévisions sont désagrégées. Les valeurs valides sont proportions_of_historical_average et average_historical_proportions.
max_nodes Nombre de nœuds de calcul à utiliser dans le travail d’entraînement.
max_concurrency_per_node Nombre de processus AutoML à exécuter sur chaque nœud. Par conséquent, la simultanéité totale d'un travail HTS est max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Délai d’expiration des composants de nombreux modèles spécifié en secondes.
forecast_mode Mode d'inférence pour l'évaluation du modèle. Les valeurs valides sont recursive et rolling. Pour plus d’informations, consultez Inférence et évaluation des modèles de prévision et la référence sur la classe HTSInferenceParameters.
step Taille de pas pour la prévision mobile (la valeur par défaut est 1). Pour plus d’informations, consultez Inférence et évaluation des modèles de prévision et la référence sur la classe 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
    }

Construisez le pipeline en utilisant la fonction de fabrique. Les données d’entraînement et de test se trouvent respectivement dans les dossiers locaux ./data/train et ./data/test. Enfin, définissez le calcul par défaut et envoyez le travail comme indiqué dans l’exemple suivant :

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)

Une fois le travail terminé, vous pouvez télécharger les métriques d’évaluation localement en utilisant la même procédure que dans le pipeline d’exécution d’entraînement unique.

Pour un exemple plus détaillé, voir le bloc-notes de prévision de la demande avec des séries chronologiques hiérarchiques.

Considérations relatives à l’entraînement pour une exécution HTS

Les composants d’entraînement et d’inférence HTS partitionnent conditionnellement vos données en fonction du paramètre hierarchy_column_names afin que chaque partition se trouve dans son propre fichier. Ce processus peut être très lent ou échouer lorsque les données sont très volumineuses. Nous vous recommandons de partitionner vos données manuellement avant d’exécuter l’entraînement ou l’inférence HTS.

Remarque

La limite de parallélisme par défaut pour une exécution HTS dans un abonnement est définie sur 320. Si votre charge de travail nécessite une limite plus élevée, vous pouvez contacter le Support Microsoft.

Prévision à grande échelle : entraînement DNN distribué

Comme décrit précédemment dans cet article, vous pouvez activer l’apprentissage pour les réseaux neuronaux profonds (DNN). Pour découvrir comment fonctionne l’entraînement distribué pour les tâches de prévision DNN, consultez Entraînement des réseaux neuronaux profonds distribués (préversion).

Pour les scénarios nécessitant des données volumineuses, l’entraînement distribué avec AutoML est disponible pour un ensemble limité de modèles. Vous trouverez plus d’informations et d’exemples de code dans AutoML à grande échelle : entraînement distribué.

Explorer des exemples de notebooks

Des exemples de code détaillés qui illustrent des configurations de prévision avancées sont disponibles dans le dépôt GitHub AutoML Forecasting Sample Notebooks. Voici quelques exemples de notebooks :

Contenu connexe