Entraîner et évaluer un modèle de prévision de série chronologique

Dans ce notebook, nous développons un programme pour prévoir les données de série chronologique qui ont des cycles saisonniers. Nous utilisons le jeu de données NYC Property Sales avec des dates comprises entre 2003 et 2015 publié par NYC Department of Finance sur le NYC Open Data Portal.

Prérequis

• Obtenir un abonnement Microsoft Fabric. Ou, inscrivez-vous pour un essai gratuit de Microsoft Fabric.

• Connectez-vous à Microsoft Fabric.

• Utilisez le sélecteur d’expérience sur le côté gauche de votre page d’accueil pour passer à l’expérience science des données Synapse.

  

• Une connaissance des notebooks Microsoft Fabric.
• Un lakehouse pour stocker des données pour cet exemple. Pour plus d’informations, consultez Ajouter un lakehouse à votre notebook.

Suivre dans un notebook

Vous pouvez suivre dans un notebook l’une des deux façons suivantes :

• Ouvrez et exécutez le notebook intégré dans l’expérience science des données Synapse.
• Téléchargez votre notebook depuis GitHub vers l’expérience science des données Synapse.

Ouvrir le notebook intégré

L’exemple de notebook Série chronologique accompagne ce tutoriel.

Pour ouvrir l’exemple de notebook intégré du tutoriel dans l’expérience de science des données Synapse :

1. Accédez à la page d’accueil science des données Synapse.

2. Sélectionnez Utiliser un échantillon.

3. Sélectionnez l’échantillon correspondant :

   • À partir de l’onglet par défaut Workflows de bout en bout (Python), si l’exemple concerne un tutoriel Python.
   • À partir de l’onglet Workflows de bout en bout (R), si l’exemple concerne un tutoriel R.
   • À partir de l’onglet Tutoriels rapides, si l’exemple concerne un tutoriel rapide.

4. Attachez un lakehouse au notebook avant de commencer à exécuter le code.

Importer un notebook à partir de GitHub

AIsample - Time Series Forecasting.ipynb est le notebook qui accompagne ce tutoriel.

Pour ouvrir le notebook accompagnant ce tutoriel, suivez les instructions fournies dans Préparer votre système pour le tutoriel sur la science des données afin d’importer les notebooks dans votre espace de travail.

Si vous préférez copier et coller le code de cette page, vous pouvez créer un nouveau notebook.

Assurez-vous d’attacher un lakehouse au notebook avant de commencer à exécuter du code.

Étape 1 : Installer des bibliothèques personnalisées

Lorsque vous développez un modèle Machine Learning ou que vous gérez l’analyse de données ad hoc, vous devrez peut-être installer rapidement une bibliothèque personnalisée (telle que prophet dans ce notebook) pour votre session Apache Spark. Pour cela, deux choix sont possibles.

1. Vous pouvez utiliser les fonctionnalités d’installation en ligne (par exemple, %pip, %conda, etc.) pour commencer rapidement avec de nouvelles bibliothèques. Elles permettent d’installer les bibliothèques personnalisées uniquement dans le notebook actuel et non dans l’espace de travail.

# Use pip to install libraries
%pip install <library name>

# Use conda to install libraries
%conda install <library name>

2. Vous pouvez également créer un environnement Fabric, installer des bibliothèques à partir de sources publiques ou y charger des bibliothèques personnalisées. Ensuite, l’administrateur de votre espace de travail peut attacher l’environnement en tant qu’environnement par défaut pour l’espace de travail. Toutes les bibliothèques de l’environnement seront ensuite disponibles pour être utilisées dans les notebooks et les définitions de travail Spark dans l’espace de travail. Pour plus d’informations sur les environnements, consultez Créer, configurer et utiliser un environnement dans Microsoft Fabric.

Pour ce notebook, vous utilisez %pip install pour installer la bibliothèque prophet. Le noyau PySpark redémarre après %pip install. Cela signifie que vous devez installer la bibliothèque avant d’exécuter d’autres cellules.

# Use pip to install Prophet
%pip install prophet

Étape 2 : Chargement des données

Dataset

Ce notebook utilise le jeu de données NYC Property Sales. Il couvre les données comprises entre 2003 et 2015, publiées par NYC Department of Finance sur le NYC Open Data Portal.

Le jeu de données contient un enregistrement de chaque immeuble vendu sur le marché immobilier new-yorkais sur une période de 13 ans. Reportez-vous au Glossaire des termes pour les fichiers de ventes de propriétés pour la définition des colonnes dans du jeu de données.

L’objectif est de créer un modèle qui prévoit les ventes totales mensuelles, en fonction des données historiques. Pour cela, vous utilisez Prophet, une bibliothèque de prévision de code source ouvert développée par Facebook. Prophet est basé sur un modèle additif, où les tendances non linéaires sont adaptées à la saisonnalité quotidienne, hebdomadaire et annuelle, et le nombre de jours fériés. Prophet fonctionne mieux sur les jeux de données des séries chronologiques ayant des effets saisonniers forts et plusieurs saisons de données historiques. En outre, Prophet gère de manière robuste les données manquantes et les valeurs hors norme des données.

Prophet utilise un modèle de série chronologique décomposable, composé de trois composants :

• tendance : Prophet suppose un taux de croissance constant à la pièce avec sélection automatique du point de Modifications
• saisonnier : par défaut, Prophet utiliser la sérier Fourier pour adapter la saisonnalité hebdomadaire et annuelle.
• jours fériés : Prophet exige tous les jours fériés passés et futurs. Si un jour férié ne se répète pas à l’avenir, Prophet ne l’inclura pas dans la prévision.

Ce notebook agrège les données mensuellement, de sorte qu’il ignore les jours fériés.

Lisez le document officiel pour plus d’informations sur les techniques de modélisation de Prophet.

Télécharger le jeu de données et le charger dans un lakehouse

La source de données se compose de 15 fichiers .csv. Ces fichiers contiennent des enregistrements de vente de propriétés de cinq arrondissements de New York entre 2003 et 2015. Par souci de commodité, le fichier nyc_property_sales.tar contient tous ces fichiers .csv, en les compressant dans un seul fichier. Un stockage d’objets blob publiquement disponible héberge ce fichier .tar.

URL = "https://synapseaisolutionsa.blob.core.windows.net/public/NYC_Property_Sales_Dataset/"
TAR_FILE_NAME = "nyc_property_sales.tar"
DATA_FOLDER = "Files/NYC_Property_Sales_Dataset"
TAR_FILE_PATH = f"/lakehouse/default/{DATA_FOLDER}/tar/"
CSV_FILE_PATH = f"/lakehouse/default/{DATA_FOLDER}/csv/"

EXPERIMENT_NAME = "aisample-timeseries" # MLflow experiment name

Ce code télécharge une version du jeu de données accessible au public, puis stocke ce jeu de données dans un Lakehouse Fabric.

import os

if not os.path.exists("/lakehouse/default"):
    # Add a lakehouse if the notebook has no default lakehouse
    # A new notebook will not link to any lakehouse by default
    raise FileNotFoundError(
        "Default lakehouse not found, please add a lakehouse for the notebook."
    )
else:
    # Verify whether or not the required files are already in the lakehouse, and if not, download and unzip
    if not os.path.exists(f"{TAR_FILE_PATH}{TAR_FILE_NAME}"):
        os.makedirs(TAR_FILE_PATH, exist_ok=True)
        os.system(f"wget {URL}{TAR_FILE_NAME} -O {TAR_FILE_PATH}{TAR_FILE_NAME}")

    os.makedirs(CSV_FILE_PATH, exist_ok=True)
    os.system(f"tar -zxvf {TAR_FILE_PATH}{TAR_FILE_NAME} -C {CSV_FILE_PATH}")

Commencez à enregistrer le temps nécessaire à l’exécution de ce notebook.

# Record the notebook running time
import time

ts = time.time()

Configurer le suivi des expériences MLflow

Pour étendre les fonctionnalités de journalisation MLflow, la synchronisation automatique capture automatiquement les valeurs des paramètres d’entrée et des métriques de sortie d’un modèle Machine Learning pendant sa formation. Ces informations sont ensuite enregistrées dans l’espace de travail, où les API MLflow ou l’expérience correspondante dans l’espace de travail peuvent y accéder et les visualiser. Pour plus d’informations sur la synchronisation automatique, consultez cette ressource.

# Set up the MLflow experiment
import mlflow

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable MLflow autologging

Lire les données de date brutes de la lakehouse

df = (
    spark.read.format("csv")
    .option("header", "true")
    .load("Files/NYC_Property_Sales_Dataset/csv")
)

Étape 3 : Commencer l’analyse exploratoire des données

Pour passer en revue le jeu de données, vous pouvez examiner manuellement un sous-ensemble des données pour mieux le comprendre. Vous pouvez utiliser la fonction display pour imprimer le DataFrame. Vous pouvez également afficher les vues de diagramme pour visualiser facilement des sous-ensembles du jeu de données.

display(df)

Un examen manuel du jeu de données conduit à quelques observations précoces :

• Instances de 0,00 $ de prix de vente. Selon le glossaire des termes, cela implique un transfert de propriété sans considération en espèces. En d’autres termes, aucune trésorerie n’a été acheminée dans la transaction. Vous devez supprimer les ventes avec des valeurs sales_price de 0,00 $ du jeu de données.

• Le jeu de données couvre différentes classes de construction. Toutefois, ce notebook se concentre sur les bâtiments résidentiels qui, selon le glossaire des termes, sont marqués comme type « A ». Vous devez filtrer le jeu de données pour inclure uniquement les bâtiments résidentiels. Pour ce faire, incluez les colonnes building_class_at_time_of_sale ou building_class_at_present. Vous devez inclure uniquement les données building_class_at_time_of_sale.

• Le jeu de données inclut des instances où les valeurs total_units sont égales à 0 ou où les valeurs gross_square_feet sont égales à 0. Vous devez supprimer toutes les instances où les valeurs total_units ou gross_square_units sont égales à 0.

• Certaines colonnes (par exemple, apartment_number, tax_class, build_class_at_present, etc.) ont des valeurs NULL ou manquantes. Supposons que les données manquantes impliquent des erreurs matérielles ou des données inexistantes. L’analyse ne dépend pas de ces valeurs manquantes. Vous pouvez donc les ignorer.

• La colonne sale_price est stockée sous forme de chaîne, avec un caractère « $ » prédéfini. Pour poursuivre l’analyse, représentez cette colonne sous forme de nombre. Vous devez convertir la colonne sale_price en un nombre entier.

Conversion et filtrage de type

Pour résoudre certains des problèmes identifiés, importez les bibliothèques requises.

# Import libraries
import pyspark.sql.functions as F
from pyspark.sql.types import *

Convertir les données de ventes de la chaîne en un nombre entier

Utilisez des expressions régulières pour séparer la partie numérique de la chaîne du symbole dollar (par exemple, dans la chaîne $300,000, fractionnez $ et 300,000), puis convertissez la partie numérique en tant qu’entier.

Ensuite, filtrez les données pour inclure uniquement les instances qui répondent à toutes ces conditions :

1. sales_price est supérieur à 0
2. total_units est supérieur à 0
3. gross_square_feet est supérieur à 0
4. building_class_at_time_of_sale est de type A

df = df.withColumn(
    "sale_price", F.regexp_replace("sale_price", "[$,]", "").cast(IntegerType())
)
df = df.select("*").where(
    'sale_price > 0 and total_units > 0 and gross_square_feet > 0 and building_class_at_time_of_sale like "A%"'
)

Agrégation mensuelle

La ressource de données suit les ventes de propriétés quotidiennes, mais cette approche est trop granulaire pour ce notebook. Au lieu de cela, agrégez les données tous les mois.

Tout d’abord, modifiez les valeurs de date pour afficher uniquement les données de mois et d’année. Les valeurs de date incluent toujours les données d’année. Vous pouvez toujours faire la distinction entre, par exemple, décembre 2005 et décembre 2006.

En outre, conservez uniquement les colonnes pertinentes pour l’analyse. Il s’agit notamment de sales_price, total_units, gross_square_feet et sales_date. Vous devez également renommer sales_date en month.

monthly_sale_df = df.select(
    "sale_price",
    "total_units",
    "gross_square_feet",
    F.date_format("sale_date", "yyyy-MM").alias("month"),
)
display(monthly_sale_df)

Agrégez les valeurs et sale_price, total_units et gross_square_feet par mois. Ensuite, regroupez les données par month, puis additionnez toutes les valeurs au sein de chaque groupe.

summary_df = (
    monthly_sale_df.groupBy("month")
    .agg(
        F.sum("sale_price").alias("total_sales"),
        F.sum("total_units").alias("units"),
        F.sum("gross_square_feet").alias("square_feet"),
    )
    .orderBy("month")
)

display(summary_df)

Conversion Pyspark vers Pandas

Les DataFrames Pyspark gèrent bien les jeux de données volumineux. Toutefois, en raison de l’agrégation de données, la taille du DataFrame est plus petite. Cela suggère que vous pouvez désormais utiliser des DataFrames Pandas.

Ce code convertit le jeu de données d’un DataFrame Pyspark en un DataFrame Pandas.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualisation

Vous pouvez examiner la tendance du commerce des propriétés de New York pour mieux comprendre les données. Cela conduit à des insights sur les modèles potentiels et les tendances saisonnières. En savoir plus sur la visualisation des données Microsoft Fabric à cette ressource.

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

f, (ax1, ax2) = plt.subplots(2, 1, figsize=(35, 10))
plt.sca(ax1)
plt.xticks(np.arange(0, 15 * 12, step=12))
plt.ticklabel_format(style="plain", axis="y")
sns.lineplot(x="month", y="total_sales", data=df_pandas)
plt.ylabel("Total Sales")
plt.xlabel("Time")
plt.title("Total Property Sales by Month")

plt.sca(ax2)
plt.xticks(np.arange(0, 15 * 12, step=12))
plt.ticklabel_format(style="plain", axis="y")
sns.lineplot(x="month", y="square_feet", data=df_pandas)
plt.ylabel("Total Square Feet")
plt.xlabel("Time")
plt.title("Total Property Square Feet Sold by Month")
plt.show()

Résumé des observations de l’analyse exploratoire des données

• Les données montrent un modèle récurrent clair sur une cadence annuelle ; cela signifie que les données ont une saisonnalité annuelle
• Les mois d’été semblent avoir des volumes de ventes plus élevés par rapport aux mois d’hiver
• En comparant les années avec des ventes élevées et les années avec des ventes faibles, la différence de chiffre d’affaires entre les mois de ventes élevés et les mois de ventes faibles dans les années de ventes élevées dépasse, en termes absolus, la différence de chiffre d’affaires entre les mois de ventes élevés et les mois de ventes faibles dans les années de ventes élevées.

Par exemple, en 2004, la différence de chiffre d’affaires entre le mois de ventes le plus élevé et le mois de ventes le plus bas est d’environ :

$900,000,000 - $500,000,000 = $400,000,000

Pour 2011, ce calcul des différences de revenus est d’environ :

$400,000,000 - $300,000,000 = $100,000,000

Cela devient important plus tard, quand vous devez décider entre les effets multiplicatifs et additifs de saisonnalité.

Étape 4 : formation et suivi du modèle

Ajustement de modèle

L’entrée de Prophet est toujours un DataFrame à deux colonnes. Une colonne d’entrée est une colonne de temps nommée ds, et une colonne d’entrée est une colonne de valeur nommée y. La colonne de temps doit avoir un format de données date, heure ou DateHeure (par exemple, YYYY_MM). Le jeu de données présent ici répond à cette condition. La colonne de valeur doit être un format de données numériques.

Pour l’ajustement du modèle, vous devez uniquement renommer la colonne de temps en ds et la colonne de valeur en y, et transmettre les données à Prophet. Pour plus d’informations, lisez la documentation sur l’API Python de Prophet.

df_pandas["ds"] = pd.to_datetime(df_pandas["month"])
df_pandas["y"] = df_pandas["total_sales"]

Prophet suit la convention scikit-learn . Tout d’abord, créez une instance de Prophet, définissez certains paramètres (par exemple, seasonality_mode), puis ajustez cette instance au jeu de données.

• Bien qu’un facteur additif constant soit l’effet saisonnier par défaut pour Prophet, vous devez utiliser la saisonnalité « multiplicative » pour le paramètre d’effet saisonnier. L’analyse de la section précédente a montré qu’en raison de changements dans l’amplitude de saisonnalité, une saisonnalité additive simple ne correspondra pas bien aux données du tout.

• Définissez le paramètre weekly_seasonality sur désactivé, car les données ont été agrégées par mois. Par conséquent, les données hebdomadaires ne sont pas disponibles.

• Utilisez les méthodes Markov Chain Monte Carlo (MCMC) pour capturer les estimations d’incertitude de saisonnalité. Par défaut, Prophet peut fournir des estimations d’incertitude sur la tendance et le bruit d’observation, mais pas pour la saisonnalité. MCMC nécessite plus de temps de traitement, mais il permet à l’algorithme de fournir des estimations d’incertitude sur la saisonnalité, ainsi que le niveau de tendance et d’observation. Pour plus d’informations, lisez la documentation sur les intervalles d’incertitude Prophet.

• Paramétrez la sensibilité de détection automatique des points de modification via le paramètre changepoint_prior_scale. L’algorithme Prophet tente automatiquement de trouver des instances dans les données où les trajectoires changent brusquement. Il peut devenir difficile de trouver la valeur correcte. Pour résoudre ce problème, vous pouvez essayer différentes valeurs, puis sélectionner le modèle avec les meilleures performances. Pour plus d’informations, consultez la documentation des points de modification des tendances de Prophet.

from prophet import Prophet

def fit_model(dataframe, seasonality_mode, weekly_seasonality, chpt_prior, mcmc_samples):
    m = Prophet(
        seasonality_mode=seasonality_mode,
        weekly_seasonality=weekly_seasonality,
        changepoint_prior_scale=chpt_prior,
        mcmc_samples=mcmc_samples,
    )
    m.fit(dataframe)
    return m

Validation croisée

Prophet dispose d’un outil de validation croisée intégré. Cet outil peut estimer l’erreur de prévision et trouver le modèle avec les meilleures performances.

La technique de validation croisée peut valider l’efficacité du modèle. Cette technique entraîne le modèle sur un sous-ensemble du jeu de données et exécute des tests sur un sous-ensemble précédemment invisible du jeu de données. Cette technique peut vérifier la généralisation d’un modèle statistique pour un jeu de données indépendant.

Pour la validation croisée, réservez un échantillon particulier du jeu de données, qui ne fait pas partie du jeu de données d’entraînement. Ensuite, testez le modèle entraîné sur cet exemple avant le déploiement. Toutefois, cette approche ne fonctionne pas pour les données de série chronologique, car si le modèle a vu des données des mois de janvier 2005 et mars 2005, et que vous essayez de prédire le mois de février 2005, le modèle peut essentiellement tricher, car il peut voir où la tendance des données mène. Dans les applications réelles, l’objectif est de prévoir l’avenir, comme des régions invisibles.

Pour gérer cela et rendre le test fiable, fractionnez le jeu de données en fonction des dates. Utilisez le jeu de données jusqu’à une certaine date (par exemple, les 11 premières années de données) pour l’entraînement, puis utilisez les données invisibles restantes pour la prédiction.

Dans ce scénario, commencez par 11 ans de données d’entraînement, puis effectuez des prédictions mensuelles à l’aide d’un horizon d’un an. Plus précisément, les données d’entraînement contiennent tous les éléments de 2003 à 2013. Ensuite, la première exécution gère les prédictions de janvier 2014 à janvier 2015. L’exécution suivante gère les prédictions de février 2014 à février 2015, et ainsi de suite.

Répétez ce processus pour chacun des trois modèles entraînés pour voir quel modèle fonctionne le mieux. Ensuite, comparez ces prédictions avec des valeurs réelles pour établir la qualité de prédiction du meilleur modèle.

from prophet.diagnostics import cross_validation
from prophet.diagnostics import performance_metrics

def evaluation(m):
    df_cv = cross_validation(m, initial="4017 days", period="30 days", horizon="365 days")
    df_p = performance_metrics(df_cv, monthly=True)
    future = m.make_future_dataframe(periods=12, freq="M")
    forecast = m.predict(future)
    return df_p, future, forecast

Modèle de journal avec MLflow

Consignez les modèles pour suivre leurs paramètres et enregistrez les modèles pour une utilisation ultérieure. Toutes les informations pertinentes de modèles sont consignées dans l’espace de travail sous le nom de l’expérience. Le modèle, les paramètres et les métriques, ainsi que les éléments de synchronisation automatique MLflow, sont enregistrés dans une exécution MLflow.

# Setup MLflow
from mlflow.models.signature import infer_signature

Effectuer des expériences

Une expérience d’apprentissage automatique sert d’unité principale d’organisation et de contrôle pour toutes les exécutions d’apprentissage automatique connexes. Une exécution correspond à une seule exécution de code de modèle. Le suivi des expériences Machine Learning fait référence à la gestion de toutes les différentes expériences et de leurs composants. Cela inclut des paramètres, des métriques, des modèles et d’autres artefacts, et il permet d’organiser les composants requis d’une expérience Machine Learning spécifique. Le suivi des expériences Machine Learning permet également la duplication facile des résultats passés avec des expériences enregistrées. En savoir plus sur expériences de Machine Learning dans Microsoft Fabric. Une fois que vous avez déterminé les étapes que vous envisagez d’inclure (par exemple, l’ajustement et l’évaluation du modèle Prophet dans ce notebook), vous pouvez exécuter l’expérience.

model_name = f"{EXPERIMENT_NAME}-prophet"

models = []
df_metrics = []
forecasts = []
seasonality_mode = "multiplicative"
weekly_seasonality = False
changepoint_priors = [0.01, 0.05, 0.1]
mcmc_samples = 100

for chpt_prior in changepoint_priors:
    with mlflow.start_run(run_name=f"prophet_changepoint_{chpt_prior}"):
        # init model and fit
        m = fit_model(df_pandas, seasonality_mode, weekly_seasonality, chpt_prior, mcmc_samples)
        models.append(m)
        # Validation
        df_p, future, forecast = evaluation(m)
        df_metrics.append(df_p)
        forecasts.append(forecast)
        # Log model and parameters with MLflow
        mlflow.prophet.log_model(
            m,
            model_name,
            registered_model_name=model_name,
            signature=infer_signature(future, forecast),
        )
        mlflow.log_params(
            {
                "seasonality_mode": seasonality_mode,
                "mcmc_samples": mcmc_samples,
                "weekly_seasonality": weekly_seasonality,
                "changepoint_prior": chpt_prior,
            }
        )
        metrics = df_p.mean().to_dict()
        metrics.pop("horizon")
        mlflow.log_metrics(metrics)

Visualiser un modèle avec Prophet

Prophet a des fonctions de visualisation intégrées qui peuvent afficher les résultats de l’ajustement du modèle.

Les points noirs indiquent les points de données utilisés pour entraîner le modèle. La ligne bleue est la prévision et la zone bleu clair montre des intervalles d’incertitude. Vous avez créé trois modèles avec des valeurs changepoint_prior_scale différentes. Les prédictions de ces trois modèles sont affichées dans les résultats de ce bloc de code.

for idx, pack in enumerate(zip(models, forecasts)):
    m, forecast = pack
    fig = m.plot(forecast)
    fig.suptitle(f"changepoint = {changepoint_priors[idx]}")

La plus petite valeur changepoint_prior_scale du premier graphique entraîne un sous-ajustement des changements de tendance. La plus grande valeur changepoint_prior_scale dans le troisième graphique pourrait entraîner un surajustement. Par conséquent, le deuxième graphique semble être le meilleur choix. Cela implique que le deuxième modèle est le plus approprié.

Visualiser les tendances et la saisonnalité avec Prophet

En outre, Prophet peut facilement visualiser les tendances et les saisons sous-jacentes. Les visualisations du deuxième modèle sont affichées dans les résultats de ce bloc de code.

BEST_MODEL_INDEX = 1  # Set the best model index according to the previous results
fig2 = models[BEST_MODEL_INDEX].plot_components(forecast)

Dans ces graphiques, l’ombrage bleu clair reflète l’incertitude. Le graphique du haut montre une tendance oscillante forte et longue. Les volumes de ventes augmentent et chutent sur quelques années. Le graphique du bas montre que les ventes ont tendance à atteindre un pic en février et en septembre, atteignant leurs valeurs maximales pour l’année dans ces mois. Peu après ces mois, en mars et en octobre, ils tombent aux valeurs minimales de l’année.

Évaluez les performances des modèles à l’aide de différentes métriques, par exemple :

• erreur carrée moyenne (MSE)
• erreur quadratique moyenne (RMSE)
• erreur absolue moyenne (MAE)
• erreur de pourcentage absolue moyenne (MAPE)
• erreur de pourcentage absolue médiane (MDAPE)
• erreur de pourcentage absolue moyenne symétrique (SMAPE)

Évaluez la couverture à l’aide des estimations yhat_lower et yhat_upper. Notez les horizons variés dans lesquels vous prévoyez une année à l’avenir, 12 fois.

display(df_metrics[BEST_MODEL_INDEX])

Avec la métrique MAPE, pour ce modèle de prévision, les prédictions qui s’étendent un mois à l’avenir impliquent généralement des erreurs d’environ 8 %. Toutefois, pour les prédictions sur un an, l’erreur augmente d’environ 10 %.

Étape 5 : Noter le modèle et enregistrer les résultats de prédiction

Maintenant, notez le modèle et enregistrez les résultats de prédiction.

Effectuer des prédictions avec Predict Transformer

Vous pouvez maintenant charger le modèle et l’utiliser pour effectuer des prédictions. Les utilisateurs peuvent opérationnaliser des modèles Machine Learning avec PREDICT, une fonction évolutive de Microsoft Fabric qui prend en charge le scoring par lots dans n’importe quel moteur de calcul. En savoir plus sur PREDICT et comment l’utiliser dans Microsoft Fabric à cette Ressources.

from synapse.ml.predict import MLFlowTransformer

spark.conf.set("spark.synapse.ml.predict.enabled", "true")

model = MLFlowTransformer(
    inputCols=future.columns.values,
    outputCol="prediction",
    modelName=f"{EXPERIMENT_NAME}-prophet",
    modelVersion=BEST_MODEL_INDEX,
)

test_spark = spark.createDataFrame(data=future, schema=future.columns.to_list())

batch_predictions = model.transform(test_spark)

display(batch_predictions)

# Code for saving predictions into lakehouse
batch_predictions.write.format("delta").mode("overwrite").save(
    f"{DATA_FOLDER}/predictions/batch_predictions"
)

# Determine the entire runtime
print(f"Full run cost {int(time.time() - ts)} seconds.")

Contenu connexe

• Modèle d’apprentissage automatique dans Microsoft Fabric
• Entraîner des modèles Machine Learning
• Expériences d’apprentissage automatique dans Microsoft Fabric