N-BEATS

Overview

N-BEATS, short for Neural Basis Expansion Analysis for Time Series, is a deep learning model for forecasting. It is built only from fully connected layers, arranged in blocks that are stacked one after another. Each block looks at the part of the history that earlier blocks could not explain, makes a partial forecast, and passes the leftover to the next block. The final forecast is the sum of all the partial forecasts.

The model is known for two things. First, it showed that a plain neural network with no recurrence, no convolution and no attention could reach very strong accuracy on public forecasting benchmarks, with no hand-made features. Second, it offers an interpretable version in which the blocks are forced to output trend and seasonal shapes, so you can plot what each part contributes. If you want accurate univariate forecasting and you have many series to learn from, N-BEATS is a classic choice. It sits in the same family as TFT, PatchTST and Chronos, and it is a useful contrast to a transparent baseline such as Prophet.

What it is

N-BEATS is a feed-forward neural network designed for univariate point forecasting. You give it a window of past values (the lookback) and it returns the next several values (the horizon). There are no extra inputs by default. It learns directly from the raw numbers.

The shape of the network

The network has three levels of structure.

1. Block. A small stack of fully connected layers followed by two linear heads. One head produces a backcast (an attempt to rebuild the input window) and the other produces a forecast (a guess about the future).
2. Stack. A group of blocks connected in a chain. The backcast of one block is subtracted from its input, and the remainder goes to the next block.
3. Model. One or more stacks. The forecasts from every block are added up to give the final forecast.

Everyday analogy

Picture a team of editors working on a messy draft. The first editor fixes the biggest problem and hands over a marked-up copy with that problem removed. The second editor fixes the next biggest problem in what is left. Each editor writes down their fix, and the final document is the sum of all fixes. N-BEATS works like this. Each block explains some pattern, removes it from the signal, and passes the rest along.

Two configurations

• Generic. Blocks have free-form linear heads. The network learns whatever shapes help. It is the more accurate setup in most tests, but its blocks are hard to read.
• Interpretable. One stack is forced to produce a polynomial trend and another a Fourier-style seasonal curve. This gives a clear split into trend and seasonality, much like a classical decomposition, but learned by a neural network.

Training style

N-BEATS is trained on many windows cut from many series. Each window is a training example. This makes it a global model: one set of weights serves all series. This is a major difference from fitting a separate model per series, as classical methods do.

Where it came from

N-BEATS was introduced in a 2019 paper by Boris Oreshkin and co-authors, and later presented at a major machine learning conference in 2020. The authors set out to test a bold idea: could a pure deep learning model, with no statistical components inside, beat the best classical and hybrid methods on a well-known forecasting competition benchmark? Before this work, strong results in that competition came from hybrids that mixed neural networks with classical exponential smoothing.

The context

For many years, forecasters believed that deep learning did not help much on univariate series. Statistical methods like ARIMA and exponential smoothing were hard to beat, and neural nets were seen as data-hungry and fragile. The N-BEATS paper reported that a carefully designed network, with ensembling, could outperform those baselines on several standard datasets. The result reshaped the field's view of what plain neural forecasters can do.

Design ideas borrowed from elsewhere

• Residual learning. The idea of passing leftovers forward, as in residual networks for images.
• Basis expansion. The idea of expressing a curve as a weighted sum of fixed shapes, like polynomials or sine waves.
• Ensembling. Training many models with different lookback lengths, loss functions and random seeds, then combining their outputs. The paper leaned on large ensembles to reach top accuracy.

What came after

N-BEATS inspired a wave of related designs. Variants added the ability to use extra inputs (known future covariates, static features). Others made the model faster for long horizons by using multi-rate sampling and hierarchical interpolation. Follow-up models in this line, such as N-HiTS, focus on long-horizon forecasting with lower compute. The core idea of stacking simple blocks with a residual backcast has since appeared in many time-series libraries.

How it works

This section explains the flow of data through N-BEATS, with analogies and the key math in plain words.

Step 1: Cut the data into windows

Take a long series. Slide a window along it. Each position gives a pair: the last L values (the input) and the next H values (the target). L is the lookback and H is the horizon. In the paper, the lookback is a small multiple of the horizon, such as two to seven times.

Analogy: studying for an exam by practicing many past papers. Each window is one practice question, with the answer known.

Step 2: Scale the inputs

Series have different sizes. One might be in the hundreds, another in the millions. Common practice is to scale each window or each series so that values are comparable, for example by dividing by the window's mean or max. This helps the network learn shared patterns across series.

Step 3: Send the window into the first block

The input window passes through a stack of fully connected layers with non-linear activations (often four layers of equal width). This produces a hidden vector, a compact summary of the window.

Step 4: Two heads, two jobs

From the hidden vector, two linear maps produce coefficients called theta. One set of theta is used for the backcast and one for the forecast.

• In the generic version, theta is mapped directly to output values by a learned linear layer.
• In the interpretable version, theta weights a fixed basis. For trend, the basis is polynomials of low degree: a constant, a line, a gentle curve. For seasonality, the basis is sines and cosines.

Analogy: a painter has a small set of brushes (the basis). The network decides how much of each brush to use (theta). In the interpretable version the brushes are fixed and meaningful. In the generic version the brushes are learned.

Step 5: Subtract the backcast

The block's backcast is the part of the input it can explain. The next block's input is the current input minus that backcast. This is the residual connection that makes the model a chain of "explain and remove" steps.

Step 6: Add up the forecasts

Each block also produces a forecast of length H. The stack's forecast is the sum of its blocks' forecasts. The model's forecast is the sum over all stacks. There are often dozens of blocks.

Step 7: Train with a forecasting loss

The network is trained by gradient descent. The loss is chosen to match the evaluation metric, often a scaled absolute error such as sMAPE, MASE or plain MAE. Because the loss is applied on many series with different scales, the choice of a scale-free loss matters.

Training details seen in practice:

• Sample random windows from random series each step.
• Use a restriction on how far back in history windows may start, to focus on recent behavior.
• Use early stopping on a validation window.
• Use ensembles of models with different lookbacks for robustness.

Step 8: Forecast

At prediction time, feed the latest window and read the forecast. Multi-step forecasts come out in one shot. The model is direct, not recursive. That means it does not feed its own predictions back as inputs, which avoids the buildup of errors that plagues recursive forecasting.

Step 9: Interpret (optional)

In the interpretable version, plot the trend stack's output and the seasonality stack's output separately. This looks like a decomposition plot, and a person can see how much of the forecast comes from each pattern.

Why it works

• Many real series share shapes: rising lines, repeating waves, level shifts. A global model learns these shapes once and reuses them.
• Residual stacking lets early blocks catch big patterns and later blocks refine.
• Ensembling reduces variance, which matters for small data.

Key concepts and terms

A worked example

This example trains a small N-BEATS model with a deep learning library. The code uses placeholder file names. It shows the typical flow: prepare data, define the model, train, forecast.

Preparing a long-format table

Most time-series libraries want a long table with three columns: a series id, a timestamp and a value.

import pandas as pd

df = pd.read_csv("sales_long.csv")   # columns: series_id, date, value
df = df.rename(columns={"series_id": "unique_id", "date": "ds", "value": "y"})
df["ds"] = pd.to_datetime(df["ds"])
print(df.groupby("unique_id").size().describe())

Check that every series has enough points. As a rule of thumb, you want at least several times the lookback.

Fitting a global model

from neuralforecast import NeuralForecast
from neuralforecast.models import NBEATS
from neuralforecast.losses.pytorch import MAE

horizon = 14
model = NBEATS(
    h=horizon,
    input_size=3 * horizon,          # lookback = 3 x horizon
    stack_types=["identity", "trend", "seasonality"],
    max_steps=800,
    loss=MAE(),
    random_seed=1,
)
nf = NeuralForecast(models=[model], freq="D")
nf.fit(df=df)
forecast = nf.predict()
print(forecast.head())

The library handles windowing, batching and scaling. The stack types shown here mix a generic block, a trend block and a seasonal block. Names and options differ between libraries, so check the version you use.

Backtesting

cv = nf.cross_validation(df=df, n_windows=4, step_size=14)
cv["abs_err"] = (cv["y"] - cv["NBEATS"]).abs()
print(cv.groupby("unique_id")["abs_err"].mean().describe())

This repeats the forecast over four past windows and measures the error per series. It is the honest way to judge accuracy.

A hand-sized numeric walk-through

Imagine a tiny input of six values and a horizon of two:

input   = [10, 12, 14, 16, 18, 20]

Block 1 learns a trend shape. Suppose its backcast is [10, 12, 14, 16, 18, 20] (a perfect line) and its forecast is [22, 24]. The residual is all zeros. Block 2 sees zeros and outputs a forecast near [0, 0]. The final forecast is [22, 24].

Now suppose the input is [10, 14, 14, 18, 18, 22], a line with a zigzag of plus or minus two. Block 1 may explain the line: backcast [10, 12, 14, 16, 18, 20], forecast [22, 24]. The residual is [0, 2, 0, 2, 0, 2]. Block 2 learns the zigzag: forecast [0, 2]. Final forecast: [22, 26]. Each block did one job, and the sum is the answer. Real networks work with many more values and learned shapes, but the principle is the same.

Reading the result

If you use the interpretable setup, extract the trend and seasonal outputs and plot them under the forecast. If the seasonal part looks like noise, the lookback may be too short to see a full cycle.

Building a simple baseline to compare against

Before trusting any network, compute a seasonal naive forecast. It repeats the last full cycle.

import numpy as np

def seasonal_naive(history, horizon, season=7):
    history = np.asarray(history)
    reps = int(np.ceil(horizon / season))
    return np.tile(history[-season:], reps)[:horizon]

def mae(a, b):
    return float(np.mean(np.abs(np.asarray(a) - np.asarray(b))))

If the network does not beat this by a clear margin on your backtest, it is not adding value yet.

Adding quantile outputs for intervals

To get a range rather than a single line, train with a quantile (pinball) loss for several levels, such as 10, 50 and 90 percent. The library call usually looks like this:

from neuralforecast.losses.pytorch import MQLoss

model = NBEATS(
    h=horizon,
    input_size=3 * horizon,
    loss=MQLoss(level=[80, 90]),
    max_steps=800,
)

The 50 percent line is the median forecast. The outer lines give a band you can use for planning. Check coverage on a backtest: an 80 percent band should contain about 80 percent of actual values.

A step-by-step recap of the workflow

1. Collect many related series in one long table.
2. Pick the horizon from the business need.
3. Choose a lookback of a few horizons.
4. Hold out the last windows for validation and test, in time order.
5. Train the generic model and an interpretable model.
6. Compare with seasonal naive and a tree model on lag features.
7. Ensemble a few seeds or lookbacks.
8. Inspect the worst series and fix data problems.
9. Package the model and the scaling logic together.
10. Schedule retraining and monitoring.

Thinking about the loss in more detail

The loss tells the network what "good" means. A few common choices behave differently.

When you mix series of very different size, a scale-free loss keeps big series from dominating training.

Reading the stacks

In an interpretable model, you can pull out the output of each stack and plot it.

• The trend stack should look smooth and slowly varying. A jagged trend means the polynomial degree is too high or the lookback is too short.
• The seasonality stack should repeat with a clear period. If it does not, the window may not hold a full cycle.
• The leftover, if any, is what the model could not explain. Large leftovers hint at events or noise.

Common tuning knobs

Strengths and limitations

Strengths

• No feature engineering. The network learns from the raw window.
• Strong accuracy. Competitive with or better than classical methods on many benchmarks when trained on enough series.
• Global learning. One model serves thousands of series and learns shared shapes.
• Fast inference. A feed-forward pass is cheap, with no recurrence to unroll.
• Easy to train. Fully connected layers are stable and parallelize well.
• Optional interpretability. The trend and seasonality version gives readable components.
• Direct multi-step output. No error buildup from recursion.
• Works well in ensembles. Variance falls as you combine models.

Limitations

• Univariate focus. The original design handles one target series at a time as input. Extra covariates need later variants.
• Fixed lookback. The window length is set before training. The model cannot use arbitrarily long history.
• Needs data. With few or very short series, a classical method may do as well or better.
• Training cost for big ensembles. The best published results used many models.
• No native uncertainty. The base model outputs point forecasts. Intervals need quantile losses, ensembles or conformal methods.
• Limited handling of events. Holidays and promotions are not first-class unless added as inputs.
• Interpretable mode is less accurate. There is often a trade-off between readability and score.
• Long horizons are heavy. The output layer grows with the horizon, which is why later variants use interpolation.

How it compares with alternatives

A simple rule: if you have a big pool of related series and care about raw accuracy, N-BEATS is a strong candidate. If you need rich covariates, look at TFT. If you have no training data for a series, look at a pre-trained model.

Role in tabular foundation models

N-BEATS is not a tabular foundation model. It trains on windows of numbers, not on tables of mixed types, and it does not adapt in context. Still, its design touches several themes that matter for models that learn from raw tables.

Rows, columns and windows

A tabular foundation model reads rows and columns. N-BEATS reads one row per window, where the columns are the lagged values. If you flatten a window of L past values into a table, you get L numeric columns and H target columns. That makes a time series look like a plain regression table. This is also the approach used when people apply XGBoost, LightGBM or TabPFN to lag features. N-BEATS can be seen as a neural network specialized for this particular flattened table, with an inductive bias (the residual block structure) that suits curves.

Mixed types

Real tables have categories, dates and text. N-BEATS takes numbers only. The base model has no way to read a category such as "store type" or a text note. Extensions allow static features and known future inputs, but the encoding of categories is still left to the user. A foundation model for tables, such as TabICL or FT-Transformer, embeds mixed types in one network. If your table has strong categorical signal, you may combine them: use N-BEATS-style outputs as numeric features, or feed the series history as columns to a table model.

Missing values

N-BEATS has no built-in missing-value handling. Gaps must be filled before windowing, by interpolation, seasonal fill or a model-based method. Some libraries add masks as extra inputs. Tabular foundation models, in contrast, are often pre-trained with missing cells present so that they handle gaps natively. See imputation networks for related ideas.

No column names

N-BEATS never uses names. The position in the window is the only identity a value has. That makes it name-blind by construction, which is the same property that tests of tabular foundation models try to enforce: the model should understand the structure of data, not the words in headers.

Pre-training and transfer

N-BEATS was shown to transfer across datasets in the original work: a model trained on one set of series can forecast another set with little or no retraining. That is an early version of the pre-train-then-apply idea that now drives time-series foundation models like Chronos. The difference is scale. N-BEATS transfer used tens or hundreds of thousands of series from known benchmarks, while foundation models use far larger and more varied pools, often with synthetic series mixed in. See transfer learning and zero-shot learning for the general ideas, and synthetic data generation for how artificial pre-training data is made.

In-context and continual learning

N-BEATS does not learn in context. After training, its weights are fixed, and adapting to a new regime means fine-tuning or retraining. For continual learning, teams usually retrain on a schedule or fine-tune on recent windows, taking care to avoid forgetting older patterns. A table foundation model that conditions on a few labeled rows in its prompt (the approach used by in-context learners) can adapt without any weight updates. This is a clear difference in workflow: N-BEATS adapts through training, such models adapt through examples.

Imputation

The backcast idea has a link to imputation. A block tries to rebuild its input, and the gap between the backcast and the true input is the residual. In principle, a model with a strong backcast can fill missing positions by reconstruction. In practice, N-BEATS is trained for forecasting, not reconstruction, and dedicated imputers or autoencoders do the job better.

Anomaly detection

Forecast residuals are a standard anomaly signal. If actual values drift far from the N-BEATS forecast, flag them. With an interpretable version, you can also see whether the unusual point is a trend break or a seasonal surprise. For detection across many columns, see anomaly detection and predictive maintenance.

Sector and semantic classification

Deciding what a column or a series means (for instance, whether a series is retail demand, energy load or web traffic) is a classification task. The shape of a series carries clues: weekly spikes, a daily cycle, a long ramp. Embeddings from the hidden vector of an N-BEATS block can serve as a compact shape descriptor for this kind of grouping. A table foundation model that reads values and structure together can do the same at the column level. For how such systems are built and evaluated, see /model/architecture, /model/research and /model/benchmarks.

The bottom line

N-BEATS is a specialist for numeric sequences, with ideas (global training, transfer, residual decomposition) that point toward foundation models. It does not replace a table-native model, but the two can be combined in one pipeline.

Practical guidance and best practices

Data

• Gather as many related series as you can. Global models improve with variety.
• Keep series on a common frequency.
• Fill gaps before training and record which values were filled.
• Do not leak the future. Split by time, never at random.
• Scale per series or per window.

Model setup

• Set the lookback to two to seven times the horizon, then test a few values.
• Start with the generic setup for accuracy. Use the interpretable setup when you must explain results.
• Keep layers moderately wide and the number of blocks modest at first.
• Choose a loss that matches the metric you report.
• Use several random seeds and average.

Training

• Use a validation window at the end of each series for early stopping.
• Watch for overfitting on short series. Add dropout or weight decay if needed.
• Use a learning rate schedule and gradient clipping.
• Train on GPU if you have thousands of series. For small sets, a CPU is enough.
• Track results with a fixed backtest so changes are comparable.

Evaluation

• Backtest over several cutoffs.
• Compare with strong baselines: seasonal naive, exponential smoothing, Prophet and a tree model on lag features.
• Report error by horizon and by series group.
• Check calibration if you add intervals.

Deployment

• Package the model with its scaling rules so inference matches training.
• Version the data window logic. A one-off change in windowing silently changes results.
• Export through a standard format such as ONNX Runtime if you need portable inference.
• Monitor error over time and set a retraining rule.
• Keep a fallback forecast, such as seasonal naive, for when inputs are bad.

Choosing the number of blocks

More blocks give more capacity. The original work used dozens of blocks. For a small project, start with a few stacks and a handful of blocks each. Add more only if validation error keeps falling. If it stops falling, extra blocks just add training time.

When to choose something else

• Very few series and short history: use classical statistics.
• Many known future covariates: use TFT or a boosted tree model.
• No history for a new series: use a pre-trained model such as Chronos.
• Very long horizons on multivariate data: look at PatchTST or N-HiTS style models.

Common mistakes

1. Random train and test splits. They leak the future. Always split in time.
2. Mixing scales without normalizing. One huge series can dominate the loss.
3. Lookback too short. The model cannot see a full seasonal cycle.
4. Lookback too long for the data. Too many inputs for too few windows leads to overfitting.
5. Using the wrong loss. Training on squared error and reporting a percentage error can give mismatched results.
6. Single-model reporting. Results from one seed can be lucky. Use several seeds or an ensemble.
7. Ignoring covariates that matter. If promotions drive demand, a pure univariate model will miss them.
8. Forgetting to fill gaps. Missing values turn into NaN and break training.
9. Over-reading the interpretable output. The trend and seasonal parts are learned approximations, not ground truth.
10. No baseline. Without a seasonal naive baseline, you cannot tell if the network adds value.
11. Skipping retraining. Patterns drift, and an old model degrades.
12. Applying it to a single short series. Global models need many windows.

Frequently asked questions

What does N-BEATS stand for?

It stands for Neural Basis Expansion Analysis for Time Series. The name describes the core idea: the network expresses the forecast as a sum of basis shapes, with the weights on those shapes produced by neural layers.

Is N-BEATS a transformer?

No. It uses only fully connected layers with residual connections between blocks. It has no attention mechanism, no convolution and no recurrence. This simplicity is part of its appeal, and it makes the model quick to run.

Can N-BEATS use extra features such as holidays or prices?

The original version works on the target series alone. Later variants and library implementations allow static features and known future inputs. If covariates are central to your problem, a model built for them, such as TFT, is often a more direct fit.

How much data does N-BEATS need?

It does best with many related series or a long single series that yields many windows. With a handful of short series, it may overfit, and a classical method can match it. As a rough guide, you want thousands of training windows.

What is the difference between the generic and interpretable versions?

The generic version lets the network learn any shape for its outputs and usually scores slightly better. The interpretable version fixes the output shapes to trend (polynomials) and seasonality (Fourier terms), so you can plot and explain each part. The choice is accuracy versus readability.

Does N-BEATS give prediction intervals?

Not by default. It outputs point forecasts. You can get intervals by training with a quantile loss, by using an ensemble of models, or by applying conformal prediction on top of backtest errors.

How is N-BEATS different from an LSTM?

An LSTM reads the series step by step and keeps a memory state. N-BEATS reads the whole window at once with fully connected layers and has no memory state. N-BEATS is generally faster to train and easier to parallelize, while an LSTM handles variable-length sequences more naturally.

Is N-BEATS a foundation model?

Not in the modern sense. It is trained on a specific pool of series and can transfer to similar ones, but it was not built as a large pre-trained model that works zero-shot on any series. Models such as Chronos aim at that goal.

What is N-HiTS and how does it relate?

N-HiTS is a follow-up design in the same family. It keeps the stacked-block, residual structure but adds multi-rate input sampling and hierarchical interpolation of outputs. These changes cut compute and improve long-horizon forecasts. It is a good next step if N-BEATS is too slow or inaccurate at long horizons.

When should I prefer N-BEATS over Prophet?

Prefer N-BEATS when you have many related series, care most about accuracy, and have little need for a calendar-based explanation. Prefer Prophet when you have a single series with clear holidays and seasonality and need a quick, transparent result.

Glossary

• Backcast. A block's rebuilt version of its own input window.
• Basis function. A fixed shape, such as a polynomial or a sine wave, used to build curves.
• Block. The repeated unit of N-BEATS, with a shared body and two output heads.
• Direct forecasting. Predicting all future steps in one pass.
• Ensemble. A group of models combined to reduce variance.
• Global model. A model trained on many series at once.
• Horizon. The number of future steps to predict.
• Lookback. The number of past steps used as input.
• MASE. Mean absolute scaled error, a scale-free metric.
• Residual connection. A link that passes what is left after subtracting an explained part.
• sMAPE. Symmetric mean absolute percentage error.
• Stack. A chain of blocks that share a role.
• Theta. The coefficients that weight a basis.
• Univariate. Concerned with one target series.
• Zero-shot. Predicting on unseen data with no training on it.

Summary

N-BEATS is a neural forecasting model built from stacked fully connected blocks that each explain part of a series, subtract it, and pass the remainder on. It needs no hand-made features, trains as a global model across many series, and can reach strong accuracy, especially in ensembles. An interpretable mode adds readable trend and seasonal components.

Its limits are a focus on univariate input, a fixed lookback, point forecasts by default and a need for data. For tabular foundation models, it is best seen as a specialist for numeric sequences that anticipates ideas such as global training, transfer across datasets and residual decomposition. Use it when you have many related series and want accuracy, compare it honestly against Prophet and boosted trees, and look to TFT, PatchTST or Chronos when your problem calls for covariates, long horizons or zero-shot use.

Related

It belongs to Forecasting and tasks in my stack, under Foundation models and applied ML. Others in the same group: