Module 21: Macroeconomics for Statisticians

Macroeconomics studies the economy as a whole — aggregate output, price levels, employment, and the policy levers that influence them. For a statistician, macroeconomics is a treasure trove of time series, ratio estimators, index numbers, structural breaks, and causal inference challenges. This module translates the core macro concepts into the statistical language you already speak.

21.1 — GDP as a Time Series

Gross Domestic Product (GDP) is the single most important macroeconomic indicator. It measures the total market value of all final goods and services produced in a country over a given period. From a statistical perspective, GDP is a quarterly time series with trend, seasonal, and cyclical components.

The GDP Deflator and Chain-Weighting

The conversion from nominal to real GDP requires a price index. The GDP deflator is implicitly defined as:

Modern GDP calculations use chain-weighting, which updates the base-year weights every period rather than fixing them. This avoids the substitution bias inherent in fixed-weight indices (Laspeyres bias).

Seasonal Adjustment: The X-13 ARIMA-SEATS Filter

Raw GDP data has strong seasonal patterns (e.g., holiday spending in Q4). The Bureau of Economic Analysis (BEA) uses the Census Bureau's X-13 ARIMA-SEATS method to remove seasonal components. This is a sophisticated decomposition:

The seasonally adjusted series removes S_t, leaving the trend-cycle and irregular components. The annualized quarter-over-quarter growth rate that gets reported in the news is:

Trend vs. Cycle: The Hodrick-Prescott Filter

Separating the long-run trend from the business cycle is a fundamental problem in macroeconometrics. The most widely used (and most criticized) method is the Hodrick-Prescott (HP) filter.

The HP filter solves the optimization problem:

where τ_t is the trend, y_t is the observed series, and λ controls the smoothness of the trend. For quarterly data, the standard choice is λ = 1600.

Python
# Download and decompose real GDP using FRED
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pandas_datareader import data as pdr

# Download Real GDP from FRED
gdp = pdr.get_data_fred("GDPC1", start="1970-01-01")
gdp.columns = ["real_gdp"]
gdp["log_gdp"] = np.log(gdp["real_gdp"])

# Hodrick-Prescott Filter
from statsmodels.tsa.filters.hp_filter import hpfilter

cycle, trend = hpfilter(gdp["log_gdp"].dropna(), lamb=1600)

# Hamilton (2018) alternative: regress y_t on y_{t-8}
from statsmodels.api import OLS, add_constant
y = gdp["log_gdp"].dropna()
y_lag8 = y.shift(8).dropna()
y_aligned = y.loc[y_lag8.index]
X = add_constant(y_lag8)
hamilton_model = OLS(y_aligned, X).fit()
hamilton_cycle = hamilton_model.resid

# Compute annualized growth rates
gdp["growth_qoq"] = gdp["real_gdp"].pct_change()
gdp["growth_annual"] = ((1 + gdp["growth_qoq"]) ** 4 - 1) * 100

print("Real GDP Time Series Analysis")
print("=" * 50)
print(f"Sample: {gdp.index[0].date()} to {gdp.index[-1].date()}")
print(f"Observations: {len(gdp)}")
print(f"Mean annualized growth: {gdp['growth_annual'].mean():.1f}%")
print(f"Std of annualized growth: {gdp['growth_annual'].std():.1f}%")
print(f"\nHP cycle std: {cycle.std():.4f}")
print(f"Hamilton cycle std: {hamilton_cycle.std():.4f}")

21.2 — Inflation: The CPI as a Weighted Price Index

Inflation measures the rate of change of the general price level. The Consumer Price Index (CPI) is the most widely followed measure, but its construction involves substantial statistical methodology that most people never consider.

CPI Construction: A Laspeyres Index

The CPI is fundamentally a modified Laspeyres price index:

where w_i,0 are base-period expenditure weights and p_i,t / p_i,0 are the price relatives. The weights come from the Consumer Expenditure Survey (CE survey) and are updated approximately every two years.

Core vs. Headline: Signal Extraction

Core CPI excludes food and energy because they are volatile and driven by supply shocks rather than underlying demand. From a statistical perspective, core CPI is a trimmed or filtered estimator that attempts to extract the persistent signal from the noisy headline measure.

Even more aggressive filtering exists: the Cleveland Fed Median CPI (the median component price change) and the Cleveland Fed 16% Trimmed-Mean CPI (excludes the top and bottom 8% of component price changes). These are robust estimators of central tendency applied to the cross-section of price changes.

CPI vs. PCE: Why the Fed Prefers PCE

Python
# Download and compare inflation measures from FRED
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pandas_datareader import data as pdr

# FRED series codes
series = {
    "CPI (All Items)": "CPIAUCSL",
    "Core CPI": "CPILFESL",
    "PCE": "PCEPI",
    "Core PCE": "PCEPILFE",
}

inflation = pd.DataFrame()
for name, code in series.items():
    df = pdr.get_data_fred(code, start="2000-01-01")
    # Compute year-over-year percent change
    inflation[name] = df.iloc[:, 0].pct_change(12) * 100

inflation = inflation.dropna()

print("Inflation Measures Comparison")
print("=" * 55)
print(inflation.describe().round(2).to_string())

print(f"\nCorrelation Matrix:")
print(inflation.corr().round(3).to_string())

# Difference between CPI and PCE
print(f"\nMean CPI - PCE gap: {(inflation['CPI (All Items)'] - inflation['PCE']).mean():.2f}pp")
print(f"Mean Core CPI - Core PCE gap: {(inflation['Core CPI'] - inflation['Core PCE']).mean():.2f}pp")

21.3 — The Unemployment Rate: A Ratio Estimator

The unemployment rate is one of the most politically sensitive and widely reported macroeconomic indicators. But few people understand that it is a survey-based ratio estimator with a specific sampling design, definitions, and margin of error.

The Current Population Survey (CPS)

The unemployment rate comes from the Current Population Survey (CPS), a monthly household survey of approximately 60,000 households conducted by the Census Bureau for the Bureau of Labor Statistics. Key statistical features:

• Sampling design: Stratified multi-stage probability sample with a 4-8-4 rotation scheme (interviewed for 4 months, out for 8, back for 4).
• Sample size: ~60,000 households, yielding ~100,000 individuals 16+.
• Standard error: The 90% confidence interval for the unemployment rate is approximately ±0.2 percentage points.
• Non-response: The CPS has a response rate of ~80%, with potential non-response bias.

Alternative Unemployment Measures: U-1 through U-6

Python
# Download and analyze unemployment data from FRED
import pandas as pd
import numpy as np
from pandas_datareader import data as pdr
import matplotlib.pyplot as plt

# Key labor market series
series = {
    "U-3 (Official)": "UNRATE",
    "U-6 (Broad)": "U6RATE",
    "Labor Force Participation": "CIVPART",
}

labor = pd.DataFrame()
for name, code in series.items():
    df = pdr.get_data_fred(code, start="1994-01-01")
    labor[name] = df.iloc[:, 0]

labor = labor.dropna()

print("Unemployment Rate: Statistical Summary")
print("=" * 55)
print(labor.describe().round(2).to_string())

# Margin of error analysis
latest_u3 = labor["U-3 (Official)"].iloc[-1]
se = 0.12  # approximate standard error
print(f"\nLatest U-3: {latest_u3:.1f}%")
print(f"90% CI: [{latest_u3 - 1.645*se:.1f}%, {latest_u3 + 1.645*se:.1f}%]")
print(f"A 0.1pp monthly change is often within sampling error.")

# U-6 / U-3 ratio over time
labor["U6_U3_ratio"] = labor["U-6 (Broad)"] / labor["U-3 (Official)"]
print(f"\nMean U-6/U-3 ratio: {labor['U6_U3_ratio'].mean():.2f}")
print(f"The broad measure is typically ~{labor['U6_U3_ratio'].mean():.1f}x the headline rate.")

21.4 — The Phillips Curve: A Scatterplot with History

The Phillips Curve posits an inverse relationship between inflation and unemployment: when unemployment is low, inflation tends to rise (and vice versa). This is one of the most debated empirical relationships in economics, and it provides an excellent case study in the instability of statistical relationships.

Testing the Phillips Curve

Python
# Test the Phillips Curve: inflation vs unemployment
import pandas as pd
import numpy as np
from pandas_datareader import data as pdr
import matplotlib.pyplot as plt
from scipy import stats

# Download data
unemp = pdr.get_data_fred("UNRATE", start="1960-01-01")
cpi = pdr.get_data_fred("CPIAUCSL", start="1960-01-01")
inflation = cpi.pct_change(12) * 100

# Merge on date
df = pd.DataFrame({
    "unemployment": unemp.iloc[:, 0],
    "inflation": inflation.iloc[:, 0]
}).dropna()

# Full sample regression
slope_full, intercept_full, r_full, p_full, se_full = stats.linregress(
    df["unemployment"], df["inflation"]
)

print("Phillips Curve: Full Sample (1960-present)")
print("=" * 50)
print(f"Slope: {slope_full:.3f} (se = {se_full:.3f})")
print(f"R-squared: {r_full**2:.3f}")
print(f"p-value: {p_full:.4f}")

# By decade: show parameter instability
decades = [
    ("1960s", "1960", "1970"),
    ("1970s", "1970", "1980"),
    ("1980s", "1980", "1990"),
    ("1990s", "1990", "2000"),
    ("2000s", "2000", "2010"),
    ("2010s", "2010", "2020"),
]

print(f"\n{'Decade':>8}  {'Slope':>8}  {'R-sq':>6}  {'p-val':>8}")
print("-" * 40)
for label, start, end in decades:
    subset = df.loc[start:end]
    if len(subset) < 10:
        continue
    s, i, r, p, se = stats.linregress(subset["unemployment"], subset["inflation"])
    print(f"{label:>8}  {s:>8.3f}  {r**2:>6.3f}  {p:>8.4f}")

print("\nThe slope changes dramatically by decade — parameter instability!")

21.5 — Central Bank Policy as Intervention Analysis

Central banks (the Federal Reserve in the US, ECB in Europe, Bank of Japan, etc.) are the most powerful economic actors. Their primary tool is the policy interest rate — the rate at which banks borrow overnight from each other. Changes in this rate ripple through the entire economy.

The Taylor Rule: A Predictive Model for Policy

The Taylor Rule (1993) is a simple regression-based prescription for setting the federal funds rate:

The Taylor Rule is essentially a linear regression of the policy rate on the inflation gap and the output gap. When the actual rate deviates from the Taylor Rule prescription, it indicates that the Fed is being more hawkish (rate above Taylor) or dovish (rate below).

Quantitative Easing (QE): When Rates Hit Zero

When the policy rate reaches zero (the "zero lower bound"), the conventional tool is exhausted. Central banks then turn to Quantitative Easing (QE): purchasing large quantities of bonds to directly lower long-term interest rates and increase the money supply.

Python
# Compute the Taylor Rule and compare to actual Fed Funds Rate
import pandas as pd
import numpy as np
from pandas_datareader import data as pdr
import matplotlib.pyplot as plt

# Download data from FRED
fed_funds = pdr.get_data_fred("FEDFUNDS", start="1990-01-01")
cpi = pdr.get_data_fred("CPIAUCSL", start="1989-01-01")
gdp = pdr.get_data_fred("GDPC1", start="1989-01-01")
pot_gdp = pdr.get_data_fred("GDPPOT", start="1989-01-01")

# Compute inflation (YoY CPI)
inflation = cpi.pct_change(12).dropna() * 100
inflation.columns = ["inflation"]

# Compute output gap
output_gap = ((gdp.iloc[:, 0] - pot_gdp.iloc[:, 0]) / pot_gdp.iloc[:, 0] * 100).dropna()

# Resample to quarterly and merge
infl_q = inflation.resample('QS').last()
ff_q = fed_funds.resample('QS').last()

# Taylor Rule parameters
r_star = 2.0
pi_star = 2.0

# Build merged DataFrame
taylor = pd.DataFrame({
    "fed_funds": ff_q.iloc[:, 0],
    "inflation": infl_q.iloc[:, 0],
    "output_gap": output_gap
}).dropna()

taylor["taylor_rule"] = (r_star + taylor["inflation"]
                          + 0.5 * (taylor["inflation"] - pi_star)
                          + 0.5 * taylor["output_gap"])

taylor["taylor_rule_clamped"] = taylor["taylor_rule"].clip(lower=0)

print("Taylor Rule vs Actual Fed Funds Rate")
print("=" * 50)
gap = taylor["fed_funds"] - taylor["taylor_rule_clamped"]
print(f"Mean gap (actual - Taylor): {gap.mean():.2f}pp")
print(f"Std gap: {gap.std():.2f}pp")
print(f"Correlation: {taylor['fed_funds'].corr(taylor['taylor_rule_clamped']):.3f}")

21.6 — Leading, Coincident, and Lagging Indicators

Macroeconomic indicators can be classified by their timing relative to the business cycle. This classification is fundamentally about the cross-correlation function between each indicator and aggregate economic activity.

21.7 — The Yield Curve as a Recession Predictor

The yield curve is a plot of interest rates (yields) on government bonds of different maturities. Normally, longer-maturity bonds have higher yields (compensation for duration risk). When the curve inverts — short-term rates exceed long-term rates — it has historically preceded recessions with remarkable accuracy.

Why Does the Yield Curve Predict Recessions?

• Expectations hypothesis: Long-term rates reflect expectations of future short-term rates. If investors expect the Fed to cut rates (because of recession), long-term rates fall below current short-term rates.
• Term premium: The extra yield for holding longer-duration bonds. When uncertainty is high, the term premium can compress or turn negative.
• Bank profitability channel: Banks borrow short and lend long. An inverted curve squeezes bank margins, reducing lending, which slows the economy. This makes the yield curve partly causal, not just predictive.

Python
# Yield Curve as Recession Predictor
import pandas as pd
import numpy as np
from pandas_datareader import data as pdr
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score

# Download yield curve data and recession indicators
y10 = pdr.get_data_fred("GS10", start="1976-01-01")
y2 = pdr.get_data_fred("GS2", start="1976-01-01")
rec = pdr.get_data_fred("USREC", start="1976-01-01")

# Compute term spread
spread = pd.DataFrame({
    "spread": y10.iloc[:, 0] - y2.iloc[:, 0],
    "recession": rec.iloc[:, 0]
}).dropna()

# Create forward-looking recession indicator (recession within 12 months)
spread["recession_12m"] = spread["recession"].rolling(12).max().shift(-12)
spread = spread.dropna()

# Classification performance
spread["inverted"] = (spread["spread"] < 0).astype(int)

tp = ((spread["inverted"] == 1) & (spread["recession_12m"] == 1)).sum()
fp = ((spread["inverted"] == 1) & (spread["recession_12m"] == 0)).sum()
fn = ((spread["inverted"] == 0) & (spread["recession_12m"] == 1)).sum()
tn = ((spread["inverted"] == 0) & (spread["recession_12m"] == 0)).sum()

print("Yield Curve Inversion as Recession Classifier")
print("=" * 50)
print(f"Sensitivity (recall): {tp/(tp+fn):.1%}")
print(f"Specificity:          {tn/(tn+fp):.1%}")
print(f"Precision:            {tp/(tp+fp):.1%}")

# Probit model (logistic approximation)
X = spread["spread"].values.reshape(-1, 1)
y_target = spread["recession_12m"].values
model = LogisticRegression()
model.fit(X, y_target)
y_prob = model.predict_proba(X)[:, 1]
auc = roc_auc_score(y_target, y_prob)
print(f"ROC AUC (probit model): {auc:.3f}")

21.8 — Business Cycle Dating: Change-Point Detection

In the US, the official arbiter of business cycle dates is the National Bureau of Economic Research (NBER) Business Cycle Dating Committee. They determine when recessions begin (peaks) and end (troughs). From a statistical perspective, this is a change-point detection problem.

Hamilton's Markov-Switching Model

Hamilton's (1989) seminal model treats the business cycle as a latent state variable S_t ∈ {0, 1} (expansion or recession) that follows a Markov chain:

Python
# Hamilton Markov-Switching Model for Business Cycle Dating
import pandas as pd
import numpy as np
from pandas_datareader import data as pdr
import statsmodels.api as sm

# Download GDP growth
gdp = pdr.get_data_fred("GDPC1", start="1960-01-01")
gdp_growth = gdp.pct_change().dropna() * 100
gdp_growth.columns = ["growth"]

# Fit Markov-Switching AR(1) model
mod = sm.tsa.MarkovAutoregression(
    gdp_growth["growth"].dropna(),
    k_regimes=2,
    order=1,
    switching_ar=False,
    switching_variance=True
)
res = mod.fit(search_reps=20)

print("Markov-Switching Model for Business Cycle")
print("=" * 50)
print(f"Regime 0 (expansion) mean growth: {res.params['const[0]']:.2f}%")
print(f"Regime 1 (recession) mean growth: {res.params['const[1]']:.2f}%")

# Transition probabilities
print(f"\nTransition probabilities:")
print(f"  P(stay in expansion): {res.params['p[0->0]']:.3f}")
print(f"  P(stay in recession): {res.params['p[1->1]']:.3f}")

# Expected duration of each regime
dur_exp = 1 / (1 - res.params['p[0->0]'])
dur_rec = 1 / (1 - res.params['p[1->1]'])
print(f"\nExpected duration:")
print(f"  Expansion: {dur_exp:.1f} quarters ({dur_exp/4:.1f} years)")
print(f"  Recession: {dur_rec:.1f} quarters ({dur_rec/4:.1f} years)")

# Smoothed recession probabilities
recession_prob = res.smoothed_marginal_probabilities[1]
print(f"\nRecession probability > 50% in {(recession_prob > 0.5).sum()} quarters")

21.9 — Fiscal vs. Monetary Policy: Two Levers

Macroeconomic stabilization has two main policy levers: monetary policy (controlled by the central bank) and fiscal policy (controlled by the government through taxation and spending). Understanding the difference is essential for interpreting macroeconomic data.

21.10 — Putting It All Together: A Macro Dashboard

Python
# Comprehensive macro data download and summary
import pandas as pd
import numpy as np
from pandas_datareader import data as pdr

# Define key macro series
macro_series = {
    "Real GDP Growth (Q/Q Ann.)": "A191RL1Q225SBEA",
    "CPI Inflation (YoY)": "CPIAUCSL",
    "Core PCE Inflation (YoY)": "PCEPILFE",
    "Unemployment Rate": "UNRATE",
    "Fed Funds Rate": "FEDFUNDS",
    "10Y Treasury Yield": "GS10",
    "2Y Treasury Yield": "GS2",
}

# Download all
data_dict = {}
for name, code in macro_series.items():
    try:
        df = pdr.get_data_fred(code, start="2020-01-01")
        data_dict[name] = df.iloc[:, 0]
    except:
        print(f"Could not download {name}")

# Current snapshot
print("Current Macroeconomic Snapshot")
print("=" * 55)
for name, series in data_dict.items():
    latest = series.dropna().iloc[-1]
    date = series.dropna().index[-1].date()
    print(f"  {name:35s}: {latest:>7.2f}  ({date})")

# Yield curve status
if "10Y Treasury Yield" in data_dict and "2Y Treasury Yield" in data_dict:
    spread = (data_dict["10Y Treasury Yield"].dropna().iloc[-1] -
              data_dict["2Y Treasury Yield"].dropna().iloc[-1])
    status = "INVERTED (recession signal)" if spread < 0 else "Normal"
    print(f"\n  Yield Curve Spread (10Y-2Y): {spread:.2f}pp — {status}")

print("\nThis data forms the macro context for any investment decision.")

21.11 — Summary

This module has translated the core concepts of macroeconomics into statistical language:

1. GDP is a quarterly time series with trend, seasonal, and cyclical components, decomposed using HP filters or Hamilton regressions.
2. Inflation (CPI) is a weighted Laspeyres price index with known biases. Core measures are robust estimators of underlying price trends.
3. Unemployment is a ratio estimator from a survey (CPS) with a margin of error that most people ignore.
4. The Phillips Curve is an unstable regression with time-varying coefficients — a cautionary tale about structural change.
5. Central bank policy is an intervention in a time series, with the Taylor Rule as a predictive model and QE as an unconventional treatment.
6. Leading indicators are predictive variables; coincident indicators are concurrent measures; lagging indicators are retrospective.
7. The yield curve is a binary classifier for recession with impressive historical ROC performance.
8. Business cycle dating is a change-point detection problem, solvable with Markov-switching models.
9. Fiscal multipliers are heterogeneous treatment effects estimated with IV, local projections, or SVARs.