Prophet vs. Neural Forecasting: A Real Comparison

Two philosophies of forecasting

Prophet decomposes a series into trend, seasonality and holiday effects, fits them as a structural model, and hands you interpretable components. Neural forecasters learn a mapping from a window of history to a window of the future, usually across many related series at once. They fail in different ways, and that difference is the whole story.

1. Where Prophet-style models shine

• A single series, or a handful, with clear weekly and yearly seasonality.
• Strong known calendar effects — holidays, promotions, campaign windows you can encode directly.
• Short histories where a deep model has nothing to learn from.
• Stakeholders who need to see why the forecast moved. Component plots are a genuine business feature.
• Fast iteration: fits in seconds, no GPU, few decisions to get wrong.

2. Where neural forecasters pull ahead

• Hundreds or thousands of related series — cross-learning across them is the single biggest advantage.
• Rich exogenous inputs: prices, weather, inventory, upstream demand signals.
• Non-additive interactions, such as a promotion whose effect depends on the season and the channel.
• Long horizons where errors compound and direct multi-step forecasting beats recursion.
• Probabilistic requirements met by quantile heads rather than parametric intervals.

3. The baseline both must beat

Before either model, fit seasonal naive: the forecast for next Tuesday is last Tuesday. On many real retail and traffic series it is embarrassingly hard to beat, and it makes error numbers interpretable through MASE — a scale-free ratio against that baseline.

from math import sin, pi

# Synthetic daily series: weekly seasonality + gentle trend
series = [100 + 5 * i / 30.0 + 12 * sin(2 * pi * (i % 7) / 7) for i in range(120)]
season = 7
horizon = 14
train, test = series[:-horizon], series[-horizon:]

def seasonal_naive(train, horizon, season):
    return [train[-season + (i % season)] for i in range(horizon)]

def mae(actual, pred):
    return sum(abs(a - p) for a, p in zip(actual, pred)) / len(actual)

def mase(actual, pred, train, season):
    naive_error = sum(abs(train[i] - train[i - season])
                      for i in range(season, len(train))) / (len(train) - season)
    return mae(actual, pred) / naive_error

pred = seasonal_naive(train, horizon, season)
print("Seasonal naive MAE : %.3f" % mae(test, pred))
print("Seasonal naive MASE: %.3f" % mase(test, pred, train, season))
print()
print("MASE below 1.0 means you beat the naive benchmark. Anything above it means stop.")

4. Evaluating like the forecast will be used

A random train/test split on time series is simply wrong. Use rolling-origin (backtesting) evaluation: train up to a cutoff, forecast the horizon, roll the cutoff forward, repeat. Average across all origins, and report per-horizon errors — a model that is excellent at day 1 and useless at day 14 is not an excellent model if you plan two weeks ahead.

from math import sin, pi

series = [100 + 5 * i / 30.0 + 12 * sin(2 * pi * (i % 7) / 7) for i in range(140)]
season, horizon = 7, 7

def seasonal_naive(train, horizon, season):
    return [train[-season + (i % season)] for i in range(horizon)]

def drift_naive(train, horizon):
    slope = (train[-1] - train[0]) / (len(train) - 1)
    return [train[-1] + slope * (i + 1) for i in range(horizon)]

origins = range(90, len(series) - horizon, 7)
for name, model in [("seasonal", seasonal_naive), ("drift", drift_naive)]:
    errors = []
    for cutoff in origins:
        train, actual = series[:cutoff], series[cutoff:cutoff + horizon]
        pred = model(train, horizon, season) if name == "seasonal" else model(train, horizon)
        errors.append(sum(abs(a - p) for a, p in zip(actual, pred)) / horizon)
    print("%-9s folds=%d mean MAE=%.3f worst fold=%.3f" %
          (name, len(errors), sum(errors) / len(errors), max(errors)))
print()
print("Report the worst fold too. Averages hide the week your forecast fell apart.")

5. Caveats worth internalising

• Prophet will happily extrapolate a trend off a cliff. Cap it, or use a damped trend, whenever the quantity is physically bounded.
• Neural forecasters need scaling per series and careful handling of intermittent zeros — count data breaks naive normalisation.
• Data leakage in time series is subtle: any feature computed with future information (a full-history mean, a target encoding) invalidates the whole backtest.
• Retraining cadence is part of the model. A weekly-retrained simple model often beats a quarterly-retrained sophisticated one.
• Forecast intervals are usually the deliverable. Point forecasts alone rarely change a decision.

How to choose

Few series, clear seasonality, explanation required: structural models like Prophet. Many related series, rich covariates, accuracy is the product: neural forecasters. In both cases the seasonal naive baseline and rolling-origin backtesting decide the argument — not the architecture's reputation.