A base station has a few milliseconds to choose transmit powers or beamforming weights before the radio channel changes. Classical solvers are too slow for that window. Deep unfolding helps: it turns a fixed handful of solver iterations into a small trained network, and on digital hardware that already gives 8–24× speedups. On digital chips, though, most of the energy goes into moving the channel matrix and weights between memory and arithmetic units. Analog in-memory computing removes most of that movement. It stores a matrix as the electrical conductances of a grid of memory devices, called a crossbar, and multiplies it by a vector in one physical step. The catch is that in-memory solvers get their large gains only when the matrix is written once and then read many times. A wireless channel matrix changes every coherence interval, which is the short period during which the channel stays roughly constant.
The proposal is to treat the crossbar as a slowly updated copy of the channel. Each coherence interval, we rewrite only the cells whose channel entries have drifted past a threshold, using single programming pulses with no check-and-retry loop. The unfolded solver is trained end-to-end against that stale, noisy copy, so its learned step sizes absorb the error. The trained solver weights sit in a separate crossbar that is written once and never touched again. The claim to test is that this keeps near-WMMSE sum-rate (WMMSE, weighted minimum mean-square error, is the standard iterative solver) while cutting device writes far enough that the hardware survives deployment. A simple endurance calculation shows that full rewriting would wear the devices out very quickly.
Core Claim
The decisive cost in this setting is not reading the crossbar but writing it, and that cost can be bounded. Memory devices tolerate roughly $10^5$ to $10^8$ writes. At one full rewrite per millisecond coherence interval, $10^8$ writes last about a day and $10^5$ writes last under two minutes. Any design that reprograms the channel matrix every interval is therefore dead on arrival, however good its energy per solve looks.
The proposal makes two moves. The first borrows the threshold-triggered "blind update" that Mixed-Precision Deep Learning Based on Computational Memory used for neural network weight gradients. We apply it instead to a time-varying input operand, the channel, and the update rate becomes a property of how fast users move. The second makes staleness and programming noise part of the training distribution of the unfolded solver.
The threshold can be tied to an existing stability analysis. Chowdhury, Gama and Segarra derived per-layer perturbation bounds for unfolded WMMSE. If every stored entry is within $\delta$ of the true channel, the stored copy is a bounded perturbation of the true one. Their analysis then predicts an output error that grows with $\delta$ and with the per-layer sensitivity across the $K$ layers. This gives a principled starting value for $\delta$, which training then tunes. That paper also reports that 4% of nodes exceeded the predicted first-order bound, so we treat the bound as a guide rather than a guarantee and measure violations directly.
Research Program
We build two solver families, each matched to a crossbar mapping.
The first is ad-hoc power allocation, following Unfolding WMMSE Using Graph Neural Networks for Efficient Power Allocation. That paper unfolds WMMSE into 4 layers whose update parameters come from a graph neural network, a network that passes messages between transmitter–receiver pairs. Its channel-dependent operations multiply vectors by the matrix of squared channel gains $|h_{ij}|^2$. Those entries are non-negative, so they map directly onto conductances without paired positive and negative devices. This is the cleanest test of the write-sparse idea.
The second is multi-antenna beamforming. Here we unfold projected gradient ascent rather than WMMSE, as Joint Communications and Sensing Hybrid Beamforming Design via Deep Unfolding did. Gradient steps need only products with $H$ and its conjugate transpose $H^H$, not the cubic-cost matrix inversions that unfolded WMMSE keeps in every layer. We take the symmetric block trick from the RRAM primal-dual solver of Vo et al., which stores $[0, K^\top; K, 0]$ so that one array serves both $Kx$ and $K^\top y$. We apply it to the real-valued expansion of the complex channel, so one crossbar serves both $H$ and $H^H$ without a transposed duplicate.
On complex numbers specifically: the research file argues that complex arithmetic needs four separate real crossbars, each with its own converters. The real-valued expansion $[\mathrm{Re}\,H, -\mathrm{Im}\,H; \mathrm{Im}\,H, \mathrm{Re}\,H]$ instead needs one array with four times the cells but only $2N$ output conversions per pass. Whether that actually avoids the converter bottleneck is something we measure, not assume.
Simulation extends MemTorch, a PyTorch simulator of memristive devices with variability, stuck-at faults and analog-to-digital converter (ADC) resolution. It currently handles only static feedforward vision models. We add two things. One is a write channel that records every programming event, with its energy and its wear on the device. The other is a crossbar state that persists across solver calls, so stale entries carry from one interval to the next. Device models for RRAM are cross-checked against the MELISO+ chemistries reported by Vo et al.
The benchmarks in the file use independent channel draws. We therefore add first-order autoregressive temporal correlation to the geometric-Rayleigh and Saleh-Valenzuela generators and sweep the correlation over a range of mobility levels. This is our own extension; no source in the file reports such a correlated variant.
Training follows the unsupervised sum-rate objectives of the source papers. Inside the forward pass, a simulated crossbar replaces the exact channel, with the threshold $\delta$, the programming noise and the converter bit-width sampled in the loop. Three outcomes are analyzed jointly: sum-rate, the per-cell write rate (from which device lifetime follows), and energy and latency per solve broken down into reads, writes and conversions.
Baselines
The do-nothing reference is the trained unfolded solver run in floating point on a GPU. That means the 4-layer UWMMSE for power allocation and the unfolded projected gradient ascent for beamforming, trained on the same correlated channels. It fixes the sum-rate ceiling and the digital energy, which we take from hardware counters on the same platform. The file reports only latency, not energy, for these solvers. UWMMSE reports an average sum-rate of 83.21 against 82.94 for 100-iteration WMMSE, at about 2 ms against 16 ms per sample, on 20-pair geometric-Rayleigh networks (UWMMSE). The complex-valued graph unfolding reports 54 ms against 1,305 ms for WMMSE in MU-MIMO Rayleigh fading (Deep Graph Unfolding for Beamforming). For the joint communications-and-sensing mmWave benchmark, the reference reports 33.5% higher sum-rate and 65% lower run time than iterative projected gradient ascent (JCAS-HBF). We reproduce these numbers before comparing anything.
The strongest competitor is a hybrid split. The solver weights live in a written-once analog crossbar, but every channel-dependent product is computed by near-memory digital logic. This captures most of the analog benefit with no channel writes and no channel-side analog noise. To keep the comparison fair, it uses the same trained model, the same converter budget and the same digital process assumptions. Beating it means lower total energy per solve at equal sum-rate (within 1% of the floating-point reference) at array sizes we will identify. We expect this to hold only above some antenna or user count, and we expect to lose at 20 single-antenna pairs.
The naive analog design rewrites the full channel every interval with check-and-retry programming. It sets the endurance floor. Beating it means at least an order of magnitude longer device lifetime at matched sum-rate.
Two ablations isolate the key ingredients. The first keeps threshold updates but trains the solver on exact channels, which tests whether noise-aware training matters. The second applies blind full rewrites every interval with noise-aware training, which tests whether the threshold itself matters. Every variant gets the same training samples and the same hyperparameter search budget.
Why not just…?
Why not just keep the channel math digital and put only the weights in analog? This is the most serious threat, and for small problems we expect it to win. In the 20-pair power-allocation setting the channel matrix is only 20×20, so digital near-memory compute is cheap. Sze et al. and Cavigelli et al. show that data movement dominates energy, and that cost grows with the size of the matrices being shuttled. The channel matrix is that growing term in 64- and 128-antenna arrays. The array-size sweep will locate the crossover, and if none appears below 256 antennas we will report that the write-sparse design is not worth building.
Why not just truncate classical WMMSE and run it on a DSP? UWMMSE needs 4 layers to match what classical WMMSE reaches only after 100 iterations (UWMMSE). Truncated WMMSE would also keep its per-iteration matrix inversions and their data movement. We include 4-iteration WMMSE as a sanity row, but it does not answer the energy question.
Why not just rewrite the whole channel cheaply, with single pulses and no checks? This is the second ablation. It may match sum-rate, but the endurance arithmetic above caps its lifetime at days or less. The comparison that matters is lifetime at equal sum-rate. Measuring it also tells us how much of the benefit comes from skipping writes rather than from cheaper writes.
Why not just tolerate stale channels without any updates? Under high mobility, the stored copy drifts beyond what any trained correction can absorb. Setting the threshold to infinity is one endpoint of our $\delta$ sweep, so this alternative is covered directly.
Proposed Experiments
The central experiment traces sum-rate against device lifetime and against energy per solve. It sweeps the threshold $\delta$, the mobility level, the converter bit-width (from 3 to 8 bits, given the 4–5-bit accuracy cliff MemTorch reports for vision models) and the array size. It covers the geometric-Rayleigh 20-to-100-pair power-allocation benchmark and the Saleh-Valenzuela 32- and 64-antenna beamforming benchmark.
Beyond sum-rate as a fraction of the floating-point reference, we report how often per-user power-budget constraints are violated. Analog error can silently break feasibility, and to our knowledge no source in the file has measured this for unfolded solvers.
Three findings would sink the idea. The first is if threshold updates with noise-aware training fail to beat blind full rewrites by an order of magnitude in lifetime at matched sum-rate. The second is if noise-aware training adds nothing over training on exact channels. The third is if the hybrid digital split wins energy at every array size up to 256 antennas.
A supporting check compares measured output error against the perturbation bound of Chowdhury, Gama and Segarra as a function of $\delta$. It tells us whether that bound can set the write threshold in practice, or whether higher-order terms, which caused the 4% of bound violations they report, dominate on analog hardware.
References
- Mixed-Precision Deep Learning Based on Computational Memory
- Stability Analysis of Unfolded WMMSE for Power Allocation
- Unfolding WMMSE Using Graph Neural Networks for Efficient Power Allocation
- Joint Communications and Sensing Hybrid Beamforming Design via Deep Unfolding
- From GPUs to RRAMs: Distributed In-Memory Primal-Dual Hybrid Gradient Method for Solving Large-Scale Linear Optimization Problem
- MemTorch: An Open-source Simulation Framework for Memristive Deep Learning Systems
- Deep Graph Unfolding for Beamforming in MU-MIMO Interference Networks
- Hardware for machine learning: Challenges and opportunities
- Hyperdrive: A Multi-Chip Systolically Scalable Binary-Weight CNN Inference Engine