Facebook Prophet

Time series forecasting and trend analysis with Facebook Prophet.

Setup & Installation

Installation & Basic Setup

# Install Prophet
pip install prophet

# Install additional dependencies
pip install pandas numpy matplotlib seaborn

# Basic imports
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from prophet import Prophet
import warnings
warnings.filterwarnings('ignore')

# Set up plotting
plt.style.use('default')
plt.rcParams['figure.figsize'] = (12, 6)

Basic Forecasting

Simple Forecast

# Create sample data
dates = pd.date_range('2020-01-01', '2023-12-31', freq='D')
values = 100 + np.cumsum(np.random.randn(len(dates)) * 0.5) + 10 * np.sin(np.arange(len(dates)) * 2 * np.pi / 365)

# Create DataFrame
df = pd.DataFrame({
    'ds': dates,
    'y': values
})

# Initialize and fit Prophet model
model = Prophet()
model.fit(df)

# Create future dataframe
future = model.make_future_dataframe(periods=365)  # Forecast 1 year ahead
forecast = model.predict(future)

# Plot the forecast
fig = model.plot(forecast)
plt.title('Prophet Forecast')
plt.show()

# Plot components
fig = model.plot_components(forecast)
plt.show()

# Access forecast data
print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())

With Seasonality

# Create data with strong seasonality
dates = pd.date_range('2020-01-01', '2023-12-31', freq='D')
# Add yearly seasonality
yearly_season = 20 * np.sin(2 * np.pi * np.arange(len(dates)) / 365.25)
# Add weekly seasonality
weekly_season = 5 * np.sin(2 * np.pi * np.arange(len(dates)) / 7)
# Add trend
trend = np.linspace(100, 200, len(dates))
# Add noise
noise = np.random.randn(len(dates)) * 2

values = trend + yearly_season + weekly_season + noise

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

# Initialize Prophet with custom seasonality
model = Prophet(
    yearly_seasonality=True,
    weekly_seasonality=True,
    daily_seasonality=False,
    seasonality_mode='multiplicative'  # or 'additive'
)

# Add custom seasonality
model.add_seasonality(name='monthly', period=30.5, fourier_order=5)

# Fit the model
model.fit(df)

# Make predictions
future = model.make_future_dataframe(periods=365)
forecast = model.predict(future)

# Plot results
fig = model.plot(forecast)
plt.title('Prophet Forecast with Seasonality')
plt.show()

# Plot components
fig = model.plot_components(forecast)
plt.show()

Advanced Features

Holidays and Events

# Create custom holidays
holidays = pd.DataFrame({
    'holiday': ['New Year', 'Christmas', 'Black Friday', 'Summer Sale'],
    'ds': pd.to_datetime(['2020-01-01', '2020-12-25', '2020-11-27', '2020-07-15',
                         '2021-01-01', '2021-12-25', '2021-11-26', '2021-07-15',
                         '2022-01-01', '2022-12-25', '2022-11-25', '2022-07-15']),
    'lower_window': 0,
    'upper_window': 1,
})

# Create sample data with holiday effects
dates = pd.date_range('2020-01-01', '2022-12-31', freq='D')
base_values = 100 + np.cumsum(np.random.randn(len(dates)) * 0.3)

# Add holiday effects
holiday_effects = np.zeros(len(dates))
for _, holiday in holidays.iterrows():
    mask = (dates >= holiday['ds']) & (dates <= holiday['ds'] + pd.Timedelta(days=holiday['upper_window']))
    holiday_effects[mask] += 20  # Boost during holidays

values = base_values + holiday_effects

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

# Initialize Prophet with holidays
model = Prophet(holidays=holidays)
model.fit(df)

# Make predictions
future = model.make_future_dataframe(periods=365)
forecast = model.predict(future)

# Plot results
fig = model.plot(forecast)
plt.title('Prophet Forecast with Holidays')
plt.show()

# Plot components including holidays
fig = model.plot_components(forecast)
plt.show()

External Regressors

# Create data with external regressors
dates = pd.date_range('2020-01-01', '2023-12-31', freq='D')

# Create external regressors
temperature = 20 + 10 * np.sin(2 * np.pi * np.arange(len(dates)) / 365.25) + np.random.randn(len(dates)) * 2
advertising = np.random.exponential(100, len(dates))
competitor_price = 50 + np.cumsum(np.random.randn(len(dates)) * 0.1)

# Create target variable influenced by regressors
base_sales = 1000
temp_effect = 5 * temperature
ad_effect = 0.1 * advertising
price_effect = -2 * competitor_price
trend = np.linspace(0, 200, len(dates))
noise = np.random.randn(len(dates)) * 50

sales = base_sales + temp_effect + ad_effect + price_effect + trend + noise

# Create DataFrame
df = pd.DataFrame({
    'ds': dates,
    'y': sales,
    'temperature': temperature,
    'advertising': advertising,
    'competitor_price': competitor_price
})

# Initialize Prophet and add regressors
model = Prophet()
model.add_regressor('temperature')
model.add_regressor('advertising')
model.add_regressor('competitor_price')

# Fit the model
model.fit(df)

# Create future dataframe with regressor values
future = model.make_future_dataframe(periods=365)

# For future periods, you need to provide regressor values
# This is a simplified example - in practice, you'd forecast these too
future['temperature'] = np.tile(temperature[-365:], 1)  # Repeat last year
future['advertising'] = np.tile(advertising[-365:], 1)
future['competitor_price'] = np.tile(competitor_price[-365:], 1)

# Make predictions
forecast = model.predict(future)

# Plot results
fig = model.plot(forecast)
plt.title('Prophet Forecast with External Regressors')
plt.show()

Model Evaluation

Cross-Validation and Metrics

from prophet.diagnostics import cross_validation, performance_metrics
from prophet.plot import plot_cross_validation_metric
import matplotlib.pyplot as plt

# Create sample data
dates = pd.date_range('2020-01-01', '2023-12-31', freq='D')
values = 100 + np.cumsum(np.random.randn(len(dates)) * 0.5) + 10 * np.sin(np.arange(len(dates)) * 2 * np.pi / 365)

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

# Initialize and fit model
model = Prophet()
model.fit(df)

# Cross-validation
df_cv = cross_validation(
    model, 
    initial='730 days',  # Use first 2 years for training
    period='180 days',   # Every 6 months
    horizon='90 days',   # Forecast 3 months ahead
    parallel="processes"
)

# Calculate performance metrics
df_performance = performance_metrics(df_cv)
print("Performance Metrics:")
print(df_performance.head())

# Plot cross-validation metrics
fig = plot_cross_validation_metric(df_cv, metric='mape')
plt.title('Mean Absolute Percentage Error')
plt.show()

# Manual evaluation
def evaluate_model(model, df, test_size=0.2):
    # Split data
    split_point = int(len(df) * (1 - test_size))
    train_df = df[:split_point]
    test_df = df[split_point:]
    
    # Fit model on training data
    model.fit(train_df)
    
    # Make predictions for test period
    future = model.make_future_dataframe(periods=len(test_df))
    forecast = model.predict(future)
    
    # Get predictions for test period
    test_forecast = forecast[split_point:].reset_index(drop=True)
    
    # Calculate metrics
    mae = np.mean(np.abs(test_df['y'] - test_forecast['yhat']))
    mape = np.mean(np.abs((test_df['y'] - test_forecast['yhat']) / test_df['y'])) * 100
    rmse = np.sqrt(np.mean((test_df['y'] - test_forecast['yhat'])**2))
    
    print(f"MAE: {mae:.2f}")
    print(f"MAPE: {mape:.2f}%")
    print(f"RMSE: {rmse:.2f}")
    
    return mae, mape, rmse

# Evaluate model
mae, mape, rmse = evaluate_model(model, df)

Quick Reference

Key Parameters:

• yearly_seasonality - Enable yearly patterns
• weekly_seasonality - Enable weekly patterns
• daily_seasonality - Enable daily patterns
• seasonality_mode - 'additive' or 'multiplicative'
• changepoint_prior_scale - Trend flexibility
• seasonality_prior_scale - Seasonality strength

Common Methods:

• fit() - Train the model
• predict() - Make forecasts
• plot() - Plot forecast
• plot_components() - Plot components
• add_seasonality() - Custom seasonality
• add_regressor() - External variables