uwca-semantic-mac/docs/EXPERIMENTS.md

# Study Documentation

Detailed description of every study behind the manuscript
"Relevance-Aware Semantic Multiple Access via Meta-Learned User-Wise
Cross-Attention": the question each study answers, the exact setup, the
procedure, the metrics, the key results, and the artifact paths. All
studies run on a single NVIDIA RTX A4500 (PyTorch 2.10, CUDA 12.8), seed
42, and write raw JSON results consumed only by
`experiments/make_figures.py`.

**Common system model** (all `experiments/` studies, matching the
manuscript's received-signal model): single superimposed uplink
y = sum_v |h_v| e^{j dphi_v} (e_v (.) m_v) + n over one d=64-dimensional
frame; fixed {0,1} disjoint transmit block masks (d/U coordinates per user,
identical for every compared scheme); per-rail noise
std = sqrt(mean|y_tx|^2 / SNR); U=4 users and the HIGH/LOW/MIX scenarios of
the manuscript unless stated. The decoder-side masks are separate learned
soft masks in [0,1]^d initialized at the block pattern. Training is the
manuscript's first-order meta-training aggregated over SNR tasks
{0,4,...,20} dB, Adam 1e-3 (mask logits 0.1), 250-300 epochs, batch 64;
evaluation uses 150-200 Monte Carlo batches of 64 per point.

---

## E1 — Comparison fairness against optimal linear receivers

- **Question.** Is the d/U subspace ceiling of orthogonal access an
  artifact of weak comparison schemes, and how much of the UWCA gain is
  mere dimensionality rather than relevance exploitation?
- **Setup.** For each scenario the true relevance matrix B (B_uv =
  beta_u beta_v for a shared scene, else 0) and the per-realization channel
  magnitudes are formed. Receivers evaluated on the *same* received frame:
  `uwca` (trained), `ofdma`, `sfdma`, `noma` (full-band power-domain SIC,
  powers 0.40/0.30/0.20/0.10), `lmmse_blind` (closed-form Wiener with
  cross-covariances zeroed), `lmmse_genie` (closed form with true B and
  channel gains, the manuscript's Proposition on optimal linear receivers),
  and `tdma_proj` (random orthonormal 16-dim projection per user — an
  arbitrary orthogonal partition).
- **Key results.** lmmse_blind = OFDMA at every SNR in all scenarios
  (SER 0.509 vs 0.508 @10 dB HIGH), and tdma_proj and SFDMA coincide with
  them — the ceiling binds every correlation-blind receiver. HIGH @20 dB:
  blind 0.327 -> UWCA 0.110 -> genie 0.044, so UWCA recovers 77% of the
  blind-to-genie gap without side information. LOW: genie = blind (nothing
  to exploit), UWCA within 0.02 SER.
- **Artifacts.** `experiments/e1_fair_baselines.py` ->
  `experiments/data/e1_fair_baselines.json` -> `fig/fig_fair.pdf`
  (manuscript Fig. 3). Trained checkpoints `e1_uwca_{HIGH,LOW,MIX}.pt`
  (reused by E4/E6).

## E2 — Full complex-baseband phase errors and CSI error

- **Question.** Does the multi-user superposition amplify residual phase
  errors into severe inter-user interference once every leakage path is
  simulated explicitly?
- **Setup.** Complex channel with per-user residual dphi_u ~ N(0, sigma^2),
  sigma in {0,5,10,15,20,30} deg; both rails simulated. Three decoders:
  mismatch-trained (never saw phase errors), phase-augmented (trained with
  sigma ~ U[0,20] deg), and a two-rail variant whose keys/values read
  [Re;Im]. CSI sweep: amplitude error h_hat = h(1+eps),
  eps ~ N(0, sigma_h^2), sigma_h up to 0.2, at 10 deg. The learned-mask
  overlap (mean pairwise cosine) is also measured.
- **Key results.** Mismatch-trained @10 dB: SER 0.270 -> 0.291 (20 deg) ->
  0.332 (30 deg); @20 dB 0.110 -> 0.127; augmentation and I/Q reading
  change the curves by less than the Monte Carlo spread. The leakage is
  second order because it scales with sin(dphi) times the mask overlap
  (measured 0.26). CSI: UWCA unchanged within 0.004 (it uses no explicit
  CSI).
- **Artifacts.** `experiments/e2_phase_iui.py` ->
  `experiments/data/e2_phase_iui.json`; `fig/fig_phase2.pdf`.

## E3 — Dynamic user population

- **Question.** Does a decoder provisioned for U_max users need retraining
  when users arrive and depart?
- **Setup.** U_max = 8 mask slots (d=64, 8 dims/slot), high-correlation
  scenario (beta_u = 0.6, one scene). The active set is resampled per
  frame; inactive users transmit nothing and their softmax scores are
  masked out (the scheduler announces the active set). Compared: one model
  trained with the full population always active (never retrained), an
  activity-sampled model, and per-count models retrained from scratch for
  |A| in {2,4,6,8}. Metric: mean cosine (the sqrt(1/8)=0.35 subspace
  ceiling saturates the binary SER at this scale).
- **Key results.** The single full-population model sustains fidelity over
  every active count (c 0.34 -> 0.39 for |A| = 2 -> 8 @10 dB) and matches
  or exceeds the per-count retrained models (0.33/0.32/0.36/0.39);
  per-count retraining is counterproductive, since sparse populations train
  each slot on a fraction of the traffic.
- **Artifacts.** `experiments/e3_dynamic_users.py` ->
  `experiments/data/e3_dynamic_users.json`; `fig/fig_dynusers.pdf`.

## E4 — Symbol-timing offsets and receiver-side realignment

- **Question.** How does the decoder behave under asynchronous reception,
  and what does the standard timing-correction chain restore?
- **Setup.** Per-user integer offsets delta_u ~ U{0..Delta} symbols,
  Delta in {0,1,2,4,8}, shift each user's transmitted block within the
  frame (edge energy lost). Conditions: uncorrected reception (UWCA and
  OFDMA), block-wise realignment using pilot-estimated offsets (each
  user's block region shifted back individually), and realignment with a
  deliberately impaired estimator (+-1 symbol on 20% of users).
- **Key results.** Uncorrected offsets are catastrophic for *every*
  embedding-level scheme (one symbol: UWCA 0.26 -> 0.73, OFDMA 0.51 ->
  0.76), because i.i.d. embedding coordinates fully decorrelate under a
  one-symbol misalignment — synchronization is a shared physical-layer
  prerequisite, not a property of the multiple-access mechanism. With
  realignment the degradation is gradual (0.266 -> 0.304 @Delta=1, 0.455
  @Delta=8) and realigned UWCA stays below realigned OFDMA (0.536-0.638)
  at every offset. The impaired estimator costs 0.14 SER: whole-symbol
  residuals sacrifice the affected block, so timing must be held to
  sub-symbol accuracy (which the closed-loop timing advance provides).
- **Artifacts.** `experiments/e4_async.py` ->
  `experiments/data/e4_async.json`; `fig/fig_async.pdf`.

## E5 — Nonlinear inter-user semantic structure

- **Question.** Does the mechanism survive when no scalar or linear
  description of the inter-user dependence exists?
- **Setup.** Embeddings e_u = normalize(g_u([s; p_u])) with fixed random
  two-layer tanh view networks g_u per user (seed 7): users share the
  scene s only through independent nonlinear transformations. Cases:
  shared scene vs independent scenes (control). Schemes: trained UWCA,
  OFDMA, NOMA-SIC, and the scalar-parameterized genie LMMSE fed the
  *measured* mean pairwise cosine.
- **Key results.** The linear correlation is destroyed (mean cosine
  0.006), so the genie LMMSE collapses onto the ceiling (0.515 vs OFDMA
  0.518 @10 dB) — no scalar or linear receiver can represent the shared
  structure. UWCA still attains 0.363 @10 dB / 0.220 @20 dB. The
  independent-scene control (UWCA 0.441) isolates the manifold-prior
  share, so the further reduction to 0.363 is pure nonlinear cross-user
  structure.
- **Artifacts.** `experiments/e5_nonlinear.py` ->
  `experiments/data/e5_nonlinear.json`.

## E6 — Residual orthogonality vs content preservation

- **Question.** What exactly decorrelates at the decoder output: the
  delivered content, or the errors?
- **Setup.** E1's trained HIGH decoder; per-sample Pearson correlation
  across the 64 dimensions, averaged over user pairs and 100x64 samples
  per SNR, for: input embeddings, decoded embeddings, and decoding
  residuals r_u = e_hat_u - e_u; OFDMA decoded correlation as reference.
- **Key results.** The decoded-embedding correlation rises with SNR from
  0.31 toward the 0.39 input level (the shared content is delivered, not
  stripped), while the residual correlation falls 0.23 -> 0.14 (2.8x below
  the input level) — the emergent residual orthogonality. OFDMA's decoded
  correlation is 0.00 at every SNR: orthogonal access erases the
  inter-user semantic structure from the delivered embeddings.
- **Artifacts.** `experiments/e6_residual_orth.py` ->
  `experiments/data/e6_residual_orth.json` -> `fig/fig_resorth.pdf`
  (manuscript Fig. 4).

## E7 — Adaptation across fading families

- **Question.** Does the meta-trained initialization cover a
  multi-dimensional space of operating conditions that a one-dimensional
  per-SNR model bank cannot, and is the sharpness scalar stable?
- **Setup.** Task family = 6 SNRs x {Rayleigh, Rician K=5 dB, K=10 dB} x
  phase residual {0,10} deg (36 tasks). Systems: one initialization
  meta-trained over the full family (300 epochs, eta and outer-gradient
  norm logged every epoch); a per-SNR specialist bank trained on
  Rayleigh/no-phase and indexed by nearest SNR. Held-out tests: Rician
  K=20 dB + 15 deg (10/18 dB), Nakagami m=3 + 5 deg (a fading law in no
  training task), Rayleigh + 20 deg @6 dB, plus an in-distribution check;
  zero-shot and after S in {1,5,10,20} inner steps (SGD 0.02, one
  64-sample support batch).
- **Key results.** The family initialization transfers zero-shot with
  9-46% lower SER than the specialist bank on every held-out condition
  (e.g. 0.114 vs 0.158 Rician-K20-15deg @10 dB; 0.139 vs 0.190 under the
  unseen Nakagami law); inner-loop adaptation is stable (within 0.005 over
  20 steps). eta converges to 0.94 (max 1.00) and the outer gradient norm
  stays below 0.024 against a clipping bound of 5 — no softmax saturation
  or divergence.
- **Artifacts.** `experiments/e7_meta.py` ->
  `experiments/data/e7_meta.json` (includes eta/gradient trajectories).

## E8 — End-to-end training with anti-collapse regularization

- **Question.** Can the encoder be trained jointly with the decoder
  without representation collapse, and what causes the collapse when it
  occurs?
- **Setup.** Four configurations on HIGH: frozen encoder (reference);
  naive end-to-end with the distortion measured against the encoder's own
  output (a moving target); source-anchored end-to-end (distortion vs
  normalize(x)); moving target + a VICReg-style variance-covariance
  regularizer (hinge at 1/sqrt(d) per-dim std, 25x variance + 100/d
  covariance weights). Collapse-proof metric: batch nearest-neighbor
  retrieval accuracy over the *encoded* gallery, plus the effective rank
  of the encoder-output covariance.
- **Key results.** The naive configuration collapses (retrieval falls to
  chance, 0.005 vs 0.536 frozen @10 dB), locating the pathology in the
  moving-target objective rather than the cross-attention. Source
  anchoring keeps effective rank 59.6 of 64 and lands within 0.04 SER of
  the frozen reference; the variance-covariance regularizer restores
  retrieval to 0.509 with a learned task-specific code. The frozen encoder
  in the main experiments is therefore a controlled-isolation choice.
- **Artifacts.** `experiments/e8_e2e.py` ->
  `experiments/data/e8_e2e.json`.

## E9 — Online top-k relevance acquisition and measured overhead

- **Question.** How does sparse top-k attention obtain the relevance
  ranking it needs, starting from no knowledge, and what does the
  acquisition cost?
- **Setup.** U=32, eight relevance clusters of four, k=4, briefly trained
  full-attention model. Protocol: frames 1-3 run full attention (which
  needs no relevance knowledge) while the BS accumulates beta_hat by EWMA
  (zeta=0.5) of decoded-embedding cosines; from frame 4, per-row top-k via
  argpartition on beta_hat. References: an oracle whose peers are selected
  from the true clusters, and permanent full attention. Timing: decoder
  forward vs EWMA-update-plus-selection wall-clock for
  U in {8,16,32,64,128} (256-sample frames, GPU, 20-run averages).
- **Key results.** From the first post-warm-up frame the online selection
  matches the oracle exactly and slightly exceeds full attention
  (discarding irrelevant peers discards their noise); ranking needs far
  less accuracy than estimation because intra-cluster (~0.42) and
  inter-cluster (~0) cosines are well separated. Estimation plus selection
  cost 0.02-0.04 ms against the 0.3-5.4 ms decoder pass, incurred once per
  relevance coherence interval.
- **Artifacts.** `experiments/e9_topk_online.py` ->
  `experiments/data/e9_topk_online.json` (trajectory + timing).

---

## Simulation studies (`simulation/`)

- **Three-scenario SER study** (manuscript Fig. 2): analytical simulation
  `simulation/semantic_correlation_sim.py` with the trained decoder-only
  overlay from `simulation/maml_semantic.py --decoder_only`; threshold
  sweep tau in [0.30,0.50] and the mean-cosine comparison in
  `simulation/revision_experiments.py`.
- **beta sweep** (monotone gain law): `simulation/revision_betasweep.py`
  (figure `fig/fig4_beta_sweep.pdf`).
- **Attention heatmaps**: `simulation/plot_figures.py`
  (figure `fig/fig6_hlm.pdf`).
- **Hyperparameter studies** (S, lambda, d, H, K):
  `simulation/revision_ablation.py`, `simulation/revision_dsweep.py`,
  `simulation/revision_e2e.py`.
- **Real-data study** (manuscript Fig. 5): UCI optical-recognition digits
  (8x8=64 dimensions), `simulation/revision_realdata_train.py` +
  `simulation/revision_realdata_plot.py`.