Advanced

Time Series Best Practices

Deploy forecasting models to production, monitor for drift, use ensemble methods, and learn from real-world case studies.

Production Deployment

Automate retraining
Schedule regular model retraining (daily, weekly) as new data arrives. Stale models degrade quickly.
Serve predictions via API
Wrap your model in a REST API. Return predictions with confidence intervals and metadata.
Store forecasts
Log every forecast with its timestamp, model version, and input data for retrospective analysis.
Monitor accuracy
Continuously compare forecasts against actuals and alert when error exceeds thresholds.

Monitoring Forecast Drift

Python - Monitoring forecast accuracy

import pandas as pd
import numpy as np

def monitor_forecast(actuals, forecasts, threshold_mape=15.0):
    """Monitor forecast accuracy and alert on degradation."""
    errors = np.abs((actuals - forecasts) / actuals) * 100
    rolling_mape = pd.Series(errors).rolling(window=7).mean()

    alerts = []
    if rolling_mape.iloc[-1] > threshold_mape:
        alerts.append({
            'type': 'HIGH_ERROR',
            'message': f"7-day rolling MAPE is {rolling_mape.iloc[-1]:.1f}%",
            'action': 'Consider retraining the model'
        })

    # Check for systematic bias
    bias = np.mean(actuals - forecasts)
    if abs(bias) > np.std(actuals) * 0.5:
        alerts.append({
            'type': 'SYSTEMATIC_BIAS',
            'message': f"Mean forecast bias: {bias:.2f}",
            'action': 'Model consistently over/under-predicts'
        })

    return alerts

Ensemble Methods

Combining multiple forecasting models often produces more robust predictions than any single model.

Python - Forecast ensembling

# Simple average ensemble
ensemble_forecast = (arima_pred + prophet_pred + lstm_pred) / 3

# Weighted average (weights from validation performance)
weights = np.array([0.3, 0.5, 0.2])  # Prophet best on validation
ensemble_forecast = (
    weights[0] * arima_pred +
    weights[1] * prophet_pred +
    weights[2] * lstm_pred
)

# Stacking: train a meta-model on base model predictions
from sklearn.linear_model import Ridge
meta_features = np.column_stack([arima_val, prophet_val, lstm_val])
meta_model = Ridge().fit(meta_features, y_val)
ensemble_forecast = meta_model.predict(
    np.column_stack([arima_pred, prophet_pred, lstm_pred])
)

Real-World Case Studies

📈

Stock Price Forecasting

Combine technical indicators (RSI, MACD) with LSTM networks. Focus on directional accuracy rather than exact price prediction. Include market sentiment as external features.

🌦

Weather Forecasting

Use spatial-temporal models. Ensemble multiple models (physics-based + ML). Short-range (1-3 days) achievable with LSTM; longer ranges need large-scale models.

🛒

Demand Forecasting

Prophet with holiday effects and promotions as regressors. Hierarchical forecasting for multi-store scenarios. Focus on MAPE and bias metrics for inventory planning.

Common Pitfalls

⚠

Using random train/test splits: Always split chronologically. Never shuffle time series data.
Look-ahead bias: Using future information in features (centered moving averages, future lags).
Ignoring uncertainty: Always provide confidence intervals, not just point forecasts.
Overfitting to noise: Complex models with many parameters overfit small time series. Start simple.
Not retraining: Time series patterns change. A model trained once will degrade over time.

Frequently Asked Questions

As a rule of thumb: at least 2-3 full seasonal cycles. For monthly data with yearly seasonality, you need 2-3 years minimum. For daily data with weekly patterns, at least 2-3 months. More data is generally better, but very old data may not reflect current patterns.

Market prices are notoriously difficult to forecast due to the efficient market hypothesis. You can predict volatility and directional trends better than exact prices. Never trust a model that claims to consistently predict exact stock prices - if it worked, everyone would use it and the edge would disappear.

Start with classical methods (ARIMA, exponential smoothing) as baselines. Use deep learning when you have large datasets, multivariate inputs, or complex non-linear patterns that classical methods cannot capture. In competitions, ensembles combining both approaches often win.