Spectrum-Aligned Sparse Denoisers for Real-Time Interference Coordination

Learned spectrum schedulers can recover capacity that static allocation wastes. One example is a diffusion model, a generator that learns by gradually turning random noise into structured outputs; here it is used to decide how much each cell should prefer each slice of spectrum. The catch is cost. Every scheduling decision runs a neural network several times, and it must finish inside a fixed control deadline. xDiff reports about 21.8 ms per decision on a three-cell testbed. The relevant control loop, the Near-Real-Time RAN Intelligent Controller (an edge server that steers base stations every 10 ms to 1 s), allows at least 10 ms. With dozens of cells and hundreds of resource blocks (the smallest frequency-time units a base station hands out), the network grows and the deadline is missed. Hardware-aligned pruning compresses networks into patterns of zeros that GPU sparse units actually execute faster, such as "2:4" sparsity (two of every four weights are zero). It looks like the obvious remedy, but generic pruning ignores what the network is computing.

Our idea is to choose the sparsity structure from the physics of the radio channel. Neighbouring resource blocks within one coherence bandwidth fade together, meaning they lie in a frequency span over which the channel is roughly constant. Bandwidth parts and subbands also group resource blocks in the standard itself. We therefore compress each scheduler layer into a 2:4 sparse core wrapped by small block-diagonal mixing matrices, with blocks that coincide with these physical groupings rather than arbitrary index ranges. The bet is simple: if the hardware's block structure and the spectrum's correlation structure line up, the network can be made sparse and fast while losing almost nothing in interference coordination.

Core Claim

ARMOR is the method we build on. It approximates each weight matrix as a 2:4 sparse core between two block-diagonal "corrector" matrices and fits them by alternating optimization. On language models it halves the perplexity gap left by SparseGPT and Wanda, and it reaches a 1.57x layer speedup on Qwen 2.5-14B (versus 1.86x for naive 2:4). In ARMOR the block boundaries are generic index ranges. We instead permute and group the resource-block-indexed dimensions so that each diagonal block covers one physically coherent subband:

$$\hat{W} = P^\top A\,(W' \odot M)\,B\,P,$$

The symbols are as follows. $P$ is a fixed permutation that places resource blocks of the same subband (and the same cell) contiguously. $A$ and $B$ are block-diagonal matrices whose blocks match those subbands. $W' \odot M$ is the weight matrix under a 2:4 mask $M$.

The claim has two parts. The first is that, at equal measured latency, this spectrum-aligned factorization gives better scheduling quality than three alternatives: naive 2:4 pruning, ARMOR with generic blocks, and a narrower dense network. The second is that the accuracy advantage comes specifically from the alignment, so it should disappear when $P$ is replaced by a random permutation.

No paper in the file prunes a spectrum controller. xDiff, Iris, MADSPG and the HetNet allocator all run dense networks. The HetNet allocator explicitly names edge compute overhead as future work.

Research Program

We first reimplement an xDiff-style conditional denoiser and its double-Q critic. Its input and output layers are indexed by cell and resource block, so that weight rows and columns correspond to physical spectrum. xDiff supplies the training recipe, reward and soft per-resource-block preference outputs in $[-1,1]$. We do not modify those, since our contribution concerns the compute path.

Second, we build a scalable simulator that extends the three-cell setting to 7, 19 and 37 cells with 50 to 270 resource blocks per cell. Channels follow standard frequency-selective fading with configurable coherence bandwidth. This regime is the one xDiff leaves open, and it is also where the matrices become large enough for sparse hardware units to pay off. At three cells, launch overhead probably dominates whatever the sparsity.

Third, we fit the factorization with ARMOR's block-coordinate procedure, using denoiser activations collected from rollouts as calibration data. ARMOR itself calibrates on 128 SlimPajama samples, so we use an analogous small rollout buffer. Following ARMOR's own observation that its speedup depends on hand-fused kernels, we write a fused Triton kernel for the block-diagonal multiplications and the 2:4 multiply.

Fourth, we treat the latency budget as the primary constraint rather than the sparsity ratio. Every method is placed on a frontier of scheduling quality against measured wall-clock latency. That frontier is traced by varying denoising steps, network width and compression.

A secondary track tests portability, which Direction 1 lists as an open problem. We run the same spectrum-aligned blocks as CPU block sparsity in the style of Fast Sparse ConvNets on an ARM edge CPU. The question is whether physical alignment helps beyond NVIDIA's 2:4 units.

Baselines

Dense reference. The naive reference is the dense xDiff-style denoiser at its native step count. Its quality defines the ceiling we compress toward, and its latency defines what must be beaten. The only reported anchor is xDiff's approximately 21.8 ms on three cells. No reported result was found on Lacuna for xDiff at larger cell counts or for any pruned spectrum controller, so the larger-scale dense latencies will be our own measurements.

Naive 2:4 pruning. This baseline applies one-shot Wanda/SparseGPT-style 2:4 masks to the same trained network, using the same calibration buffer. It isolates whether any correction is needed at all. ARMOR's language-model results suggest it will lose quality, but scheduler networks are small and may tolerate it, so this must be checked rather than assumed.

Generic-block ARMOR. The strongest existing method is ARMOR with its default block layout. It runs with the identical calibration buffer, number of optimization rounds and fused kernel. Its reported numbers are on language models (1.57x layer speedup, about 84% of the theoretical 2:4 maximum, roughly half the perplexity gap of the next-best baseline on Llama-2-13B), not on radio tasks.

Hierarchical pruning. We also run FlexHiNM-GP, which mixes dense, 2:4 and fully pruned regions and learns channel permutations. It reports 79.46% top-1 accuracy on DeiT-Base at 80% sparsity. It tests whether a learned permutation already discovers the subband structure we impose by hand.

Key ablation. The decisive ablation keeps our full method but replaces the physical permutation $P$ with a random one of identical block sizes.

Fairness and the win condition. All methods share data, a fixed GPU-hour budget for calibration and tuning, and the same kernel stack. "Beating" a baseline means higher mean user throughput and fewer UE (user handset) disconnections at equal measured latency. It also means meeting the 10 ms budget at a cell count where the baseline cannot.

Why not just…?

Why not just train a smaller dense network? This is the most serious threat. A narrower dense denoiser can be fast without any sparse kernels, and for the small multilayer networks used by Iris and MADSPG it would almost certainly win, which is why we do not target those networks. We make the dense-width sweep a primary baseline on the latency frontier. If it matches our method at every cell count, we will report that hardware-aligned sparsity is unnecessary for spectrum controllers at these scales, which is itself a useful negative result.

Why not just reduce the number of denoising steps or distill the sampler? Fewer steps cut latency roughly linearly and are orthogonal to per-step cost. We therefore sweep step count for every method and report the joint frontier. Our claim survives only if sparsity shifts that frontier, meaning better quality at equal latency for some step count. Simply matching what step reduction achieves would not count.

Why not let the pruning method learn the permutation, as FlexHiNM-GP does? It might rediscover the subband structure on its own, which would make our physical prior redundant. Running FlexHiNM-GP directly, and inspecting whether its learned groupings correlate with coherence-bandwidth chunks, settles this. If they do and quality matches, our contribution shrinks to a cheaper calibration, because a fixed $P$ avoids the k-means and Hungarian-algorithm cost.

Why not use classical graph-coloring or game-theoretic allocation and skip neural networks? The HetNet allocator reports a fairness score of about 11.5 against about 8.5 for such methods. xDiff reports that DDQN and DDPG baselines caused UE disconnections under strong inter-cell interference. We nonetheless include a fractional-frequency-reuse heuristic as a quality floor.

Proposed Experiments

We validate on an OpenAirInterface and FlexRIC testbed of the same three-cell configuration xDiff used, confirming that compressed models keep commercial UEs connected. Scaling claims are tested in the simulator. Metrics are measured denoiser latency on an Ampere-class GPU at batch size 1, the end-to-end control-loop time, aggregate and fifth-percentile user throughput, Jain fairness, and the disconnection rate.

Three checks would decide the proposal. The first is whether spectrum-aligned factorization strictly dominates the dense-width and step-reduction frontier at 19 and 37 cells. The second is whether the random-permutation ablation loses that advantage. The third, a dose-response test, varies the simulated coherence bandwidth: the alignment benefit should grow when channels are more frequency-correlated and vanish when fading is independent across resource blocks. If all three hold, physical structure is doing real work. If only the first holds, the gain is generic compression and ARMOR deserves the credit.