A base station serving many users has to recompute its beamformer every time the radio channel changes. The beamformer is the set of complex antenna weights that aims each user's signal and suppresses interference to the others, and the channel can change within a millisecond. The standard algorithms for this are iterative and slow. Deep unfolding is a fix from the machine-learning side: it cuts an iterative solver to a fixed number of steps and learns each step's parameters, so the solver becomes a short feedforward network. Photonic chips look like a natural place to run such a network, because light performs a matrix-vector multiply in picoseconds.
The catch is the boundary between electronics and light. In the one on-chip photonic optimization solver we found, the optics take about 129 ps per iteration and the full iteration takes 265.1 ns. Nearly all of that time goes to digital-to-analog and analog-to-digital converters and the controlling electronics (16-channel Photonic Solver for Optimization Problems on a Silicon Chip). Our proposal is to count those boundary crossings, rather than arithmetic operations, as the cost that deep unfolding is trained to minimize. The unfolded beamforming algorithm is restructured and trained so that the channel-dependent matrix is written into the photonic core once per channel update. Several unfolded steps then chain in the optical domain without being read out. Readouts, and their bit-width, are placed where a learned latency penalty says they are worth paying for.
Core Claim
The claim is specific. Take a beamforming algorithm whose iterations mix linear steps with occasional nonlinear updates, such as the Weighted Minimum Mean Square Error (WMMSE) algorithm. It can be split into a nonlinear outer loop that runs rarely in electronics and linear inner chains that run in optics. The split point, the number of optical passes per chain, and the precision of each readout can be learned jointly with the step sizes, under a differentiable model of conversion latency and analog noise.
In the regime where plain linear precoders fall short of WMMSE (users approaching the antenna count), we expect such a network to reach the sum-rate of existing digital unfolded networks with a number of domain crossings per solve that stays roughly constant in the unfolding depth $K$. Offloading each layer to the optical core one at a time costs about $2K$ crossings.
The observation that makes this possible has been glossed over in the photonic-accelerator literature. In a neural network on photonic hardware, the matrices are learned weights that stay fixed. In unfolded wireless optimization, the matrices are the channel itself: the users' channels stacked as $H$, or its Gram matrix $H^H H$. They change every coherence block while staying constant across all $K$ unfolded steps inside that block. For gradient-type inner updates of the form $x \leftarrow x - \alpha_k (A x - b)$, with the same data-dependent $A$ reused at every step $k$, the expensive matrix write is paid once and the chain of steps needs no nonlinearity between them.
Relation to Prior Work
Three groups of prior work bear on this.
Photonic co-design work supplies the hardware assumptions and precision numbers, and all of it treats static weights. ENLighten co-designs low-rank-plus-sparse compression of Vision Transformers with a reconfigurable photonic tensor core, and it reports robustness at 8-bit precision with 3% noise injection (ENLighten). MDTransformer replaces multi-wavelength light sources with spatial mode multiplexing and runs at sub-4-bit effective precision (MDTransformer). Both compile pre-trained feedforward networks. Neither faces weights that must be rewritten every millisecond from measured data, which is the situation here.
The architecture model of Architecture-Level Modeling of Photonic Deep Neural Network Accelerators adapts the CiMLoop compute-in-memory modeling tool to track energy across digital, analog-electrical and analog-optical domains. It shows that converters and memory dominate, and that data reuse cuts converter energy by 42%. We reuse that style of accounting as the cost model inside training rather than as an after-the-fact profiler.
Photonic optimization solvers show the gap. The 16-channel chip and SUANPAN, a photonic vector machine that avoids large converter arrays by using time-domain and spatial encoding (SUANPAN), both drive heuristic Ising and annealing loops from outside. Every iteration crosses the boundary. We keep their hardware premise and drop the external per-iteration loop.
Digital unfolding supplies the algorithms. IAIDNN unfolds WMMSE for multi-user precoding, replacing inversions with a first-order Taylor approximation, and reaches 91–99% of WMMSE sum-rate (IAIDNN). UWMMSE unfolds WMMSE for power allocation with graph neural networks in 4 layers (UWMMSE). The DPST detector works natively in complex arithmetic, which matches coherent optics, which represent complex numbers directly as optical amplitude and phase (Deep Unfolding for MIMO Signal Detection). A-MMMSE removes inversions in favour of matrix products suited to GPUs (A-MMMSE). All of these are trained in floating point with no notion of which operations cross a domain boundary.
IAIDNN also constrains the design: it reports degradation in the fully loaded regime. That is exactly where we must show gains, so it is a risk we take on directly rather than avoid.
Research Program
The first component is an unfolded architecture with two timescales. The outer loop updates the nonlinear WMMSE quantities, the per-user receive filters and weights. It runs in electronics for a learned, small number of rounds $R$. Each inner chain approximately solves the linear system for the precoder by $L$ optical passes of a learned gradient or truncated-series iteration on the channel Gram matrix, written into the core once.
Power normalization and the weight update happen only at chain boundaries. This avoids depending on fast all-optical nonlinearities, which are either slow liquid-crystal devices (Femtojoule optical nonlinearity) or laser-cavity devices with limited ReLU/ELU-like shapes (20-GHz optical activation function). We will also test, as a secondary arm, whether a ReLU-like optical activation can replace one electronic projection.
The second component is a differentiable cost model. Per coherence block, latency is modeled as
$$T = n_W\, t_W + \sum_{j} t_V(b_j) + R\,L\,t_{\text{opt}},$$
where the terms are defined as follows. $n_W$ is the number of matrix writes and $t_W$ the time per write. $t_V(b_j)$ is the time of the $j$-th vector readout and re-injection at bit-width $b_j$. $t_{\text{opt}}$ is the time of one optical pass, of order 129 ps from the silicon-chip measurement.
Training minimizes
$$\mathcal{L} = -\,\mathbb{E}_H\big[\text{SumRate}(H;\theta)\big] + \lambda\, T(\theta),$$
where $\theta$ holds the step sizes, $R$, $L$ and the bit-widths $b_j$ (discrete choices relaxed during training). The trade-off weight $\lambda$ is swept to trace a sum-rate versus latency curve. An analogous energy term uses converter and memory energies taken from the architecture-level photonic model.
The file gives no measured reconfiguration time for the phase shifters that program the matrix. We therefore treat the ratio $t_W/t_V$ as a swept parameter, from fast electro-optic writes to slow thermal writes, and report where the approach wins and where it cannot.
The third component is noise-aware training. Each optical pass injects multiplicative and additive noise and phase error, calibrated to three reported levels: 3% (ENLighten), 1.2–3.3% root-mean-square (NOMA), and sub-4-bit effective precision (MDTransformer). Noise compounds along an inner chain, so the learned chain length $L$ is expected to shrink as noise rises. That dependence is a result we will report, not assume.
Baselines
The naive reference point is classical WMMSE run to convergence, around 100 iterations, in floating point. It sets the sum-rate ceiling that IAIDNN and UWMMSE normalize against. It is included for accuracy, not speed.
The strongest accuracy-per-step competitor is IAIDNN, retrained on our channel distributions with the same training budget. It reports 91–99% of WMMSE sum-rate and 0.13 s versus 5.14 s for WMMSE in the 128×30 setup (IAIDNN). Those latencies come from general-purpose software, so beating them proves little. The fair latency comparison runs the same IAIDNN graph on digital hardware models: a GPU implementation in the A-MMMSE style, and a fixed-point accelerator model at matched bit-width. It should also be run on the same photonic cost model with per-layer offload.
A-MMMSE is the strongest inversion-free digital solver. It reports a 3× speedup over GPU-accelerated reduced-WMMSE at 2048 antennas and a 5× runtime reduction on CPU at WMMSE-level weighted sum-rate (A-MMMSE). We run it on the same GPU with identical channel batches.
For the power-allocation variant, UWMMSE is the baseline. It reports average sum-rate 83.21 versus 82.94 for WMMSE, at about 2 ms versus 16 ms per sample.
Regularized zero-forcing, a closed-form linear precoder, is the simplest baseline. We found no reported result on Lacuna for it in these setups, so we will measure it ourselves.
The photonic reference point is naive per-layer offload: every unfolded layer is one optical pass with a full readout and re-injection. This mirrors the operating mode of the 16-channel solver, where one iteration costs 265.1 ns against 129 ps of optics. The key ablation keeps our architecture and turns off the conversion penalty ($\lambda=0$, full-precision readout after every pass). This isolates whether the learned crossing placement matters rather than the two-timescale structure alone. A second ablation removes noise injection during training.
Beating the baselines means the following. At a matched sum-rate of at least IAIDNN's fraction of WMMSE, in the fully loaded regime, the proposal must show lower end-to-end modeled latency and energy than both the per-layer photonic offload and the digital accelerator models, across a stated range of $t_W/t_V$.
Why not just…?
Why not just run an inversion-free solver on a GPU? A-MMMSE shows that reformulation into matrix products already gives large digital speedups, and this is a real threat. Our position is not that GPUs are too slow in general. It is that per-block latency and energy at large antenna counts are dominated by memory traffic, which the architecture-level photonic model shows dominates in hybrid systems too. The experiment settles this by placing A-MMMSE and our method on the same sum-rate versus latency and energy axes. If A-MMMSE matches us at realistic $t_W$, we report that the photonic route is not justified for this workload.
Why not just offload each unfolded layer to the photonic core? That is the 16-channel solver's operating mode, and its own measurements show more than 99.9% of the iteration time lost to conversions. The $\lambda=0$ ablation and the per-layer baseline test directly how much of that tax the conversion-budgeted design removes.
Why not just use regularized zero-forcing, which needs no iteration? In lightly loaded cells, zero-forcing is close to WMMSE, and there our method has little to add. That is why the evaluation concentrates on the fully loaded and interference-limited regime, and why zero-forcing computed optically by the same inner chain is itself a point on our curve. If the full two-timescale network does not beat that point in sum-rate at acceptable extra latency, the outer loop is not worth having.
Why not just build a digital fixed-point accelerator for IAIDNN? It avoids noise and drift entirely. We model it at the same bit-widths chosen by our training, so the comparison isolates whether optical passes provide an advantage at all once conversions are minimized.
Proposed Experiments
The data are synthetic Rayleigh multi-user channels at the IAIDNN scales (8×4 up to 128×30, including fully loaded configurations), the 20-pair ad hoc interference graphs from UWMMSE, and DeepMIMO ray-tracing channels. DeepMIMO is held out entirely from training to test mismatch; no prior reported numbers on it were found. The metrics are sum-rate as a fraction of WMMSE, modeled end-to-end latency and energy per coherence block including all conversions, the number of crossings per solve, and sensitivity to injected noise level.
The first decisive check is scaling: crossings per solve should stay nearly flat as effective unfolding depth $RL$ grows, while per-layer offload grows linearly. The second is noise: at 3% per-pass noise, the noise-aware network should stay within a few points of its floating-point sum-rate while the noise-unaware ablation degrades. The third is the crossover: we report the $t_W/t_V$ ratio above which a single matrix write per block makes the photonic design no faster than the digital accelerator model. If that crossover lies below the reconfiguration speeds plausible for integrated phase shifters, the proposal's premise fails, and the note will say so.
References
- 16-channel Photonic Solver for Optimization Problems on a Silicon Chip
- ENLighten: Lighten the Transformer, Enable Efficient Optical Acceleration
- MDTransformer: A Hardware-Software Co-Design of Mode-Division Photonic Transformer Accelerator with Inverse-Designed Coherent Crossbar
- Architecture-Level Modeling of Photonic Deep Neural Network Accelerators
- SUANPAN: Scalable Photonic Linear Vector Machine
- Iterative Algorithm Induced Deep-Unfolding Neural Networks: Precoding Design for Multiuser MIMO Systems
- Unfolding WMMSE Using Graph Neural Networks for Efficient Power Allocation
- Deep Unfolding for MIMO Signal Detection
- An Accelerated Mixed Weighted-Unweighted MMSE Approach for MU-MIMO Beamforming
- Femtojoule optical nonlinearity for deep learning with incoherent illumination
- 20-GHz bandwidth optical activation function based on a semiconductor laser