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/threshold_phase_study.py.
beta sweep (monotone gain law): simulation/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/ablation_hks.py, simulation/dsweep.py, simulation/e2e_check.py.
Real-data study (manuscript Fig. 5): UCI optical-recognition digits (8x8=64 dimensions), simulation/realdata_train.py + simulation/realdata_plot.py.

13 KiB Executable File Raw Blame History