Introduction à la bibliothèque Multimodale AutoML d’Amazon AutoGluon avec un problème de prévision de séries chronologiques.
Introduction à AutoGluon
AutoGluon est une bibliothèque python multimodale open source pour AutoML, lancée par Amazon. Construite sur PyTorch, la bibliothèque utilise des modèles de pointe (SOTA) pour obtenir les modèles les plus performants pour divers problèmes d’apprentissage automatique.
Équipé de modèles SOTA Deep Learning, AutoGluon propose des solutions à des problèmes tels que la classification d’images, la détection d’objets, la prédiction de texte, la segmentation d’images, la prévision de séries chronologiques et bien plus encore, comme dans l’image de couverture. Cette page vise à montrer aux lecteurs comment utiliser AutoGluon pour une tâche de prévision de séries chronologiques en considérant le célèbre ensemble de données Airlines avec un minimum de code.
Il est conseillé de créer un nouvel environnement Python pour les expériences Autogluon afin d’éviter les conflits avec d’autres bibliothèques. Une fois le nouvel environnement créé, installez Autogluon en exécutant la commande ci-dessous.
pip install autogluon
import autogluon
AutoGluon TimeSeriesPredictor attend des données dans un format spécifique avec multi-index. Un index doit être l’horodatage et l’autre doit être un identifiant unique (il peut s’agir de n’importe quelle valeur). Une trame de données pandas normale peut être convertie dans ce format à l’aide de TimeSeriesDataFrame.from_data_frame().
from autogluon.timeseries import TimeSeriesPredictor, TimeSeriesDataFrame
Commençons par charger les données et les placer dans un DataFrame de série temporelle :
import pandas as pd
data = pd.read_excel(‘airlinesData.xlsx’)
data[‘Month’] = pd.to_datetime(data[‘Month’]) #convert to datetime
id = [‘airline’] * len(data) #create list of id to add to dataframe
data[‘id’] = id #add new colum ‘id’ to dataframe
data = TimeSeriesDataFrame.from_data_frame(
data,
id_column= »id »,
timestamp_column= »Month »
)
data.tail()
Puis on split les données (attention ici on n’a pas fait de cross-validation) :
data.shape
(96, 3)
data.columns
Index([‘Passengers’], dtype=’object’)
»’split data into train and test »’
train = data.head(77)
test = data.tail(19)
Comment entrainer le prédicateur
La métrique d’évaluation choisie dépend si vous avez besoin d’une prévision probabiliste ou d’une prévision ponctuelle. Un tableau contenant différentes mesures est présenté ci-dessous.
Différents modèles formés sur les données du train, les paramètres choisis et la métrique d’évaluation peuvent être consultés dans le journal de formation. La bibliothèque exploite des modèles statistiques et des modèles SOTA Deep Learning pour la formation. Par défaut, un modèle WeightedEnsemble sera également essayé par le modèle. il peut être désactivé en définissant activate_ensemble = False dans la méthode .fit().
predictor = TimeSeriesPredictor(target='Passengers',
prediction_length=19,
eval_metric="MASE",).fit(train)No path specified. Models will be saved in: "AutogluonModels\ag-20240202_034220"
Beginning AutoGluon training...
AutoGluon will save models to 'AutogluonModels\ag-20240202_034220'
=================== System Info ===================
AutoGluon Version: 1.0.0
Python Version: 3.8.18
Operating System: Windows
Platform Machine: AMD64
Platform Version: 10.0.22621
CPU Count: 12
GPU Count: 0
Memory Avail: 0.59 GB / 7.33 GB (8.0%)
Disk Space Avail: 262.60 GB / 476.08 GB (55.2%)
===================================================
Fitting with arguments:
{'enable_ensemble': True,
'eval_metric': MASE,
'hyperparameters': 'default',
'known_covariates_names': [],
'num_val_windows': 1,
'prediction_length': 19,
'quantile_levels': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
'random_seed': 123,
'refit_every_n_windows': 1,
'refit_full': False,
'target': 'Passengers',
'verbosity': 2}
Inferred time series frequency: 'MS'
Provided train_data has 77 rows, 1 time series. Median time series length is 77 (min=77, max=77).
Provided dataset contains following columns:
target: 'Passengers'
AutoGluon will gauge predictive performance using evaluation metric: 'MASE'
This metric's sign has been flipped to adhere to being higher_is_better. The metric score can be multiplied by -1 to get the metric value.
===================================================
Starting training. Start time is 2024-02-02 09:12:20
Models that will be trained: ['SeasonalNaive', 'CrostonSBA', 'NPTS', 'AutoETS', 'DynamicOptimizedTheta', 'AutoARIMA', 'RecursiveTabular', 'DirectTabular', 'DeepAR', 'TemporalFusionTransformer', 'PatchTST']
Training timeseries model SeasonalNaive.
-0.8728 = Validation score (-MASE)
0.02 s = Training runtime
6.75 s = Validation (prediction) runtime
Training timeseries model CrostonSBA.
-1.4745 = Validation score (-MASE)
0.00 s = Training runtime
15.24 s = Validation (prediction) runtime
Training timeseries model NPTS.
-2.3546 = Validation score (-MASE)
0.02 s = Training runtime
2.85 s = Validation (prediction) runtime
Training timeseries model AutoETS.
-0.8152 = Validation score (-MASE)
0.02 s = Training runtime
30.67 s = Validation (prediction) runtime
Training timeseries model DynamicOptimizedTheta.
-1.4460 = Validation score (-MASE)
0.02 s = Training runtime
29.97 s = Validation (prediction) runtime
Training timeseries model AutoARIMA.
-0.7476 = Validation score (-MASE)
0.02 s = Training runtime
21.59 s = Validation (prediction) runtime
Training timeseries model RecursiveTabular.
-0.5560 = Validation score (-MASE)
4.89 s = Training runtime
0.38 s = Validation (prediction) runtime
Training timeseries model DirectTabular.
-3.5581 = Validation score (-MASE)
0.65 s = Training runtime
0.08 s = Validation (prediction) runtime
Training timeseries model DeepAR.
-1.1489 = Validation score (-MASE)
55.81 s = Training runtime
0.08 s = Validation (prediction) runtime
Training timeseries model TemporalFusionTransformer.
-0.8554 = Validation score (-MASE)
144.14 s = Training runtime
0.02 s = Validation (prediction) runtime
Training timeseries model PatchTST.
-0.9520 = Validation score (-MASE)
32.19 s = Training runtime
0.03 s = Validation (prediction) runtime
Fitting simple weighted ensemble.
Ensemble weights: {'AutoARIMA': 0.09, 'NPTS': 0.07, 'RecursiveTabular': 0.04, 'SeasonalNaive': 0.35, 'TemporalFusionTransformer': 0.44}
-0.2127 = Validation score (-MASE)
1.67 s = Training runtime
31.59 s = Validation (prediction) runtime
Training complete. Models trained: ['SeasonalNaive', 'CrostonSBA', 'NPTS', 'AutoETS', 'DynamicOptimizedTheta', 'AutoARIMA', 'RecursiveTabular', 'DirectTabular', 'DeepAR', 'TemporalFusionTransformer', 'PatchTST', 'WeightedEnsemble']
Total runtime: 347.54 s
Best model: WeightedEnsemble
Best model score: -0.2127Voir les résultats
Pour cela, il suffit d’utiliser la fonction :
predictor.leaderboard()
Sans spécifier de modèle, le prédicteur considérera le meilleur modèle de prédiction qui est WeightedEnsemble dans ce cas.
predictions = predictor.predict(train)
predictions Model not specified in predict, will default to the model with the best validation score: WeightedEnsemble
Par défaut, AutoGluon prédit les niveaux quantiles [0,1, 0,2, 0,3, 0,4, 0,5, 0,6, 0,7, 0,8, 0,9]. Pour prédire un ensemble différent de quantiles, vous pouvez utiliser les arguments quantile_levels comme :
prédicteur = TimeSeriesPredictor(eval_metric=”WQL”,quantile_levels=[0.1, 0.5, 0.75, 0.9]) [2].
Il est aussi possible d’afficher la prédiction :
import matplotlib.pyplot as plt
plt.figure(figsize=(20, 3))
item_id = "airline"
y_past = train.loc[item_id]["Passengers"]
y_pred = predictions.loc[item_id]
y_test = test.loc[item_id]["Passengers"]
plt.plot(y_past, label="Past time series values")
plt.plot(y_pred["mean"], label="Mean forecast")
plt.plot(y_test, label="Future time series values")
plt.fill_between(
y_pred.index, y_pred["0.1"], y_pred["0.9"], color="red", alpha=0.1, label=f"10%-90% confidence interval"
)
plt.legend();
Pour utiliser un modèle spécifique parmi les modèles formés, choisissez dans le classement ou les modèles disponibles peuvent être vus avec le morceau de code suivant.
Utilisation de DeepAR
Un modèle préféré peut être choisi dans Model Zoo et utilisé. En choisissant DeepAR comme modèle d’intérêt, l’entrainement peut être effectuée comme ci-dessous.
predictor = TimeSeriesPredictor(target='Passengers', prediction_length=19).fit(
train,
hyperparameters={
"DeepAR": {},
},
)Beginning AutoGluon training...
AutoGluon will save models to 'AutogluonModels\ag-20240201_193851'
=================== System Info ===================
AutoGluon Version: 1.0.0
Python Version: 3.8.18
Operating System: Windows
Platform Machine: AMD64
Platform Version: 10.0.22621
CPU Count: 12
GPU Count: 0
Memory Avail: 1.51 GB / 7.33 GB (20.6%)
Disk Space Avail: 262.48 GB / 476.08 GB (55.1%)
===================================================Fitting with arguments:
{‘enable_ensemble’: True,
‘eval_metric’: WQL,
‘hyperparameters’: {‘DeepAR’: {}},
‘known_covariates_names’: [],
‘num_val_windows’: 1,
‘prediction_length’: 19,
‘quantile_levels’: [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
‘random_seed’: 123,
‘refit_every_n_windows’: 1,
‘refit_full’: False,
‘target’: ‘Passengers’,
‘verbosity’: 2}
Inferred time series frequency: ‘MS’
Provided train_data has 77 rows, 1 time series. Median time series length is 77 (min=77, max=77).
Provided dataset contains following columns:
target: ‘Passengers’
AutoGluon will gauge predictive performance using evaluation metric: ‘WQL’
This metric’s sign has been flipped to adhere to being higher_is_better. The metric score can be multiplied by -1 to get the metric value.
===================================================
Starting training. Start time is 2024-02-02 01:08:51
Models that will be trained: [‘DeepAR’]
Training timeseries model DeepAR.
-0.1003 = Validation score (-WQL)
50.19 s = Training runtime
0.11 s = Validation (prediction) runtime
Not fitting ensemble as only 1 model was trained.
Training complete. Models trained: [‘DeepAR’]
Total runtime: 50.33 s
Best model: DeepAR
Best model score: -0.1003
predictions = predictor1.predict(train)
predictionsModel not specified in predict, will default to the model with the best validation scorepredictions = predictor.predict(train)
predictions
import matplotlib.pyplot as plt
plt.figure(figsize=(20, 3))
item_id = « airline »
y_past = train.loc[item_id][« Passengers »]
y_pred = predictions.loc[item_id]
y_test = test.loc[item_id][« Passengers »]
plt.plot(y_past, label= »Past time series values »)
plt.plot(y_pred[« mean »], label= »Mean forecast »)
plt.plot(y_test, label= »Future time series values »)
plt.fill_between(
y_pred.index, y_pred[« 0.1 »], y_pred[« 0.9″], color= »red », alpha=0.1, label=f »10%-90% confidence interval »
)
plt.legend();
Les modèles s’auto-tune pour trouver le meilleur paramètrage. AutoGluon est un outil d’autoML, l’utilisateur n’a pas besoin de tuner lui-même les modèles.
Liste des méthodes
Modèle naïf – Modèle de référence qui définit la prévision égale à la dernière valeur observée.
SaisonnierNaïfModèle – Modèle de référence qui définit la prévision égale à la dernière valeur observée pour la même saison.
Modèle moyen – Modèle de référence qui définit la prévision égale à la moyenne ou au quantile historique.
ModèleMoyenSaisonnier – Modèle de référence qui définit la prévision égale à la moyenne historique ou au quantile de la même saison.
Modèle Zéro – Un prévisionniste naïf qui renvoie toujours 0 prévision sur l’horizon de prévision, où les intervalles de prévision sont calculés à l’aide d’une prédiction conforme.
Modèle ETS – Lissage exponentiel avec tendance et saisonnalité.
Modèle AutoARIMA – Modèle ARIMA réglé automatiquement.
Modèle AutoETS – Lissage exponentiel automatiquement ajusté avec tendance et saisonnalité.
Modèle AutoCES – Prévision avec un modèle de lissage exponentiel complexe où la sélection du modèle est effectuée à l’aide du critère d’information d’Akaike.
ThêtaModèle – Modèle de prévision thêta [Assimakopoulos2000].
ADIDAModèle – Modèle de prévision de la demande intermittente utilisant l’approche de demande intermittente globale-désagrégée [Nikolopoulos2011].
CrostonClassicModèle – Modèle de prévision de la demande intermittente utilisant le modèle de Croston où le paramètre de lissage est fixé à 0,1 [Croston1972].
CrostonModèle optimisé – Modèle de prévision de la demande intermittente utilisant le modèle de Croston où le paramètre de lissage est optimisé [Croston1972].
CrostonSBAModèle – Modèle de prévision de la demande intermittente utilisant le modèle de Croston avec l’approche de correction du biais Syntetos-Boylan [SyntetosBoylan2001].
Modèle IMAPA – Modèle de prévision de la demande intermittente utilisant l’algorithme de prévision d’agrégation multiple intermittente [Petropoulos2015].
Modèle NPTS – Prévisionniste de séries chronologiques non paramétriques.
Modèle DeepAR – Modèle de prévision autorégressif basé sur un réseau neuronal récurrent [Salinas2020].
DLinéaireModèle – Réseau neuronal simple à rétroaction qui soustrait la tendance avant la prévision [Zeng2023].
PatchTSTModèle – Prévisionniste basé sur un transformateur qui segmente chaque série temporelle en correctifs [Nie2023].
SimpleFeedForwardModel – Réseau neuronal simple à rétroaction qui prédit simultanément toutes les valeurs futures.
Modèle de transformateur de fusion temporelle – Combine LSTM avec une couche de transformateur pour prédire les quantiles de toutes les valeurs cibles futures [Lim2021].
Modèle WaveNet – Estimateur WaveNet qui utilise l’architecture proposée dans [Oord2016] avec des cibles quantifiées.
ModèleTabulaire Direct – Prédisez simultanément toutes les valeurs futures des séries chronologiques à l’aide de TabularPredictor d’AutoGluon-Tabular.
ModèleTabulaire Récursif – Prédisez les valeurs futures des séries chronologiques une par une à l’aide de TabularPredictor d’AutoGluon-Tabular.
Choix des métriques
Choisir la bonne métrique d’évaluation est l’un des choix les plus importants lors de l’utilisation d’un framework AutoML. Cette page répertorie les métriques d’évaluation des prévisions disponibles dans AutoGluon, explique quand différentes métriques doivent être utilisées et décrit comment définir des métriques d’évaluation personnalisées.
Lorsque vous utilisez AutoGluon, vous pouvez spécifier la métrique à l’aide de l’argument eval_metric de TimeSeriesPredictor, par exemple :
from autogluon.timeseries import TimeSeriesPredictor
predictor = TimeSeriesPredictor(eval_metric= »MASE »)
AutoGluon rapporte toujours toutes les mesures dans un format « le plus élevé est le meilleur ». A cet effet, certaines métriques sont multipliées par -1. Par exemple, si nous définissons eval_metric= »MASE », le prédicteur rapportera en fait -MASE (c’est-à-dire le score MASE multiplié par -1). Cela signifie que le test_score sera compris entre 0 (prévision la plus précise) et (prévision la moins précise).
Actuellement, AutoGluon prend en charge les métriques d’évaluation suivantes :
SQL Perte quantile mise à l’échelle.
WQL Perte quantile pondérée.
MAE Erreur absolue moyenne.
MAPE Erreur moyenne absolue en pourcentage.
MASE Erreur d’échelle absolue moyenne.
MSE Erreur quadratique moyenne.
RMSE Erreur quadratique moyenne.
RMSSE Erreur d’échelle quadratique moyenne.
SMAPE Erreur de pourcentage absolu moyenne symétrique.
WAPE Erreur en pourcentage absolu pondéré.
Vous pouvez également définir une métrique d’évaluation des prévisions personnalisée.
Si vous ne savez pas quelle mesure d’évaluation choisir, voici trois questions qui peuvent vous aider à faire le bon choix pour votre cas d’utilisation.
1. Etes-vous intéressé par une prévision ponctuelle ou une prévision probabiliste ?
Si votre objectif est de générer une prévision probabiliste précise, vous devez utiliser des métriques WQL ou SQL. Ces métriques sont basées sur la perte quantile et mesurent l’exactitude des prévisions quantiles. Par défaut, AutoGluon prédit les niveaux quantiles [0,1, 0,2, 0,3, 0,4, 0,5, 0,6, 0,7, 0,8, 0,9]. Pour prédire un ensemble différent de quantiles, vous pouvez utiliser l’argument quantile_levels :
prédicteur = TimeSeriesPredictor(eval_metric= »WQL », quantile_levels=[0.1, 0.5, 0.75, 0.9])
Toutes les autres mesures de prévision décrites sur cette page sont des mesures de prévision ponctuelles. Notez que si vous sélectionnez eval_metric pour une métrique de prévision ponctuelle lors de la création de TimeSeriesPredictor, la prévision minimisant cette métrique sera toujours fournie dans la colonne « moyenne » du bloc de données de prédictions.
2. Vous souciez-vous davantage de prédire avec précision les séries chronologiques avec de grandes valeurs ?
Si la réponse est « oui » (par exemple, s’il est important de prédire plus précisément les ventes de produits populaires), vous devez utiliser des mesures dépendant de l’échelle telles que WQL, MAE, RMSE ou WAPE. Ces métriques sont également bien adaptées au traitement de séries temporelles clairsemées (intermittentes) comportant de nombreux zéros.
Si la réponse est « non » (vous vous souciez de la même manière de toutes les séries chronologiques de l’ensemble de données), envisagez des métriques mises à l’échelle telles que SQL, MASE et RMSSE. Alternativement, les mesures basées sur un pourcentage MAPE et SMAPE peuvent également être utilisées pour égaliser l’échelle entre les séries chronologiques. Cependant, ces mesures basées sur des pourcentages présentent certaines limites bien documentées, nous ne recommandons donc pas de les utiliser dans la pratique. Notez que les mesures mises à l’échelle et basées sur un pourcentage sont mal adaptées aux données clairsemées (intermittentes).
3. (Prévision ponctuelle uniquement) Voulez-vous estimer la moyenne ou la médiane ?
Pour estimer la médiane, vous devez utiliser des métriques telles que MAE, MASE ou WAPE. Si votre objectif est de prédire la moyenne (valeur attendue), vous devez utiliser les métriques MSE, RMSE ou RMSSE.
FR 
EN 
ES