Multi-Step Forecasting

Why Does This Exist?

Nobody staffs a warehouse on tomorrow alone. Planners need the next seven days of demand, the grid needs the next 24 hours of load, and a single next-step model cannot answer either. Call the number of future steps the horizon $h$, which means the count of values $y_{t+1}$ through $y_{t+h}$ you must emit.

Stretching a one-step model across a horizon is a design decision with real costs. Reuse one model and early mistakes become later inputs. Train one model per step and the steps stop agreeing with each other. Emit the whole vector at once and training gets harder as $h$ grows.

This page compares the three standard plans on one fixture so you can pick deliberately. For the recurrent model that often produces the vector, see LSTM for forecasting. When each step should carry its uncertainty, continue to probabilistic forecasting.

Think of It Like This

How It Actually Works

Fix a horizon of $h = 3$ and a history of $[10, 12, 15]$. Assume the one-step rule adds $2$ to the last value. All three plans start from the same history and the same rule, and they diverge only in how the three outputs relate.

Recursive trains one model for $y_{t+1}$ and iterates. It predicts $17$, feeds $17$ back, predicts $19$, feeds that back, predicts $21$. One model, three calls, and a miss at step one shifts every step after it.

Direct trains three models, one per step, all reading the same history. Model one predicts $17$, model two predicts $18$, model three predicts $21$. No forecast becomes an input, so errors never compound, but the three answers can contradict each other because the models never coordinate.

Multi-output trains one model that emits the vector $[17, 19, 21]$ in a single pass. The steps stay consistent because one set of weights produces all of them, at the price of fitting an $h$-dimensional output.

Worked example

Take history $[10.0, 12.0, 15.0]$ with step $2.0$ and horizon $3$. The recursive path is $15 + 2 = 17$, then $17 + 2 = 19$, then $19 + 2 = 21$. Now suppose the true first value turns out to be $16$ while the model said $17$. The recursive second step starts from $17$ instead of $16$, so the one-unit miss is baked into $19$ and carried into $21$. Direct avoids this entirely because its second model never sees the $17$. That single carried unit is the compounding the diagram traces.

Code

This recursive rollout replays the fixture with only the standard library:

1def recursive(history: list[float], step: float, horizon: int) -> list[float]:2    path = list(history)3    for _ in range(horizon):4        path.append(path[-1] + step)5    return path[-horizon:]6
7
8print(recursive([10.0, 12.0, 15.0], 2.0, 3))  # -> [17.0, 19.0, 21.0]

The output matches the hand trace: 17.0, then 19.0, then 21.0. Pass a history ending in 16.0 instead and the whole vector shifts down by one, which is compounding made visible.

Watch Out For

The Quick Version

• Multi-step forecasting emits $y_{t+1}$ through $y_{t+h}$, where $h$ is the horizon the planner actually needs.
• Recursive reuses one model and feeds each forecast back, so a one-unit miss at step one shifts every later step.
• Direct trains one model per step with no feedback, so steps never compound but can contradict each other.
• Multi-output emits the whole vector in one pass, keeping steps consistent at the cost of harder training.
• A history of 10, 12, 15 with step 2 gives 17, 19, 21, and the recursive path carries any early miss forward.
• Score the full horizon curve, and audit direct features so nothing past $t$ leaks into $X_t$.

What to Read Next

• LSTM for Forecasting
• Probabilistic Forecasting