What Are We Forecasting?

The target is quarterly real GDP growth, expressed at an annual rate. This matches the way BEA usually presents quarter to quarter GDP growth in its releases. It is more useful for this tutorial than forecasting the raw GDP level because a growing level can make a weak model look accurate.

The target for quarter t is based on real GDP in quarter t and quarter t minus one. The code uses the same compounding idea behind BEA annualized quarterly growth.

A 1.5 percent annualized quarterly growth rate does not mean the economy grew 1.5 percent during those three months. The underlying quarter to quarter increase is smaller. Annualization asks what the rate would look like if that quarterly pace continued for a full year.

Use BEA for the Official GDP Story and FRED for Easy Access

BEA is the original source for U.S. national GDP statistics. FRED, maintained by the Federal Reserve Bank of St. Louis, provides a convenient way to download the same GDP series and many related indicators.

The main target series is GDPC1, Real Gross Domestic Product. It is quarterly, seasonally adjusted at an annual rate, and reported in billions of chained 2017 dollars. For the multivariate tutorial model, the example also uses a quarterly industrial production index, real private investment, the PCE price index, and real government consumption and investment.

Using native quarterly series makes the worked example easier to audit. Monthly indicators such as payroll employment, unemployment, the federal funds rate, and CPI can also be useful, but their timing must be handled carefully. A production forecast should only use values that were actually available at the forecast origin.

Build a GDP Forecasting Python Dataset

The model sample runs from 2000 through the second quarter of 2026. The goal is not to use every economic series available. It is to create a small dataset where each feature has a clear economic meaning and a clear release timing.

Industrial production adds information about real output outside the GDP release. Private investment is sensitive to the business cycle. The PCE price index gives an inflation signal. Government spending can move GDP directly. Each predictor is lagged by one quarter in the Ridge model so that the forecast for a new quarter does not use information from the future.

Data dictionary

Calculate Quarterly Real GDP Growth

The article calculates annualized quarter to quarter growth from the real GDP level. This makes the target easy to compare with the growth rate in BEA releases.

The same transformation can be applied to several real activity series. Price indexes need different wording because their growth is inflation, not real output growth.

def annualized_qoq(series):
    return 100 * ((series / series.shift(1)) ** 4 - 1)

data["gdp_growth"] = annualized_qoq(data["GDPC1"])
data["ip_growth"] = annualized_qoq(data["IPB50001SQ"])
data["investment_growth"] = annualized_qoq(data["GPDIC1"])
data["pce_inflation"] = annualized_qoq(data["PCECTPI"])
data["government_growth"] = annualized_qoq(data["GCEC1"])

for lag in range(1, 5):
    data[f"gdp_lag{lag}"] = data["gdp_growth"].shift(lag)

for col in [
    "ip_growth",
    "investment_growth",
    "pce_inflation",
    "government_growth"
]:
    data[f"{col}_lag1"] = data[col].shift(1)

Create Lagged Features Without Data Leakage

Lagged variables are the core of this GDP forecasting Python workflow. The forecast for a quarter can use earlier GDP growth and earlier indicator values, but it cannot use data from the quarter being predicted unless the task is explicitly a nowcast.

The Ridge model uses four lags of GDP growth and one lag each of industrial production growth, real private investment growth, PCE inflation, and real government spending growth. The scaler is fitted inside a pipeline using training data only.

This design is conservative. It gives up some very recent information, but it makes the timing easy to explain and protects the backtest from look ahead bias.

Use a Time Ordered Train and Test Split

Random shuffling is wrong for a GDP forecasting Python task. A forecast made in 2023 should not learn from 2025 before it predicts 2023.

The worked example uses expanding rolling origin evaluation from 2022 Q1 through 2026 Q2. At each step, the model is fitted on all earlier observations, predicts the next quarter, then moves forward one quarter. This produces 18 out of sample forecasts.

The test period is recent enough to reflect the current economy, while the training history still includes the pandemic shock. That makes the exercise harder, but it also shows why GDP forecast uncertainty can become large.

Start With a Simple Baseline

A complex model has to beat something simple. The baseline in this tutorial assumes the next quarter will grow at the same annualized rate as the previous quarter.

That rule has no tuning and almost no explanation cost. If a more advanced model cannot improve on it, the extra complexity has not earned its place.

Model 1: Four Lag Autoregression

The autoregression uses the last four quarterly GDP growth observations, plus a constant and a time trend. It asks whether recent GDP growth contains enough information to improve on the persistence benchmark.

In the recent rolling test, this model produced the lowest MAE and RMSE. That does not prove it will remain the best model. It only means it performed best on the evaluation period used here.

Model 2: Ridge Regression With Lagged Indicators

The Ridge model adds lagged economic indicators to lagged GDP growth. Ridge regression is useful when predictors can move together because it shrinks coefficients instead of allowing unstable estimates to grow too large.

The model is placed in a scikit learn pipeline with StandardScaler. The scaler is refitted at every forecast origin using training data only. This detail matters because fitting a scaler on the full dataset leaks information from the future.

Rolling origin evaluation code

test_start = "2022-01-01"
predictions = []

for forecast_date in model_data.loc[test_start:].index:
    train = model_data.loc[
        model_data.index < forecast_date
    ]

    ar = AutoReg(
        train["gdp_growth"],
        lags=4,
        trend="ct",
        old_names=False
    ).fit()

    ar_pred = ar.predict(
        start=len(train),
        end=len(train)
    ).iloc[0]

    ridge = Pipeline([
        ("scale", StandardScaler()),
        ("model", Ridge(alpha=10.0))
    ])

    ridge.fit(
        train[feature_cols],
        train["gdp_growth"]
    )

    ridge_pred = ridge.predict(
        model_data.loc[[forecast_date], feature_cols]
    )[0]

    predictions.append({
        "date": forecast_date,
        "actual": model_data.loc[
            forecast_date,
            "gdp_growth"
        ],
        "autoreg": ar_pred,
        "ridge": ridge_pred
    })

Compare Forecast Accuracy

MAE measures the average absolute forecast error. RMSE also measures error, but it gives more weight to large misses. Lower values are better for both metrics.

From 2022 Q1 through 2026 Q2, the four lag autoregression had an MAE of about 1.24 percentage points and an RMSE of about 1.57. The Ridge model had an MAE of about 1.60 and an RMSE of about 1.95. The persistence benchmark had an MAE of about 2.04 and an RMSE of about 2.79.

The autoregression also correctly identified whether growth would speed up or slow down from the prior quarter in about 83 percent of the test observations. Directional accuracy is only a secondary check, but it helps readers see a different side of forecast performance.

Plot the Forecasts, Not Just the Scores

A model comparison table can hide when errors happened. The forecast chart shows that no model tracks every quarter perfectly. The visual check is especially important around turning points, when the economy can change faster than a simple time series rule.

Residuals should also be inspected. A residual is actual growth minus forecast growth. Large or persistent residual patterns can show that the model is missing an important part of the data generating process.

Animate the Rolling Forecast Origins

The interactive animation is titled How the U.S. GDP Forecast Changes at Each Forecast Origin. Each frame shows the GDP growth history available at that stage, the one quarter ahead AutoReg forecast, the actual result after it became known, and the forecast error.

The purpose of the animation is educational. A normal static line can make a forecast look as if it was produced with knowledge of the future. Moving through forecast origins shows what the model knew at each step.

Forecast U.S. GDP Growth for 2026 Q3

After the evaluation, the selected four lag autoregression was refitted through 2026 Q2. Its tutorial forecast for 2026 Q3 is 3.0 percent annualized real GDP growth. The persistence benchmark gives 1.5 percent, while the Ridge indicator model gives 2.5 percent.

The AutoReg model also produces a wide 80 percent model based interval, from about -3.3 percent to 9.4 percent. That range is a reminder that quarterly GDP is difficult to predict. The model was estimated on a history that includes extreme pandemic movements, which increases estimated uncertainty.

This is a tutorial model forecast, not an official BEA forecast, a Federal Reserve forecast, or a market consensus. It should be used to understand the forecasting workflow rather than as a trading or policy signal.

final_model = AutoReg(
    model_data["gdp_growth"],
    lags=4,
    trend="ct",
    old_names=False
).fit()

forecast = final_model.get_prediction(
    start=len(model_data),
    end=len(model_data)
)

forecast_table = forecast.summary_frame(alpha=0.20)
print(forecast_table)

Forecast Uncertainty and Data Revisions Matter

GDP data are revised. BEA publishes an advance estimate, later estimates, and periodic annual updates. FRED normally shows the latest revised history. If you train a historical model on today's revised series, the model may see values that forecasters did not know at the time.

For a GDP forecasting Python backtest, that problem is called revision bias or vintage bias. For a serious real time backtest, use ALFRED or another vintage data source so every historical forecast uses the data available on that date.

The current tutorial uses the latest revised series because it is easier for readers to reproduce. That choice is clearly stated as a limitation.

Common GDP Forecasting Mistakes

The most common mistake is forecasting the GDP level and then judging the model mainly by a high R squared value. A smooth upward level can create impressive looking scores without a useful growth forecast.

Other mistakes include random train and test splits, fitting a scaler on the whole dataset, using revised values as if they were known in real time, mixing monthly and quarterly data without a timing rule, and using a monthly value from the forecast quarter before it was released.

Another mistake is reporting one point forecast without uncertainty. Even a well tested model can miss badly during a shock or turning point. Forecasts are estimates, not promises.