NeuroFlexMLP: a Low-Complexity MLP Architecture for Long-Term Time Series Forecasting

Pablo Fernández Pérez^†★  ·  Claudio Fiandrino^★  ·  Marco Fiore^★  ·  Joerg Widmer^★

^†Universidad Carlos III de Madrid, Spain    ^★IMDEA Networks Institute, Madrid, Spain

🏆 Winner of the Mario Gerla Best Paper Award at the MAIN conference (Mediterranean Communication and Computer Networking Conference, Mondello — Palermo, Italy, 2026).

---

Overview

NeuroFlexMLP is a deep learning model for multivariate long-term time series forecasting that is flexible by design: it adapts to the diverse complexity of real-world time series while remaining computationally lightweight enough for deployment on constrained platforms.

Recent research has been dominated by transformer-based architectures that capture long-range dependencies in sequential data. Yet several studies have shown that far simpler linear models can outperform transformers by avoiding overfitting during training. NeuroFlexMLP navigates this complexity–accuracy trade-off directly: it starts from a purely linear block and adds non-linear residual blocks only when the data requires them.

This design yields three practical advantages:

• Adaptable complexity. A first fully linear block produces a forecast already aligned with the prediction horizon; subsequent non-linear residual blocks refine it, introducing non-linearity only when beneficial.
• Minimal tuning. Model capacity is controlled by just two hyperparameters — the number of residual blocks and their hidden size — making hyperparameter search cheap compared to transformers.
• High efficiency. Its pure Multi-Layer Perceptron (MLP) design scales to long input sequences without the (near-)exponential cost growth of attention, enabling on-board deployment.

Headline result — LEO satellite beam hopping

We validate NeuroFlexMLP on a Low Earth Orbit (LEO) satellite beam-hopping traffic-forecasting use case, where an on-board scheduler must forecast per-cell demand under severe size, weight, and power constraints. NeuroFlexMLP achieves:

• up to 35.9% MSE reduction over the Informer transformer, and
• up to 28% lower total provisioning cost under an asymmetric cost model that penalizes under-allocation more heavily than over-allocation,

all at a fraction of the training cost — making it suitable for on-board deployment where transformers are impractical.

Architecture

input ──► RevIN(norm) ──► [ Linear block ]───────────────┐  (already horizon-aligned)
                                                          ▼
                          [ Residual block 1 ] ──► ( + )  refine with non-linear residual
                                                    │
                          [ Residual block N ] ──► ( + )
                                                    ▼
                                            RevIN(denorm) ──► forecast

Each residual block is two linear layers around a ReLU non-linearity (optionally operating on trend/seasonal components via series decomposition). The number of blocks (--layers) and their hidden size (--hidden_size) are the two hyperparameters that flex the model's capacity. See models/NeuroFlexMLP.py.

Repository structure

NeuroFlexMLP/
├── run_longExp.py            # Main training / evaluation entry point
├── models/                   # NeuroFlexMLP and all baseline models
├── layers/                   # Building blocks (RevIN, decomposition, attention, ...)
├── data_provider/            # Dataset loaders and data factory
├── exp/                      # Experiment runners (training / validation / test loops)
├── utils/                    # Metrics, time features, tooling
├── scripts/                  # Reproduction scripts
│   ├── NeuroFlexMLP/         #   NeuroFlexMLP on all benchmarks (ETT, weather, traffic, ...)
│   ├── Baselines/            #   Baseline configurations
│   ├── PatchTST/             #   PatchTST baseline
│   └── beam_hopping/         #   LEO beam-hopping experiments
├── networking-test/          # LEO beam-hopping use case (KPI analysis + scheduler simulation)
│   ├── comparison/           #   NeuroFlexMLP vs Informer KPI comparison + scheduler sim
│   ├── neuroflexmlp/         #   NeuroFlexMLP KPI results
│   └── informer/             #   Informer KPI results
├── complexity_analysis/      # Computational-complexity and flexibility analysis
├── job.slurm                 # Example SLURM submission script
└── requirements.txt

Installation

git clone https://github.com/RAINet-Lab/NeuroFlexMLP.git
cd NeuroFlexMLP

# (recommended) create an isolated environment
python -m venv .venv && source .venv/bin/activate      # or use conda
pip install -r requirements.txt

Requirements: Python 3.8+, PyTorch, NumPy, pandas, scikit-learn, matplotlib, einops==0.4.1. A CUDA-capable GPU is recommended for training the transformer baselines but is not required for NeuroFlexMLP.

Datasets

The benchmark datasets are not bundled with this repository. NeuroFlexMLP is evaluated on the standard long-term forecasting benchmarks (ETTh1/ETTh2/ETTm1/ETTm2, Electricity, Traffic, Weather, ILI) plus networking traces (Milan, EUMA) and the LEO beam-hopping traces.

1. Download the standard benchmarks (e.g. from the Autoformer / LTSF-Linear releases).
2. Place the .csv files under ./dataset/.
3. The reproduction scripts point to --root_path ./dataset/ by default.

Reproducing the results

Every experiment in the paper is scripted. For example, to reproduce NeuroFlexMLP on ETTh1:

bash scripts/NeuroFlexMLP/etth1.sh

Run all main benchmarks:

bash scripts/NeuroFlexMLP/all.sh

Under the hood these call run_longExp.py. A minimal invocation:

python -u run_longExp.py \
  --is_training 1 \
  --model NeuroFlexMLP \
  --data ETTh1 --root_path ./dataset/ --data_path ETTh1.csv \
  --features M --enc_in 7 \
  --seq_len 576 --pred_len 96 \
  --layers 1 --hidden_size 100 \
  --des Exp --itr 1 --batch_size 128 --learning_rate 0.001

Supported models (via --model): NeuroFlexMLP, NeuroFlexMLP_D, Informer, Autoformer, Transformer, PatchTST, DLinear, NLinear, Linear, TSMixer, CrossFormer, and more (see exp/exp_main.py).

LEO beam-hopping use case

The networking-test/ directory contains the full networking-KPI comparison and the beam-hopping scheduler simulation that produce the headline result:

cd networking-test/comparison/script
python compare_networking_kpis.py     # forecast-quality KPIs (NeuroFlexMLP vs Informer)
python scheduler_simulation.py        # beam-hopping scheduler simulation
python plot_asymmetric_cost.py        # asymmetric provisioning-cost analysis

The KPI CSVs and reports are included so results can be inspected directly. The large per-step prediction arrays (.npy) used as inputs are regenerable from the training pipeline above and are omitted here to keep the repository lightweight; they are available on request.

Citation

If you use NeuroFlexMLP in your research, please cite:

@inproceedings{fernandez2026neuroflexmlp,
  title     = {{NeuroFlexMLP}: a Low-Complexity {MLP} Architecture for Long-Term Time Series Forecasting},
  author    = {Fern{\'a}ndez P{\'e}rez, Pablo and Fiandrino, Claudio and Fiore, Marco and Widmer, Joerg},
  booktitle = {Mediterranean Communication and Computer Networking Conference (MAIN)},
  year      = {2026},
  note      = {Mario Gerla Best Paper Award},
  url       = {https://github.com/RAINet-Lab/NeuroFlexMLP}
}

Acknowledgements

This codebase builds on the experimental framework of LTSF-Linear, Autoformer, and PatchTST. We thank the authors for releasing their code.

License

Released under the MIT License. See DISCLAIMER for the warranty notice.

---

Developed at the IMDEA Networks Institute · RAINet Lab