Comparator-Only Readout for Unfolded Hybrid Beamforming on Analog Hardware

Large antenna arrays at millimeter-wave and terahertz frequencies cannot give every antenna its own radio chain, the bundle of data converters, mixers and amplifiers behind each element. Designers instead use "hybrid beamforming": a small digital stage feeding a large network of analog phase shifters. Choosing those phase settings is a hard non-convex optimization, and it must be redone every few milliseconds as the channel changes. Deep unfolding turns a fixed number of iterations of a classical solver into the layers of a small trainable network, and it has made this optimization roughly a thousand times faster in software. The natural next step is to run these unfolded solvers on analog matrix-multiply hardware: in-memory crossbars or photonic tensor cores, which compute a matrix-vector product in one physical step. That step meets a known obstacle. On such hardware, the analog-to-digital converters (ADCs) that read results out dominate power, and their output noise is the error that hurts accuracy most.

This note argues that unfolded hybrid beamforming has an unusual property that removes most of that obstacle. Each analog-precoder layer ends by snapping every entry to one of a few allowed phases, because practical phase shifters have only one to three bits. Only the phase sector of each output entry matters, not its magnitude. Deciding a sector among $2^b$ choices takes $2^{b-1}$ one-bit comparators, each reading a rotated combination of the real and imaginary outputs, and those rotations can be built into the analog matrix itself. The proposal is to co-design the unfolded solver, the phase-shifter bit depth, and a comparator-only readout. The iterate then circulates between layers as $b$-bit phase indices, with no multi-bit ADC anywhere in the analog-precoder loop. The design is trained with output-noise injection at the comparator inputs, which is where the hardware actually fails.

Core Claim

Write $F_{RF}^{(k)}$ for the $N_t \times N_{RF}$ analog precoder after unfolded layer $k$, $F_{BB}^{(k)}$ for the small digital precoder, $H$ for the channel, $G$ for the gradient of the spectral-efficiency objective, and $\alpha_k$ for a trainable step size. Each analog-precoder layer then has the form

$$F_{RF}^{(k+1)} = Q_b\!\left(F_{RF}^{(k)} - \alpha_k\, G(F_{RF}^{(k)}, F_{BB}^{(k)}; H)\right), \qquad Q_b(z) = e^{\,j 2\pi m^\star / 2^b},\; m^\star = \arg\max_m \mathrm{Re}\!\left(z\, e^{-j 2\pi m / 2^b}\right),$$

where $Q_b$ maps each complex entry to the nearest of $2^b$ phases. Two facts follow. The first is that $m^\star$ is fixed by the signs of $\mathrm{Re}(z e^{-j\theta})$ at the $2^{b-1}$ sector-boundary angles $\theta$, so each entry needs one comparator per boundary instead of two multi-bit ADCs. The second is that $Q_b(cz) = Q_b(z)$ for any $c > 0$. A gain error or conductance drift shared by an entry's real and imaginary paths therefore cancels exactly, and that is the dominant slow error in these devices. The claim is that these two facts make the analog-precoder loop of an unfolded solver both far cheaper to read out and more tolerant of simulation-versus-hardware mismatch than a generic network mapped to the same substrate. With training that accounts for sector boundaries, the spectral-efficiency loss compared with an ideal floating-point unfolded solver should be small for $b \le 3$.

The claim has stated limits. For $b = 4$, eight comparators per entry approach the cost of a 3-bit flash ADC, so the advantage should vanish there; locating that crossover is part of the work. Per-device variation, mismatch between the real and imaginary columns, and comparator offset do not cancel. They matter most for entries that sit near a sector boundary, and the training method targets exactly those entries.

Relation to Prior Work

The closest work supplies the solver. Deep Unfolding Hybrid Beamforming Designs for THz Massive MIMO Systems unfolds projected gradient descent into ManNet and subManNet. These networks are trained without labels on spectral efficiency, and they reach the performance of manifold-optimization alternating minimization at over 1000 times its speed. Joint Communications and Sensing Hybrid Beamforming Design via Deep Unfolding adds inner analog loops nested inside an outer digital loop, with layer-wise step sizes, to correct an imbalance between the analog and digital gradients. Both papers assume continuous ideal phases and floating-point digital execution. Neither touches converters or hardware. We reuse their layer structure and their unsupervised loss. What changes is the projection: it becomes a hardware-quantized operation, and its readout becomes the design variable.

The constraining evidence comes from the in-memory computing side. Hardware-aware training for large-scale and diverse deep learning inference workloads using in-memory computing-based accelerators shows that noise at the crossbar output, from ADC quantization and conversion, degrades accuracy far more than noise in the stored weights. It also shows that injecting realistic noise during training recovers much of the loss, but only for standard vision, language and speech networks. TeMPO reports that DAC and ADC power can exceed three-quarters of a photonic tensor core's total, and Newton makes the same argument for crossbars: once arithmetic is nearly free, conversion is the cost. These results motivate attacking the readout rather than the arithmetic.

On phase quantization, Hybrid Digital and Analog Beamforming Design for Large-Scale Antenna Arrays reports that simply rounding phases after optimization can cost about 5 dB. That figure is why quantization must sit inside the unfolded loop and inside training, not be applied at the end. Dynamic Symmetric Point Tracking shows that static calibration of analog references costs pulse overhead scaling as $O(1/\Delta w_{\min})$, where $\Delta w_{\min}$ is the smallest programmable weight step. Our scale invariance is a different answer to the same problem: rather than tracking the reference, the readout is built to ignore its common-mode part.

One practical constraint shapes the substrate choice. The matrices inside $G$ depend on the channel and change every coherence block. Writing nonvolatile crossbars (PCM, ReRAM) at millisecond rates is unrealistic for speed and device endurance. The primary target is therefore a dynamic analog engine in the TeMPO style, where both operands are modulated at run time. Nonvolatile crossbars are reserved for the channel-independent learned parts of the network.

Research Program

The first component is the solver. We will build a quantization-native variant of ManNet in which each analog-precoder layer computes $2^{b-1}$ rotated outputs per entry: the rotations are folded into extra analog output columns, then thresholded by comparators. Iterates pass between layers as $b$-bit phase indices. For $b \le 2$ these indices drive the input modulators directly as values in $\{\pm 1, \pm j\}$, so the input DACs become trivial. The small digital precoder $F_{BB}$, of size $N_{RF} \times N_s$, stays in digital logic. We keep the inner-outer loop structure of the joint communications and sensing paper, so the analog block takes several inner steps for each digital step.

The second component is training. A hard sector decision has zero gradient almost everywhere. We will compare two ways around this: a straight-through estimator, and a softmax over sectors whose temperature is annealed toward hard decisions. During training we will inject comparator offset, thermal noise, column mismatch and common-mode drift at the comparator inputs, with magnitudes drawn from the AIHWKit device models documented in Using the IBM Analog In-Memory Hardware Acceleration Kit. A margin term will push pre-quantization outputs away from sector boundaries. This is the specific ingredient we expect a generic hardware-aware training recipe to lack.

The third component is a cost and latency model for the whole transceiver. It will combine the radio-chain power for a given $N_{RF}$, the phase-shifter count and bit depth, and the converter and comparator energy of the baseband engine. The model addresses a trade-off the literature leaves open: removing radio chains moves work onto baseband hardware that has its own conversion bottleneck. If solver energy turns out negligible next to radio-chain power, the model will say so, and it will also report the latency gain, since a comparator decision takes one cycle while a successive-approximation ADC takes several.

Baselines

The naive reference point is ManNet as published, run in floating point on a digital processor, with its continuous phases rounded to $b$ bits after the final layer. This is the "do nothing" deployment. The 5 dB rounding penalty reported by Hybrid Digital and Analog Beamforming Design suggests it will be clearly beatable. The same network evaluated with ideal continuous phases serves as an upper reference for accuracy, not as a competitor.

The strongest accuracy competitor is manifold-optimization alternating minimization from Alternating Minimization Algorithms for Hybrid Precoding. That paper reports spectral efficiency "nearly identical to an unconstrained, fully digital system" on its 144-transmit, 36-receive benchmark. ManNet is reported "comparable to or better" at "over 1000 times faster" with "complexity reduced by a factor of six" at 128 transmit antennas. No absolute spectral-efficiency value in bits per second per hertz was found on Lacuna for either method. We will therefore re-run both on identical channel realizations and report our own numbers, with the alternating-minimization method given unlimited iterations and with $b$-bit quantization applied by the best discrete projection we can find.

The strongest practical competitor is a fully digital quantized unfolded solver. This is the same quantization-aware ManNet with 8-bit and then 4-bit integer arithmetic, given the same training data, the same number of layers, and an equal hyperparameter-search budget. It has no simulation-to-hardware gap at all, so it is the real threat. Beating it means matching its spectral efficiency within 0.5 dB at $b \le 3$ while showing lower modeled energy and latency per solve. The energy comparison uses the same technology assumptions on both sides.

The fourth baseline is the naive analog transfer: the quantization-aware ManNet mapped onto the same analog engine with conventional multi-bit ADCs (4 to 8 bits), trained with the standard hardware-aware recipe of Hardware-aware training for large-scale and diverse deep learning inference workloads. It isolates whether the comparator readout itself is what helps. Two ablations isolate the remaining ingredients: comparator readout trained without the margin term and without noise injection, and comparator readout with common-mode drift turned off during evaluation, which measures how much robustness the scale invariance actually supplies.

Why not just…?

Why not just run a quantized unfolded solver on a digital signal processor? This is the strongest alternative, and it may win whenever solver energy is small next to radio-chain power. The 54 ms per solve reported by Deep Graph Unfolding for Beamforming in MU-MIMO Interference Networks suggests that digital unfolded solvers can still miss millisecond coherence times. That figure is for a different solver, though, and ManNet's absolute latency is not reported in the file. The end-to-end budget model, together with the matched digital-integer baseline, settles the question directly. If the analog design does not win on energy per solve at equal spectral efficiency, we will report that outcome.

Why not just apply off-the-shelf hardware-aware training with a low-bit ADC? Output noise is the most damaging error on these substrates. A generic multi-bit readout spends its resolution on magnitudes that the phase projection then discards. The fourth baseline tests this directly at matched readout energy, comparing 2- to 4-bit ADCs against the equivalent comparator count.

Why not just use classical phase-extraction alternating minimization or orthogonal matching pursuit? These avoid training and the hardware gap entirely. However, the alternating-minimization paper notes that the phase-extraction variant buys speed by imposing orthogonality constraints that cost spectral efficiency. The iterative versions also need repeated matrix inversions whose cost grows cubically with array size, which ManNet's reported sixfold complexity reduction reflects. We will include phase-extraction alternating minimization with the same $b$-bit quantization, and its latency will be measured on the same digital processor.

Proposed Experiments

All experiments use extended Saleh-Valenzuela channels in three configurations: the 128-transmit-antenna THz setting of ManNet, the 144-by-36 setting of the alternating-minimization paper, and the 64-by-16 point-to-point setting of Sohrabi and Yu. We sweep $b \in \{1, 2, 3, 4\}$, $N_{RF} \in \{N_s, 2N_s\}$, and fully versus sub-connected arrays. The hardware model comes from AIHWKit, extended with comparator offset and column mismatch, and the power model follows the TeMPO style. No results on Sionna, DeepMIMO or CrossSim were found on Lacuna, so we do not rely on them.

The metrics are spectral efficiency, energy per solve, latency per solve, and spectral efficiency as a function of simulated drift time.

Three checks decide the proposal. The first is a crossover sweep over $b$: comparator readout should beat multi-bit-ADC readout at matched energy for $b \le 3$ and lose its advantage near $b = 4$. A clear advantage at every $b$ would indicate an error in the cost model.

The second is a mismatch test that stands in for the simulation-to-hardware gap. We train under one noise model and evaluate under a perturbed one, with doubled offsets, different drift exponents and added IR drop. The scale-invariant comparator design should degrade measurably less than the multi-bit-ADC analog transfer.

The third is the matched digital-integer comparison. Unless the analog design reaches equal spectral efficiency with lower modeled energy or latency, the proposal reduces to a negative result, which is still worth publishing.

Where the IBM Fusion chip is accessible, we will run the channel-independent learned layers on it to calibrate the noise model against real silicon.