CellTwin: Reproducible Cellular Network Emulation via High Resolution, in situ Measurement-Driven ML

arXiv:2604.26080 · cs.NI, cs.LG · Submitted 2026-04-28 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: We're looking at the paper: "CellTwin: Reproducible Cellular Network Emulation via High Resolution, in situ Measurement-Driven ML".

Jane: Here's the gist of the paper. The gist NeuralEmu presents a high-fidelity, machine learning-based emulation framework that learns complex 5G scheduler resource allocation behaviors directly from extremely high-resolution network telemetry tools to bridge the reality gap between theoretical algorithm design and real-world cellular performance.

Tom: Current evaluation tools are hamstrung by the inability of record-and-replay emulators to sever the feedback interaction that exists between application end points and a commercial operator’s proprietary 5G scheduler, while full-stack simulators rely on overly simplistic scheduling logic.

Jane: The core problem is that the scheduler maps the current UE state to dynamic bandwidth resource allocation at a slot granularity, and recreating this mapping faithfully is critical to narrow the gap.

Tom: NeuralEmu Architecture NeuralEmu functions as a high-fidelity, machine learning-based emulation framework that learns complex 5G scheduler resource allocation behaviors directly from extremely high-resolution network telemetry tools.

Paper summary: Tom: So, looking at CellTwin: Reproducible Cellular Network Emulation via High Resolution, in situ Measurement-Driven ML, it’s really about using machine learning to learn how a 5G scheduler actually makes decisions based on real network data <ref:2604.26080#pg1,in situ Measurement-Driven ML>.

Jane: It bridges that gap between theoretical algorithm design and what happens in the wild by creating an intuitive framework that learns those complex allocation behaviors directly from telemetry.

Lu: The authors are aiming to provide a standardized testing ground for tomorrow's real-time interactive network protocols and applications by being able to emulate multiple concurrent flows.

Meng: For me, it’s about the fact that they are using measurement driven ML rather than just feeding it simplified rules, which is what I’d actually deploy in production environments where we need reliability.

Tom: They show a significant reduction in emulation error for things like web-page load time and cloud gaming packet one way delay, hitting numbers like fifty five percent and fifty one percent respectively.

Jane: The paper points out that if researchers can't test how an algorithm handles a true 5G environment accurately, then algorithmic innovation in this space will stagnate <ref:2604.26080#pg1>.

Lu: Ultimately, CellTwin is about proving that high resolution measurement driven ML can capture the fundamental relationship between the cellular network’s scheduler and the applications it serves.

Conclusion: Tom: So, to wrap up this CellTwin paper, they’re showing how you can actually make an emulator that matches what happens in a real 5G network using measurement driven machine learning to learn the scheduler's decisions directly from telemetry data <ref:2604.26080#pg1>.

Jane: It’s like taking the black box of a commercial operator's system and feeding it high resolution data so an AI can learn exactly how it allocates bandwidth in real time.

Lu: The core idea is that you need to sever that feedback loop, because current tools either record and replay or use dumb scheduling logic, which just doesn't work for complex real-world stuff.

Meng: And they built this framework using two models, a Neural Scheduler that mimics the base station and a Traffic Reconstructor to figure out the hidden traffic patterns of those background users we usually ignore.

Lalam: The authors are presenting this as a way to get high fidelity emulation for things like web load time and cloud gaming delays, showing errors around fifty percent for those metrics.

Tom: I’m interested in the fact that they used specific telemetry like NR-Scope and CellNinja to feed the training data. That shows a serious effort at getting real, measurable inputs instead of just random traffic.

Jane: And what this means for us is that we can finally test new network algorithms against something that actually behaves like a live cell, not some simplified simulation.

Lu: It’s about creating a standardized testing ground where you can plug in any new scheduling idea and see how it performs under realistic cross-user contention, which is usually the hardest part to model right now.

Meng: From an engineering standpoint, if this works at scale on actual traffic data, that drastically lowers the cost of training and deploying models for network optimization because we’re not guessing what happens next.

Lalam: The conclusion is that this high resolution approach brings the emulation error down to a level where it becomes a valid tool for evaluating real-time protocols.

Tom: So, in short, CellTwin gives us a machine learning system that learns how 5G schedulers work by looking at real network measurements and delivers much more accurate testing results <ref:2604.26080#pg1>.

Jane: It really changes the game by making high fidelity emulation accessible to researchers who want to test real-world performance of new protocols.

Lu: It opens up a path for deeper research into complex resource allocation strategies that are currently too hard to capture accurately with current modeling techniques.

Meng: If this moves from lab setup to actual production traffic, it would be a huge win for deployment because you’re validating the model before you spend resources on real hardware.

Lalam: The implication is that we can stop relying on approximations and start using data driven methods to truly understand how these networks function.

Tom: It moves us from theoretical models to empirically validated testing, which is exactly what we need when dealing with ultra low latency requirements for the next generation of applications.

Haoran Wan, Yaxiong Xie, Kyle Jamieson

Princeton University · University at Buffalo, SUNY

cs.NI, cs.LG

Submitted: 2026-04-28

Updated: 2026-10-20

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 83/100

The gist: The gist NeuralEmu presents a high-fidelity, machine learning-based emulation framework that learns complex 5G scheduler resource allocation behaviors directly from extremely high-resolution network

Key concepts

Neural Scheduler: This is the core engine that mimics a commercial 5G base station. It takes real-time data like user buffer occupancy and channel quality indicators (CQI) as input to dynamically decide how to allocate resources, such as which physical resource blocks (PRBs) to give to each user and what modulation scheme (MCS) should be used for transmission.
Traffic Reconstructor: This model solves an inverse problem. Instead of just observing the scheduler's output, it analyzes the scheduling results to deduce hidden information, such as the actual channel quality indicators and the underlying traffic patterns of uncontrolled background users within the cell.
High-Resolution Telemetry: The system relies on extremely detailed network data captured from sources like a software-defined radio (NR-Scope) and diagnostic modem logs. This high resolution is crucial because it provides the granular, instantaneous information needed to accurately train the machine learning models to replicate complex scheduling decisions.
Earth Mover's Distance (EMD): EMD is a metric used to quantify how similar two distributions are. In this context, it measures the 'distance' between the performance of NeuralEmu and a real-world cellular network, allowing researchers to objectively measure the accuracy of their emulation framework across various network applications.

Terminology

Fidelity — 1× in this paper · explained in 2 episodes

Summary

The gist NeuralEmu presents a high-fidelity, machine learning-based emulation framework that learns complex 5G scheduler resource allocation behaviors directly from extremely high-resolution network telemetry tools to bridge the reality gap between theoretical algorithm design and real-world cellular performance.

Motivation

Current evaluation tools are hamstrung by the inability of record-and-replay emulators to sever the feedback interaction that exists between application end points and a commercial operator’s proprietary 5G scheduler, while full-stack simulators rely on overly simplistic scheduling logic. The core problem is that the scheduler maps the current UE state to dynamic bandwidth resource allocation at a slot granularity, and recreating this mapping faithfully is critical to narrow the gap.

NeuralEmu Architecture

NeuralEmu functions as a high-fidelity, machine learning-based emulation framework that learns complex 5G scheduler resource allocation behaviors directly from extremely high-resolution network telemetry tools. It utilizes two synergistic ML models to forge a highly accurate emulator of the RAN.

Neural Scheduler: This serves as the core emulation engine; it ingests instantaneous buffer occupancies and channel quality indicators (CQI) to dynamically generate resource schedules, faithfully mimicking a commercial 5G base station.
Traffic Reconstructor: This model inverts observable scheduling telemetry to deduce hidden CQI and ingress traffic patterns of uncontrolled background users, reconstructing the cell’s overall buffer dynamics.

Data Collection and Inference

The system collects data from multiple sources to infer invisible states.

**- The network’s view: A software-defined radio running NR-Scope passively eavesdrops on the 5G air interface to capture resource allocation (p[i] and m[i]). The device’s view: CellNinja extracts diagnostic modem logs to reveal the CQI (c1:k[i]) our devices report back to the tower. The Traffic Reconstructor solves the inverse problem by mapping observable scheduling results to inputs like internal CQI and ingress data size. It divides the predictive workload into two specialized networks: a PRB model and an MCS model. The PRB model uses a Gated Recurrent Unit to extract historical time-series features and transformer encoder layers to learn cross-user contention patterns. The output of these models are combined to compute transmission budgets (TBS) for each user over the coming slots. The system is implemented as a high-performance middlebox utilizing Linux AF XDP sockets. The inference and deployment code is written in around 2K lines of C++ code, using NVIDIA TensorRT for low inference latency. The training involves a randomized data collection framework where sessions spawn random users and applications. Training uses PyTorch distributed training on A100 GPUs through slurm job. Each task takes two days to converge, yielding 2000 samples per second from collected data. The checkpoint contains 3.2 and 1.1 MB modes in Neural Scheduler for PRB allocation and MCS selection models. The model inference time is around 456.3 µs when deployed with LibTorch-CPU/GPU and TensorRT. The system mimics HARQ retransmission mechanisms by retrying after ten slots. The framework allows for plug-and-play algorithm evaluation. The study compares NeuralEmu with CellReplay and Mahimahi in single-user setups and demonstrates its ability to emulate multiple concurrent flows. The evaluation uses Earth Mover’s Distance (EMD) to quantify emulation errors.

Improvements for AI systems

Improved AI system can accurately emulate complex 5G scheduler behaviors by learning them directly from high-resolution in situ network telemetry tools using a Neural Scheduler model that maps historical RAN states to future resource allocations.
Improved AI system can reconstruct hidden background user traffic patterns by utilizing a Traffic Reconstructor model that inverts observable scheduling telemetry to deduce the hidden CQI and ingress traffic patterns of uncontrolled background users.
Improved AI system can function as a scheduler-driven digital twin by treating the proprietary commercial scheduler as a black box, learning the mapping from historical network states to future resource allocations using Machine Learning.

Abstract

Current and future applications demand ultra-low latency and consistent throughput, yet frequently traverse 5G cellular networks, so cope with volatile packet dynamics, as 5G base station schedulers dynamically react to user workloads and wireless channel conditions. The task of evaluating network algorithms in these environments is hamstrung by current tools: record-and-replay emulators sever the feedback interaction that exists between application end points and a commercial operator's proprietary 5G scheduler, while full-stack simulators rely on overly simplistic scheduling logic. To bridge this reality gap, we present NeuralEmu, a high-fidelity, machine learning-based emulation framework that learns complex 5G scheduler resource allocation behaviors directly from extremely high-resolution network telemetry tools. The first emulator to handle multiple clients, NeuralEmu utilizes machine learning to dynamically predict resource block allocations and modulation schemes based on instantaneous user buffer occupancy and channel states. To capture realistic cross-user contention, a traffic reconstruction model inverts cellular network scheduling results to recover the underlying traffic patterns of uncontrolled background users. Implemented as an high-performance Linux middlebox emulator, NeuralEmu reduces emulation error relative to the state of the art for various network applications including but not limited to 55% for web-page load time, 57% for WebRTC encoder bit rate, and 51% for cloud gaming packet one-way delay, providing an accurate, standardized testing ground for tomorrow's real-time interactive network protocols and applications.