Prophet : Maîtrisez les Prévisions Temporelles avec Facebook Prophet

Résumé

Prophet est un modèle de prévision des séries temporelles développé par l’équipe Core Data Science de Meta (anciennement Facebook). Conçu pour être à la fois puissant et accessible, Prophet repose sur un modèle additif décomposable qui capture trois composantes fondamentales : la tendance, la saisonnalité et les effets de jours fériés. Contrairement aux modèles classiques comme ARIMA, Prophet ne requiert ni stationnarité des données ni expertise approfondie en statistique. Il tolère élégamment les valeurs manquantes, les anomalies et les changements structurels de tendance grâce à sa détection automatique de « changepoints ». Ce guide explore en détail le principe mathématique de Prophet, son implémentation pratique en Python, ses hyperparamètres clés, ainsi que ses cas d’usage concrets en entreprise et en recherche.

Principe Mathématique de Prophet

Au cœur de Prophet se trouve un modèle additif décomposable qui s’exprime sous la forme suivante :

$$y(t) = g(t) + s(t) + h(t) + \varepsilon_t$$

où chaque terme possède une signification précise et interprétable.

La tendance $g(t)$

Le terme $g(t)$ représente la tendance de long terme. Prophet propose deux formulations :

• Tendance piecewise linéaire : la série est découpée en segments linéaires séparés par des points de rupture appelés changepoints. Entre deux changepoints consécutifs, la pente est constante. À chaque changepoint, la pente s’ajuste d’un montant $\delta_j$. Mathématiquement :

$$g(t) = (k + a(t)^\top \delta) \cdot t + (m + a(t)^\top \gamma)$$

où $k$ est la pente initiale, $m$ est le décalage initial, $\delta$ est le vecteur des ajustements de pente aux changepoints, et $a(t)$ est un vecteur indicateur indiquant dans quel segment se trouve $t$. Le terme $\gamma_j$ assure la continuité aux points de jonction :

$$\gamma_j = -s_j \cdot \delta_j$$

où $s_j$ est le moment du $j$-ème changepoint.

• Tendance logistique : lorsque la croissance atteint un plafond naturel (capacité de marché, saturation), Prophet utilise une courbe logistique :

$$g(t) = \frac{C(t)}{1 + \exp(-(k + a(t)^\top \delta) \cdot (t – m – a(t)^\top \gamma))}$$

où $C(t)$ représente la capacité maximale (plafond) à l’instant $t$.

La détection des changepoints repose sur l’hypothèse que ces points suivent un processus de Poisson de taux $\lambda$. Le paramètre changepoint_prior_scale contrôle la régularisation des ajustements de pente via une distribution de Laplace (sparse), ce qui encourage la parcimonie : seuls les changepoints véritablement significatifs reçoivent un ajustement non nul.

La saisonnalité $s(t)$

Le terme $s(t)$ capture les patterns périodiques à travers une série de Fourier :

$$s(t) = \sum_{j=1}^{N} [a_j \cdot \cos(2\pi j t / P) + b_j \cdot \sin(2\pi j t / P)]$$

où $P$ est la période (365,25 pour la saisonnalité annuelle, 7 pour la saisonnalité hebdomadaire) et $N$ est le nombre de termes de Fourier. Un $N$ élevé permet de capturer des variations complexes mais risque le surapprentissage ; un $N$ faible produit une saisonnalité lisse.

Pour la saisonnalité hebdomadaire, Prophet utilise généralement $N = 3$, produisant 6 degrés de liberté. Pour la saisonnalité annuelle, $N = 10$ est la valeur par défaut, offrant 20 degrés de liberté.

Les coefficients $a = [a_1, …, a_N, b_1, …, b_N]$ sont régularisés par une distribution normale avec variance contrôlée par le paramètre seasonality_prior_scale.

L’effet des jours fériés $h(t)$

Le terme $h(t)$ modélise l’impact des événements ponctuels (jours fériés, promotions, lancements de produits) :

$$h(t) = \sum_{i=1}^{L} \kappa_i \cdot \mathbb{1}(t \in D_i)$$

où $D_i$ est l’ensemble des jours couverts par l’événement $i$ (incluant souvent une fenêtre autour de la date exacte), et $\kappa_i$ est le coefficient d’impact suivant une distribution normale. Le paramètre holidays_prior_scale contrôle la variance de cette distribution.

Ce mécanisme est particulièrement puissant pour les données commerciales : Black Friday, Noël, le 14 juillet, le Ramadan — chaque événement peut être spécifié avec une date, un nom et une fenêtre d’impact (jours avant et après).

Le bruit $\varepsilon_t$

Le terme $\varepsilon_t$ représente le bruit résiduel non expliqué par le modèle. Prophet l’assume distribué normalement : $\varepsilon_t \sim N(0, \sigma^2)$. En pratique, les intervalles de prédiction de Prophet sont construits en simulant à partir de la distribution postérieure des paramètres via l’inférence variationnelle (L-BFGS ou MCMC).

Les Changepoints

Les changepoints sont des moments où la pente de $g(t)$ change structurellement. Prophet les sélectionne automatiquement : par défaut, 25 changepoints potentiels sont placés uniformément sur les 80 % premiers de la série temporelle. L’algorithme d’inférence détermine ensuite quels changepoints méritent un ajustement de pente significatif grâce à la régularisation parcimonieuse de Laplace. Cette approche évite à la fois le surapprentissage (trop de changepoints actifs) et le sous-apprentissage (changepoints importants ignorés).

Intuition : Pourquoi Prophet est Différent

Imaginez un comptable chevronné qui doit prédire les revenus futurs de son entreprise. Ce comptable ne se contente pas de projeter une droite sur un graphique. Il raisonne en plusieurs couches :

La tendance générale : « Regarde, nos ventes ont augmenté de 15 % par an pendant trois ans, mais cette année, la croissance a ralenti à 8 %. Il y a eu un changement de rythme vers le milieu de l’année dernière. » Prophet identifie ces ruptures automatiquement — ce sont les changepoints.

Les cycles saisonniers : « Chaque année, on vend beaucoup plus en décembre à cause de Noël, et nos ventes chutent en août pendant les vacances d’été. Chaque semaine, le vendredi est notre meilleur jour. » Prophet modélise ces patterns avec des séries de Fourier qui capturent des formes de saisonnalité complexes, pas seulement des pics fixes.

Les jours spéciaux : « Attention, le Black Friday va doubler nos ventes sur trois jours. Et la fête des mères crée un petit pic en mai. » Prophet accepte une liste de jours fériés personnalisés avec des fenêtres d’impact flexibles.

L’ajustement automatique : « Tiens, depuis que notre concurrent a baissé ses prix en mars, notre pente de croissance a changé. Je dois recalibrer ma méthode. » Prophet ajuste ses changepoints en cours de route grâce à la régularisation parcimonieuse de Laplace.

Ce qui rend Prophet véritablement unique, c’est sa philosophie de design : c’est un modèle fait pour les humains, pas seulement pour les data scientists. Sean Taylor et Ben Loughmire, ses créateurs chez Facebook, l’ont conçu spécifiquement pour que des analystes métier puissent produire des prévisions fiables sans maîtriser les subtilités de la modélisation ARIMA ou les diagnostics de stationnarité. L’interface est intentionnellement simple : deux colonnes (ds pour la date, y pour la valeur), une commande fit(), une commande predict(), et le tour est joué.

Implémentation Python avec Prophet

Installation

pip install prophet

La bibliothèque prophet est le successeur officiel de fbprophet. Elle s’installe désormais facilement via pip sans dépendance Stan complexe.

Préparation des données

Le format requis par Prophet est extrêmement simple : un DataFrame pandas avec deux colonnes obligatoires, ds (dates) et y (valeurs numériques).

import pandas as pd
from prophet import Prophet
import matplotlib.pyplot as plt

# Chargement des données
# Exemple : ventes quotidiennes d'un magasin
df = pd.read_csv("ventes_quotidiennes.csv")

# Prophet attend exactement deux colonnes : 'ds' (date) et 'y' (valeur)
df = df.rename(columns={"date": "ds", "ventes": "y"})
df["ds"] = pd.to_datetime(df["ds"])

# Vérification
print(f"Nombre d'observations : {len(df)}")
print(f"Période : {df['ds'].min()} à {df['ds'].max()}")
print(df.head())

Construction et entraînement du modèle

# Création du modèle Prophet avec paramètres par défaut
model = Prophet(
    yearly_seasonality=True,
    weekly_seasonality=True,
    daily_seasonality=False,  # Pour des données quotidiennes, pas nécessaire
    changepoint_prior_scale=0.05,
    seasonality_prior_scale=10.0,
    growth="linear"
)

# Ajout de jours fériés personnalisés (exemple français)
df_holidays = pd.DataFrame({
    "holiday": ["noel", "noel", "nouvel_an", "nouvel_an", "fete_travail",
                "fete_nationale", "fete_nationale", "black_friday"],
    "ds": pd.to_datetime([
        "2022-12-24", "2022-12-25", "2023-01-01", "2024-01-01",
        "2023-05-01", "2023-07-13", "2023-07-14", "2023-11-24"
    ]),
    "lower_window": [-1, -1, 0, 0, 0, -1, -1, -2],
    "upper_window": [1, 1, 0, 0, 0, 0, 0, 1],
})

model.add_country_holidays(country_name="FR")
model.add_holidays(df_holidays)

# Entraînement du modèle
model.fit(df)
print("Modèle entraîné avec succès.")

Prévision sur 365 jours futurs

# Création du DataFrame futur pour 365 jours
future = model.make_future_dataframe(periods=365, freq="D")

# Prédiction
forecast = model.predict(future)

# Affichage des résultats
print(forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].tail(10))

# Visualisation de la prévision complète
fig1 = model.plot(forecast)
plt.title("Prévisions Prophet — Ventes quotidiennes")
plt.xlabel("Date")
plt.ylabel("Ventes")
plt.show()

Visualisation des composantes

# Décomposition des composantes : tendance, saisonnalité, jours fériés
fig2 = model.plot_components(forecast)

# Cette figure affiche :
# 1. La tendance (trend) avec les changepoints
# 2. La saisonnalité hebdomadaire (weekly)
# 3. La saisonnalité annuelle (yearly)
# 4. L'effet des jours fériés (holidays)
plt.show()

Détection automatique des changepoints

from prophet.plot import add_changepoints_to_plot

fig, ax = plt.subplots(figsize=(14, 5))
ax.plot(forecast["ds"], forecast["yhat"], label="Prévision")
ax = add_changepoints_to_plot(ax, model, forecast)
ax.set_title("Détection automatique des changepoints par Prophet")
ax.set_xlabel("Date")
ax.set_ylabel("Valeur prédite")
ax.legend()
plt.show()

# Affichage des changepoints détectés
changepoints = model.changepoints
print(f"Nombre de changepoints détectés : {len(changepoints)}")
print(f"Derniers changepoints : {changepoints[-5:]}")

Évaluation du modèle

from prophet.diagnostics import cross_validation, performance_metrics

# Validation croisée avec horizon de 90 jours
df_cv = cross_validation(
    model,
    initial="730 days",   # 2 ans d'entraînement initial
    period="180 days",     # espacement entre les coupures
    horizon="90 days",     # horizon de prédiction
    parallel="processes"
)

# Métriques de performance
df_metrics = performance_metrics(df_cv, metrics=["mape", "rmse", "mae"])
print(df_metrics.head())

# Visualisation des métriques
fig3 = model.plot(forecast)
plt.title("Évaluation croisée de Prophet")
plt.show()

Hyperparamètres Clés de Prophet

La puissance de Prophet réside dans la simplicité de ses hyperparamètres. Contrairement aux modèles SARIMA qui nécessitent le réglage minutieux de $(p, d, q) \times (P, D, Q)_s$, Prophet offre une poignée de paramètres intuitifs :

changepoint_prior_scale (défaut : 0.05)

Ce paramètre contrôle la flexibilité de la tendance. Il s’agit du facteur de régularisation appliqué aux ajustements de pente aux changepoints. Une valeur élevée (ex. : 0.5) rend la tendance très flexible, susceptible de suivre le bruit. Une valeur faible (ex. : 0.001) produit une tendance plus lisse, potentiellement au prix de sous-apprentissage.

# Tendance plus flexible
model = Prophet(changepoint_prior_scale=0.5)

# Tendance plus lisse
model = Prophet(changepoint_prior_scale=0.001)

seasonality_prior_scale (défaut : 10.0)

Contrôle l’amplitude de la saisonnalité. Un prior élevé permet à la saisonnalité de suivre des variations complexes ; un prior faible la force vers zéro (pas de saisonnalité).

# Saisonnalité forte et flexible
model = Prophet(seasonality_prior_scale=20.0)

# Saisonnalité atténuée
model = Prophet(seasonality_prior_scale=0.1)

holidays_prior_scale (défaut : 10.0)

Régule l’impact des jours fériés. Si vos jours fériés n’ont pas d’effet significatif, réduisez ce paramètre pour éviter que le modèle ne surajuste à des variations aléatoires coïncidant avec des dates fériées.

model = Prophet(holidays_prior_scale=5.0)

growth : "linear" ou "logistic"

Détermine la forme de la tendance fondamentale. Le modèle linéaire convient aux séries sans plafond naturel. Le modèle logistique est idéal lorsque la croissance est limitée par une capacité maximale.

# Croissance logistique avec capacité
df["cap"] = 10000  # plafond de capacité
df["floor"] = 0    # plancher optionnel

model = Prophet(growth="logistic")
model.fit(df)

yearly_seasonality et weekly_seasonality

Peuvent être fixés à True, False, ou un entier. Un entier spécifie le nombre de termes de Fourier (plus c’est élevé, plus la saisonnalité peut capturer de détails complexes).

# Saisonnalité annuelle très détaillée (20 termes de Fourier = 40 degrés de liberté)
model = Prophet(yearly_seasonality=20, weekly_seasonality=3)

n_changepoints (défaut : 25)

Nombre de changepoints potentiels placés uniformément sur les 80 premiers pourcents de la série. Pour des séries très longues (plus de 5 ans), on peut augmenter ce nombre.

model = Prophet(n_changepoints=50)

Avantages et Limites de Prophet

Avantages

1. Accessibilité remarquable : Interface intuitive avec seulement deux colonnes requises. Un analyste métier peut produire une prévision en quelques lignes de code, sans connaissance en statistiques avancées. C’est l’avantage principal qui a propulsé Prophet auprès de millions d’utilisateurs.
2. Robustesse aux anomalies et données manquantes : Contrairement aux modèles ARIMA qui deviennent instables face à des valeurs aberrantes ou des lacunes, Prophet tolère naturellement les données imparfaites grâce à son approche bayésienne avec régularisation.
3. Interprétabilité exceptionnelle : La décomposition additive (tendance + saisonnalité + jours fériés + bruit) permet de comprendre exactement ce qui motive les prévisions. Chaque composante est visualisable séparément. On peut dire au dirigeant : « vos ventes augmentent parce que la tendance de fond est à la hausse (+8 %) et parce que Noël arrive (+25 %). »
4. Détection automatique des changepoints : Plus besoin de tester manuellement des ruptures structurelles. Prophet les identifie automatiquement et ajuste sa tendance en conséquence.
5. Flexibilité saisonnière : Séries de Fourier pour les patterns périodiques, jours fériés personnalisés, saisonnalités multiples (hebdomadaire, annuelle, voire quotidienne). On peut même ajouter des régresseurs externes (température, promotions, prix).
6. Intervalles de confiance bayésiens : Prophet fournit automatiquement des intervalles de prédiction (yhat_lower, yhat_upper) qui quantifient l’incertitude de manière probabiliste.

Limites

1. Inadapté aux séries multivariées complexes : Prophet modélise une seule série à la fois. Bien qu’il accepte des régresseurs externes, il ne capture pas les interactions complexes entre multiples séries comme le ferait un VAR ou un réseau de neurones récurrent.
2. Sensibilité au choix des hyperparamètres : Les valeurs par défaut fonctionnent étonnamment bien dans la majorité des cas, mais pour des séries atypiques (forte volatilité, saisonnalité irrégulière), un réglage fin est indispensable — et le grid search peut être coûteux en temps de calcul.
3. Performance computationnelle : L’inférence via L-BFGS ou MCMC (Stan) est plus lente qu’un simple lissage exponentiel. Sur des séries massives (millions d’observations) ou pour du forecasting en temps réel, Prophet peut devenir un goulot d’étranglement.
4. Hypothèse additive restrictive : Le modèle suppose que les composantes s’additionnent. Dans la réalité, l’effet de Noël peut être multiplicatif (un pourcentage de la tendance, pas une valeur fixe). Bien que la transformation logarithmique permette partiellement de contourner ce problème, la nature additive reste une simplification.
5. Absence de modélisation autocorrélative : Prophet ne modélise pas explicitement l’autocorrélation des résidus. Si vos erreurs présentent une structure temporelle forte (ex. : un jour de forte vente entraîne un autre jour de forte vente), des modèles comme ARIMA ou SARIMAX seront plus appropriés.

4 Cas d’Usage Concrets de Prophet

Cas 1 : Prévision des ventes dans le commerce de détail

Une chaîne de supermarchés souhaite anticiper ses ventes quotidiennes par magasin pour optimiser ses stocks. Prophet est idéal car il capture naturellement :

• La tendance de croissance globale (ouverture de nouveaux magasins, expansion du marché)
• La saisonnalité hebdomadaire (pics du week-end, creux du mardi)
• La saisonnalité annuelle (Noël, soldes d’été, rentrée scolaire)
• Les effets de jours fériés (14 juillet, Toussaint, Black Friday)
• Les promotions comme régresseurs externes

# Ajout des promotions comme régresseur externe
model = Prophet()
model.add_regressor("promotion_active")
model.add_regressor("taux_remise")

Résultat obtenu : Réduction de 30 % des ruptures de stock grâce à des prévisions plus précises, et diminution de 15 % du gaspillage alimentaire.

Cas 2 : Prévision de la demande énergétique

Un gestionnaire de réseau électrique doit anticiper la consommation d’électricité à l’horizon 24-72 heures pour équilibrer production et demande.

• Saisonnalité quotidienne : pics matin (7h-9h) et soir (18h-21h)
• Saisonnalité hebdomadaire : consommation plus faible le week-end
• Saisonnalité annuelle : chauffage en hiver, climatisation en été
• Régresseurs externes : température, humidité, jour ouvré vs. jour férié

df["temperature"] = ...
df["humidite"] = ...
df["est_jour_ouvre"] = df["ds"].dt.dayofweek < 5

model = Prophet(daily_seasonality=4)
model.add_regressor("temperature")
model.add_regressor("est_jour_ouvre")

Résultat obtenu : Précision de prédiction à 97 % sur un horizon de 24 heures, permettant une optimisation significative du mix énergétique.

Cas 3 : Prévision du trafic web pour un site e-commerce

Une marketplace veut dimensionner ses serveurs et planifier ses campagnes marketing. Le trafic web présente des patterns saisonniers très marqués.

• Tendance de croissance organique du site
• Saisonnalité hebdomadaire : moins de trafic le week-end pour un site B2B, plus pour un site B2C
• Saisonnalité annuelle : soldes, rentrée, période des fêtes
• Effets de campagne marketing (régresseurs externes : budget publicitaire, emails envoyés)

future = model.make_future_dataframe(periods=30, freq="D")
future["budget_pub"] = planned_budget
future["emails_envoyes"] = planned_emails

forecast = model.predict(future)

Résultat obtenu : Capacité infrastructurelle ajustée au plus près de la demande réelle, avec une réduction de 40 % des coûts de surprovisionnement.

Cas 4 : Prévision des admissions hospitalières

Un hôpital souhaite anticiper le nombre d’admissions quotidiennes aux urgences pour optimiser ses plannings d’infirmiers et de médecins.

• Tendance de long terme (croissance démographique, évolution de la morbidité)
• Saisonnalité hebdomadaire (plus d’urgences le week-end)
• Saisonnalité annuelle (grippe en hiver, allergies au printemps, accidents en été)
• Effets spéciaux : canicules, épidémies, jours fériés

df["canicule"] = (df["temperature"] > 35).astype(int)
model = Prophet()
model.add_regressor("canicule")
model.add_country_holidays(country_name="FR")

Résultat obtenu : Réduction de 20 % du temps d’attente aux urgences grâce à un dimensionnement proactif des équipes.

Prophet vs. Alternatives : Quand Choisir Quoi

En résumé : Choisissez Prophet quand vous avez besoin de prévisions interprétables, avec des données quotidiennes ou hebdomadaires, des effets de calendrier importants, et une équipe qui n’est pas composée exclusivement de data scientists. Tournez-vous vers ARIMA pour des séries univariées stationnaires propres, vers le lissage exponentiel pour des prévisions ultra-rapides, et vers le deep learning pour des séries multivariées complexes avec des volumes de données massifs.

Bonnes Pratiques pour Prophet en Production

1. Validez avec une split temporelle : Ne mélangez jamais passé et futur dans votre validation. Entraînez sur les premiers mois, testez sur les derniers. La validation croisée temporelle de Prophet (cross_validation) automatise ce processus.
2. Surveillez les résidus : Après la prédiction, examinez les résidus. S’ils présentent une autocorrélation significative ou une hétéroscédasticité, votre modèle ne capture pas toute la structure temporelle.
3. Mettez à jour régulièrement : Les changepoints détectés sur un modèle entraîné en janvier peuvent être obsolètes en juin si le contexte économique a changé. Réentraînez Prophet mensuellement ou trimestriellement.
4. Combinez avec un modèle de référence : Comparez toujours les prévisions de Prophet avec un modèle de référence naïf (ex. : « demain = aujourd’hui » ou « demain = même jour la semaine dernière »). Si Prophet ne bat pas ce baseline, le problème vient probablement des données, pas du modèle.
5. Documentez les événements exceptionnels : La pandémie COVID-19, une grève nationale, un changement réglementaire — ces événements rendent les données historiques peu pertinentes pour l’avenir. Excluez-les ou marquez-les comme régresseurs pour éviter de polluer le modèle.

Voir Aussi

• Maîtrisez les Nombres Triffle en Python : Guide Complet pour Développeurs
• Démystifiez le Module ‘abc’ en Python : Guide Complet avec Exemples Pratiques