Safeguarded Convolutional Preconditioners for Large-Array Beamforming

Choosing phases for a reflecting surface with thousands of elements, or precoders for a base station with a hundred antennas, is usually done with iterative solvers. Each step of these solvers is limited by a single worst-case step size, and computing that step size, via the largest eigenvalue of a big channel matrix, costs as much as a matrix inversion. Recent work replaces the step-size rule with a small neural network, which speeds things up considerably. That speedup comes with two costs. The solver no longer improves the objective at every step, and the network is tied to the array size and geometry it was trained on. This note proposes a different split. A fully convolutional network reads a per-element "image" of the channel and the current gradient, and outputs a separate step size for every antenna or surface element. The classical solver keeps final authority: a learned step is accepted only when a cheap check confirms it improves the solver's own lower bound on the objective, and otherwise the solver falls back to the conservative step.

Two properties make this worth testing. First, a convolution slides the same small filter across the array, so a network trained on a 16×16 surface runs unchanged on a 64×64 one. Cost per iteration grows linearly with element count, and the network needs no retraining when the hardware changes. Second, the acceptance check means the method can never do worse per iteration than the classical algorithm it accelerates. Deployment in a real radio controller would plausibly require that guarantee, and current learned beamformers give it up.

Core Claim

A per-element step size, predicted by a convolutional feature extractor without pooling or normalization layers and gated by a minorization check, can match the speed of learned unfolded solvers while keeping strict monotone improvement. It should also transfer from small to much larger arrays, including reconfigurable intelligent surfaces (passive panels of tunable reflectors, abbreviated RIS). There, classical solvers become impractical, and no existing learned method in the file has been shown to scale.

Why This Gap, and Which Prior Work Plays Which Role

The scaling problem is well documented. Interior-point relaxations scale as $O(N^6)$ or $O(N^{4.5})$ in the number of elements. WMMSE and fractional programming need $O(N_t^3)$ inversions at every iteration. RIS phase optimization is flagged as the bottleneck once arrays reach hundreds or thousands of elements, and beyond-diagonal surfaces make it worse through quadratic variable growth (Beyond Diagonal RIS).

Three deep-unfolding papers supply the method family we build on and also define what we must beat. DeepFP unrolls FastFP, a fractional-programming beamformer that avoids inversions. It then replaces FastFP's $O(N_t^3)$ eigenvalue step-size rule with network-predicted per-user step sizes. The result reaches 97.4% of the weighted sum rate (WSR) of 100-iteration FastFP using 11.7% of its CPU time. Its authors state that it loses monotone convergence and assumes fixed linear or planar arrays. UPGANet unrolls projected gradient ascent for hybrid beamforming in joint communication and sensing, learning the step sizes. ManNet unrolls Riemannian gradient descent for THz hybrid precoding and runs over 1000× faster than manifold optimization. All three learn a fixed number of layers tied to one problem size, and none keeps a per-iteration improvement guarantee.

We differ from them in three ways. We learn a preconditioner for every element rather than scalars for every user or layer. We keep the classical iteration and its guarantee intact. And we make size transfer a design goal instead of an afterthought.

Augmented Deep Unfolding is the closest in spirit. It leaves WMMSE intact as a fixed operator and puts a learned calibration network in front of it. It also found that black-box networks failed to generalize as antennas scaled from 40 to 72, while the augmented design kept improving. That result motivates keeping the solver in charge. We push the idea further by letting the network touch only the step size, with a formal fallback.

The feature-extraction literature supplies the extractor and also constrains its design. The surveys (CNN review; detection evolution) describe the standard recipe of stacked local filters, pooling, and depth. Two standard ingredients of that recipe are wrong for this task. Pooling discards exact position, but a per-element step must be spatially exact, so we use a U-shaped encoder–decoder that restores full resolution, plus dilated convolutions for context. Normalization removes absolute magnitude, and NF-KD showed directly that it hurts on channel data. In that paper, normalized distillation was worse than no distillation at low bit rates, and dropping normalization improved reconstruction from −11.98 to −12.87 dB NMSE on DeepMIMO. We therefore use no normalization layers. We also add globally averaged, unnormalized summary features to every element's input, so the network sees array-wide energy even when its receptive field covers only part of a large array.

CNN-based cell-free power allocation shows convolution can extract interference structure from a network-layout tensor. However, it outputs allocations directly, with no feasibility or improvement guarantee, and its input size is fixed.

Research Program

The base algorithm is a minorization–maximization (MM) iteration, meaning each step maximizes a simple lower bound on the objective that touches it at the current point. For RIS phases $\theta \in \mathbb{C}^N$ with unit-modulus entries, the objective reduces locally to a quadratic form with Hermitian matrix $A$, built from the cascaded channels and the quadratic-transform auxiliary variables. The standard update is

$$\theta^{t+1} = \mathrm{proj}_{|\cdot|=1}\big(\theta^t + D^{-1}\nabla f(\theta^t)\big),$$

where $\nabla f$ is the gradient and the projection normalizes each entry to unit magnitude. FastFP-style methods set $D = \lambda_{\max}(A)\, I$, a scalar multiple of the identity. Any positive diagonal $D \succeq A$ keeps the lower bound valid. We let a convolutional network $g_\phi$ output $D = \mathrm{diag}(g_\phi(X^t))$. Its input $X^t$ is a multi-channel map over the element grid containing the real and imaginary parts of the current phase and gradient, the per-element cascaded channel magnitudes to each user, and the diagonal of $A$. Magnitudes are left unnormalized throughout.

The safeguard checks whether the learned step increases the lower-bound function. Doing so costs one evaluation of that function, which is $O(NK)$ for $K$ users, so no eigenvalue or inversion is ever needed. If the check fails, the iteration uses the classical row-sum diagonal majorizer instead. That majorizer is valid by diagonal dominance, avoids the eigenvalue computation, and is also one of our baselines. By construction, every iteration improves the objective.

Training unrolls $T$ safeguarded iterations and maximizes the final sum rate. Following DeepFP, we first run a warm-start phase that imitates the classical trajectory. Training is done at small sizes only, and testing covers sizes up to 16× larger in element count. The same machinery applies to precoding: in the FastFP setting, the grid is the base station antenna array and the network predicts per-antenna steps.

Beyond the method, we will analyze three things. The first is how often the safeguard fires as array size grows, since a rising rejection rate would indicate the receptive field is too small. The second is whether the learned $D$ resembles known preconditioners, such as the row sums of $|A|$ or local channel energy. That comparison is our route to interpretability. The third is how many iterations are needed to reach 97% of the converged objective, as a function of $N$.

Baselines

The naive reference point is classical MM with the conservative scalar step $\lambda_{\max}(A)$, computed by power iteration and run to convergence. Its converged value defines 100%, and its wall-clock time defines the budget for time-matched comparisons. Next to it we run the row-sum diagonal majorizer. It is the cheapest non-learned per-element preconditioner with the same guarantee, and it is the most dangerous simple competitor. Beating it by a clear wall-clock margin at equal final objective is the minimum bar for claiming that learning adds anything.

The strongest existing learned method is DeepFP. It reports 97.4% of 100-iteration FastFP WSR at 11.7% of the CPU time in its 7-cell, $N_t=64$ setup, and about 97% when tested on 16 to 56 antennas. We will re-run it in that same 7-cell simulator, using the same channel draws, the same training-sample budget, and the same hyperparameter-search budget. Beating it means reaching at least 97.4% WSR at no more than its CPU time, with zero objective decreases. On transfer to $N_t = 128$, which it never saw, beating it means holding at least 97% where DeepFP degrades. For RIS phase optimization, I found no reported result on Lacuna for a learned method at large element counts. The RIS baselines are therefore DeepFP-style per-user step prediction, adapted by us and retrained at each size, plus manifold optimization in the ManNet comparison class. For manifold optimization, the file gives only relative speed figures: over 1000× slower than ManNet.

The key ablations isolate each ingredient in turn. Removing the safeguard tests whether the guarantee costs speed. Inserting batch normalization tests whether the NF-KD finding carries over from compression to optimization. Replacing the U-shaped extractor with a pooled encoder tests whether spatial exactness matters. Replacing the convolution with a graph network over elements tests whether grid structure matters beyond weight sharing.

Why not just…?

Why not just use a classical adaptive preconditioner, like the row-sum majorizer or Adam-style diagonal scaling, with backtracking? This is the real threat, because these methods are also per-element, size-agnostic, and cheap. They lack foresight: they react to past gradients or worst-case bounds rather than predicting from channel structure where large steps are safe. No paper in the file compares against them, so the experiments decide the question. If the row-sum majorizer plus backtracking gets within a few percent of our wall-clock curve, the learned component is not justified and we will report that.

Why not just retrain DeepFP at each array size? DeepFP already transfers reasonably across 16 to 56 antennas, but it gives up monotonicity. Retraining for every RIS size and geometry is also costly: a surface layout change should not require new training data. Distributed deep learning for resource management needed about 2.5 billion samples and full retraining whenever topology changed, which illustrates the price. We report DeepFP retrained at every size as a ceiling it is allowed to reach.

Why not just group elements into tiles and solve a smaller classical problem? Tiling reduces dimension but fixes a coarse phase pattern and loses array gain. ManNet's sub-connected variant similarly degrades when sparsity cannot be offset by array size. We include tiled MM followed by per-element refinement as a baseline. If it matches us, the multi-scale structure, not the learning, is doing the work.

Proposed Experiments

The first testbed reproduces the 7-hexagonal-cell, 64-antenna, 4-receive-antenna simulator used by DeepFP. It checks, on DeepFP's own ground, whether safeguarded per-antenna preconditioning reaches its 97.4%/11.7% operating point, and then extends the antenna sweep to 128. The second testbed is RIS-aided multi-user downlink. We draw base-station and user channels from DeepMIMO scenario O1, the ray-traced setup used by NF-KD, and place a planar RIS at a ray-traced location. We train at 16×16 elements and test at 32×32 and 64×64, with user counts of 4 to 16.

The metrics are fraction of the converged sum rate at matched wall-clock time, time to reach 97%, measured runtime scaling exponent in $N$, the number of objective decreases (which must be zero for our method), and safeguard rejection rate.

The decisive checks are these. Train-small, test-large transfer must hold within 3% of the converged value at 64×64. The method must beat the row-sum majorizer in time to reach 97%. Removing normalization must measurably help, as it did for compression. The safeguard must cost less than 10% of the speedup relative to the unsafeguarded variant.