Forward in Time: Mastering Seasonal and Trend Forecasting#

What Is a Time Series?#

A time series is a sequence of data points collected over time in a specific order. Examples include daily stock prices, monthly temperature readings, quarterly revenue figures, or even hourly website traffic. The key feature of a time series is that the data points are dependent on their order, meaning the value at time ( t ) often depends on values at times close to ( t ).

Understanding time series data requires distinguishing it from cross-sectional data (data collected at one point in time across multiple subjects) and from panel data (a combination of time series and cross-sectional data where multiple subjects are tracked over time).

Key Components of Time Series#

When you look at a time series, three major components typically stand out:

1. Trend: The overall upward or downward movement of the series.
2. Seasonality: Regular variations that take place in fixed periods (daily, weekly, monthly, yearly, etc.).
3. Random (Error) Component: Unpredictable variation that cannot be easily explained by trend or seasonality.

Some series will also show cyclic patterns, which resemble seasonality but do not follow a fixed calendar-based cycle and often correspond to business or economic cycles.

Seasonality and Its Significance#

Seasonality is a repeating pattern in a time series that occurs at regular intervals. For instance:

• Retail sales often spike in December (holiday season).
• Electricity consumption might peak during summer months due to air conditioning usage.
• Website traffic might follow daily or weekly cycles.

Why it matters: Capturing seasonality effectively is vital because failing to account for repeating patterns leads to inaccuracies in forecasting. If your model ignores a known seasonal pattern, it might draw incorrect conclusions about the ongoing trend or the random noise.

Trend in Time Series#

A trend represents the overall direction of the data over an extended time period. A trend can be:

• Upward (values increase over time),
• Downward (values decrease over time),
• Flat or Zero Trend (values remain fairly constant).

Trends can take different forms, such as linear, exponential, or logistic. Before applying complex models, its helpful to perform a visual inspection of your time series by plotting it. Identifying a raw upward or downward slope can quickly tell you that a trend component is present.

Cyclicality vs. Seasonality#

Cyclic behavior is often confused with seasonality, but the two are not identical:

• Seasonality is strictly based on known and fixed periods (e.g., 12 months in a year, 7 days in a week).
• Cyclic behavior sees repeated, irregular fluctuations that do not adhere to a fixed interval. Economic cycles, for instance, may repeat but do so over varying, non-uniform time spans.

Naive Forecasting#

One of the simplest forecasting methods is the naive approach, which basically states:

• Naive Forecast 1: The forecast for tomorrow is the same as todays value.
• Naive Forecast with Seasonality: The forecast for the next period is the same as the period from one full season in the past. For instance, if you know your data has a weekly seasonality, then the forecast for next Monday would be the actual value from the most recent Monday.

While naive forecasts are simplistic, they often serve as competitive benchmarks. If sophisticated models cant outperform the naive approach, it suggests either a low signal-to-noise ratio in the data or that the model is not tuned effectively.

Moving Average Smoothing#

The simple moving average (SMA) is: [ \text{SMA}t = \frac{y_t + y{t-1} + \dots + y_{t-n+1}}{n} ] where ( n ) is the number of observations to average. This technique addresses short-term fluctuations by smoothing out the data. However, it doesnt inherently handle seasonality or complex trends.

Exponential Smoothing#

Exponential smoothing gives more weight to recent observations and less weight to older observations. The simplest form is given by: [ \hat{y}_{t+1} = \alpha y_t + (1 - \alpha)\hat{y}_t ] where ( 0 < \alpha < 1 ). More sophisticated forms such as Holts linear trend method or Holt-Winters (HW) exponential smoothing extend the idea to include trend and seasonality.

ARIMA Models#

ARIMA stands for AutoRegressive Integrated Moving Average. The structure is often denoted as ARIMA((p, d, q)):

• (p) = Order of the autoregressive part (the number of lagged observations included).
• (d) = Degree of differencing (how many times the data is differenced to remove trend).
• (q) = Order of the moving average part (the number of lagged forecast errors included).

ARIMA models assume stationarity (mean, variance, and autocorrelation structure are stable over time). Non-stationary data often needs to be differenced (which is what the ( d ) in ARIMA handles) to make it approximately stationary.

SARIMA and SARIMAX#

When seasonality is present, we often use SARIMA (Seasonal ARIMA), structured as ARIMA((p, d, q)) x ((P, D, Q))(_m), where (m) is the seasonal period. The letters (P, D, Q) represent the seasonal autoregressive, differencing, and moving average terms respectively.

• SARIMAX extends SARIMA by adding eXogenous variables. If we have external factors that help forecast our time series (like holidays or other regressors), we can incorporate them into the model.

Additive and Multiplicative Decomposition#

Time series decomposition involves splitting a series ( Y ) into three parts: trend ((T)), seasonality ((S)), and residual ((R)):

• Additive: ( Y = T + S + R )
• Multiplicative: ( Y = T \times S \times R )

In practice, multiplicative decomposition is often used when the magnitude of the seasonal effect grows with the level of the series. When the seasonal effect is roughly constant across time, an additive approach may be sufficient.

Data Preparation#

Suppose we have a CSV file named “monthly_sales.csv” with two columns: “date” (YYYY-MM format) and “sales”:

1
import pandas as pd
2

3
# Read the CSV
4
df = pd.read_csv("monthly_sales.csv", parse_dates=["date"])
5
df.set_index("date", inplace=True)
6

7
# Quick inspection
8
print(df.head())
9
print(df.describe())
10

11
# Let's assume our data has a monthly frequency
12
df = df.asfreq("MS")  # MS stands for Month Start

Exploratory Analysis#

Before any modeling, plot the time series to see if there is an obvious trend or seasonality:

1
import matplotlib.pyplot as plt
2

3
plt.figure(figsize=(10, 4))
4
plt.plot(df["sales"], marker='o')
5
plt.title("Monthly Sales")
6
plt.ylabel("Sales")
7
plt.xlabel("Date")
8
plt.show()

You might notice a clear seasonal pattern with peaks and troughs repeating each year. This suggests we should explore a seasonal model.

Modeling with SARIMA#

We can use the statsmodels library to fit a SARIMA model:

1
import itertools
2
import statsmodels.api as sm
3

4
# We'll define a function to find the best SARIMA parameters
5
p = d = q = range(0, 2)
6
P = D = Q = range(0, 2)
7
seasonal_period = 12
8

9
pdq = list(itertools.product(p, d, q))
10
seasonal_pdq = [
11
    (x[0], x[1], x[2], seasonal_period)
12
    for x in list(itertools.product(P, D, Q))
13
]
14

15
best_aic = float("inf")
16
best_params = None
17
best_seasonal_params = None
18

19
for param in pdq:
20
    for sparam in seasonal_pdq:
21
        try:
22
            model = sm.tsa.statespace.SARIMAX(
23
                df["sales"],
24
                order=param,
25
                seasonal_order=sparam,
26
                enforce_stationarity=False,
27
                enforce_invertibility=False
28
            )
29
            results = model.fit(disp=False)
30
            if results.aic < best_aic:
31
                best_aic = results.aic
32
                best_params = param
33
                best_seasonal_params = sparam
34
        except:
35
            continue
36

37
print("Best ARIMA params:", best_params)
38
print("Best Seasonal params:", best_seasonal_params)
39
print("Best AIC:", best_aic)

This grid search tries different combinations of ( p, d, q ) for the non-seasonal part and ( P, D, Q ) for the seasonal part. It reports the best combination based on the AIC (Akaike Information Criterion), which is a way to measure the models quality while accounting for complexity.

After identifying the best parameters, we can fit the final model:

1
final_model = sm.tsa.statespace.SARIMAX(
2
    df["sales"],
3
    order=best_params,
4
    seasonal_order=best_seasonal_params,
5
    enforce_stationarity=False,
6
    enforce_invertibility=False
7
).fit(disp=False)
8

9
print(final_model.summary())

Model Evaluation and Diagnostics#

Diagnostic plots can help you evaluate how well the model captured the dependencies in the data:

1
final_model.plot_diagnostics(figsize=(12, 8))
2
plt.show()

Look for:

• Standardized Residuals: Should be randomly distributed, centered around zero.
• Autocorrelation (ACF) of Residuals: Significant autocorrelation in residuals suggests a pattern remains unmodeled.
• Normal Q-Q Plot: Residuals should be roughly along the 45-degree line if they are normally distributed.
• Probability Plot: Similar to Q-Q but more general.

You can then create forecasts:

1
forecast_steps = 12
2
forecast_results = final_model.get_forecast(steps=forecast_steps)
3
forecast_df = forecast_results.conf_int()
4
forecast_df["forecast"] = final_model.predict(
5
    start=forecast_df.index[0],
6
    end=forecast_df.index[-1]
7
)
8

9
# Plot
10
plt.figure(figsize=(10, 4))
11
plt.plot(df["sales"], label="Actual")
12
plt.plot(forecast_df["forecast"], label="Forecast", color="red")
13
plt.fill_between(
14
    forecast_df.index,
15
    forecast_df["lower sales"],
16
    forecast_df["upper sales"], color="pink", alpha=0.3
17
)
18
plt.legend()
19
plt.show()

State Space Models (ETS)#

The term ETS refers to Error, Trend, and Seasonality. State space models for exponential smoothing, often called ETS models, are robust in handling trending and seasonal data. They build on the idea of exponential smoothing but in a more systematic framework. Libraries like statsmodels and other specialized toolkits allow fitting ETS models.

One advantage of these models over ARIMA is that they handle out-of-sample forecasting of complex seasonal patterns more intuitively. ETS is often used for univariate data where you focus heavily on capturing different types of seasonality and trends with a well-tuned exponential smoothing approach.

Vector Autoregression (VAR) for Multivariate Series#

In many real-world scenarios, your time series depends on multiple variables. If you have two or more related series, a Vector Autoregression (VAR) model can be effective. Unlike univariate ARIMA, VAR can handle multiple input series and capture interdependencies (e.g., how one series affects or is affected by another).

To fit a VAR model with statsmodels:

1
from statsmodels.tsa.vector_ar.var_model import VAR
2

3
# Assume we have multiple columns in df (e.g., df["sales"] and df["temperature"])
4
df_multi = df[["sales", "temperature"]].dropna()
5

6
model_var = VAR(df_multi)
7
results_var = model_var.fit(maxlags=15, ic='aic')  # Choose `ic` to let the model pick best lags
8
print(results_var.summary())
9

10
# Forecasting
11
lag_order = results_var.k_ar
12
forecast_input = df_multi.values[-lag_order:]
13
forecast_var = results_var.forecast(y=forecast_input, steps=12)

Machine Learning and Forecasting#

Time series forecasting can benefit from machine learning models like random forests, gradient boosting, or neural networks. These methods:

• Can capture non-linear patterns.
• Often require thorough feature engineering (lags, rolling means, external factors).
• Do not rely on stationarity in the same way ARIMA does.

However, watch out for cross-validation pitfalls. Time series data must be split in a way that respects the time order (e.g., walk-forward validation).

When Multiple Frequencies Matter#

Some datasets exhibit multiple seasonal periods encompassed in the same time series. For instance, if you analyze daily timeseries data for a business, you might see:

• A weekly pattern (frequency of 7 days).
• Perhaps a large annual pattern (365 days).
• Periodic events or moving holidays.

Effectively capturing both short-term and long-term seasonalities can be challenging with traditional SARIMA alone.

Time Series Decomposition Review#

To handle multiple seasonalities, advanced decomposition or specialized tooling may be required. Some decomposition libraries allow specifying multiple frequencies. Alternatively, you can use methods like TBATS (Exponential smoothing state space model with Box-Cox transformation, ARMA errors, trend, and seasonal components), which is implemented in various statistical packages.

Quick Start with Prophet#

Installation typically requires:

1
pip install prophet

(Ensure you have a proper environment set up, as Prophet can have dependencies on pystan or cmdstanpy.)

A quick code example:

1
from prophet import Prophet
2
import pandas as pd
3

4
# For Prophet, rename columns to "ds" (date) and "y" (value)
5
prophet_df = df.reset_index()[["date", "sales"]]
6
prophet_df.columns = ["ds", "y"]
7

8
model = Prophet(yearly_seasonality=True, weekly_seasonality=False, daily_seasonality=False)
9
model.fit(prophet_df)
10

11
# Create future dataframe for 12 months
12
future = model.make_future_dataframe(periods=12, freq='MS')
13
forecast = model.predict(future)
14

15
model.plot(forecast)

Prophets Advanced Settings#

Prophet also provides functionalities such as:

• Add regressors (like promotions or price changes).
• Advanced seasonalities (like weekly or daily).
• Holiday effects (including custom holiday definitions).

To add a custom regressor:

1
model = Prophet()
2
model.add_regressor('some_external_factor')
3
# Make sure 'some_external_factor' is present in your training data
4
model.fit(prophet_df_with_regressor)

Recurrent Neural Networks (RNN)#

Traditional RNNs maintain a hidden state as they iterate over time steps, which helps them process sequences. However, vanishing or exploding gradients can be an issue for longer sequences.

LSTM and GRU for Time Series#

Long Short-Term Memory (LSTM) and Gated Recurrent Units (GRU) are designed to handle long-term dependencies more effectively than vanilla RNNs.

An example (using Keras) for a univariate forecasting:

1
import numpy as np
2
from tensorflow.keras.models import Sequential
3
from tensorflow.keras.layers import LSTM, Dense
4

5
# Suppose we have a window of past 12 months to predict the next month.
6
timesteps = 12
7

8
# Convert series to supervised learning
9
data = df["sales"].values
10
X, y = [], []
11
for i in range(len(data) - timesteps):
12
    X.append(data[i:i+timesteps])
13
    y.append(data[i+timesteps])
14

15
X, y = np.array(X), np.array(y)
16
X = np.reshape(X, (X.shape[0], X.shape[1], 1))
17

18
# Build LSTM model
19
model = Sequential()
20
model.add(LSTM(50, activation='relu', input_shape=(timesteps, 1)))
21
model.add(Dense(1))
22
model.compile(optimizer='adam', loss='mse')
23

24
model.fit(X, y, epochs=50, batch_size=32, verbose=1)
25

26
# Inference for next step
27
seed_data = data[-timesteps:]
28
seed_data = seed_data.reshape((1, timesteps, 1))
29
predicted = model.predict(seed_data)
30
print("Predicted Value:", predicted[0][0])

Hybrid Models and Future Trends#

Some practitioners combine statistical models (like ARIMA or ETS) with neural network outputs, resulting in hybrid models. Hybrid models might use the neural network to capture complex non-linearities and the statistical model to capture well-understood seasonal or trend structures. This is an active area of research, so expect continuous development.