PaperlayerView exact revision on arXiv

Source-linked AI summary

Fast Tri-Hybrid Beamforming via Deep Unfolding

Pinjun Zheng, Md. Jahangir Hossain, Anas Chaaban

arXiv:2608.27759v1eess.SP

TL;DR

Tri-hybrid beamforming is difficult to optimize because digital, analog, and electromagnetic domains are strongly coupled, while practical systems require low-latency reconfiguration. The paper develops a WMMSE-based closed-form iterative solver and unfolds it into a GraphSAGE-driven trainable network. The unfolded method achieves comparable WSR with fewer iterations and reduces runtime by more than an order of magnitude, while remaining subject to training and architecture-specific scope limits.

  • Problem

    Strong coupling among three precoding domains and hardware constraints makes tri-hybrid beamforming computationally intensive for latency-sensitive systems.

  • Method

    The paper combines a closed-form WMMSE-based iterative algorithm with a GraphSAGE deep unfolding network that learns CSI-dependent acceleration parameters.

  • Results

    The unfolded algorithm achieves performance comparable to 50 or 200 iterations of the original algorithm using 2 or 4 iterations, respectively, and reduces runtime by more than an order of magnitude.

  • Takeaways & Limitations

    Deep unfolding provides an effective way to reduce the computational burden of DMA-based tri-hybrid beamforming and facilitate real-time implementation.

  • Takeaways & Limitations

    The method requires offline training, and different antenna technologies or system architectures require network redesign and retraining.

Abstract

from arXiv · show

Tri-hybrid multiple-input multiple-output architectures have recently emerged as a promising enabler for next-generation wireless systems, as they potentially provide enhanced design flexibility without a proportional increase in hardware cost or power consumption. However, the resulting triple-domain coupling renders beamforming optimization challenging and computationally demanding. This paper develops a fast tri-hybrid beamforming framework for multiuser downlink systems employing dynamic metasurface antennas (DMAs). Based on the equivalence between weighted sum-rate maximization and weighted sum-minimum mean square error minimization, an iterative algorithm is first derived under per-DMA input power constraints, with all update equations available in closed form, but convergence inherently remains slow. To enable real-time operation, the algorithm is further unfolded into a trainable finite-iteration architecture using graph neural networks that ensure permutation equivariance and support varying numbers of users. Trained on ray-tracing channel data, the unfolded method achieves comparable or higher system sum-rates while reducing runtime by more than an order of magnitude. The method also demonstrates strong scalability, robustness, and generalization across various environments.

I. INTRODUCTION

Tri-hybrid MIMO adds antenna-domain control but makes multi-domain beamforming highly coupled and computationally demanding. The paper combines a closed-form iterative method with a GraphSAGE-based deep unfolding network trained for fast, flexible inference.

  • Motivation: Tri-hybrid MIMO extends hybrid digital-analog architectures with a third antenna or electromagnetic domain for additional control.The architecture can integrate technologies such as DMAs, pixel antennas, lens antennas, and fluid antennas.
  • Motivation: Jointly optimizing digital, analog, and EM precoders under hardware constraints creates a strongly coupled problem without a simple solution.The formulation includes multiuser precoding, Lorentzian-constrained DMA weights, and per-DMA input power constraints.
  • Motivation: Hundreds of iterations can remain necessary even with low-complexity closed-form updates, producing substantial practical runtime.Beamforming is latency-sensitive because channel coherence time is limited and real-time reconfiguration is required.
  • Contributions: The paper first develops a low-complexity WMMSE-based iterative algorithm and then unfolds it into a trainable finite-iteration network.The iterative method targets multiuser DMA tri-hybrid sum-rate maximization with closed-form updates, but can converge slowly.
  • Contributions: GraphSAGE learns acceleration parameters from user CSI while preserving permutation equivariance and accommodating varying user counts.The network is trained inductively on fully connected user graphs.
  • Evaluation: The method is trained on ray-tracing data from multiple cities and evaluated in another city for acceleration, scalability, CSI-error robustness, and generalization.Training data preprocessing and parameter initialization are designed specifically for effective training.

B. Signal Transmission and Performance Metric

The system uses three sequential precoding domains to serve multiple users, with weighted sum-rate as the performance objective. The resulting formulation jointly captures multiuser processing and practical DMA and RF constraints.

  • Signal Model: The received signal contains the desired signal, multiuser interference, and additive white Gaussian noise.Each user has a channel matrix, allocated data streams, and a corresponding digital precoder.
  • Performance Metric: The performance metric is weighted sum-rate, formed from users’ achievable spectral efficiencies and priority weights βk > 0.The spectral-efficiency expression assumes Gaussian signaling.
  • Problem Formulation: The optimization jointly designs antenna-domain, RF-domain, and baseband precoders to maximize system WSR.The problem is highly nonconvex because variables are coupled and RF and antenna-domain hardware impose constant-modulus constraints.
  • Problem Formulation: The formulation uniquely combines multiuser MIMO precoding, Lorentzian DMA weights, RF processing, and per-DMA input power constraints.The authors state that this particular combination had not previously been investigated.
  • Solution Strategy: A two-stage strategy first solves a virtual fully digital problem and then decomposes its solution into RF and baseband components.This removes RF constant-modulus constraints from the intermediate problem while retaining DMA physical and power constraints.

III. ITERATIVE TRI-HYBRID BEAMFORMING

The iterative solver reformulates nonconvex WSR maximization as WMMSE minimization and updates variable blocks alternately. Closed-form updates and per-DMA block partitioning improve tractability while preserving the power constraints.

  • WMMSE Reformulation: WMMSE equivalence transforms the nonconvex WSR problem into a more tractable minimization involving auxiliary variables.The reformulation addresses strong coupling among the optimization variables.
  • Alternating Optimization: The algorithm uses a virtual digital precoder and later recovers hybrid precoders by decomposition into RF and baseband components.This follows the two-stage strategy used to simplify the original formulation.
  • Alternating Optimization: The resulting block structure enables sequential updates of {Ωk}, {Γk}, FA, and FD while holding the remaining blocks fixed.Each subproblem either has a closed-form optimum or a closed-form monotonic-improvement update.
  • Per-DMA Updates: Per-DMA optimization partitions the digital precoder so each DMA-associated vector is subject to a single power constraint.The digital vector and DMA tuning vector form a coupled block for the same physical unit.
  • Per-DMA Updates: The DMA block update alternates between its digital precoder vn and tuning vector un using lightweight closed-form expressions.The antenna-domain model is partitioned by DMA and by user-channel blocks to expose the relevant composite terms.

2) Update un Given vn:

With vn fixed, the DMA tuning update avoids solving the exact unit-modulus quadratic program. Instead, it minimizes a quadratic upper bound to obtain a lightweight monotonic update.

  • Subproblem: Fixing vn yields a unit-modulus quadratic program for optimizing the DMA tuning vector un.The exact subproblem could be solved by manifold optimization, but that would add iterative overhead inside the outer loop.
  • Update Rule: Majorization-minimization replaces the exact optimum with a quadratic upper-bound minimization that produces a closed-form update.The approximation is considered sufficient when it ensures a monotonic non-increase of the objective.
  • Update Rule: The update’s monotonic non-increasing property is ensured by choosing ρn ≥ λmax(Mn).Here λmax(Mn) denotes the maximum eigenvalue of Mn.

D. Algorithm Summary

Alg. 1 solves P1 through closed-form alternating updates with monotonic WSR convergence, but its overall cost can remain high because many iterations may be required.

  • Algorithmic structure: The objective value of P1 converges because each update monotonically non-decreases WSR, which is upper-bounded.
  • Implementation: The RF-baseband decomposition in P2 is solved approximately using an existing method and therefore does not guarantee local optimality for the original nonconvex problem.
  • Implementation: The algorithm accepts channel matrices, priority weights, per-DMA power constraints, waveguide responses, and a maximum iteration count as inputs.
  • Complexity: The overall complexity is O(L Citer), with large DMA arrays dominated by quadratic scaling in NT.

IV. DEEP ALGORITHM UNFOLDING

Deep unfolding treats the slow alternating solver as a model-based backbone and learns finite-iteration updates for real-time operation, while preserving the structure of the original beamforming procedure.

  • Evaluation: The unfolded pipeline is evaluated against Alg. 1 and the P2 solver, with Fig. 2 focusing on convergence performance and runtime.
  • Rationale: Deep unfolding targets the slow convergence of Alg. 1 by learning update rules that reach desired performance in only a few iterations.This addresses scenarios where runtime is constrained by the channel coherence interval.
  • Rationale: The unfolded solver accelerates finite-iteration performance rather than merely reducing individual update complexity.This distinguishes it from matrix-inverse-free WMMSE approaches that primarily reduce per-iteration cost.
  • Auxiliary-variable updates: Trainable matrices Xk augment the auxiliary-variable updates to guide them toward improved solutions beyond the original update rule.Hermitian-preserving augmentation uses Xk + Xk^H when required by the original update structure.
  • Auxiliary-variable updates: The auxiliary-update network Ψa uses GraphSAGE to support varying user counts and permutation-equivariant user reordering.Its kth node receives user-specific parameters (Hk, σk, βk), and outputs are read from the final node representations.
  • Input preprocessing: System-parameter normalization mitigates scaling ambiguities and supports stable training, with channel and weight features constructed for GNN input.The preprocessing includes normalized channel-related features and normalized user-weight information.

3) Message Passing:

GraphSAGE message passing updates each user-node representation using trainable layer weights, neighboring features, and a nonlinear activation.

  • Message Passing: At each GraphSAGE layer, node features are transformed through trainable weights and a nonlinear activation such as ReLU.The layerwise node feature matrix collects the representations y_k^(i) for all K users.

4) Final Feature Readout:

The final readout stage maps GNN representations to acceleration variables, while training optimizes the achieved sum-rate through differentiable unfolded layers.

  • Final Feature Readout: The auxiliary network reads Xk from each final-layer node through an MLP readout.
  • Final Feature Readout: The precoder network Ψp adaptively selects scalar hyperparameters ρn to accelerate precoder-related updates.Its scalar outputs keep this module lightweight and computationally efficient.
  • Final Feature Readout: Ψp uses graph-level mean pooling because its desired outputs are global quantities independent of the number of users or nodes.An MLP then produces z = [z1, …, zNT]^T from the pooled representation.
  • Training: Training minimizes a differentiable WSR-based loss with stochastic gradient descent and requires only problem instances, not labeled optimal solutions.

2) Iteration Initialization:

The unfolded solver requires fixed initialization across training and inference, while its complexity reflects both model-based iterations and GraphSAGE processing. Runtime savings mainly come from using fewer unfolded layers, and the architecture scales favorably with users and RF-chain changes.

  • 2) Iteration Initialization:: Initialization must remain identical during training and inference because changing it alters the unfolded loss landscape.
  • 2) Iteration Initialization:: Zero-initializing each module’s output-layer weights improves training stability and makes the initial augmented terms zero.
  • GNN Complexity:: The GNN cost grows linearly with node-feature dimension, quadratically with users for the fully connected graph, and linearly with GraphSAGE depth.
  • Online Inference Complexity:: Online inference costs O(L(Citer + CGNN) + CP2), excluding gradient computation and optimizer updates.
  • Online Inference Complexity:: Runtime savings primarily arise because the unfolded solver uses a much smaller number of layers than the model-based algorithm.
  • Additional Scalability Remarks:: Changing NRF affects only the final decomposition cost and accuracy, while changing K alters graph size without requiring network retraining.

V. NUMERICAL RESULTS

The numerical evaluation uses DMA-based tri-hybrid systems, DeepMIMO training data, city-separated testing, and benchmarks adapted to the problem setting. Results examine decomposition loss, direct tri-domain optimization, and training behavior.

  • Evaluation Settings:: The evaluation uses 20 MHz bandwidth, linearly spaced DMA elements with half-wavelength spacing, and waveguide attenuation coefficient ϱm = 0.6 m−1.
  • Evaluation Settings:: The network trains on 20,000 problem instances from New York, Los Angeles, and Chicago, then tests on 1,000 independent Miami instances.
  • Evaluation Settings:: The adopted benchmarks include DMA alternating optimization and a matrix-decomposition approach adapted to tri-hybrid beamforming.
  • Model-Based Algorithm Performance: For most power levels and RF-chain counts, RF-baseband decomposition causes negligible loss relative to the virtual fully digital reference.
  • Training Performance: The training loss is the negative mean WSR computed for batches containing 50 problem instances.
  • Model-Based Algorithm Performance: With NRF = 8, the two-stage design outperforms direct tri-domain alternating optimization across the tested power range.

C. Unfolded Model Training and Inference

The unfolded model matches the original algorithm's performance with far fewer iterations and substantially lower runtime. Its effectiveness persists across layer counts, array scales, noisy CSI, and unseen city datasets, while practical hardware and retraining constraints remain.

  • Training: Zero-initializing the output-layer weights starts training at a performance level matching Alg. 1, unlike nonzero random initialization.Both methods use L = 3 iterations; random initialization starts below the original solution and makes training harder.
  • Inference: The unfolded algorithm substantially reduces required iterations without compromising optimized WSR on 1,000 test problem instances.The comparison includes Alg. 1 with L = {4, 10, 50, 200} and the unfolded version with L = {2, 3, 4}.
  • Inference: More than an order-of-magnitude runtime reduction is achieved without sacrificing WSR, with higher unfolded-layer counts trading longer runtime for higher WSR.The unfolded method reaches a high-WSR, low-runtime regime not attained by the two benchmark approaches.
  • Scalability: WSR improves as unfolding layers increase but saturates for L > 5, while execution time increases linearly with layer count.The method remains effective as the array configuration scales, although larger configurations produce higher WSR and longer runtimes.
  • Robustness: Under noisy CSI, unfolded Alg. 1 with L = 2 has robustness comparable to original Alg. 1 with L = 200, whereas L = 4 degrades substantially.Increasing iteration count reduces robustness for both algorithms, with the effect more pronounced for the unfolded method; degradation from inaccurate CSI remains limited.
  • Generalization: Across Miami, Austin, Columbus, and Dallas datasets, the proposed algorithms outperform benchmarks, while the unfolded version offers lower runtime for real-time deployment.The city datasets differ from those used for training, supporting generalization across unseen environments.
  • Limitations: The method requires offline training, and different antenna technologies or system architectures require redesigning and retraining the unfolding network.The paper states that no unified solution currently exists for all tri-hybrid beamforming scenarios.
  • Limitations: Omitted realistic DMA effects, including frequency selectivity and finite-resolution tuning, may degrade performance in practical implementations.Incorporating these hardware constraints is identified as an important direction for future work.

APPENDIX

The appendix derives a majorization-minimization update for a unit-modulus quadratic program by constructing a linear surrogate and applying phase projection.

  • Proof: The appendix formulates the subproblem as a unit-modulus quadratic program and applies quadratic majorization with ρ ≥ λmax(M).The resulting surrogate is optimized over |[u]m| = 1.
  • Proof: Phase projection gives the constant-modulus minimizer of the linear surrogate, yielding the stated update for the original subproblem.The update is identified as a majorization-minimization step.
  • Proof: Because the surrogate upper-bounds the objective and is tight at the current iterate, standard majorization-minimization theory guarantees descent.The proof concludes after establishing this update property.
Loading 2608.27759v1…