Facebook Prophet: Guida Completa al Forecasting di Serie Temporali

Previsioni per il Futuro: La Semplice Potenza di Facebook Prophet

Immaginate di poter guardare avanti e anticipare cosa accadrà nel vostro business, con una chiarezza che va oltre la semplice intuizione. Che si tratti delle vendite del prossimo trimestre, del traffico sul vostro sito web o del numero di passeggeri su un volo, capire il futuro può trasformare il modo in cui prendete decisioni. Non stiamo parlando di una sfera di cristallo, ma di uno strumento concreto, accessibile anche a chi non è esperto di statistiche complesse.

Facebook Prophet è nato proprio per questo: rendere la previsione di serie temporali un’attività alla portata di tutti, senza sacrificare la robustezza e l’accuratezza. Questa libreria, sviluppata da Meta, è come un interprete che decifra i segreti nascosti nei vostri dati storici, rivelando trend, cicli stagionali e l’impatto di eventi speciali. In questa guida completa, vi accompagneremo passo dopo passo nel mondo di Prophet, mostrandovi come applicare questa potente soluzione a scenari reali e ottenere previsioni affidabili per il vostro contesto.

 Perché usarlo?

Prophet è una libreria open-source sviluppata da Meta (ex Facebook) per la previsione (forecasting) di serie temporali. È particolarmente utile quando i dati presentano stagionalità (giornaliera, settimanale, annuale), vacanze e tendenze non lineari.

È progettato per essere:

• Facile da usare anche senza conoscenze statistiche avanzate
• Robusto in presenza di dati mancanti, outlier e cambiamenti stagionali
• Interattivo: puoi personalizzare festivi, cambiamenti di trend e stagionalità

Installazione

Con pip:

pip install prophet

Nota: su alcune versioni di Python (soprattutto su Windows), potrebbe essere necessario:

pip install pystan==2.19.1.1
pip install prophet

Importazione dei moduli e dataset di esempio

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

Dataset: esempio semplice

df = pd.read_csv('https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-passengers.csv')
df.columns = ['ds', 'y']  # Prophet richiede colonne 'ds' (data) e 'y' (valore)
df['ds'] = pd.to_datetime(df['ds'])
df.head()

Addestramento del modello

m = Prophet()
m.fit(df)

Cosa fa:

Questa è la fase iniziale e fondamentale.

m = Prophet(): Crea una nuova “istanza” del modello Prophet. Pensa a questo come creare un “cervello” vuoto, pronto per imparare dai dati. In questa fase, è possibile specificare parametri globali del modello, come vedremo più avanti.

m.fit(df): Questo è il comando di “addestramento”. Il modello m analizza il DataFrame df che contiene i dati storici. Prophet si aspetta che questo DataFrame abbia almeno due colonne con nomi specifici:

ds: La colonna delle date (datestamp). Deve essere in un formato di data o timestamp.

y: La colonna del valore numerico che vogliamo prevedere (es. vendite, utenti, temperatura).

Perché è importante:

Durante la fase di fit, Prophet scompone la serie storica nei suoi elementi base: il trend (la direzione generale dei dati nel tempo), la stagionalità (pattern che si ripetono, come quelli settimanali o annuali) e l’effetto di eventuali festività. Senza questa fase, il modello non sa nulla del passato e non può fare alcuna previsione.

Creazione del futuro (forecast horizon)

future = m.make_future_dataframe(periods=12, freq='M')  # Previsione per 12 mesi
future.tail()

Cosa fa:

future = m.make_future_dataframe(...): Il modello addestrato ha bisogno di sapere per quali date future deve generare una previsione. Questa funzione crea un nuovo DataFrame che contiene tutte le date della serie storica originale (df) più un numero di date future aggiuntive.

periods=12: Specifica quanti periodi futuri vogliamo prevedere. In questo caso, 12.

freq='M': Specifica la frequenza di questi periodi. 'M' sta per mese (Month). Altre opzioni comuni sono 'D' (giorno), 'W' (settimana), 'H' (ora).

future.tail(): Questo comando serve solo a visualizzare le ultime righe del DataFrame future per verificare che le 12 date mensili future siano state aggiunte correttamente.

Perché è importante: Bisogna definire esplicitamente l’orizzonte temporale della previsione. Prophet non può “indovinare” per quanto tempo nel futuro vogliamo la nostra stima.

Generazione delle previsioni

forecast = m.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()

• yhat: previsione centrale
• yhat_lower, yhat_upper: intervallo di confidenza al 95%

Cosa fa:

forecast = m.predict(future): Questo è il momento in cui avviene la “magia”. Il modello addestrato m prende il DataFrame future (che contiene sia date passate che future) e calcola la previsione per ogni data.

Il risultato forecast è un DataFrame molto ricco di informazioni. Le colonne più importanti sono:

ds: La data.

yhat: La previsione puntuale, ovvero il valore più probabile previsto dal modello.

yhat_lower e yhat_upper: Rappresentano l’intervallo di confidenza (o di incertezza). Il modello ci dice che, con una probabilità del 95% (default), il valore reale si troverà all’interno di questo range.

Perché è importante: Questo è l’obiettivo finale del processo. Non solo otteniamo una stima (yhat), ma anche una misura della sua incertezza (yhat_lower, yhat_upper), che è fondamentale per prendere decisioni informate. Una previsione senza un’indicazione di incertezza è incompleta.

Visualizzazione

fig1 = m.plot(forecast)
plt.show()

Cosa fa: Prophet include delle funzioni di visualizzazione molto comode.

m.plot(forecast): Genera automaticamente un grafico che mostra:

I punti neri: i dati storici reali.

La linea blu: la previsione del modello (yhat).

L’area azzurra: l’intervallo di incertezza (yhat_lower e yhat_upper).

Perché è importante: Un’immagine vale più di mille parole. Questo grafico permette di valutare visivamente e immediatamente la qualità del modello: come si adatta ai dati passati e come appare la previsione futura.

Componenti del modello

Prophet stima trend, stagionalità e festività separatamente.

fig2 = m.plot_components(forecast)
plt.show()

Cosa fa: Questa funzione crea grafici separati per ogni componente che il modello ha stimato. Di solito mostra:

Trend: La curva di crescita/decrescita a lungo termine. Mostra anche i “changepoints” (punti di cambiamento del trend) rilevati automaticamente.

Yearly seasonality: Il pattern che si ripete ogni anno (es. vendite più alte in estate e più basse in inverno).

Weekly seasonality: Il pattern che si ripete durante la settimana (es. più traffico nei giorni feriali e meno nel weekend).

Perché è importante: Aiuta a capire il “ragionamento” del modello. Possiamo vedere quali pattern ha identificato e quanto ciascuno contribuisce alla previsione finale. Ad esempio, se la previsione per un certo giorno è alta, possiamo vedere se è a causa del trend generale, della stagionalità annuale o di quella settimanale.

Aggiungere festività personalizzate (es. Natale, Pasqua)

from prophet.make_holidays import make_holidays_df

holidays = pd.DataFrame({
  'holiday': 'natale',
  'ds': pd.to_datetime(['2019-12-25', '2020-12-25', '2021-12-25']),
  'lower_window': 0,
  'upper_window': 1,
})

m = Prophet(holidays=holidays)
m.fit(df)
forecast = m.predict(future)
m.plot(forecast)

Cosa fa: Le festività (come Natale, Pasqua) possono avere un impatto significativo ma non seguono un pattern settimanale o annuale regolare (la data di Pasqua cambia ogni anno). Questa sezione permette di informare esplicitamente il modello su queste date speciali.

Si crea un DataFrame holidays con le colonne holiday (nome della festa) e ds (data).

lower_window e upper_window: Parametri molto utili. lower_window: 0 e upper_window: 1 per il Natale significa che il modello considererà un effetto speciale non solo il 25 Dicembre, ma anche il giorno dopo (26 Dicembre). Se l’effetto iniziasse prima (es. saldi del Black Friday), si userebbe un lower_window negativo.

m = Prophet(holidays=holidays): Il DataFrame delle festività viene passato al modello al momento della sua creazione.

Perché è importante: Permette al modello di attribuire picchi o cali anomali a eventi specifici, invece di interpretarli erroneamente come un cambio di trend o di stagionalità. Questo rende le previsioni più accurate.

Aggiungere stagionalità personalizzata

m = Prophet()
m.add_seasonality(name='monthly', period=30.5, fourier_order=5)
m.fit(df)

Cosa fa: A volte, i dati hanno cicli che non sono quelli standard (settimanale, annuale). Ad esempio, potrebbero esserci dei cicli mensili o trimestrali.

m.add_seasonality(...): Permette di aggiungere un ciclo personalizzato.

name: Un nome per questa nuova stagionalità.

period: La durata del ciclo in giorni (es. 30.5 per un mese, 91.25 per un trimestre).

fourier_order: Un parametro tecnico che controlla la flessibilità della curva stagionale. Un valore più alto permette di modellare pattern più complessi, ma aumenta il rischio di “overfitting” (imparare il rumore casuale invece del segnale reale).

Perché è importante: Offre la flessibilità di modellare cicli specifici del proprio dominio di dati, che altrimenti verrebbero ignorati.

Valutazione del modello

Aggiungiamo una metrica come l’RMSE (Root Mean Squared Error):

from sklearn.metrics import mean_squared_error
import numpy as np

# dividere in train/test
train = df[:-12]
test = df[-12:]

model = Prophet()
model.fit(train)

future = model.make_future_dataframe(periods=12, freq='M')
forecast = model.predict(future)

pred = forecast[-12:]['yhat'].values
true = test['y'].values

rmse = np.sqrt(mean_squared_error(true, pred))
print(f'RMSE: {rmse:.2f}')

Cosa fa: Questa sezione implementa una procedura standard per misurare oggettivamente le performance del modello.

Divisione Train/Test: I dati vengono divisi. Il modello viene addestrato solo sui dati più vecchi (train).

Previsione sul Test set: Si fa una previsione per il periodo coperto dal test set (i dati che il modello non ha mai visto).

Confronto: Si confrontano i valori previsti (pred) con i valori reali che erano stati messi da parte (true).

Calcolo della Metrica: L’RMSE (Root Mean Squared Error) è una metrica comune che misura l’errore medio del modello. Un valore di RMSE più basso indica un modello più preciso.

Perché è importante: Non basta “sentire” che una previsione sia buona. È necessario avere una metrica numerica per confrontare diversi modelli o diverse configurazioni dello stesso modello e scegliere oggettivamente il migliore.

Parametri utili del modello

growth: Può essere 'linear' (il trend cresce o decresce in modo costante) o 'logistic' (il trend ha un punto di saturazione, una crescita che rallenta fino a un massimo).

changepoint_prior_scale: Controlla la flessibilità del trend. Un valore più alto permette al trend di cambiare più bruscamente, un valore più basso lo rende più rigido. È uno dei parametri più importanti da “tarare” (tuning).

seasonality_mode: Può essere 'additive' (la stagionalità aggiunge/sottrae un valore fisso, es. +100 in estate) o 'multiplicative' (la stagionalità aumenta/diminuisce in percentuale, es. +10% in estate). La modalità moltiplicativa è utile quando l’ampiezza delle oscillazioni stagionali cresce insieme al trend.

Perché è importante: I parametri di default di Prophet funzionano bene in molti casi, ma la personalizzazione avanzata permette di adattare il modello alle caratteristiche specifiche della propria serie storica, migliorando notevolmente l’accuratezza.

Esempio:

m = Prophet(
    growth='linear',
    changepoint_prior_scale=0.1,
    seasonality_mode='multiplicative'
)

Previsione con regressori esterni (extra regressors)

df['promo'] = [0, 1, 0, 0, 1, 0, ...]  # aggiungi una colonna binaria
m = Prophet()
m.add_regressor('promo')
m.fit(df)

future = m.make_future_dataframe(periods=12, freq='M')
future['promo'] = [0, 1, 0, ...]  # stesso numero di righe
forecast = m.predict(future)

Cosa fa: Permette di includere nella previsione l’effetto di altre variabili (regressori) di cui conosciamo i valori sia passati che futuri. L’esempio è una campagna promozionale.

Si aggiunge una colonna al DataFrame (df['promo']) che indica quando l’evento esterno era attivo (es. 1 se c’era una promo, 0 altrimenti).

m.add_regressor('promo'): Si dice esplicitamente al modello di usare questa colonna come un fattore predittivo.

Cruciale: Quando si crea il DataFrame future, bisogna aggiungere anche i valori futuri del regressore. Per prevedere l’effetto di una promozione futura, devi sapere in anticipo quando quella promozione avverrà.

Perché è importante: Se la tua serie storica è influenzata da fattori esterni noti (promozioni, lanci di prodotti, condizioni meteo, ecc.), includerli come regressori può migliorare drasticamente la precisione del modello.

Salvataggio e caricamento del modello

import joblib

joblib.dump(m, 'prophet_model.pkl')

# Per ricaricare:
model = joblib.load('prophet_model.pkl')

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

# Step 1: Caricamento dati
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-passengers.csv'
df = pd.read_csv(url)
df.columns = ['ds', 'y']  # Prophet richiede queste intestazioni
df['ds'] = pd.to_datetime(df['ds'])

# Step 2: Creazione e addestramento modello
m = Prophet()
m.fit(df)

# Step 3: Estensione nel futuro di 12 mesi
future = m.make_future_dataframe(periods=12, freq='M')

# Step 4: Previsione
forecast = m.predict(future)

# Step 5: Visualizzazione
fig = m.plot(forecast)
plt.show()

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

# Simulazione dati trimestrali
np.random.seed(42)
months = pd.date_range(start='2020-01-01', periods=36, freq='M')
sales = 200 + 50 * np.sin(2 * np.pi * months.month / 3) + np.random.normal(0, 10, 36)

df = pd.DataFrame({'ds': months, 'y': sales})

# Modello con stagionalità personalizzata
m = Prophet()
m.add_seasonality(name='trimestrale', period=90, fourier_order=5)
m.fit(df)

# Previsione
future = m.make_future_dataframe(periods=12, freq='M')
forecast = m.predict(future)
m.plot(forecast)
plt.show()

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

holidays = pd.DataFrame({
    'holiday': 'natale',
    'ds': pd.to_datetime(['2020-12-25', '2021-12-25', '2022-12-25']),
    'lower_window': -1,
    'upper_window': 2,
})

# Dati simulati con picchi a dicembre
dates = pd.date_range(start='2020-01-01', periods=36, freq='M')
sales = 100 + 30 * (dates.month == 12) + np.random.normal(0, 5, 36)

df = pd.DataFrame({'ds': dates, 'y': sales})

m = Prophet(holidays=holidays)
m.fit(df)

future = m.make_future_dataframe(periods=12, freq='M')
forecast = m.predict(future)
m.plot(forecast)
plt.show()

from sklearn.metrics import mean_squared_error
import numpy as np
import pandas as pd
from prophet import Prophet
import matplotlib.pyplot as plt

# Per questo esercizio, riutilizziamo il df dell'Esercizio 1 per coerenza
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-passengers.csv'
df = pd.read_csv(url)
df.columns = ['ds', 'y']
df['ds'] = pd.to_datetime(df['ds'])

# Suddivisione train/test
train = df[:-6]
test = df[-6:]

# Addestramento
m = Prophet()
m.fit(train)

# Previsione
future = m.make_future_dataframe(periods=6, freq='M')
forecast = m.predict(future)

# Calcolo errore RMSE
pred = forecast[-6:]['yhat']
true = test['y'].values

rmse = np.sqrt(mean_squared_error(true, pred))
print(f'RMSE: {rmse:.2f}')

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

# Dati simulati con crescita e poi saturazione
dates = pd.date_range(start='2020-01-01', periods=60, freq='M')
initial_growth = 100 * (1 - np.exp(-dates.month / 10))
noise = np.random.normal(0, 5, 60)
sales = 500 / (1 + np.exp(-(dates.to_series().diff().dt.days.fillna(30).cumsum() / 100))) + noise # Simplified logistic-like growth
df = pd.DataFrame({'ds': dates, 'y': sales})


df['cap'] = 1000  # Limite massimo
df['y'] = df['y'].clip(upper=1000) # Assicurarsi che i dati non superino il cap iniziale

m = Prophet(growth='logistic')
m.fit(df)

future = m.make_future_dataframe(periods=12, freq='M')
future['cap'] = 1000 # Il cap deve essere specificato anche per il futuro
forecast = m.predict(future)
m.plot(forecast)
plt.show()

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

# Dati simulati
dates = pd.date_range(start='2020-01-01', periods=48, freq='M')
base_sales = 100 + 5 * np.arange(len(dates))
campaign_effect = np.array([30 if (i % 6 == 0) else 0 for i in range(len(dates))])
noise = np.random.normal(0, 10, len(dates))
sales = base_sales + campaign_effect + noise

df = pd.DataFrame({'ds': dates, 'y': sales})

# Simulazione dati per la colonna 'campagna'
df['campagna'] = [1 if (i % 6 == 0) else 0 for i in range(len(df))]

m = Prophet()
m.add_regressor('campagna')
m.fit(df)

future = m.make_future_dataframe(periods=12, freq='M')
# Assicurati che 'campagna' sia definita anche per i periodi futuri
future['campagna'] = [1 if (i % 6 == 0) else 0 for i in range(len(future))]

forecast = m.predict(future)
m.plot(forecast)
plt.show()

📚 15. Risorse utili

• Documentazione ufficiale
• Prophet su GitHub
• Dataset demo: Airline passenger