Stationarity in Time Series — ADF, KPSS, Differencing & Log Transformation

The Story That Explains Stationarity

Every classical time series model — AR, MA, ARMA, ARIMA — ultimately relies on stationarity. Models that assume the canal find the wild river unworkable. Before fitting any model, the single most important question you must answer is: "Is my series stationary?" This tutorial gives you the complete toolkit to answer it.

What Stationarity Actually Means

Stationarity is not one single condition — it comes in two flavours with very different practical implications. Understanding the distinction is essential before running any test.

Weak vs Strict Stationarity — Side by Side

Why Stationarity Matters — The Consequences of Ignoring It

Types of Non-Stationarity — Know Your Enemy

Non-stationarity is not a single problem — it has four distinct flavours, each requiring a different cure. Misdiagnosing the type leads to the wrong treatment.

The ADF Test — Augmented Dickey-Fuller

The KPSS Test — Flipping the Burden of Proof

The ADF test can fail to reject H₀ (non-stationarity) simply because it lacks statistical power — especially with short series. The KPSS test (Kwiatkowski-Phillips-Schmidt-Shin) reverses the hypothesis: it assumes stationarity by default and tests whether there is evidence against it.

ADF & KPSS in Python — Full Workflow

# ─── 0. Imports ──────────────────────────────────────────────────────────────
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

from statsmodels.tsa.stattools import adfuller, kpss

# ─── 1. Create two test series ───────────────────────────────────────────────
np.random.seed(42)
n = 300

# Non-stationary: random walk (unit root)
rw = np.cumsum(np.random.normal(0, 1, n))
rw_series = pd.Series(rw, name='Random Walk')

# Stationary: AR(1) with φ=0.7
ar = np.zeros(n)
for t in range(1, n):
    ar[t] = 0.7 * ar[t-1] + np.random.normal(0, 1)
ar_series = pd.Series(ar, name='AR(1) φ=0.7')

# ─── 2. Reusable test function ────────────────────────────────────────────────
def run_stationarity_tests(series, name=""):
    print(f"\n{'─'*54}")
    print(f" Series: {name}")
    print(f"{'─'*54}")

    # ── ADF (H₀: unit root / non-stationary) ──
    adf_stat, adf_p, adf_lags, _, adf_crit, _ = adfuller(series, autolag='AIC')
    print(f"\n[ADF Test]  H₀: unit root (non-stationary)")
    print(f"  ADF Stat  : {adf_stat:>10.4f}")
    print(f"  p-value   : {adf_p:>10.6f}")
    print(f"  Crit 1%   : {adf_crit['1%']:>10.4f}")
    print(f"  Crit 5%   : {adf_crit['5%']:>10.4f}")
    print(f"  Lags used : {adf_lags}")
    adf_conc = 'STATIONARY ✓' if adf_p < 0.05 else 'NON-STATIONARY ✗'
    print(f"  Verdict   : {adf_conc}")

    # ── KPSS (H₀: stationary) ──
    kpss_stat, kpss_p, kpss_lags, kpss_crit = kpss(series, regression='c', nlags='auto')
    print(f"\n[KPSS Test] H₀: stationary")
    print(f"  KPSS Stat : {kpss_stat:>10.4f}")
    print(f"  p-value   : {kpss_p:>10.4f}")
    print(f"  Crit 5%   : {kpss_crit['5%']:>10.4f}")
    kpss_conc = 'NON-STATIONARY ✗' if kpss_p < 0.05 else 'STATIONARY ✓'
    print(f"  Verdict   : {kpss_conc}")

    # Combined conclusion
    if adf_p < 0.05 and kpss_p > 0.05:
        combined = "✅ BOTH AGREE: STATIONARY"
    elif adf_p > 0.05 and kpss_p < 0.05:
        combined = "❌ BOTH AGREE: NON-STATIONARY"
    elif adf_p < 0.05 and kpss_p < 0.05:
        combined = "⚠️  TREND-STATIONARY (disagree)"
    else:
        combined = "⚠️  INCONCLUSIVE (disagree)"
    print(f"\n  Combined  : {combined}")

run_stationarity_tests(rw_series, "Random Walk")
run_stationarity_tests(ar_series, "AR(1) φ=0.7")

Differencing — The Most Powerful Stationarity Fix

Log Transformation — Taming Growing Variance

The Complete Stationarity Pipeline in Python

We now build the full end-to-end workflow: generate a non-stationary series with both trend and growing variance, apply log transformation, apply first differencing, verify stationarity at each step.

# ─── 1. Generate realistic non-stationary series ─────────────────────────────
# Simulates GDP-like data: exponential growth + seasonal pattern + noise
np.random.seed(99)
n = 240   # 20 years of monthly data

t        = np.arange(n)
trend    = 100 * np.exp(0.008 * t)                     # exponential growth
seasonal = 10  * np.sin(2 * np.pi * t / 12)            # yearly cycle
noise    = trend * 0.04 * np.random.randn(n)             # proportional noise

raw = pd.Series(trend + seasonal + noise,
                index=pd.date_range('2000-01-01', periods=n, freq='MS'),
                name='Simulated GDP-like Series')

print(f"Shape: {raw.shape}")
print(f"Range: {raw.min():.1f}  to  {raw.max():.1f}")

# ─── 2. Step-by-step transformation pipeline ─────────────────────────────────
stages = {}
stages['1_raw']       = raw
stages['2_log']       = np.log(raw)
stages['3_log_diff']  = np.log(raw).diff().dropna()
stages['4_seas_diff'] = stages['3_log_diff'].diff(12).dropna()

print(f"{'Stage':<22} {'ADF p':>10}  {'KPSS p':>10}  {'Verdict'}")
print("-" * 65)

for label, s in stages.items():
    adf_p = adfuller(s, autolag='AIC')[1]
    kpss_p = kpss(s, regression='c', nlags='auto')[1]

    if adf_p < 0.05 and kpss_p > 0.05:
        verdict = "✅ STATIONARY"
    elif adf_p > 0.05 and kpss_p < 0.05:
        verdict = "❌ NON-STATIONARY"
    else:
        verdict = "⚠️  INCONCLUSIVE"

    print(f"{label:<22} {adf_p:>10.4f}  {kpss_p:>10.4f}  {verdict}")

# ─── 3. Detailed ADF on final stationary series ──────────────────────────────
final_series = stages['3_log_diff']
run_stationarity_tests(final_series, "Log-Differenced GDP-like Series")

# ─── 4. Verify: mean, variance, and ACF are stable ───────────────────────────
# Split into three equal thirds and compare statistics
thirds = np.array_split(final_series, 3)
print(f"\n{'Period':<10} {'Mean':>10} {'Std Dev':>12} {'Min':>10} {'Max':>10}")
print("-" * 56)
for i, seg in enumerate(thirds, 1):
    print(f"Period {i}   {seg.mean():>10.5f} {seg.std():>12.5f} {seg.min():>10.5f} {seg.max():>10.5f}")

# ─── 5. Visual comparison of all four stages ─────────────────────────────────
fig, axes = plt.subplots(4, 1, figsize=(12, 10))

titles = [
    '① Raw Series — exponential trend + growing variance (NON-STATIONARY)',
    '② After log() — growth linearised, variance still rising (NON-STATIONARY)',
    '③ After log + diff() — stationary! (STATIONARY ✓)',
    '④ After log + diff + seasonal diff — removes seasonal pattern too'
]

colors = ['#f87171', '#f59e0b', '#34d399', '#60a5fa']

for ax, (label, s), title, color in zip(axes, stages.items(), titles, colors):
    s.plot(ax=ax, color=color, linewidth=1.2)
    ax.axhline(s.mean(), color=color, linestyle='--', alpha=0.6, linewidth=1)
    ax.set_title(title, fontsize=9, pad=4)
    ax.set_facecolor('#0d1117')
    ax.spines['bottom'].set_color('#2a3050')
    ax.spines['left'].set_color('#2a3050')

plt.tight_layout(pad=1.5)
plt.savefig('stationarity_pipeline.png', dpi=120, facecolor='#0d1117')
plt.show()

Stationarity Tests — Complete Comparison

Transformation Reference — What Each Fix Does

Golden Rules — Stationarity in Practice