Exercises

Classical MP assumes integer Doppler. NN learns non-integer structure.

Phase noise, PA nonlinearity. NN absorbs these patterns.

Impulsive noise, interference. NN learns non-Gaussian likelihoods.

On perfect channel: NN matches classical. Gain comes from realism.

No structural assumptions. Any function of received signal. $\sim 10^6$ parameters.

Inherits MP iteration structure. Per-iteration parameters are learnable. $\sim 10^4$ parameters.

Pure NN: more expressive, worse OOD. Unfolded: less expressive, better OOD, interpretable. Unfolded preferred for safety- critical; pure NN for stable conditions.

NN trained on simulated channels: 2-3 dB worse on real channels due to hardware imperfections, different path statistics, etc.

Train on wide range of simulated parameters. Reduces gap to ~1 dB.

Fine-tune on small real-world sample. Recovers another 0.5 dB.

0.5-1 dB. Acceptable for deployment.

3 conv, 32 filters, kernel 3×3 on 2-channel input (I/Q): 32 × 2 × 9 = 576 weights + 32 biases per layer = 608. Layer 2 and 3: 32 × 32 × 9 = 9216 + 32 = 9248 each. Total conv: ~19k parameters.

Flatten from 32 × 16 × 16 = 8192 features (example MN=256). Dense 256: 8192 × 256 + 256 = 2.1M parameters. Dense output: 256 × 4 + 4 = 1028 (4 QAM bits).

~2.1M parameters. Trainable on modern GPU in ~1 hour.

For 2M parameters: need ~10x = $10^7$ training samples. Simulated OTFS data: generate in 1-2 hours.

$\|\mathbf{p}\|_0 = 5$ out of 1024. Fraction: 0.5%.

$\alpha \|\mathbf{p}\|_0 = 5 \alpha$. Small compared to other terms. Encourages more sparsity if $\alpha$ small.

Sparse pilot: less interference with data; lower PAPR. Classical comparison: 1-3% pilot overhead. Learned: 0.5% (via $\ell_0$ encouragement).

Unfolded NN layer-by-layer initialized to match classical MP update rules. Output identical to MP at start.

Gradient descent on per-iteration hyperparameters. Structure preserved. Performance fine-tunes.

Core update rule from MP provides convergence guarantees. NN layers constrained to MP-like operations.

Per-iteration learnable parameters: damping, weighting, activation. NN expressivity within MP structure.

Less expressive than pure NN. More robust. 1-2 dB better than classical; safer than pure NN.

Total samples: $100 \times 10^3 = 10^5$. Comparable to moderate centralized training.

FedAvg: $\mathcal{O}(T)$ rounds for centralized-equivalent convergence. Typical: $T = 100$-$1000$ rounds.

Per round: 10 MB × 100 UEs = 1 GB. Total: $10^2$-$10^3$ GB across rounds. Spread over days-weeks.

After convergence: ~95% of centralized performance. Accept small gap for privacy.

$T \times 100 = 800$ parameters. Compact.

$10^5$ parameters. 125× more than unfolded.

Rule of thumb: 10x-100x more data than parameters needed for good generalization. Unfolded: $10^4$-$10^5$ samples. Pure NN: $10^6$-$10^7$ samples.

Unfolded: trained on simulation + small real-world fine-tuning. Pure NN: requires large training dataset, federated helps.

Layer $t$ of unfolded MP: update $\mu^{(t+1)} = \alpha_t \mu^{(t)} + (1 - \alpha_t) f_\theta(\mu^{(t)})$. At initialization: $\alpha_t = \alpha_{\mathrm{classical}}$, $f_\theta$ identical to classical update.

At init: $f_\theta$ implements classical update rule exactly. $\alpha_t$ matches classical damping. Layer output = classical iteration output.

Cascaded: unfolded $=$ classical MP with $T$ iterations. Performance identical.

Training perturbs $\alpha_t, f_\theta$ to minimize loss on data. Performance improves beyond classical. $\blacksquare$

Simulator produces (channel, data) pairs. Parameters: V2X channel profile, fractional Doppler, SNR distribution.

$\mathbf{y} = \mathbf{H}(\mathbf{p}_\theta + \mathbf{x}) + \mathbf{w}$ where $\mathbf{p}_\theta$ is pilot, $\mathbf{H}$ channel. Differentiable end-to-end.

Estimator $h_\psi(\mathbf{y}, \mathbf{p}_\theta) = \hat{H}$. Detector $d_\phi(\mathbf{y}, \hat{H}) = \hat{x}$. Parameters: $\{\theta, \psi, \phi\}$ trained jointly.

$\mathcal{L} = \|\hat{x} - x\|^2 + \alpha \|\mathbf{p}_\theta\|_0 + \beta \mathrm{PAPR}(\mathbf{p}_\theta)$

Adam optimizer, batch size 64, 10⁴ epochs. Convergence: BER 3 dB better than classical at 15 dB SNR.

Export $(\mathbf{p}_\theta^*, \psi^*, \phi^*)$ for on-chip use. Pilot stored as 5 DD cell values; detector as NN weights.

Every 100 frames: collect channel measurements. Compare NN prediction vs classical reference.

If |NN BER - classical BER| > threshold: trigger adaptation.

Small gradient step on NN parameters via recent data. Learning rate: 10⁻⁴ (small; avoids catastrophic forgetting).

Limit adaptation to last-layer parameters. Freeze deep layers to maintain pretrained structure.

Per adaptation: 1000 frames × forward+backward = ~1M ops. At frame rate 100 Hz: 100 ms per adaptation. Feasible.

Lipschitz constant: large (expressive network). Perturbation of 0.5 dB can shift output significantly. BER under attack: 10× worse than clean.

Structure from classical MP: bounded Lipschitz. Perturbation bounded. BER under attack: 2-3× worse than clean.

Unfolded: 3-5× more robust than pure NN. Important for safety-critical applications.

Include perturbations in training. Both NN types improve. Unfolded still wins by ~1 dB.

Different UEs have different channel distributions. Local gradients point in different directions. Naive averaging causes NN to zig-zag.

Weight updates by data size or loss. Prioritize high-quality clients.

Shared global model + per-UE personalization head. UE-specific adaptation without losing global convergence.

Proximal term in local objective: $\text{local loss} + \mu \|\theta - \theta_{\text{global}}\|^2$. Keeps UEs close to global.

Convergence to a model that works well across most UEs. Each UE fine-tunes locally for its specific channel.

$T \cdot MN \cdot P = 10 \cdot 10^4 \cdot 8 = 8 \cdot 10^5$ ops/frame.

Same structure + per-iteration learned parameters. ~1.5x overhead. $1.2 \cdot 10^6$ ops/frame.

3 conv layers × 32 filters × 9 kernel × $MN$: 3 × 32 × 9 × 10⁴ = $8.6 \cdot 10^6$ ops/frame.

Self-attention: $MN^2$. $10^8$ ops/frame. 100× slower.

MP ≈ unfolded MP < CNN << transformer. Choice: performance vs compute budget. URLLC favors unfolded; best-performance (offline) favors transformer.

Channel has $P = 5$-$20$ paths; DD tensor is 99% zeros.

Input: received DD samples (2 channels for I/Q). CNN: 3 layers, attention over DD. Output: sparse channel tensor.

$\mathcal{L} = \|\hat{H} - H\|^2 + \alpha \|\hat{H}\|_1$ ($\ell_1$ regularization encourages sparsity).

Compared to OMP: slightly better MSE, same compute. Compared to pure LS: 3 dB better. Benefits from joint training with detector for end-to-end optimization.

Pre-trained on simulation, fine-tuned on deployment. Handles fractional Doppler structure automatically.

Learned pilots are UE-capability-specific. Need standardized pilot-template exchange via RRC. Rel. 21 expected.

3GPP test: demonstrate learned pilots outperform classical across diverse profiles. Requires large simulation campaigns.

Learned pilot algorithms are somewhat patent-protected (Ma-Wang-Caire + CommIT). FRAND licensing expected.

Legacy UEs: fall back to classical pilots. Rel. 21 UEs: optional learned.

Rel. 20 (2026-2028): study item. Rel. 21 (2028-2030): spec. Rel. 22 (2030+): deployment.