RouteNet-Fermi: GNN for Network Metrics

• The paper presents RouteNet-Fermi as a graph neural network that uses customized flow, queue, and link representations along with GRU-based message passing to predict key flow-level metrics.
• It overcomes limitations of traditional queueing theory and packet-level simulators by accurately handling diverse traffic models and scaling to larger, unseen network topologies.
• Subsequent studies demonstrate its effectiveness in simulator-to-real transfer learning, emphasizing fine-tuning distinct network blocks to bridge the simulation–reality gap.

Searching arXiv for RouteNet-Fermi and related papers to ground the article in the cited literature. RouteNet-Fermi is a graph-neural-network-based network model for network performance prediction that was introduced to estimate flow-level metrics such as delay, jitter, and packet loss from a representation of topology, routing, queueing or scheduling configuration, and traffic demands (Ferriol-Galmés et al., 2022). Within the RouteNet family, it is characterized by a custom network representation, a modified Message-Passing Neural Network (MPNN) architecture, and GRU-based message passing over flows, queues, and links, with the stated goal of retaining the practical role of queueing theory while improving accuracy under realistic traffic models and complex QoS configurations (Güemes-Palau et al., 1 Oct 2025). Subsequent work has examined RouteNet-Fermi as both an architecture for large-scale network modeling and a case study for simulator-to-real transfer learning, including fine-tuning from OMNeT++-generated data to measurements collected in a custom testbed (Verma et al., 2024).

1. Origins, motivation, and problem setting

RouteNet-Fermi emerged from the limitations of two established approaches to network modeling. Queueing-theoretic models are fast and analytically grounded, but they rely on assumptions such as Poisson arrivals, Markovian traffic, steady-state behavior, and simplified service processes; these assumptions are often violated by bursty, autocorrelated, heavy-tailed, non-stationary, and multi-class traffic (Ferriol-Galmés et al., 2022). Packet-level simulators such as OMNeT++ and NS-3 are more detailed, but they are computationally expensive, scale poorly with network size and traffic intensity, and are slow for repeated exploration or optimization (Verma et al., 2024).

The 2022 RouteNet-Fermi paper positions the model as a data-driven graph neural network that predicts delay, jitter, and packet loss, supports arbitrary traffic models, handles routing changes and QoS scheduling, and generalizes to larger unseen topologies (Ferriol-Galmés et al., 2022). Its central claim is not merely that GNNs can fit simulator outputs, but that a suitably structured model can encode the circular dependencies among flows, queues, and links that dominate network behavior.

A closely related problem, emphasized in later work, concerns deployment outside the training domain. The 2025 transfer-learning study argues that ML-based network models require substantial training data, while real-network measurements are costly and limited, especially for rare or failure-like scenarios (Güemes-Palau et al., 1 Oct 2025). This creates a tension central to RouteNet-Fermi’s later use: simulation is abundant, diverse, and cheap, but real deployment exposes hardware-specific behavior, subtle implementation details of commercial devices, unexpected edge cases, and non-ideal traffic dynamics that are difficult or impossible to model perfectly.

2. Graph representation and message-passing design

RouteNet-Fermi is a custom GNN rather than a vanilla topology-only MPNN. The original paper represents the network through three entity sets—flows $\mathcal{F} = \{f_i\}$, queues $\mathcal{Q} = \{q_j\}$, and links $\mathcal{L} = \{l_k\}$—and models a flow as a path sequence

$$f_i = \{(q^{i,1}, l^{i,1}), \ldots, (q^{i,M}, l^{i,M})\}$$

where $M$ is the number of hops or links (Ferriol-Galmés et al., 2022).

The architectural rationale is the circular dependency structure formalized in the same paper: flow state depends on the queues and links traversed by the flow; queue state depends on the flows using the queue; and link state depends on the queues injecting traffic into the link and on scheduling policy (Ferriol-Galmés et al., 2022). This is why the model uses explicit latent states for different entity types rather than a single homogeneous node representation.

The message-passing mechanism is organized as a three-stage iterative process over flows, queues, and links (Ferriol-Galmés et al., 2022). In the conceptual description given by the 2024 analysis and re-implementation, the three-stage message passing captures dependencies among flows, queues, and links by iteratively propagating information from flows to the queues and links along their paths, updating queue and link states using incoming messages, and repeating the process to capture dependencies across multiple hops and iterations (Verma et al., 2024). In the original architecture, recurrent update blocks are implemented with GRUs: FRNN at flow level, LRNN at link level, and a queue-update GRU, with hidden size 32 and 8 message-passing iterations in the final model (Ferriol-Galmés et al., 2022).

The standard MPNN formalism appears in the original paper as

$$m_v^{t+1} = \sum_{w \in N(v)} M_t(h_v^t, h_w^t, e_{vw}),$$

$h_v^{t+1} = U_t(h_v^t, m_v^{t+1}),$

$\hat{y} = R(\{h_v^T \mid v \in G\}),$

but RouteNet-Fermi departs from this generic pattern through explicit flow–queue–link structure and recurrent path-aware updates (Ferriol-Galmés et al., 2022). This suggests that its novelty lies less in adopting message passing per se than in specializing message passing to network-performance dependencies that are not naturally expressed by a topology graph alone.

3. Inputs, outputs, and scale-aware modeling choices

The model input is a network sample consisting of topology, routing scheme, queueing or scheduling configuration, and traffic flows and parameters (Verma et al., 2024). The 2024 re-implementation describes RouteNet-Fermi as predicting end-to-end delay, jitter, and packet loss from network topology, routing, queueing or scheduling configuration, and traffic demands, with these outputs interpreted as flow-level performance metrics (Verma et al., 2024).

The original paper places particular emphasis on delay prediction. Rather than directly predicting end-to-end delay as a single scalar from the flow state, RouteNet-Fermi predicts effective queue occupancy at each hop, converts that into queuing delay, adds transmission delay, and sums hop delays along the route (Ferriol-Galmés et al., 2022). Jitter is predicted hop-by-hop and summed along the path, while packet loss is predicted directly from the final flow hidden state (Ferriol-Galmés et al., 2022). Packet loss is defined as the ratio of dropped packets to packets sent, so it is bounded in $[0,1]$ (Ferriol-Galmés et al., 2022).

A distinctive design choice is the use of scale-independent and bounded intermediate representations. Instead of raw link capacity, the model uses link load as an input feature, expressing traffic relative to capacity (Ferriol-Galmés et al., 2022). The same paper states that predicting effective queue occupancy rather than raw delay helps avoid numerical extrapolation when path lengths, capacities, and absolute delays move outside the training distribution in larger networks. This is directly tied to the paper’s generalization claim: RouteNet-Fermi was evaluated on topologies from 50 to 300 nodes after training on much smaller topologies, with the abstract highlighting delay estimates with a mean relative error of 6.24% on a test dataset of 1,000 samples including network topologies one order of magnitude larger than those seen during training (Ferriol-Galmés et al., 2022).

4. Recurrent components and later re-implementations

A central feature of RouteNet-Fermi is the use of recurrent neural network cells inside the message-passing pipeline. The 2024 analysis and re-implementation states that recurrent cells are used in the Flow-Level RNN and Link-Level RNN components to process sequential information, maintain memory of prior iterations, capture temporal dependencies in traffic and congestion evolution, and refine hidden states across message-passing rounds (Verma et al., 2024). In that work, the original GRU-based architecture was extended with LSTM and vanilla RNN variants under the same hyperparameters.

The re-implementation gives explicit recurrent equations. For the vanilla RNN,

$h_t = \tanh(W_h \cdot [h_{t-1}, x_t] + b_h).$

For the GRU,

$\mathcal{Q} = \{q_j\}$0

$\mathcal{Q} = \{q_j\}$1

$\mathcal{Q} = \{q_j\}$2

$\mathcal{Q} = \{q_j\}$3

For the LSTM,

$\mathcal{Q} = \{q_j\}$4

$\mathcal{Q} = \{q_j\}$5

$\mathcal{Q} = \{q_j\}$6

$\mathcal{Q} = \{q_j\}$7

$\mathcal{Q} = \{q_j\}$8

$\mathcal{Q} = \{q_j\}$9

(Verma et al., 2024).

The same paper reports complexity estimates for sequence length $\mathcal{L} = \{l_k\}$0, input dimension $\mathcal{L} = \{l_k\}$1, and hidden size $\mathcal{L} = \{l_k\}$2: RNN space $\mathcal{L} = \{l_k\}$3 and time $\mathcal{L} = \{l_k\}$4; GRU space $\mathcal{L} = \{l_k\}$5 and time $\mathcal{L} = \{l_k\}$6; LSTM space $\mathcal{L} = \{l_k\}$7 and time $\mathcal{L} = \{l_k\}$8 (Verma et al., 2024). Under a TensorFlow CPU training setup with hidden state size 32, batch size 2000, optimizer Adam, and learning rate 0.001, the recurrent variants were compared on delay, jitter, and packet loss tasks (Verma et al., 2024).

That comparison indicates that recurrent-cell choice materially affects RouteNet-Fermi behavior. On real traffic delay prediction, the re-implementation reports MAPE of 4.05% for RNN, 1.82% for LSTM, 2.18% for GRU, and 5.67% for the paper GRU (Verma et al., 2024). On scheduling-policy datasets, delay MAPE is reported as 9.80% for RNN, 2.96% for LSTM, 3.82% for GRU, and 3.35% for the paper GRU; jitter MAPE as 29.70%, 16.73%, 17.01%, and 17.21%; and packet-loss results as 0.007464, 0.002218, 0.002063, and 0.001978, respectively (Verma et al., 2024). The authors conclude that LSTM often gives the best accuracy, especially for delay, GRU offers a strong balance of performance and efficiency, and vanilla RNN is generally too weak for complex or large-scale scenarios (Verma et al., 2024).

5. Simulator-to-real transfer learning

The 2025 paper uses RouteNet-Fermi as the core network-performance model in a study of transfer learning from simulated to real network data (Güemes-Palau et al., 1 Oct 2025). The stated problem is that collecting real training data is costly and limited, whereas simulated data is abundant and cheap to generate; yet models trained only on simulation often transfer poorly because simulation does not capture hardware-specific behavior of routers and switches, subtle implementation details of commercial devices, unexpected edge cases, non-ideal traffic dynamics, and other real-world nuances (Güemes-Palau et al., 1 Oct 2025).

The transfer-learning workflow is a two-stage fine-tuning procedure. First, a RouteNet-Fermi model is pre-trained on a large synthetic dataset generated with a simulator. Second, the pre-trained model is adapted using a much smaller real-world dataset collected from a testbed (Güemes-Palau et al., 1 Oct 2025). During fine-tuning, training follows the original process but uses real-network samples and a smaller learning rate, approximately 10× smaller (Güemes-Palau et al., 1 Oct 2025).

The paper decomposes RouteNet-Fermi into three main blocks—Encoding, Message Passing Algorithm (MPA), and Readout—and studies configurations in which each block is frozen, fine-tuned, or re-trained (Güemes-Palau et al., 1 Oct 2025). One explicitly cited manual configuration is: freeze Encoding, fine-tune MPA, and re-train Readout. The paper also states selection principles for valid configurations: avoid freezing a block if a previous block is re-trained in a way that would break representation flow; avoid freezing everything; and avoid re-training everything, since that would be equivalent to training from scratch (Güemes-Palau et al., 1 Oct 2025).

The experimental setup combines OMNeT++-generated training data with a custom physical testbed (Güemes-Palau et al., 1 Oct 2025). The simulated dataset uses topologies ranging from 5 to 8 nodes and diverse routing configurations. The real-world dataset is collected from a custom testbed with up to 8 real routers and traffic generators connected via switches, VLAN-based configurations to emulate different topologies, links ranging from 1 to 40 Gbps, traffic generated using MGEN and Tcpreplay, and an optical splitter for passive traffic capture with low interference; in the evaluation, the real testbed is configured as a fixed 5-router topology (Güemes-Palau et al., 1 Oct 2025). Both simulated and real datasets include Poisson, On/Off, and MAWI traffic distributions, and because RouteNet-Fermi assumes stationary traffic, the paper adapts it to non-stationary conditions by splitting scenarios into 100 ms temporal windows and predicting delay for each flow-window pair (Güemes-Palau et al., 1 Oct 2025).

6. Empirical performance, related hybrids, and limitations

The empirical record for RouteNet-Fermi spans original simulation studies, physical-testbed evaluation, recurrent-cell re-implementations, and transfer-learning experiments.

In the original 2022 paper, RouteNet-Fermi is reported to outperform queueing theory across traffic models and scheduling settings. For delay MAPE under traffic models, the paper reports: Poisson 2.1% vs QT 12.6%; Deterministic 4.43% vs QT 22.4%; On-Off 2.90% vs QT 23.1%; Autocorrelated Exponentials 2.62% vs QT 21.1%; Modulated Exponentials 5.21% vs QT 68.1%; and Mixed 4.71% vs QT 35.1% (Ferriol-Galmés et al., 2022). For jitter MAPE, RouteNet-Fermi reports 6.26%, 7.17%, 8.50%, 6.29%, 10.3%, and 9.82% on the same traffic families, while QT reports 71.9%, 99.0%, 69.4%, 74.3%, 91.4%, and 69.1% (Ferriol-Galmés et al., 2022). On a physical testbed with 8 Huawei routers, 2 Huawei switches, and 4 servers, using 1,000 samples with an 800/200 train-test split and topology size up to 8 nodes, the model reports 11.0% MAPE and $\mathcal{L} = \{l_k\}$9 (Ferriol-Galmés et al., 2022). On real traffic traces using SNDlib topologies and MAWI inter-arrival traces, the same paper reports 5.67% MAPE and $$f_i = \{(q^{i,1}, l^{i,1}), \ldots, (q^{i,M}, l^{i,M})\}$$0 (Ferriol-Galmés et al., 2022).

The 2025 transfer-learning study reports that a model trained only on simulated data has errors 9.90x and 17.958x larger than the real-data-only baseline in Poisson and On/Off traffic, respectively, demonstrating a pronounced simulation-to-reality domain gap (Güemes-Palau et al., 1 Oct 2025). Its best manual fine-tuning configuration—freeze Encoding, fine-tune MPA, re-train Readout—achieves 82% improvement over the real-data baseline for Poisson and 59.4% improvement for On/Off, with normalized MAPE dropping to 0.180 and 0.406, respectively (Güemes-Palau et al., 1 Oct 2025). Among automated methods, the paper evaluates Autofreeze, L2-SP, and GTOT-Tuning; Autofreeze improves MAPE by 80% on On/Off, and GTOT-Tuning achieves the best Poisson result, with an 88% reduction in error (Güemes-Palau et al., 1 Oct 2025). In a data-efficiency experiment on MAWI traffic, MAPE improves from 19.01% to 16.19% with 5 scenarios, drops to 11.95% with 10 scenarios, and drops to 9.95% with 50 scenarios; the paper identifies the latter two as 37% and 48% reductions, and states that beyond about 125 scenarios the benefit over training from scratch disappears for this model in this setting (Güemes-Palau et al., 1 Oct 2025).

A related but distinct hybrid line is QT-Routenet, which combines an analytical queueing-theory baseline with a modified RouteNet-style GNN (Afonso et al., 2022). It is not RouteNet-Fermi itself, but it is relevant because it addresses the same generalization problem from a different direction: compute a robust approximate estimate using queueing theory, then let a smaller GNN learn a correction or refinement (Afonso et al., 2022). In the 5G challenge setting described in that paper, the analytical baseline test MAPE is 10.42, Model 1 and Model 2 each achieve 1.45, and their ensemble achieves 1.27; by contrast, raw RouteNet-style models fed with raw features are reported to exceed 300% MAPE on the competition dataset (Afonso et al., 2022). A plausible implication is that RouteNet-Fermi research occupies a broader design space in which message-passing neural surrogates can be strengthened either by architectural inductive bias, as in the original flow–queue–link formulation, or by analytically informed hybridization, as in QT-Routenet.

The limitations reported in the literature are correspondingly specific. The original RouteNet-Fermi paper states that the model provides no formal guarantees, depends on representative training data, does not generalize to traffic models not present during training, and still requires labeled simulated or measured data for training (Ferriol-Galmés et al., 2022). The 2024 re-implementation adds practical limitations, including CPU-only training, untested larger hidden states and batch sizes, and difficulty matching some results, especially jitter on traffic models (Verma et al., 2024). Across these works, jitter is repeatedly identified as especially challenging, which suggests that temporal variability and burstiness remain harder to capture than mean delay even within recurrent GNN formulations (Verma et al., 2024).