Model-Based Deep Unfolding

The Best of Both Worlds

Pure data-driven receivers (Section 1) exploit patterns but lack interpretability and may overfit. Pure model-based receivers (classical MP, MMSE) are interpretable but miss data-specific patterns. Model-based deep unfolding fuses the two: take a classical iterative algorithm (MP, MMSE, ADMM), unroll its iterations into NN layers, and make the per-iteration parameters trainable. The result: an NN that shares the structure of the classical algorithm, is initialized to match it, and fine-tunes via training. Interpretable + data-adaptive. This section develops unfolded OTFS receivers.

Definition:
Deep Unfolding for OTFS

Deep unfolding of an iterative algorithm $\mathcal{A}$ with $T$ iterations produces a neural network $\mathrm{NN}_T$ as follows:

Forward pass: each iteration $t$ of $\mathcal{A}$ becomes one NN layer.
Trainable parameters: per-iteration hyperparameters (damping factor, step size, regularizer) become learnable.
Training: end-to-end via backpropagation through all $T$ iterations.

Example — unfolded MP detector: MP iterates update messages on the DD factor graph. Unfolded: each iteration is an NN layer with learnable damping $\alpha_t$ and update rule $\mu^{(t+1)} = \alpha_t \mu^{(t)} + (1-\alpha_t) f_\theta(\mu^{(t)})$ . Training adjusts $\alpha_t$ and internal NN weights.

Key property: at initialization (untrained), NN matches classical. Training fine-tunes to beat classical on data.

Theorem: Unfolded Receiver Convergence

Consider an iterative algorithm $\mathcal{A}$ converging to a fixed point in $T^*$ iterations. The unfolded NN $\mathrm{NN}_T$ with $T$ layers achieves:

$T < T^*$ : worse than classical (incomplete iterations).
$T = T^*$ : matches classical at initialization, beats at training.
$T > T^*$ : marginal gain, risk of overfitting.

Optimal $T$ : set to the classical algorithm's convergence iterations. For MP detector: $T = 5$ - $10$ .

Performance gain: trained unfolded NN vs classical: 0.5-1.5 dB at typical SNRs.

Unfolding combines the best of both: structure from classical (convergent, well-studied), expressivity from NN (adapts to data). Too few layers: loses the structural advantage. Too many: wastes compute without gain. $T = T^*$ is the sweet spot.

Proof

At initialization

NN layers initialized to match classical update rules. Output identical to classical algorithm.

Training improvement

Gradient descent updates layer parameters. Loss improves. Performance exceeds classical by $\sim 1$ dB (empirical).

Layer count

Too few layers: not enough iterations for convergence. Matches classical (T $<$ T*) at T<T*. $T = T^*$ : best balance.

Overfitting

Too many layers: NN overfits to training noise. Gain plateaus; test performance degrades. $\blacksquare$

Definition:
Unfolded MP-OTFS Detector

Classical MP-OTFS detector: iterates message updates $\mu^{(t+1)}[\ell, m] = f_{\text{MP}}(\mu^{(t)}, \mathbf{y}, \hat{h})$ .

Unfolded MP-OTFS: per-iteration parameters:

Damping: $\alpha_t$ per iteration (not constant).
Message weighting: $\beta_t^{(\ell, m)}$ per cell, per iteration.
Soft-decision activation: learnable nonlinearity $\sigma_t$ per iteration.

Total parameters: $T \times (3 + MN + 1)$ . For $T = 10$ , $MN = 1024$ : $\sim 10^4$ parameters. Compact.

Training: backprop through all $T$ iterations. 1000 epochs on $10^4$ frames. ~1 hour GPU.

Performance: at 15 dB SNR, fractional Doppler $\epsilon = 0.3$ :

Classical MP: BER $10^{-3}$ .
Unfolded MP: BER $6 \cdot 10^{-4}$ . 0.8 dB improvement.

Unfolded MP-OTFS Detector Training

Input: Training data {(y_k, x_k)}_{k=1}^N with realistic channels,

NN architecture with T=10 unfolded layers,

Initial parameters θ_0 matching classical MP.

Output: Trained θ^* for improved detector.

1. INITIALIZE:

Set θ = θ_0: damping α_t = 0.7, weights β_t from MP formula,

activations σ_t as soft-threshold.

2. FOR epoch = 1..N_ep:

a. BATCH:

Sample B training frames.

b. FORWARD:

For each frame: run unfolded NN with current θ.

Output: soft decisions x̂.

c. COMPUTE LOSS:

L = E[||x̂ - x||²] (MSE)

OR E[-log P(x̂_k | x_k)] (cross-entropy for hard decisions)

d. BACKWARD:

Compute gradient ∂L/∂θ via backpropagation through T unfolded

layers.

e. UPDATE:

θ ← θ - η ∂L/∂θ (Adam optimizer)

3. Return θ^*.

Inference: forward pass only; same as classical MP but with

trained hyperparameters.

Complexity per frame: O(T × MN × P) ~ 3× 10⁵ ops. Real-time.

Theorem: Unfolded Detector Robustness

Unfolded detectors inherit the structural robustness of their classical counterparts. Specifically:

Out-of-distribution: 2-3 dB less degradation than pure NN.
Adversarial inputs: more robust than pure NN by $\sim 1$ dB.
Low-training-data regime: converges faster than pure NN (fewer parameters; structure regularizes).

Consequence: unfolded receivers are preferred for deployment where training data is scarce or deployment conditions vary. Pure NN preferred where copious training data exists and conditions are stable.

Classical algorithms embody engineering knowledge of the problem (physics, conservation laws, convergence properties). Pure NN ignores this; unfolded NN inherits it. The result: unfolded NN is "smarter" than pure NN given the same data. Especially valuable for safety-critical applications where OOD robustness matters.

Proof

Bias-variance

Pure NN: low bias, high variance (many parameters). Unfolded: higher bias (constrained to MP-like structure), lower variance.

OOD

OOD performance: bias often helps (structure prevents overfitting to training noise). Unfolded wins.

Adversarial

Structure constrains NN output. Attacks have smaller effect than on pure NN.

Data efficiency

Fewer parameters → faster convergence with less data. Unfolded converges in $N$ samples vs $N^2$ for pure NN. $\blacksquare$

Example: Unfolded OTFS Detector for 6G V2X

Design an unfolded MP-OTFS detector for 6G V2X (automotive safety): target BER $10^{-5}$ at 18 dB SNR, $P = 6$ paths, $\epsilon = 0.35$ fractional Doppler, hardware imperfections (phase noise, PA).

Solution

Architecture

Unfolded MP, $T = 8$ layers. 800 trainable parameters.

Training data

Simulated V2X channels: 10⁵ frames with realistic imperfections. Include fractional Doppler, phase noise, PA clipping.

Training

~1 hour on GPU. Converges to 1.2 dB better than classical MP.

BER at 18 dB

Classical MP: $10^{-4}$ (target missed). Pure NN CNN: $5 \times 10^{-6}$ (target met but 5% OOD risk). Unfolded MP: $1.5 \times 10^{-6}$ (target met with OOD robustness).

Deployment choice

V2X safety: unfolded MP. Best balance of performance, OOD robustness, and compute. Pure NN reserved for research/ specialized deployments.

Unfolded vs Classical vs Pure-NN BER

Plot BER vs SNR for classical MP, pure-NN CNN, and unfolded MP. Sliders: number of layers $T$ , training data size.

Parameters

T

layers8

\log_{10}

training frames4

\epsilon

0.3

Definition:
Other Unfolded OTFS Architectures

Beyond unfolded MP, other OTFS receivers can be unfolded:

Unfolded AMP/VAMP: approximate/vector message passing. Suited for large-scale MIMO-OTFS. Convergence faster than MP.

Unfolded MMSE: linear detector. Unfolds into a sequence of matrix operations + learned regularizer. Simpler than MP, lower performance but compact.

Unfolded ADMM: alternating direction method of multipliers. Good for sparse-channel estimation.

Unfolded OMP: for compressed-sensing channel estimation. Learns atom-selection strategy end-to-end.

Unfolded Kalman: for tracking-based OTFS (Chapter 13-14). Learns observation covariance from data.

Each unfolded architecture matches a classical algorithm; each has its deployment niche.

🔧Engineering Note

Unfolded Receivers in 6G

Deployment status (2026):

5G NR: experimental unfolded receivers in research prototypes. Not standardized.
5G Advanced (Rel. 18): AI/ML framework references unfolded methods. Vendor implementations (Qualcomm, MediaTek) use unfolded approaches for specific scenarios.
6G Foundation (Rel. 20-21): unfolded receivers become standard option. AI/ML for PHY includes unfolded as reference implementation.
6G Deployment (Rel. 22+): unfolded receivers mainstream. Combined with OTFS: unfolded MP as default for high-mobility.

Hardware: inference is same as classical MP; training is one- time. Deployment: ship pre-trained unfolded NN with UE chip. Occasional re-training via OTA update based on deployment experience.

Advantages over classical:

1-2 dB performance gain.
Robustness to imperfections.
Same inference complexity.

Advantages over pure NN:

Interpretability (structure from classical).
OOD robustness.
Data-efficient training.

For safety-critical 6G (V2X, ICS, medical): unfolded is the right choice.

Practical Constraints

•
Unfolded = classical structure + learned hyperparameters
•
Same inference complexity as classical
•
Pre-trained at vendor; deployed on UE
•
6G Rel. 21 standardization target

Learned Pilot Patterns Training and Deployment Considerations