Trading RF Chains for Time: Linear-State Pilot Integration for Hybrid Beamforming

Large antenna arrays at millimeter-wave frequencies are expensive mainly because each antenna would ideally need its own radio-frequency (RF) chain, meaning its own converter, mixer and amplifier. Hybrid beamforming addresses this by putting a cheap network of analog phase shifters in front of a few RF chains. The cost is that in any one pilot burst the base station sees only a low-dimensional projection of the channel. Existing learned systems treat each burst on its own, so they must sound the channel heavily every frame. We propose to let the base station remember. Each frame it probes the array through a different analog "viewing direction," taken from a fixed rotating schedule. A strictly linear recurrent state accumulates these few-dimensional glimpses across frames. In effect, the array synthesizes over time an aperture it cannot afford in hardware.

The linear form matters for a specific reason. A linear recurrence driven by a schedule that does not depend on the data has an exact parallel form. It is a scan, and when the schedule is periodic it is a convolution. We can therefore train it end to end on downlink sum rate over trajectories thousands of frames long, then deploy it as a constant-cost update per frame. A nonlinear recurrent net with closed-loop, data-dependent sensing loses that parallel form. The question the project settles is whether open-loop sensing plus linear memory is enough to cut pilot overhead per frame substantially at a fixed number of RF chains.

Core Claim

With $N_{RF}$ RF chains, a base station that rotates its analog sensing matrix on a learned periodic schedule can integrate the measurements in a linear state of dimension far above $N_{RF}$. It can then read out unit-modulus analog precoders and digital precoders directly. Compared with a memoryless model at the same per-frame pilot budget, this should recover much of the sum rate lost when RF chains or pilots are reduced. The gain should shrink in a predictable way as user speed rises, because the useful integration window is bounded by the channel coherence time.

Concretely, the state update and the training objective are

$$h_t = A\,h_{t-1} + B_{\tau(t)}\,y_t,\qquad y_t = W_{\tau(t)}^{H}H_t\,s + n_t,$$

$$\mathcal{L} = -\frac{1}{T}\sum_{t=1}^{T} R\big(H_{t+1};\,F_{RF}(h_t),\,F_{BB}(h_t)\big),$$

where the symbols are as follows:

  • $H_t$ is the uplink channel at frame $t$.
  • $W_{\tau(t)}$ is the unit-modulus analog sensing matrix used at that frame.
  • $\tau(t)=t \bmod P$ indexes a learned schedule of period $P$.
  • $s$ are the known pilots and $n_t$ is noise.
  • $y_t$ is the $N_{RF}$-dimensional measurement.
  • $h_t$ is the hidden state, and $A, B_\tau$ are learned.
  • $R$ is the achievable downlink sum rate on the next frame's channel.
  • $F_{RF}(\cdot)$ is a nonlinear readout followed by phase projection, $e^{j\angle(\cdot)}$, quantized to 2 bits when required.
  • $F_{BB}$ is zero-forcing on the effective channel, as in Attiah et al.

Because $A$ is fixed and $B_\tau, W_\tau$ repeat with period $P$, the map from measurements to states is time-invariant at the level of a superframe. Training can therefore use either an associative scan or a block convolution, and all nonlinearity sits in the per-frame readout.

Relation to Prior Work

Two papers motivate the gap from opposite sides.

  • Deep Learning for Channel Sensing and Hybrid Precoding in TDD Massive MIMO OFDM Systems learns the sensing matrix and analog precoder directly from pilots, trains on sum rate, and applies zero-forcing for the digital stage. It processes each burst independently. We keep its sum-rate training and its analog-then-ZF split, and add memory across frames together with a sensing schedule that varies over time.
  • MambaCSP shows that a selective state-space model predicts channels better than Transformer baselines at lower cost. It trains on channel error, though, and stops before precoding. It also treats the full channel estimate as given rather than working from few-RF-chain measurements.

Two further papers constrain the design.

The mechanism draws on three sources.

Research Program

We will build three variants of the model:

  • a scan-based version for training on long trajectories;
  • a superframe-convolution version, to verify that the two forms agree numerically;
  • a streaming version that runs one state update per frame.

The state is complex-valued with dimension $d$, swept from $N_{RF}$ up to $N_t$ (the number of antennas). The sensing schedule $\{W_\tau\}$ is learned jointly with the model under the unit-modulus constraint, by parameterizing phases directly.

The analysis has three parts. The first sweeps the schedule period $P$ against the coherence time, to locate the regime where rotating the sensing direction beats repeating it. The second compares the learned $A$ with the transition of an autoregressive channel model fitted to the data, to check whether the network rediscovers Kalman-like filtering. The third measures the cost of the open-loop restriction by comparing against closed-loop adaptive sensing.

Throughout, we fix the deployment cost per frame of every model, in floating-point operations and memory, so that comparisons are about information use rather than compute.

Baselines

Naive reference point. The first reference is the memoryless semi-direct network of Attiah et al., retrained on our channels at each pilot budget. This is "do nothing about time." That paper reports that 8 pilot frames achieve over 85% of the perfect-CSI sum rate with a 64-antenna base station on DeepMIMO and Saleh-Valenzuela channels. Beating it means matching that fraction with substantially fewer pilot frames per coherence block, with a target of 2 to 4, at the same $N_{RF}$ and the same 2-bit phase shifters.

Strongest physics-based baseline. This is a two-stage pipeline. A Kalman filter tracks the channel, fitted to the true autoregressive and Doppler statistics of each scenario. It is fed by the same rotating sensing schedule. MO-AltMin or PE-AltMin from Yu et al. then produces the precoder from the filtered estimate. We give it oracle second-order statistics, which deliberately favors it. Beating it shows that sum-rate training overcomes the metric mismatch that Attiah et al. identify, and is not merely competitive with a well-tuned filter.

Strongest learned temporal baseline. This is a MambaCSP-style selective state-space predictor trained on channel error. It is followed by the same AltMin stage, at a matched parameter count. It is not frozen at 130M parameters, since MambaCSP reports negligible gains from scaling. No sum-rate figure is reported for MambaCSP. Its reported numbers are relative: 9% lower NMSE in TDD and 12% lower NMSE in FDD than LLM baselines.

We also include an unfolded PGA precoder from Lavi et al., run on the Kalman estimate and warm-started from the previous frame. There is no reported sum-rate number found on Lacuna for that method.

Fairness and ablations. All learned models get the same trajectories, the same hyperparameter search budget, and the same per-frame inference budget. Two ablations isolate the key ingredients. The first keeps the identical model but repeats the same sensing matrix every frame, which isolates aperture synthesis over time. The second replaces the linear state with a GRU of equal size trained by truncated backpropagation through time, which isolates the contribution of linearity and long-horizon parallel training.

Why not just…?

Why not just feed the memoryless DNN a stack of the last K frames? This is the most serious threat. With a short window and slow users, a sliding-window feedforward network can integrate rotated measurements just as well. We will run it with K tuned per scenario. The claim survives only if the linear state wins when the useful memory exceeds the window that is affordable at a fixed per-frame cost, or wins at equal cost. If the stacked network matches us everywhere, the conclusion is that rotating the sensing schedule, not the recurrence, is the contribution, and we will report it that way.

Why not just use a GRU or LSTM with adaptive, closed-loop sensing? Closed-loop sensing should extract more information per pilot, and for trajectories of a few dozen frames, backpropagation through time is cheap. The LNN results in Robust Continuous-Time Beam Tracking with Liquid Neural Network show that the specific nonlinear cell matters. They do not show that linear dynamics are inadequate, since that paper compared only against LSTMs. We will train a closed-loop GRU on the same data and report two things: the sum-rate gap, and the training wall-clock as the horizon grows from 50 to 5,000 frames. If the gap is large at horizons where both remain trainable, open-loop linear memory is the wrong design for that regime.

Why not just track the channel with a Kalman filter and run classical precoding? For channels that truly follow an autoregressive process, this is near-optimal for channel error. It still minimizes the wrong objective, and it needs the right model statistics. Ray-traced DeepMIMO trajectories include blockage and path births, which a fitted filter does not capture. The oracle Kalman baseline answers this directly. If it matches us on QuaDRiGa but not on DeepMIMO, that locates where learning is needed.

Proposed Experiments

Scenarios. We use DeepMIMO O1_28 user trajectories at 5 and 20 m/s, following the LNN setup with 10,240 training and 2,560 validation samples. We also use QuaDRiGa 3GPP UMa NLOS at 10 to 100 km/h, following the MambaCSP setup of 8,000, 2,000 and 10,000 samples. The base station has 64 antennas. We sweep $N_{RF}\in\{2,4,8\}$ with 2 to 4 users, phase shifters ranging from ideal to 2-bit, and pilot frames per coherence block from 1 to 8.

Metrics.

  • Downlink sum rate, reported as a fraction of the perfect-CSI fully digital rate.
  • The pilot frames needed to reach 85% of that rate, which is the decisive quantity because it is directly comparable to Attiah et al.
  • Per-frame inference latency and memory.
  • Training throughput as a function of horizon.

Decisive checks. The project succeeds if all three of the following hold:

  1. At $N_{RF}=4$ and pedestrian speed, our model reaches 85% of perfect-CSI sum rate with at most half the per-frame pilots of the memoryless baseline.
  2. The fixed-schedule ablation loses most of that advantage.
  3. The advantage decays with speed in line with the ratio of integration window to coherence time.

The project fails if the stacked-window network or the oracle Kalman pipeline matches it at equal cost. A final check confirms that the scan form and the streaming form produce identical precoders to numerical precision. This guarantees that training cost and deployment cost are measured on the same model.