Code and stored results for the IEEE Communications Letters submission

Semantic Multiplexing Gain in Wireless Systems via Expanded Embeddings:
A BERT Case Study. Includes the shared library, all experiment scripts
(training with and without SNR-aware MAML, the token-domain comparison,
the K sweep, and DistilBERT), the replot script that regenerates every
figure from the stored results, the supplementary probe-versus-cosine
analysis, and the raw results behind every figure in the letter.

README.md

@@ -0,0 +1,81 @@
+# Semantic Multiplexing Gain in Wireless Systems via Expanded Embeddings: A BERT Case Study
+
+Code, stored results, and supplementary material for the IEEE
+Communications Letters submission by Ki-Ho Lee, Hyun-Ho Choi, and
+Jung-Ryun Lee.
+
+Multiple users share one expanded embedding block of dimension
+`d_s = K * d_b`: each user's frozen BERT sentence embedding is projected
+into the shared space, superimposed through learnable masks, and
+demultiplexed by user-wise attention. All reported transceivers are
+trained with SNR-aware MAML; the training without MAML of the earlier
+JSAC paper is included as a prior-art reference.
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `bert_semcom.py` | Shared library: BERT extractor, transceiver model, channel, MAML helpers |
+| `cl_experiments.py` | Held-out split, joint-trained configurations, ToDMA token-domain benchmark, linear probe, latency |
+| `cl_maml_all.py` | SNR-aware MAML training for every reported configuration (including the conventional orthogonal scheme) |
+| `cl_maml_extra.py` | MAML K sweep (K = 1, 2, 8) and DistilBERT replication |
+| `replot_cl.py` | Regenerates Figs. 2 and 3 of the letter from the stored JSON results |
+| `probe_vs_cosine.py` | Supplementary probe-accuracy-versus-cosine-similarity analysis |
+| `fig_cl/*.json`, `fig_cl/*.csv` | Stored raw results behind every figure and quoted number |
+
+## Reproducing
+
+Requirements: Python 3.10+, PyTorch (CUDA), `transformers`, `datasets`,
+`matplotlib`, `numpy`. AG News loads from the Hugging Face hub
+(`fancyzhx/ag_news` fallback included).
+
+```bash
+python cl_experiments.py --save-dir fig_cl   # joint runs + ToDMA benchmark (~3 h on a laptop GPU)
+python cl_maml_all.py    --save-dir fig_cl   # MAML runs (~9 h)
+python cl_maml_extra.py  --save-dir fig_cl   # MAML K sweep + DistilBERT (~6 h)
+python replot_cl.py                          # Figs. 2 and 3 from stored results
+python probe_vs_cosine.py                    # supplementary analysis below
+```
+
+All experiments fix their random seeds (training seed 42, evaluation
+seed 123, ToDMA seed 7) and evaluate on a held-out test split of 2,000
+AG News sentences disjoint from the 8,000-sentence training pool.
+`replot_cl.py` and `probe_vs_cosine.py` read only the stored results,
+so every figure is regenerable without rerunning the experiments.
+
+## Figures of the letter
+
+**Fig. 2 - per-user cosine similarity vs. SNR** (proposed scheme for
+U = 1..4 at K = 4, the conventional orthogonal scheme, the
+matched-budget schemes, and the joint training of the earlier JSAC
+paper, all on the held-out test set):
+
+![Fig. 2](fig_cl/cl_fig_mux.png)
+
+**Fig. 3 - aggregate fidelity across load** (SNR-aware MAML vs. joint
+training at 20 dB, with the fully loaded orthogonal reference):
+
+![Fig. 3](fig_cl/cl_fig_agg.png)
+
+## Supplementary: probe accuracy vs. cosine similarity
+
+The letter measures semantic fidelity by the cosine similarity of the
+recovered embeddings and corroborates it with a downstream perception
+metric: the AG News topic accuracy of a linear probe trained on clean
+training-pool embeddings and applied to the recovered test embeddings
+(clean reference about 0.855, sampling error about +/-0.01).
+
+Across 7 schemes x 7 SNRs (49 operating points), probe accuracy tracks
+cosine similarity with a Pearson correlation of **r = 0.903**:
+
+![Probe accuracy vs. cosine similarity](fig_cl/probe_vs_cosine.png)
+
+Two readings follow. First, the low-SNR advantage of the analog
+embedding schemes over the token-domain scheme appears in both metrics
+(for example 0.848 vs. 0.772 in CosSim and 0.805 vs. 0.762 in accuracy
+at 5 dB). Second, schemes within about 0.01 of each other in CosSim
+differ in accuracy only on the order of the sampling error, so the
+cosine metric used throughout the letter is consistent with downstream
+perception on this task.
+
+

bert_semcom.py

@@ -0,0 +1,785 @@
+# =========================================================
+# bert_semcom.py
+# BERT-based Multi-User Semantic Communication
+# with Expanded Shared Embedding + User-Wise Attention
+#
+# Key Idea:
+#   Each user's BERT embedding (768-dim) is EXPANDED to a
+#   larger shared embedding space (e.g., 768*K where K=4),
+#   enabling statistical multiplexing gain through masking
+#   in the over-provisioned shared space.
+#
+# Architecture:
+#   Tx:
+#     b_u = BERT(text_u)                    # (d_bert,)  e.g., 768
+#     e_u = W_tx(b_u)                       # (d_shared,) e.g., 3072
+#     x_u = e_u ⊙ m_u                      # user-masked in expanded space
+#     y   = Σ_u x_u                         # over-the-air superposition
+#     y_rx = channel(y)
+#
+#   Rx (User-wise attention demux):
+#     R_i = y_rx ⊙ m_i                     # candidate projections
+#     a_{u,i} = softmax( <norm(R_i), norm(q_u)> / sqrt(d) )
+#     z_u = Σ_i a_{u,i} R_i
+#     b̂_u = W_rx(z_u)                      # (d_bert,) recovered
+#
+#   Loss:
+#     L = (1-λ) * MSE(b_u, b̂_u) + λ * (1 - CosSim(b_u, b̂_u))
+#
+#   Metrics: Cosine similarity, MSE
+#
+# Statistical Multiplexing Gain:
+#   Even with U=2 users, projecting to d_shared = d_bert*4
+#   provides over-provisioned subspace for each user's mask,
+#   reducing inter-user interference and improving separation.
+#
+# Train modes: joint / maml_decoder / maml_full
+# =========================================================
+
+import argparse
+import math
+import random
+import csv
+import os
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+try:
+    from torch.func import functional_call
+except Exception:
+    from torch.nn.utils.stateless import functional_call
+
+
+# =========================================================
+# BERT Embedding Extractor (frozen)
+# =========================================================
+class BertEmbeddingExtractor:
+    """
+    Extract sentence-level embeddings from pre-trained BERT.
+    Uses mean pooling over non-padding tokens to mitigate
+    BERT [CLS] anisotropy. Returns un-normalized embeddings;
+    centering and L2-norm are applied at the cache level.
+    """
+    def __init__(self, model_name="bert-base-uncased", device="cpu"):
+        from transformers import BertModel, BertTokenizer
+        self.tokenizer = BertTokenizer.from_pretrained(model_name)
+        self.model = BertModel.from_pretrained(model_name).to(device)
+        self.model.eval()
+        self.device = device
+        self.embed_dim = self.model.config.hidden_size  # 768
+
+    @torch.no_grad()
+    def encode(self, texts):
+        """Mean-pooled token embedding (excluding padding)."""
+        inputs = self.tokenizer(
+            texts, padding=True, truncation=True,
+            max_length=64, return_tensors="pt"
+        ).to(self.device)
+        outputs = self.model(**inputs)
+        last_hidden = outputs.last_hidden_state          # (B, T, d)
+        mask = inputs["attention_mask"].unsqueeze(-1).float()  # (B, T, 1)
+        summed = (last_hidden * mask).sum(dim=1)         # (B, d)
+        count = mask.sum(dim=1).clamp(min=1.0)           # (B, 1)
+        mean_emb = summed / count                        # (B, d)
+        return mean_emb
+
+
+# =========================================================
+# Text Dataset
+# =========================================================
+def load_sentences(source="ag_news", max_sentences=50000,
+                   min_len=5, max_len=30):
+    """Load sentences from various sources."""
+    sentences = []
+
+    if source == "europarl":
+        try:
+            from datasets import load_dataset
+            ds = load_dataset("wmt14", "de-en", split="train", streaming=True)
+            for example in ds:
+                sent = example["translation"]["en"]
+                words = sent.split()
+                if min_len <= len(words) <= max_len:
+                    sentences.append(sent)
+                if len(sentences) >= max_sentences:
+                    break
+        except Exception:
+            print("[INFO] WMT14 not available, trying ag_news...")
+            source = "ag_news"
+
+    if source == "ag_news":
+        try:
+            from datasets import load_dataset
+            ds = load_dataset("ag_news", split="train")
+            for example in ds:
+                sent = example["text"]
+                first_sent = sent.split(".")[0].strip()
+                words = first_sent.split()
+                if min_len <= len(words) <= max_len:
+                    sentences.append(first_sent)
+                if len(sentences) >= max_sentences:
+                    break
+        except Exception:
+            print("[INFO] ag_news not available, using synthetic...")
+            source = "synthetic"
+
+    if source == "synthetic" or len(sentences) < 1000:
+        print("[INFO] Generating synthetic diverse sentences...")
+        templates = [
+            "The {} {} the {} in the {}.",
+            "A {} {} quickly {} the {}.",
+            "Several {} {} near the {} {}.",
+            "The {} and {} {} {} together.",
+            "Every {} must {} its own {}.",
+            "Under the {}, a {} {} {} softly.",
+            "The {} of {} {} a {} signal.",
+            "Without {}, the {} cannot {} properly.",
+            "A new {} {} from the {} {}.",
+            "The {} {} through the {} channel.",
+        ]
+        nouns = ["system", "signal", "network", "channel", "user", "device",
+                 "antenna", "receiver", "transmitter", "waveform", "protocol",
+                 "data", "packet", "frequency", "power", "noise", "beam",
+                 "satellite", "tower", "base station", "terminal", "sensor",
+                 "message", "code", "sequence", "spectrum", "bandwidth"]
+        verbs = ["processes", "transmits", "receives", "analyzes", "encodes",
+                 "decodes", "modulates", "filters", "amplifies", "detects",
+                 "estimates", "optimizes", "adapts", "allocates", "schedules"]
+        adjs = ["wireless", "digital", "analog", "robust", "adaptive",
+                "cognitive", "massive", "distributed", "cooperative", "mobile",
+                "reliable", "efficient", "dynamic", "intelligent", "semantic"]
+        for _ in range(max(max_sentences, 50000)):
+            tmpl = random.choice(templates)
+            n_slots = tmpl.count("{}")
+            fillers = [random.choice(random.choice([nouns, verbs, adjs]))
+                       for _ in range(n_slots)]
+            sentences.append(tmpl.format(*fillers))
+
+    random.shuffle(sentences)
+    return sentences[:max_sentences]
+
+
+# =========================================================
+# Channel
+# =========================================================
+def apply_channel(y, snr_db, channel="rayleigh"):
+    """
+    y: (d_shared,) real-valued, power-normalized embedding vector.
+    Rayleigh: magnitude fading |h| where h ~ CN(0,1).
+    """
+    snr_lin = 10 ** (snr_db / 10.0)
+    noise_var = 1.0 / snr_lin
+
+    if channel == "rayleigh":
+        # Complex Rayleigh fading -> magnitude |h|
+        h_real = torch.randn((), device=y.device)
+        h_imag = torch.randn((), device=y.device)
+        h_mag = torch.sqrt(h_real**2 + h_imag**2) / math.sqrt(2.0)
+        y = h_mag * y
+
+    noise = torch.randn_like(y) * math.sqrt(noise_var)
+    return y + noise
+
+
+# =========================================================
+# Model: Expanded Shared Embedding + User-Wise Attention
+# =========================================================
+class BertSemComMux(nn.Module):
+    """
+    BERT-based Multi-User Semantic Communication.
+
+    Key design: BERT embedding (d_bert=768) is EXPANDED to
+    d_shared = d_bert * mux_factor (e.g., 768*4=3072) to
+    provide statistical multiplexing gain.
+
+    Even with fewer users than mux_factor, the expanded space
+    gives each user more "room" for orthogonal mask allocation,
+    reducing inter-user interference.
+    """
+    def __init__(self, U, d_bert, d_shared, hidden=512):
+        super().__init__()
+        self.U = U
+        self.d_bert = d_bert          # 768
+        self.d_shared = d_shared      # e.g., 768*4 = 3072
+
+        # Tx: single-layer linear projection to the shared space
+        # (no sub-d_bert bottleneck, no costly d_shared x d_shared layer).
+        # Followed by LayerNorm for numerical stability.
+        self.tx_proj = nn.Sequential(
+            nn.Linear(d_bert, d_shared),
+            nn.LayerNorm(d_shared),
+        )
+
+        # User-specific masks in expanded shared space
+        self.user_mask = nn.Embedding(U, d_shared)
+
+        # Rx: user-wise attention queries in shared space
+        self.user_query = nn.Embedding(U, d_shared)
+
+        # Rx: single-layer linear projection back to BERT space.
+        self.rx_proj = nn.Sequential(
+            nn.LayerNorm(d_shared),
+            nn.Linear(d_shared, d_bert),
+        )
+
+        nn.init.normal_(self.user_mask.weight, std=0.5)
+        nn.init.normal_(self.user_query.weight, std=0.5)
+
+    def forward(self, bert_embs, snr_db, channel, params=None,
+                return_intermediate=False):
+        """
+        bert_embs: (U, d_bert) - BERT sentence embeddings
+        Returns: (U, d_bert) - recovered embeddings
+        """
+        dev = bert_embs.device
+
+        # ----- Tx: Project to expanded shared space -----
+        if params is None:
+            e = self.tx_proj(bert_embs)            # (U, d_shared)
+            m = self.user_mask.weight              # (U, d_shared)
+        else:
+            e = functional_call(self.tx_proj, params["tx_proj"],
+                                (bert_embs,))
+            m = functional_call(
+                self.user_mask, params["user_mask"],
+                (torch.arange(self.U, device=dev),))
+
+        # Masking in expanded space
+        x = e * m                                   # (U, d_shared)
+        y_tx = x.sum(dim=0)                         # (d_shared,)
+
+        # ----- Power normalization -----
+        # OFDM model: each subcarrier (dimension) has unit power.
+        # Larger d_shared = more subcarriers = more bandwidth.
+        # Per-dimension SNR is the same regardless of d_shared.
+        # This models the bandwidth-quality trade-off:
+        #   d_shared=128: compressed (low bandwidth, lossy)
+        #   d_shared=768: matched (1:1)
+        #   d_shared=3072: expanded (high bandwidth, room for separation)
+        y_tx = y_tx / (torch.sqrt((y_tx ** 2).mean() + 1e-8))
+
+        # ----- Channel -----
+        y_rx = apply_channel(y_tx, snr_db, channel)
+
+        # ----- Rx: user-wise attention -----
+        R = y_rx.unsqueeze(0) * m                   # (U, d_shared)
+        Rn = F.normalize(R, p=2, dim=-1)
+
+        recovered = []
+        attn_weights = []
+        for u in range(self.U):
+            if params is None:
+                q = self.user_query(torch.tensor(u, device=dev))
+            else:
+                q = functional_call(
+                    self.user_query, params["user_query"],
+                    (torch.tensor(u, device=dev),))
+
+            qn = F.normalize(q, p=2, dim=-1)
+            # Native cosine-similarity scores (no extra 1/sqrt(d_s)
+            # damping). Since Rn, qn are unit-norm, the raw dot product
+            # is already in [-1, 1] and softmax-friendly. The standard
+            # 1/sqrt(d) attention temperature would collapse softmax to
+            # near-uniform when d_s is large (e.g., 3072).
+            scores = (Rn @ qn) * 8.0  # mild temperature sharpening
+            attn = F.softmax(scores, dim=0)
+            attn_weights.append(attn.detach())
+
+            z_u = (attn.unsqueeze(-1) * R).sum(dim=0)  # (d_shared,)
+
+            # Reverse projection: shared space -> BERT space
+            if params is None:
+                b_hat_u = self.rx_proj(z_u)
+            else:
+                b_hat_u = functional_call(self.rx_proj, params["rx_proj"],
+                                          (z_u,))
+
+            recovered.append(b_hat_u)
+
+        result = torch.stack(recovered, dim=0)  # (U, d_bert)
+
+        if return_intermediate:
+            return result, {
+                "y_tx": y_tx.detach(),
+                "y_rx": y_rx.detach(),
+                "attn": torch.stack(attn_weights, dim=0),  # (U, U)
+                "masks": m.detach(),
+                "projected": e.detach(),
+            }
+
+        return result
+
+
+# =========================================================
+# Loss Function
+# =========================================================
+def semantic_loss(b_orig, b_hat, lam=0.5):
+    """
+    Combined MSE + Cosine Similarity loss.
+    b_orig, b_hat: (U, d_bert)
+    """
+    mse = F.mse_loss(b_hat, b_orig)
+    cos_sim = F.cosine_similarity(b_hat, b_orig, dim=-1).mean()
+    loss = (1.0 - lam) * mse + lam * (1.0 - cos_sim)
+    return loss, mse.item(), cos_sim.item()
+
+
+# =========================================================
+# MAML Helpers (same structure as original maml.py)
+# =========================================================
+def split_params(model: BertSemComMux):
+    return {
+        "tx_proj": dict(model.tx_proj.named_parameters()),
+        "user_mask": dict(model.user_mask.named_parameters()),
+        "user_query": dict(model.user_query.named_parameters()),
+        "rx_proj": dict(model.rx_proj.named_parameters()),
+    }
+
+
+def select_inner_keys(train_mode: str):
+    if train_mode == "maml_decoder":
+        return ["user_query", "rx_proj"]
+    if train_mode == "maml_full":
+        return ["tx_proj", "user_mask", "user_query", "rx_proj"]
+    return []
+
+
+def ordered_param_items(param_dict: dict):
+    return [(k, param_dict[k]) for k in sorted(param_dict.keys())]
+
+
+def gather_inner_params(fast_params: dict, inner_keys: list):
+    flat_list, meta_index = [], []
+    for key in inner_keys:
+        for name, p in ordered_param_items(fast_params[key]):
+            flat_list.append(p)
+            meta_index.append((key, name))
+    return flat_list, meta_index
+
+
+def apply_inner_update(fast_params, inner_keys, meta_index, grads,
+                       inner_lr, maml_order):
+    new_fast = {k: dict(v) for k, v in fast_params.items()}
+    for (key, name), g in zip(meta_index, grads):
+        if maml_order == "first":
+            g = g.detach()
+        new_fast[key][name] = new_fast[key][name] - inner_lr * g
+    return new_fast
+
+
+# =========================================================
+# Embedding Cache (pre-compute BERT embeddings)
+# =========================================================
+class EmbeddingCache:
+    """Pre-compute, center, and L2-normalize BERT embeddings.
+    Centering removes the dominant mean direction to reduce
+    anisotropy; L2 normalization gives unit-norm embeddings
+    suitable for cosine-similarity-based loss/metrics.
+    """
+    def __init__(self, bert_extractor, sentences, batch_size=64):
+        self.embeddings = []
+        self.sentences = sentences
+        print(f"[INFO] Pre-computing BERT embeddings for "
+              f"{len(sentences)} sentences...")
+        for i in range(0, len(sentences), batch_size):
+            batch = sentences[i:i+batch_size]
+            emb = bert_extractor.encode(batch)
+            self.embeddings.append(emb.cpu())
+        self.embeddings = torch.cat(self.embeddings, dim=0)
+
+        # Center (subtract mean direction) to reduce anisotropy
+        self.mean = self.embeddings.mean(dim=0, keepdim=True)
+        self.embeddings = self.embeddings - self.mean
+        # L2-normalize
+        self.embeddings = F.normalize(self.embeddings, p=2, dim=-1)
+
+        # Sanity check: random pairwise cos sim should be near 0
+        n_check = min(500, len(self.embeddings))
+        idx1 = torch.randperm(len(self.embeddings))[:n_check]
+        idx2 = torch.randperm(len(self.embeddings))[:n_check]
+        cs = F.cosine_similarity(self.embeddings[idx1],
+                                  self.embeddings[idx2], dim=-1)
+        print(f"[INFO] Cached {self.embeddings.shape[0]} embeddings, "
+              f"shape={self.embeddings.shape}")
+        print(f"[INFO] After centering: random pair cos sim "
+              f"mean={cs.mean():.4f}, std={cs.std():.4f}")
+
+    def sample(self, U, device):
+        """Sample U random embeddings."""
+        idx = torch.randint(0, len(self.embeddings), (U,))
+        return self.embeddings[idx].to(device), idx
+
+    def get_sentences(self, idx):
+        """Get sentences by index."""
+        return [self.sentences[i] for i in idx]
+
+
+# =========================================================
+# Evaluation
+# =========================================================
+@torch.no_grad()
+def evaluate(model, cache, args, device):
+    model.eval()
+    total_cos, total_mse, n_trials = 0.0, 0.0, 0
+
+    if not args.eval_adapt:
+        for _ in range(args.eval_trials):
+            b, _ = cache.sample(args.users, device)
+            b_hat = model(b, args.snr, args.channel, params=None)
+            cos = F.cosine_similarity(b_hat, b, dim=-1).mean().item()
+            mse = F.mse_loss(b_hat, b).item()
+            total_cos += cos
+            total_mse += mse
+            n_trials += 1
+        return total_cos / n_trials, total_mse / n_trials
+
+    # Few-shot adaptation
+    inner_keys = select_inner_keys(args.eval_adapt_mode)
+    base_params = split_params(model)
+
+    for _ in range(args.eval_trials):
+        b_sup, _ = cache.sample(args.users, device)
+        fast_params = {k: {n: p for n, p in v.items()}
+                       for k, v in base_params.items()}
+
+        with torch.enable_grad():
+            for _ in range(args.eval_inner_steps):
+                b_hat_sup = model(b_sup, args.snr, args.channel,
+                                  params=fast_params)
+                loss_sup, _, _ = semantic_loss(b_sup, b_hat_sup,
+                                               args.loss_lambda)
+                flat_list, meta_index = gather_inner_params(
+                    fast_params, inner_keys)
+                grads = torch.autograd.grad(loss_sup, flat_list,
+                                            create_graph=False)
+                fast_params = apply_inner_update(
+                    fast_params, inner_keys, meta_index, grads,
+                    inner_lr=args.eval_inner_lr, maml_order="first")
+
+        b_q, _ = cache.sample(args.users, device)
+        b_hat_q = model(b_q, args.snr, args.channel, params=fast_params)
+        cos = F.cosine_similarity(b_hat_q, b_q, dim=-1).mean().item()
+        mse = F.mse_loss(b_hat_q, b_q).item()
+        total_cos += cos
+        total_mse += mse
+        n_trials += 1
+
+    return total_cos / n_trials, total_mse / n_trials
+
+
+# =========================================================
+# Train & Eval
+# =========================================================
+def train_and_eval(args):
+    if args.cuda and torch.cuda.is_available():
+        device = torch.device("cuda")
+    elif torch.backends.mps.is_available():
+        device = torch.device("mps")
+    else:
+        device = torch.device("cpu")
+
+    torch.manual_seed(args.seed)
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+
+    # ---- Load BERT and pre-compute embeddings ----
+    bert = BertEmbeddingExtractor(args.bert_model, device)
+    d_bert = bert.embed_dim  # 768
+
+    # Compute d_shared = d_bert * mux_factor
+    d_shared = d_bert * args.mux_factor
+    print(f"[INFO] d_bert={d_bert}, mux_factor={args.mux_factor}, "
+          f"d_shared={d_shared}")
+
+    sentences = load_sentences(args.data_source, args.max_sentences)
+    print(f"[INFO] Loaded {len(sentences)} sentences")
+
+    cache = EmbeddingCache(bert, sentences,
+                           batch_size=args.bert_batch_size)
+
+    # Free BERT from GPU
+    del bert
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    # ---- Build model ----
+    model = BertSemComMux(args.users, d_bert, d_shared,
+                          args.hidden).to(device)
+    opt = torch.optim.Adam(model.parameters(), lr=args.lr)
+
+    train_snr_list = list(args.train_snr)
+    inner_keys = select_inner_keys(args.train_mode)
+
+    # ---- Config ----
+    print("=" * 60)
+    print(" BERT Semantic Communication - Expanded Shared Embedding")
+    print("=" * 60)
+    print(f" Device              : {device}")
+    print(f" Train mode          : {args.train_mode}")
+    print(f" MAML order          : {args.maml_order}")
+    print(f" Users (U)           : {args.users}")
+    print(f" BERT dim (d_bert)   : {d_bert}")
+    print(f" Mux factor (K)      : {args.mux_factor}")
+    print(f" Shared dim (d_shared): {d_shared}")
+    print(f" Hidden (MLP)        : {args.hidden}")
+    print(f" Channel             : {args.channel}")
+    print(f" Loss lambda         : {args.loss_lambda}")
+    print("-" * 60)
+    print(f" Train SNRs (dB)     : {train_snr_list}")
+    print(f" Eval SNR (dB)       : {args.snr}")
+    print("-" * 60)
+    print(f" Epochs              : {args.epochs}")
+    print(f" Steps/epoch         : {args.train_steps_per_epoch}")
+    print(f" Eval trials         : {args.eval_trials}")
+    if args.train_mode != "joint":
+        print("-" * 60)
+        print(f" Inner steps         : {args.inner_steps}")
+        print(f" Inner LR            : {args.inner_lr}")
+        print(f" Meta-batch          : {args.meta_batch}")
+        print(f" Inner keys          : {inner_keys}")
+    print("=" * 60)
+
+    # ---- CSV ----
+    os.makedirs(args.save_dir, exist_ok=True)
+    csv_path = os.path.join(
+        args.save_dir,
+        f"bert_{args.train_mode}_{args.users}U_K{args.mux_factor}.csv"
+    )
+
+    if not os.path.exists(csv_path):
+        with open(csv_path, "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                "epoch", "train_mode", "maml_order",
+                "users", "d_bert", "mux_factor", "d_shared",
+                "channel", "train_snrs", "eval_snr",
+                "inner_steps", "inner_lr", "meta_batch",
+                "avg_loss", "cos_sim", "mse"
+            ])
+
+    # ---- Training ----
+    for ep in range(1, args.epochs + 1):
+        model.train()
+        loss_meter = 0.0
+
+        for _ in range(args.train_steps_per_epoch):
+            if args.train_mode == "joint":
+                b, _ = cache.sample(args.users, device)
+                snr = float(random.choice(train_snr_list))
+                b_hat = model(b, snr, args.channel, params=None)
+                loss, _, _ = semantic_loss(b, b_hat, args.loss_lambda)
+                opt.zero_grad(set_to_none=True)
+                loss.backward()
+                opt.step()
+                loss_meter += loss.item()
+
+            else:
+                # MAML
+                if args.meta_batch > len(train_snr_list):
+                    snr_tasks = [float(random.choice(train_snr_list))
+                                 for _ in range(args.meta_batch)]
+                else:
+                    snr_tasks = [float(x) for x in
+                                 random.sample(train_snr_list,
+                                               args.meta_batch)]
+
+                base_params = split_params(model)
+                meta_loss = torch.tensor(0.0, device=device)
+
+                for snr in snr_tasks:
+                    fast_params = {
+                        k: {n: p for n, p in v.items()}
+                        for k, v in base_params.items()
+                    }
+
+                    for _ in range(args.inner_steps):
+                        b_sup, _ = cache.sample(args.users, device)
+                        b_hat_sup = model(b_sup, snr, args.channel,
+                                          params=fast_params)
+                        loss_sup, _, _ = semantic_loss(
+                            b_sup, b_hat_sup, args.loss_lambda)
+
+                        flat_list, meta_index = gather_inner_params(
+                            fast_params, inner_keys)
+                        create_graph = (args.maml_order == "second")
+                        grads = torch.autograd.grad(
+                            loss_sup, flat_list,
+                            create_graph=create_graph)
+                        fast_params = apply_inner_update(
+                            fast_params, inner_keys, meta_index, grads,
+                            inner_lr=args.inner_lr,
+                            maml_order=args.maml_order)
+
+                    b_q, _ = cache.sample(args.users, device)
+                    b_hat_q = model(b_q, snr, args.channel,
+                                    params=fast_params)
+                    qloss, _, _ = semantic_loss(
+                        b_q, b_hat_q, args.loss_lambda)
+                    meta_loss = meta_loss + qloss
+
+                meta_loss = meta_loss / float(args.meta_batch)
+                opt.zero_grad(set_to_none=True)
+                meta_loss.backward()
+                opt.step()
+                loss_meter += meta_loss.item()
+
+        avg_loss = loss_meter / float(args.train_steps_per_epoch)
+
+        # ---- Eval ----
+        cos_sim, mse = evaluate(model, cache, args, device)
+
+        print(f"[Epoch {ep:03d}/{args.epochs}] loss={avg_loss:.4f} | "
+              f"SNR={args.snr:.1f}dB | CosSim={cos_sim:.4f} | "
+              f"MSE={mse:.4e}")
+
+        with open(csv_path, "a", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                ep, args.train_mode, args.maml_order,
+                args.users, d_bert, args.mux_factor, d_shared,
+                args.channel, train_snr_list, args.snr,
+                (args.inner_steps if args.train_mode != "joint" else ""),
+                (args.inner_lr if args.train_mode != "joint" else ""),
+                (args.meta_batch if args.train_mode != "joint" else ""),
+                avg_loss, cos_sim, mse
+            ])
+
+    print(f"\n✅ Results saved to: {csv_path}")
+    return model
+
+
+# =========================================================
+# Main
+# =========================================================
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="BERT-based Multi-User Semantic Communication "
+                    "with Expanded Shared Embedding")
+
+    # training mode
+    parser.add_argument("--train-mode",
+                        choices=["joint", "maml_decoder", "maml_full"],
+                        default="joint")
+    parser.add_argument("--maml-order", choices=["first", "second"],
+                        default="first")
+
+    # model
+    parser.add_argument("--users", type=int, default=4)
+    parser.add_argument("--mux-factor", type=int, default=4,
+                        help="Shared dim = d_bert * mux_factor "
+                             "(e.g., 4 -> 768*4=3072)")
+    parser.add_argument("--hidden", type=int, default=512)
+
+    # BERT
+    parser.add_argument("--bert-model", type=str,
+                        default="bert-base-uncased")
+    parser.add_argument("--bert-batch-size", type=int, default=64)
+
+    # data
+    parser.add_argument("--data-source",
+                        choices=["europarl", "ag_news", "synthetic"],
+                        default="ag_news")
+    parser.add_argument("--max-sentences", type=int, default=50000)
+
+    # channel
+    parser.add_argument("--channel", choices=["awgn", "rayleigh"],
+                        default="rayleigh")
+
+    # loss
+    parser.add_argument("--loss-lambda", type=float, default=0.5)
+
+    # training
+    parser.add_argument("--epochs", type=int, default=100)
+    parser.add_argument("--train-steps-per-epoch", type=int, default=2000)
+    parser.add_argument("--train-snr", type=float, nargs="+",
+                        default=[0, 5, 10, 15, 20, 25])
+    parser.add_argument("--lr", type=float, default=1e-3)
+
+    # MAML
+    parser.add_argument("--inner-lr", type=float, default=1e-3)
+    parser.add_argument("--inner-steps", type=int, default=1)
+    parser.add_argument("--meta-batch", type=int, default=4)
+
+    # evaluation
+    parser.add_argument("--snr", type=float, default=10.0)
+    parser.add_argument("--eval-trials", type=int, default=5000)
+
+    # test-time adaptation
+    parser.add_argument("--eval-adapt", action="store_true")
+    parser.add_argument("--eval-adapt-mode",
+                        choices=["maml_decoder", "maml_full"],
+                        default="maml_decoder")
+    parser.add_argument("--eval-inner-steps", type=int, default=1)
+    parser.add_argument("--eval-inner-lr", type=float, default=1e-3)
+
+    # misc
+    parser.add_argument("--save-dir", type=str, default="results_bert")
+    parser.add_argument("--cuda", action="store_true")
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--debug-maml", action="store_true")
+
+    args = parser.parse_args()
+    train_and_eval(args)
+
+
+"""
+========================
+Example Commands
+========================
+
+[1] Joint training (U=4, K=4 -> d_shared=3072, Rayleigh)
+python3 bert_semcom.py \
+  --train-mode joint \
+  --users 4 --mux-factor 4 \
+  --snr 10 --channel rayleigh \
+  --data-source ag_news \
+  --epochs 50 --train-steps-per-epoch 2000 \
+  --eval-trials 5000 --cuda
+
+[2] Statistical mux gain: U=2, still K=4 (over-provisioned)
+python3 bert_semcom.py \
+  --train-mode joint \
+  --users 2 --mux-factor 4 \
+  --snr 10 --channel rayleigh \
+  --epochs 50 --cuda
+
+[3] Compare mux factors: K=1,2,4,8
+for K in 1 2 4 8; do
+  python3 bert_semcom.py \
+    --train-mode joint \
+    --users 4 --mux-factor $K \
+    --snr 10 --epochs 50 --cuda
+done
+
+[4] Decoder-only MAML (U=4, K=4)
+python3 bert_semcom.py \
+  --train-mode maml_decoder --maml-order first \
+  --users 4 --mux-factor 4 \
+  --meta-batch 4 --inner-lr 5e-4 --inner-steps 1 \
+  --snr 10 --epochs 50 --cuda
+
+[5] Full MAML
+python3 bert_semcom.py \
+  --train-mode maml_full --maml-order first \
+  --users 4 --mux-factor 4 \
+  --meta-batch 4 --inner-lr 5e-4 --inner-steps 1 \
+  --snr 10 --epochs 50 --cuda
+
+[6] SNR sweep
+for snr in 0 5 10 15 20 25 30; do
+  python3 bert_semcom.py \
+    --train-mode joint \
+    --users 4 --mux-factor 4 \
+    --snr $snr --epochs 50 --cuda
+done
+
+[7] User count comparison (all with K=4)
+for u in 2 4 8 16; do
+  python3 bert_semcom.py \
+    --train-mode joint \
+    --users $u --mux-factor 4 \
+    --snr 10 --epochs 50 --cuda
+done
+"""

cl_experiments.py

@@ -0,0 +1,538 @@
+# =========================================================
+# cl_experiments.py — IEEE Communications Letters revision
+#
+# New experiments addressing TVT reviewer comments:
+#   R2-2 : held-out train/test split (8000/2000, disjoint)
+#   R1-2 : bandwidth-expansion sweep K = 1, 2, 4, 8 at U = 4
+#   R1-5c: static random-projection mask baseline (frozen masks)
+#   R2-3 : ToDMA-style token-domain CS baseline (same channel budget)
+#   R1-5b: DistilBERT generalization check
+#   R2-4 : downstream AG News topic accuracy (linear probe)
+#   R1-3 : runtime latency / parameter count
+#
+# All evaluations are on the held-out test split.
+# Outputs: fig_cl/cl_results.json, fig_cl/cl_convergence.csv
+# =========================================================
+
+import argparse, os, json, csv, math, random, time, itertools
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from bert_semcom import (
+    BertSemComMux, semantic_loss,
+    split_params, select_inner_keys, gather_inner_params,
+    apply_inner_update
+)
+
+EVAL_SNRS = (0, 5, 10, 15, 20, 25, 30)
+TRAIN_SNRS = [0, 5, 10, 15, 20, 25]
+
+
+def set_seed(seed=42):
+    torch.manual_seed(seed)
+    random.seed(seed)
+    np.random.seed(seed)
+
+
+# ---------------------------------------------------------
+# Data with labels + disjoint split
+# ---------------------------------------------------------
+def load_agnews_labeled(n_train=8000, n_test=2000,
+                        min_len=5, max_len=30, seed=42):
+    from datasets import load_dataset
+    try:
+        ds = load_dataset("ag_news", split="train")
+    except Exception:
+        ds = load_dataset("fancyzhx/ag_news", split="train")
+    items = []
+    for ex in ds:
+        first = ex["text"].split(".")[0].strip()
+        w = first.split()
+        if min_len <= len(w) <= max_len:
+            items.append((first, int(ex["label"])))
+        if len(items) >= (n_train + n_test):
+            break
+    rng = random.Random(seed)
+    rng.shuffle(items)
+    train = items[:n_train]
+    test = items[n_train:n_train + n_test]
+    return train, test
+
+
+class Extractor:
+    """Frozen encoder (BERT or DistilBERT), mean-pooled."""
+    def __init__(self, model_name, device):
+        from transformers import AutoModel, AutoTokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name).to(device)
+        self.model.eval()
+        self.device = device
+        self.embed_dim = self.model.config.hidden_size
+
+    @torch.no_grad()
+    def encode(self, texts, max_length=64):
+        inputs = self.tokenizer(texts, padding=True, truncation=True,
+                                max_length=max_length,
+                                return_tensors="pt").to(self.device)
+        out = self.model(**inputs)
+        h = out.last_hidden_state
+        mask = inputs["attention_mask"].unsqueeze(-1).float()
+        return (h * mask).sum(1) / mask.sum(1).clamp(min=1.0)
+
+
+class SplitCache:
+    """Train/test embedding caches. Centering mean computed on the
+    TRAIN pool only and reused for the test split (R2-2)."""
+    def __init__(self, extractor, train_items, test_items, bs=64):
+        self.train_texts = [t for t, _ in train_items]
+        self.train_labels = torch.tensor([l for _, l in train_items])
+        self.test_texts = [t for t, _ in test_items]
+        self.test_labels = torch.tensor([l for _, l in test_items])
+
+        def enc_all(texts):
+            embs = []
+            for i in range(0, len(texts), bs):
+                embs.append(extractor.encode(texts[i:i + bs]).cpu())
+            return torch.cat(embs, 0)
+
+        print(f"[INFO] Encoding {len(self.train_texts)} train sentences...",
+              flush=True)
+        E_tr = enc_all(self.train_texts)
+        print(f"[INFO] Encoding {len(self.test_texts)} test sentences...",
+              flush=True)
+        E_te = enc_all(self.test_texts)
+
+        self.mu = E_tr.mean(0, keepdim=True)
+        self.train = F.normalize(E_tr - self.mu, p=2, dim=-1)
+        self.test = F.normalize(E_te - self.mu, p=2, dim=-1)
+
+        cs = F.cosine_similarity(
+            self.test[torch.randperm(len(self.test))[:500]],
+            self.test[torch.randperm(len(self.test))[:500]], dim=-1)
+        print(f"[INFO] test split: random-pair cos mean={cs.mean():.4f} "
+              f"std={cs.std():.4f}", flush=True)
+
+    def sample_train(self, U, device):
+        idx = torch.randint(0, len(self.train), (U,))
+        return self.train[idx].to(device), idx
+
+    def sample_test(self, U, device, gen=None):
+        idx = torch.randint(0, len(self.test), (U,), generator=gen)
+        return self.test[idx].to(device), idx
+
+
+# ---------------------------------------------------------
+# Training (train pool) + held-out evaluation (test pool)
+# ---------------------------------------------------------
+def train_config(cache, U, d_bert, K, device, mode="joint",
+                 freeze_masks=False, epochs=200, steps=300,
+                 lr=1e-3, inner_lr=5e-4, inner_steps=1, meta_batch=4,
+                 lam=0.5, channel="rayleigh", conv_trials=50,
+                 label="", seed=42):
+    set_seed(seed)
+    d_shared = d_bert * K
+    model = BertSemComMux(U, d_bert, d_shared, 512).to(device)
+    if freeze_masks:
+        model.user_mask.weight.requires_grad_(False)
+    opt = torch.optim.Adam(
+        [p for p in model.parameters() if p.requires_grad], lr=lr)
+    inner_keys = select_inner_keys(mode)
+    conv = []
+    t0 = time.time()
+
+    for ep in range(1, epochs + 1):
+        model.train()
+        loss_sum = 0.0
+        for _ in range(steps):
+            if mode == "joint":
+                b, _ = cache.sample_train(U, device)
+                snr = float(random.choice(TRAIN_SNRS))
+                b_hat = model(b, snr, channel)
+                loss, _, _ = semantic_loss(b, b_hat, lam)
+                opt.zero_grad(set_to_none=True)
+                loss.backward()
+                opt.step()
+                loss_sum += loss.item()
+            else:
+                snr_tasks = [float(x) for x in
+                             random.sample(TRAIN_SNRS, meta_batch)]
+                base_params = split_params(model)
+                meta_loss = torch.tensor(0.0, device=device)
+                for snr in snr_tasks:
+                    fp = {k: {n: p for n, p in v.items()}
+                          for k, v in base_params.items()}
+                    for _ in range(inner_steps):
+                        b_s, _ = cache.sample_train(U, device)
+                        bh = model(b_s, snr, channel, params=fp)
+                        ls, _, _ = semantic_loss(b_s, bh, lam)
+                        fl, mi = gather_inner_params(fp, inner_keys)
+                        grads = torch.autograd.grad(ls, fl)
+                        fp = apply_inner_update(fp, inner_keys, mi, grads,
+                                                inner_lr, "first")
+                    b_q, _ = cache.sample_train(U, device)
+                    bh_q = model(b_q, snr, channel, params=fp)
+                    ql, _, _ = semantic_loss(b_q, bh_q, lam)
+                    meta_loss = meta_loss + ql
+                meta_loss = meta_loss / float(meta_batch)
+                opt.zero_grad(set_to_none=True)
+                meta_loss.backward()
+                opt.step()
+                loss_sum += meta_loss.item()
+
+        # light held-out convergence eval @10 dB
+        model.eval()
+        with torch.no_grad():
+            c = 0.0
+            for _ in range(conv_trials):
+                b, _ = cache.sample_test(U, device)
+                bh = model(b, 10, channel)
+                c += F.cosine_similarity(bh, b, dim=-1).mean().item()
+        conv.append({"epoch": ep, "loss": loss_sum / steps,
+                     "cos10": c / conv_trials})
+        if ep % 20 == 0 or ep == 1 or ep == epochs:
+            print(f"  [{label} Ep {ep:03d}/{epochs}] "
+                  f"loss={loss_sum/steps:.4f} "
+                  f"cos@10dB(test)={c/conv_trials:.4f}", flush=True)
+
+    train_time = time.time() - t0
+    return model, conv, train_time
+
+
+@torch.no_grad()
+def final_eval(model, cache, U, device, channel="rayleigh",
+               trials=500, collect_at=None, seed=123):
+    """Held-out SNR sweep. If collect_at is set (snr list), also return
+    recovered embeddings + label indices for the linear probe."""
+    model.eval()
+    gen = torch.Generator().manual_seed(seed)
+    out = {}
+    collected = {}
+    for snr in EVAL_SNRS:
+        ct, mt = 0.0, 0.0
+        rec, idxs = [], []
+        for _ in range(trials):
+            b, idx = cache.sample_test(U, device, gen=gen)
+            bh = model(b, snr, channel)
+            ct += F.cosine_similarity(bh, b, dim=-1).mean().item()
+            mt += F.mse_loss(bh, b).item()
+            if collect_at and snr in collect_at:
+                rec.append(bh.cpu())
+                idxs.append(idx)
+        out[snr] = {"cos": ct / trials, "mse": mt / trials}
+        if collect_at and snr in collect_at:
+            collected[snr] = (torch.cat(rec, 0), torch.cat(idxs, 0))
+    return out, collected
+
+
+# ---------------------------------------------------------
+# Linear probe (AG News 4-class) on clean train embeddings
+# ---------------------------------------------------------
+def train_probe(cache, device, epochs=300, lr=1e-2):
+    X = cache.train.to(device)
+    y = cache.train_labels.to(device)
+    W = nn.Linear(X.shape[1], 4).to(device)
+    opt = torch.optim.Adam(W.parameters(), lr=lr)
+    for _ in range(epochs):
+        opt.zero_grad()
+        loss = F.cross_entropy(W(X), y)
+        loss.backward()
+        opt.step()
+    with torch.no_grad():
+        acc_clean = (W(cache.test.to(device)).argmax(-1).cpu()
+                     == cache.test_labels).float().mean().item()
+    print(f"[INFO] probe clean test accuracy = {acc_clean:.4f}", flush=True)
+    return W, acc_clean
+
+
+@torch.no_grad()
+def probe_accuracy(W, collected, cache, device):
+    accs = {}
+    for snr, (rec, idx) in collected.items():
+        pred = W(rec.to(device)).argmax(-1).cpu()
+        accs[snr] = (pred == cache.test_labels[idx]).float().mean().item()
+    return accs
+
+
+# ---------------------------------------------------------
+# ToDMA-style token-domain CS baseline (R2-3)
+#   - shared random Gaussian codebook over the BERT vocabulary
+#   - per-slot OMP detection (U iterations)
+#   - genie-aided token-source association (upper bound):
+#     a user's token is recovered iff it lies in the detected support
+#   - identical total channel budget: T * L = d_s = 3072 real uses
+#   - identical per-dimension sum power = 1 and noise var = 1/gamma
+# ---------------------------------------------------------
+@torch.no_grad()
+def todma_eval(extractor, cache, device, U=4, T=24, L=128,
+               n_frames=200, channel="rayleigh", seed=7,
+               collect_at=None):
+    tok = extractor.tokenizer
+    V = tok.vocab_size
+    g = torch.Generator().manual_seed(seed)
+    C = torch.randn(V, L, generator=g)
+    C = F.normalize(C, p=2, dim=1).to(device)          # unit-norm atoms
+    amp = math.sqrt(L / U)                              # per-user energy
+
+    # pre-tokenize test sentences (no special tokens), truncate to T
+    tok_ids = [tok(t, add_special_tokens=False)["input_ids"][:T]
+               for t in cache.test_texts]
+
+    results = {}
+    collected = {}
+    t_omp_total, n_omp = 0.0, 0
+    for snr in EVAL_SNRS:
+        sigma = math.sqrt(1.0 / (10 ** (snr / 10.0)))
+        cs_sum, n_sent = 0.0, 0
+        tok_err_sum, tok_cnt = 0, 0
+        rec_all, idx_all = [], []
+        rng = torch.Generator().manual_seed(seed + snr)
+        for fr in range(n_frames):
+            idx = torch.randint(0, len(cache.test), (U,), generator=rng)
+            seqs = [tok_ids[i] for i in idx.tolist()]
+            if channel == "rayleigh":
+                hr = torch.randn(U, generator=rng)
+                hi = torch.randn(U, generator=rng)
+                h = torch.sqrt(hr ** 2 + hi ** 2) / math.sqrt(2.0)
+            else:
+                h = torch.ones(U)
+            h = h.to(device)
+
+            det_ids = [[] for _ in range(U)]
+            t1 = time.time()
+            for t in range(T):
+                active = [(u, seqs[u][t]) for u in range(U)
+                          if t < len(seqs[u])]
+                if not active:
+                    break
+                y = torch.zeros(L, device=device)
+                for u, tid in active:
+                    y = y + h[u] * amp * C[tid]
+                y = y + sigma * torch.randn(L, device=device)
+                # OMP: U iterations
+                residual = y.clone()
+                support = []
+                for _ in range(min(U, len(active))):
+                    corr = torch.mv(C, residual).abs()
+                    if support:
+                        corr[torch.tensor(support, device=device)] = -1
+                    k = int(corr.argmax().item())
+                    support.append(k)
+                    A = C[support].T * amp                  # (L, |S|)
+                    coef, *_ = torch.linalg.lstsq(A, y.unsqueeze(1))
+                    residual = y - (A @ coef).squeeze(1)
+                sset = set(support)
+                for u, tid in active:
+                    tok_cnt += 1
+                    if tid in sset:
+                        det_ids[u].append(tid)              # genie assoc.
+                    else:
+                        tok_err_sum += 1                    # erasure
+            t_omp_total += time.time() - t1
+            n_omp += 1
+
+            texts = [tok.decode(d) if d else "[UNK]" for d in det_ids]
+            emb = extractor.encode(texts).cpu()
+            emb = F.normalize(emb - cache.mu, p=2, dim=-1)
+            ref = cache.test[idx]
+            cs_sum += F.cosine_similarity(emb, ref, dim=-1).sum().item()
+            n_sent += U
+            if collect_at and snr in collect_at:
+                rec_all.append(emb)
+                idx_all.append(idx)
+
+        results[snr] = {"cos": cs_sum / n_sent,
+                        "token_err": tok_err_sum / max(tok_cnt, 1)}
+        if collect_at and snr in collect_at:
+            collected[snr] = (torch.cat(rec_all, 0), torch.cat(idx_all, 0))
+        print(f"  [ToDMA T={T} L={L}] SNR={snr} "
+              f"cos={results[snr]['cos']:.4f} "
+              f"tokErr={results[snr]['token_err']:.4f}", flush=True)
+
+    results["omp_ms_per_frame"] = 1000.0 * t_omp_total / max(n_omp, 1)
+    return results, collected
+
+
+# ---------------------------------------------------------
+# Latency / parameter count (R1-3)
+# ---------------------------------------------------------
+@torch.no_grad()
+def measure_latency(model, cache, U, device, n=200):
+    b, _ = cache.sample_test(U, device)
+    for _ in range(20):
+        model(b, 10, "rayleigh")
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    t0 = time.time()
+    for _ in range(n):
+        model(b, 10, "rayleigh")
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    ms = 1000.0 * (time.time() - t0) / n
+    n_params = sum(p.numel() for p in model.parameters())
+    return ms, n_params
+
+
+@torch.no_grad()
+def measure_bert_latency(extractor, texts, n=50):
+    for _ in range(5):
+        extractor.encode(texts[:4])
+    if extractor.device == "cuda" or (hasattr(extractor.device, "type")
+                                      and extractor.device.type == "cuda"):
+        torch.cuda.synchronize()
+    t0 = time.time()
+    for i in range(n):
+        extractor.encode([texts[i % len(texts)]])
+    torch.cuda.synchronize()
+    return 1000.0 * (time.time() - t0) / n
+
+
+# ---------------------------------------------------------
+# Main
+# ---------------------------------------------------------
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--save-dir", default="fig_cl")
+    ap.add_argument("--epochs", type=int, default=200)
+    ap.add_argument("--steps", type=int, default=300)
+    ap.add_argument("--trials", type=int, default=500)
+    ap.add_argument("--todma-frames", type=int, default=200)
+    ap.add_argument("--skip-distil", action="store_true")
+    args = ap.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    os.makedirs(args.save_dir, exist_ok=True)
+    print(f"[Device: {device}]", flush=True)
+
+    train_items, test_items = load_agnews_labeled()
+    print(f"[INFO] split: {len(train_items)} train / "
+          f"{len(test_items)} test", flush=True)
+
+    bert = Extractor("bert-base-uncased", device)
+    d_bert = bert.embed_dim
+    cache = SplitCache(bert, train_items, test_items)
+
+    R = {"meta": {"epochs": args.epochs, "steps": args.steps,
+                  "trials": args.trials}}
+    conv_rows = []
+
+    # linear probe on clean train embeddings
+    probe, acc_clean = train_probe(cache, device)
+    R["probe_clean_acc"] = acc_clean
+
+    PROBE_SNRS = list(EVAL_SNRS)
+
+    # ---- (1) orthogonal baseline U=1, d=768 ----
+    # ---- (2) proposed U=1..6, K=4 ----
+    # ---- (3) K sweep U=4, K in {1,2,8} ----
+    # ---- (4) random frozen masks U=4, K=4 ----
+    # ---- (5) MAML full U=4, K=4 ----
+    configs = [
+        ("baseline_U1_K1", dict(U=1, K=1)),
+        ("prop_U1_K4", dict(U=1, K=4)),
+        ("prop_U2_K4", dict(U=2, K=4)),
+        ("prop_U3_K4", dict(U=3, K=4)),
+        ("prop_U4_K4", dict(U=4, K=4)),
+        ("prop_U5_K4", dict(U=5, K=4)),
+        ("prop_U6_K4", dict(U=6, K=4)),
+        ("ksweep_U4_K1", dict(U=4, K=1)),
+        ("ksweep_U4_K2", dict(U=4, K=2)),
+        ("ksweep_U4_K8", dict(U=4, K=8)),
+        ("randmask_U4_K4", dict(U=4, K=4, freeze_masks=True)),
+        ("maml_U4_K4", dict(U=4, K=4, mode="maml_full")),
+    ]
+
+    masks_store = {}
+    for name, kw in configs:
+        print(f"\n=== {name} ===", flush=True)
+        U, K = kw.pop("U"), kw.pop("K")
+        model, conv, ttime = train_config(
+            cache, U, d_bert, K, device,
+            epochs=args.epochs, steps=args.steps, label=name, **kw)
+        collect = PROBE_SNRS if name in (
+            "baseline_U1_K1", "prop_U4_K4", "randmask_U4_K4") else None
+        sweep, collected = final_eval(model, cache, U, device,
+                                      trials=args.trials,
+                                      collect_at=collect)
+        entry = {"U": U, "K": K, "train_s": ttime,
+                 "snr": {str(s): sweep[s] for s in EVAL_SNRS}}
+        if collect:
+            entry["probe_acc"] = {str(s): a for s, a in
+                                  probe_accuracy(probe, collected,
+                                                 cache, device).items()}
+        if name in ("prop_U2_K4", "prop_U3_K4", "prop_U4_K4"):
+            m = model.user_mask.weight.detach().cpu()
+            mn = F.normalize(m, p=2, dim=1)
+            masks_store[name] = (mn @ mn.T).numpy().tolist()
+        if name == "prop_U4_K4":
+            ms_gpu, n_params = measure_latency(model, cache, U, device)
+            cpu_model = BertSemComMux(U, d_bert, d_bert * K, 512)
+            cpu_model.load_state_dict(model.state_dict())
+            cpu_dev = torch.device("cpu")
+            b_cpu, _ = cache.sample_test(U, cpu_dev)
+            for _ in range(10):
+                cpu_model(b_cpu, 10, "rayleigh")
+            t0 = time.time()
+            for _ in range(50):
+                cpu_model(b_cpu, 10, "rayleigh")
+            ms_cpu = 1000.0 * (time.time() - t0) / 50
+            R["latency"] = {"proposed_gpu_ms": ms_gpu,
+                            "proposed_cpu_ms": ms_cpu,
+                            "params": n_params}
+            print(f"[LATENCY] proposed frame: {ms_gpu:.2f} ms (GPU) "
+                  f"{ms_cpu:.2f} ms (CPU), params={n_params/1e6:.2f}M",
+                  flush=True)
+        R[name] = entry
+        for c in conv:
+            conv_rows.append([name, c["epoch"], c["loss"], c["cos10"]])
+        with open(os.path.join(args.save_dir, "cl_results.json"), "w") as f:
+            json.dump(R, f, indent=1)
+
+    R["mask_corr"] = masks_store
+
+    # ---- (6) ToDMA-style baseline, two budget splits ----
+    print("\n=== ToDMA-style baseline ===", flush=True)
+    R["bert_tx_ms"] = measure_bert_latency(bert, cache.test_texts)
+    print(f"[LATENCY] BERT encode per sentence: {R['bert_tx_ms']:.1f} ms",
+          flush=True)
+    for (T, L) in [(24, 128), (16, 192)]:
+        res, coll = todma_eval(bert, cache, device, U=4, T=T, L=L,
+                               n_frames=args.todma_frames,
+                               collect_at=PROBE_SNRS if T == 24 else None)
+        key = f"todma_T{T}_L{L}"
+        R[key] = {str(s): res[s] for s in EVAL_SNRS}
+        R[key]["omp_ms_per_frame"] = res["omp_ms_per_frame"]
+        if coll:
+            R[key]["probe_acc"] = {str(s): a for s, a in
+                                   probe_accuracy(probe, coll,
+                                                  cache, device).items()}
+    with open(os.path.join(args.save_dir, "cl_results.json"), "w") as f:
+        json.dump(R, f, indent=1)
+
+    # ---- (7) DistilBERT generalization check ----
+    if not args.skip_distil:
+        print("\n=== DistilBERT check (U=4, K=4) ===", flush=True)
+        distil = Extractor("distilbert-base-uncased", device)
+        dcache = SplitCache(distil, train_items, test_items)
+        model, conv, _ = train_config(dcache, 4, distil.embed_dim, 4,
+                                      device, epochs=args.epochs,
+                                      steps=args.steps, label="distil")
+        sweep, _ = final_eval(model, dcache, 4, device, trials=args.trials)
+        R["distil_U4_K4"] = {"snr": {str(s): sweep[s] for s in EVAL_SNRS}}
+        for c in conv:
+            conv_rows.append(["distil_U4_K4", c["epoch"], c["loss"],
+                              c["cos10"]])
+
+    with open(os.path.join(args.save_dir, "cl_results.json"), "w") as f:
+        json.dump(R, f, indent=1)
+    with open(os.path.join(args.save_dir, "cl_convergence.csv"), "w",
+              newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["config", "epoch", "loss", "cos10_test"])
+        w.writerows(conv_rows)
+    print("\nAll CL experiments complete.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

cl_maml_all.py

@@ -0,0 +1,188 @@
+# =========================================================
+# cl_maml_all.py — promote SNR-aware MAML to the default
+# training procedure for all reported configurations.
+#
+# Adds MAML-trained counterparts of the load sweep, the
+# conventional orthogonal scheme (fairness: both sides at
+# their best), and the random-mask variant. The K sweep and
+# DistilBERT stay joint-trained (sensitivity studies).
+#
+# Held-out evaluation identical to cl_experiments.py.
+# Output: fig_cl/cl_results_maml.json (+ convergence CSV)
+# =========================================================
+
+import argparse, os, json, csv, time, random
+import torch
+import torch.nn.functional as F
+
+from bert_semcom import (
+    BertSemComMux, semantic_loss, split_params,
+    gather_inner_params, apply_inner_update
+)
+from cl_experiments import (
+    load_agnews_labeled, Extractor, SplitCache,
+    final_eval, train_probe, probe_accuracy, set_seed,
+    EVAL_SNRS, TRAIN_SNRS, measure_latency
+)
+
+
+def train_maml(cache, U, d_bert, K, device, freeze_masks=False,
+               epochs=200, steps=300, lr=1e-3, inner_lr=5e-4,
+               meta_batch=4, lam=0.5, channel="rayleigh",
+               conv_trials=50, label="", seed=42):
+    set_seed(seed)
+    model = BertSemComMux(U, d_bert, d_bert * K, 512).to(device)
+    if freeze_masks:
+        model.user_mask.weight.requires_grad_(False)
+        inner_keys = ["tx_proj", "user_query", "rx_proj"]
+    else:
+        inner_keys = ["tx_proj", "user_mask", "user_query", "rx_proj"]
+    opt = torch.optim.Adam(
+        [p for p in model.parameters() if p.requires_grad], lr=lr)
+    conv = []
+    t0 = time.time()
+    for ep in range(1, epochs + 1):
+        model.train()
+        loss_sum = 0.0
+        for _ in range(steps):
+            snr_tasks = [float(x) for x in
+                         random.sample(TRAIN_SNRS, meta_batch)]
+            base_params = split_params(model)
+            meta_loss = torch.tensor(0.0, device=device)
+            for snr in snr_tasks:
+                fp = {k: {n: p for n, p in v.items()}
+                      for k, v in base_params.items()}
+                b_s, _ = cache.sample_train(U, device)
+                bh = model(b_s, snr, channel, params=fp)
+                ls, _, _ = semantic_loss(b_s, bh, lam)
+                fl, mi = gather_inner_params(fp, inner_keys)
+                grads = torch.autograd.grad(ls, fl)
+                fp = apply_inner_update(fp, inner_keys, mi, grads,
+                                        inner_lr, "first")
+                b_q, _ = cache.sample_train(U, device)
+                bh_q = model(b_q, snr, channel, params=fp)
+                ql, _, _ = semantic_loss(b_q, bh_q, lam)
+                meta_loss = meta_loss + ql
+            meta_loss = meta_loss / float(meta_batch)
+            opt.zero_grad(set_to_none=True)
+            meta_loss.backward()
+            opt.step()
+            loss_sum += meta_loss.item()
+        model.eval()
+        with torch.no_grad():
+            c = 0.0
+            for _ in range(conv_trials):
+                b, _ = cache.sample_test(U, device)
+                bh = model(b, 10, channel)
+                c += F.cosine_similarity(bh, b, dim=-1).mean().item()
+        conv.append({"epoch": ep, "loss": loss_sum / steps,
+                     "cos10": c / conv_trials})
+        if ep % 20 == 0 or ep == 1 or ep == epochs:
+            print(f"  [{label} Ep {ep:03d}/{epochs}] "
+                  f"loss={loss_sum/steps:.4f} "
+                  f"cos@10dB(test)={c/conv_trials:.4f}", flush=True)
+    return model, conv, time.time() - t0
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--save-dir", default="fig_cl")
+    ap.add_argument("--epochs", type=int, default=200)
+    ap.add_argument("--steps", type=int, default=300)
+    ap.add_argument("--trials", type=int, default=500)
+    args = ap.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    os.makedirs(args.save_dir, exist_ok=True)
+    print(f"[Device: {device}]", flush=True)
+    train_items, test_items = load_agnews_labeled()
+    bert = Extractor("bert-base-uncased", device)
+    d_bert = bert.embed_dim
+    cache = SplitCache(bert, train_items, test_items)
+    del bert
+    torch.cuda.empty_cache()
+
+    probe, acc_clean = train_probe(cache, device)
+    R = {"probe_clean_acc": acc_clean}
+    PROBE_SNRS = list(EVAL_SNRS)
+    conv_rows = []
+
+    configs = [
+        ("mamlB_U1_K1", dict(U=1, K=1)),
+        ("mamlP_U1_K4", dict(U=1, K=4)),
+        ("mamlP_U2_K4", dict(U=2, K=4)),
+        ("mamlP_U3_K4", dict(U=3, K=4)),
+        ("mamlP_U5_K4", dict(U=5, K=4)),
+        ("mamlP_U6_K4", dict(U=6, K=4)),
+        ("mamlR_U4_K4", dict(U=4, K=4, freeze_masks=True)),
+    ]
+    masks_store = {}
+    for name, kw in configs:
+        print(f"\n=== {name} ===", flush=True)
+        U, K = kw.pop("U"), kw.pop("K")
+        model, conv, ttime = train_maml(
+            cache, U, d_bert, K, device,
+            epochs=args.epochs, steps=args.steps, label=name, **kw)
+        collect = PROBE_SNRS if name in (
+            "mamlB_U1_K1", "mamlR_U4_K4") else None
+        sweep, collected = final_eval(model, cache, U, device,
+                                      trials=args.trials,
+                                      collect_at=collect)
+        entry = {"U": U, "K": K, "train_s": ttime,
+                 "snr": {str(s): sweep[s] for s in EVAL_SNRS}}
+        if collect:
+            entry["probe_acc"] = {str(s): a for s, a in
+                                  probe_accuracy(probe, collected,
+                                                 cache, device).items()}
+        if name in ("mamlP_U2_K4", "mamlP_U3_K4"):
+            m = model.user_mask.weight.detach().cpu()
+            mn = F.normalize(m, p=2, dim=1)
+            masks_store[name] = (mn @ mn.T).numpy().tolist()
+        R[name] = entry
+        for c in conv:
+            conv_rows.append([name, c["epoch"], c["loss"], c["cos10"]])
+        R["mask_corr"] = masks_store
+        with open(os.path.join(args.save_dir,
+                               "cl_results_maml.json"), "w") as f:
+            json.dump(R, f, indent=1)
+
+    # probe accuracies for the already-trained maml_U4_K4 are collected
+    # by re-training? No — retrain U=4 MAML for probe collection and
+    # mask correlation so every reported number comes from one protocol.
+    print("\n=== mamlP_U4_K4 (retrain for probe/masks) ===", flush=True)
+    model, conv, ttime = train_maml(cache, 4, d_bert, 4, device,
+                                    epochs=args.epochs, steps=args.steps,
+                                    label="mamlP_U4_K4")
+    sweep, collected = final_eval(model, cache, 4, device,
+                                  trials=args.trials,
+                                  collect_at=PROBE_SNRS)
+    entry = {"U": 4, "K": 4, "train_s": ttime,
+             "snr": {str(s): sweep[s] for s in EVAL_SNRS}}
+    entry["probe_acc"] = {str(s): a for s, a in
+                          probe_accuracy(probe, collected,
+                                         cache, device).items()}
+    m = model.user_mask.weight.detach().cpu()
+    mn = F.normalize(m, p=2, dim=1)
+    masks_store["mamlP_U4_K4"] = (mn @ mn.T).numpy().tolist()
+    ms_gpu, n_params = measure_latency(model, cache, 4, device)
+    entry["lat_gpu_ms"] = ms_gpu
+    entry["params"] = n_params
+    R["mamlP_U4_K4"] = entry
+    R["mask_corr"] = masks_store
+    for c in conv:
+        conv_rows.append(["mamlP_U4_K4", c["epoch"], c["loss"],
+                          c["cos10"]])
+
+    with open(os.path.join(args.save_dir, "cl_results_maml.json"),
+              "w") as f:
+        json.dump(R, f, indent=1)
+    with open(os.path.join(args.save_dir, "cl_convergence_maml.csv"),
+              "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["config", "epoch", "loss", "cos10_test"])
+        w.writerows(conv_rows)
+    print("\nAll MAML-default experiments complete.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

cl_maml_extra.py

@@ -0,0 +1,77 @@
+# cl_maml_extra.py — MAML-trained K sweep (K=1,2,8) and DistilBERT
+# replication, completing the unified MAML protocol.
+import argparse, os, json, csv
+import torch
+import torch.nn.functional as F
+
+from cl_experiments import (
+    load_agnews_labeled, Extractor, SplitCache, final_eval, set_seed,
+    EVAL_SNRS
+)
+from cl_maml_all import train_maml
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--save-dir", default="fig_cl")
+    ap.add_argument("--epochs", type=int, default=200)
+    ap.add_argument("--steps", type=int, default=300)
+    ap.add_argument("--trials", type=int, default=500)
+    args = ap.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    os.makedirs(args.save_dir, exist_ok=True)
+    print(f"[Device: {device}]", flush=True)
+    train_items, test_items = load_agnews_labeled()
+    bert = Extractor("bert-base-uncased", device)
+    d_bert = bert.embed_dim
+    cache = SplitCache(bert, train_items, test_items)
+    del bert
+    torch.cuda.empty_cache()
+
+    R = {}
+    conv_rows = []
+    for name, K in [("mamlK_U4_K1", 1), ("mamlK_U4_K2", 2),
+                    ("mamlK_U4_K8", 8)]:
+        print(f"\n=== {name} ===", flush=True)
+        model, conv, ttime = train_maml(cache, 4, d_bert, K, device,
+                                        epochs=args.epochs,
+                                        steps=args.steps, label=name)
+        sweep, _ = final_eval(model, cache, 4, device, trials=args.trials)
+        R[name] = {"U": 4, "K": K, "train_s": ttime,
+                   "snr": {str(s): sweep[s] for s in EVAL_SNRS}}
+        for c in conv:
+            conv_rows.append([name, c["epoch"], c["loss"], c["cos10"]])
+        with open(os.path.join(args.save_dir,
+                               "cl_results_maml2.json"), "w") as f:
+            json.dump(R, f, indent=1)
+
+    print("\n=== mamlD_U4_K4 (DistilBERT) ===", flush=True)
+    distil = Extractor("distilbert-base-uncased", device)
+    dcache = SplitCache(distil, train_items, test_items)
+    d_d = distil.embed_dim
+    del distil
+    torch.cuda.empty_cache()
+    model, conv, ttime = train_maml(dcache, 4, d_d, 4, device,
+                                    epochs=args.epochs,
+                                    steps=args.steps, label="mamlD")
+    sweep, _ = final_eval(model, dcache, 4, device, trials=args.trials)
+    R["mamlD_U4_K4"] = {"U": 4, "K": 4, "train_s": ttime,
+                        "snr": {str(s): sweep[s] for s in EVAL_SNRS}}
+    for c in conv:
+        conv_rows.append(["mamlD_U4_K4", c["epoch"], c["loss"],
+                          c["cos10"]])
+
+    with open(os.path.join(args.save_dir, "cl_results_maml2.json"),
+              "w") as f:
+        json.dump(R, f, indent=1)
+    with open(os.path.join(args.save_dir, "cl_convergence_maml2.csv"),
+              "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["config", "epoch", "loss", "cos10_test"])
+        w.writerows(conv_rows)
+    print("\nExtra MAML experiments complete.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

cl_todma_load.py

@@ -0,0 +1,42 @@
+# cl_todma_load.py — ToDMA load sweep (evaluation only, no training).
+#
+# Evaluates the ToDMA token-domain scheme (T=24, L=128, genie-aided
+# association) for U in {1,2,3,5,6} on the held-out test set, matching
+# the U=4 run stored in cl_results.json, so that Fig. 3 can show the
+# ToDMA aggregate fidelity across load.
+import argparse, os, json
+import torch
+
+from cl_experiments import (
+    load_agnews_labeled, Extractor, SplitCache, todma_eval, EVAL_SNRS
+)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--save-dir", default="fig_cl")
+    ap.add_argument("--frames", type=int, default=200)
+    args = ap.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    os.makedirs(args.save_dir, exist_ok=True)
+    print(f"[Device: {device}]", flush=True)
+    train_items, test_items = load_agnews_labeled()
+    bert = Extractor("bert-base-uncased", device)
+    cache = SplitCache(bert, train_items, test_items)
+
+    R = {}
+    for U in [1, 2, 3, 5, 6]:
+        print(f"\n=== ToDMA U={U} (T=24, L=128) ===", flush=True)
+        res, _ = todma_eval(bert, cache, device, U=U, T=24, L=128,
+                            n_frames=args.frames)
+        key = f"todma_U{U}_T24_L128"
+        R[key] = {str(s): res[s] for s in EVAL_SNRS}
+        with open(os.path.join(args.save_dir,
+                               "cl_results_todma_u.json"), "w") as f:
+            json.dump(R, f, indent=1)
+    print("\nToDMA load sweep complete.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

fig_cl/cl_convergence_maml2.csv

@@ -0,0 +1,801 @@
+config,epoch,loss,cos10_test
+mamlK_U4_K1,1,0.3395769918461641,0.5970553267002106
+mamlK_U4_K1,2,0.21661824176708858,0.663407347202301
+mamlK_U4_K1,3,0.19135330920418103,0.6789607079327107
+mamlK_U4_K1,4,0.1688267623881499,0.7170000022649765
+mamlK_U4_K1,5,0.1635581833620866,0.7278023535013198
+mamlK_U4_K1,6,0.15552770368754865,0.7321064358949662
+mamlK_U4_K1,7,0.14887250925103823,0.6956483569741249
+mamlK_U4_K1,8,0.14149590991437436,0.7095583683252334
+mamlK_U4_K1,9,0.13910339325666427,0.7492142748832703
+mamlK_U4_K1,10,0.1388827312240998,0.7676383137702942
+mamlK_U4_K1,11,0.13788577896853288,0.7622184693813324
+mamlK_U4_K1,12,0.13349383287131786,0.7443693269789219
+mamlK_U4_K1,13,0.1310288365681966,0.7836207801103592
+mamlK_U4_K1,14,0.12814960218966007,0.7553350067138672
+mamlK_U4_K1,15,0.12337705274422964,0.7800710442662239
+mamlK_U4_K1,16,0.1274088058869044,0.7629242312908172
+mamlK_U4_K1,17,0.12006955457230409,0.7605716925859451
+mamlK_U4_K1,18,0.12000012544294199,0.7955571794509888
+mamlK_U4_K1,19,0.12327828153967857,0.7970682632923126
+mamlK_U4_K1,20,0.1210594833890597,0.7731149177253246
+mamlK_U4_K1,21,0.12155996484061082,0.756924899816513
+mamlK_U4_K1,22,0.12020212426781654,0.7779450225830078
+mamlK_U4_K1,23,0.11663664345939954,0.8017365336418152
+mamlK_U4_K1,24,0.11489173091948032,0.7824297499656677
+mamlK_U4_K1,25,0.11486184932291507,0.794362416267395
+mamlK_U4_K1,26,0.1178030712902546,0.8119315755367279
+mamlK_U4_K1,27,0.11580229875942072,0.797225725799799
+mamlK_U4_K1,28,0.10796747016410033,0.8044077944755554
+mamlK_U4_K1,29,0.11533101240793864,0.7961653138697148
+mamlK_U4_K1,30,0.11183028814693292,0.7978107976913452
+mamlK_U4_K1,31,0.11258448326339324,0.7875527828931809
+mamlK_U4_K1,32,0.10674354664981366,0.807917720079422
+mamlK_U4_K1,33,0.10819576853265366,0.807927662730217
+mamlK_U4_K1,34,0.11045404922217131,0.7892514216899872
+mamlK_U4_K1,35,0.11241467177867889,0.7921020865440369
+mamlK_U4_K1,36,0.10932925939559937,0.7903496680408716
+mamlK_U4_K1,37,0.10381663547207912,0.7668627226352691
+mamlK_U4_K1,38,0.1071135958780845,0.7730690225958824
+mamlK_U4_K1,39,0.10774661825348933,0.8059287357330323
+mamlK_U4_K1,40,0.10857624676078557,0.83376913189888
+mamlK_U4_K1,41,0.10950486143430074,0.7742104935646057
+mamlK_U4_K1,42,0.10545750390738248,0.810519278049469
+mamlK_U4_K1,43,0.1052815372745196,0.8057966285943985
+mamlK_U4_K1,44,0.10903738483786583,0.8267235445976258
+mamlK_U4_K1,45,0.10730494531492392,0.7892061904072761
+mamlK_U4_K1,46,0.10393029546986024,0.7977983325719833
+mamlK_U4_K1,47,0.10761934834221999,0.823192930817604
+mamlK_U4_K1,48,0.10633286371827126,0.7915622889995575
+mamlK_U4_K1,49,0.10852537066986163,0.8068294554948807
+mamlK_U4_K1,50,0.10527669581274192,0.8049935579299927
+mamlK_U4_K1,51,0.10183198112994432,0.8283192348480225
+mamlK_U4_K1,52,0.106179664482673,0.8038868260383606
+mamlK_U4_K1,53,0.11007975281526645,0.7701723985373974
+mamlK_U4_K1,54,0.10454111352562905,0.8153893089294434
+mamlK_U4_K1,55,0.10165571812540293,0.8099441200494766
+mamlK_U4_K1,56,0.10291118039439122,0.8030243682861328
+mamlK_U4_K1,57,0.10704815806200108,0.8102884113788604
+mamlK_U4_K1,58,0.10171569392085075,0.7968954205513
+mamlK_U4_K1,59,0.10292136568576098,0.7862212884426117
+mamlK_U4_K1,60,0.10662949436654647,0.7925063616037369
+mamlK_U4_K1,61,0.10734868448227644,0.7984207433462143
+mamlK_U4_K1,62,0.10304167098055284,0.8217874234914779
+mamlK_U4_K1,63,0.10521399758756161,0.8244336760044098
+mamlK_U4_K1,64,0.10094862267374992,0.8220500147342682
+mamlK_U4_K1,65,0.1031661332398653,0.8266524529457092
+mamlK_U4_K1,66,0.10353197903682788,0.8127677541971207
+mamlK_U4_K1,67,0.10081918518990278,0.8079964489489794
+mamlK_U4_K1,68,0.10363816128422816,0.8064543125033379
+mamlK_U4_K1,69,0.10104108888655901,0.8417371332645416
+mamlK_U4_K1,70,0.10481970300277074,0.8107023566961289
+mamlK_U4_K1,71,0.10354454388221104,0.806251373887062
+mamlK_U4_K1,72,0.10152822078516086,0.8281261730194092
+mamlK_U4_K1,73,0.10400646410882473,0.7800723713636398
+mamlK_U4_K1,74,0.10384751554578543,0.8151430320739746
+mamlK_U4_K1,75,0.10166229440520207,0.8314117884635925
+mamlK_U4_K1,76,0.10101484221716722,0.8196522581577301
+mamlK_U4_K1,77,0.10100059510519108,0.8323004174232483
+mamlK_U4_K1,78,0.10188165108362833,0.8349729001522064
+mamlK_U4_K1,79,0.10232309172550837,0.8102788186073303
+mamlK_U4_K1,80,0.10161228114118179,0.8061175668239593
+mamlK_U4_K1,81,0.10679626700778802,0.7957542228698731
+mamlK_U4_K1,82,0.09985721929619709,0.8155868190526963
+mamlK_U4_K1,83,0.10131263419985771,0.8271038043498993
+mamlK_U4_K1,84,0.10077717038492362,0.7987181535363197
+mamlK_U4_K1,85,0.10207743760198355,0.802321862578392
+mamlK_U4_K1,86,0.09966132553915183,0.7935655745863914
+mamlK_U4_K1,87,0.09967112574726343,0.8238284683227539
+mamlK_U4_K1,88,0.10276158565034468,0.8025999909639359
+mamlK_U4_K1,89,0.10255109138786793,0.8074301856756211
+mamlK_U4_K1,90,0.10022635678450266,0.7628305122256279
+mamlK_U4_K1,91,0.10245673291385174,0.8166504371166229
+mamlK_U4_K1,92,0.09916387628763915,0.8074478885531425
+mamlK_U4_K1,93,0.10233928474287192,0.841915146112442
+mamlK_U4_K1,94,0.10203774685660998,0.8012312103807926
+mamlK_U4_K1,95,0.1000142144287626,0.8060261923074722
+mamlK_U4_K1,96,0.10193064155677954,0.8143401873111725
+mamlK_U4_K1,97,0.09882214875270923,0.8182688345015049
+mamlK_U4_K1,98,0.10450279959787925,0.8467787909507751
+mamlK_U4_K1,99,0.10176315414408843,0.7878685969673097
+mamlK_U4_K1,100,0.1001277572909991,0.8041835770010948
+mamlK_U4_K1,101,0.10305923895289501,0.8290009769797325
+mamlK_U4_K1,102,0.10232010785490274,0.8266846370697022
+mamlK_U4_K1,103,0.10178076980014641,0.8354748725891114
+mamlK_U4_K1,104,0.09648833476006985,0.8330800247192383
+mamlK_U4_K1,105,0.10118337649852037,0.8440955173969269
+mamlK_U4_K1,106,0.10032680181165536,0.8250223326683045
+mamlK_U4_K1,107,0.09837850441535313,0.8044747364521027
+mamlK_U4_K1,108,0.10179255776107311,0.8232489228248596
+mamlK_U4_K1,109,0.10068597142895062,0.821098415851593
+mamlK_U4_K1,110,0.10075642358511687,0.8095153947174549
+mamlK_U4_K1,111,0.1003301202878356,0.7819948774576188
+mamlK_U4_K1,112,0.09819000442822774,0.7827690821886063
+mamlK_U4_K1,113,0.0978364572301507,0.8342666244506836
+mamlK_U4_K1,114,0.10085415149728458,0.8147234088182449
+mamlK_U4_K1,115,0.09945026468485593,0.8218076515197754
+mamlK_U4_K1,116,0.09839986380189657,0.8327551233768463
+mamlK_U4_K1,117,0.10070577573031186,0.8058769750595093
+mamlK_U4_K1,118,0.09746629691372315,0.8393159770965576
+mamlK_U4_K1,119,0.10106155103693405,0.8233879512548447
+mamlK_U4_K1,120,0.09595092674096425,0.8033852116763591
+mamlK_U4_K1,121,0.09811688131342332,0.8218545391410589
+mamlK_U4_K1,122,0.09794915122290453,0.8211795264482498
+mamlK_U4_K1,123,0.09805149165292582,0.8193078821897507
+mamlK_U4_K1,124,0.10025263633579015,0.8406993782520295
+mamlK_U4_K1,125,0.09808727153887352,0.8137885761260987
+mamlK_U4_K1,126,0.10215222335110108,0.8289594221115112
+mamlK_U4_K1,127,0.099190032693247,0.8155477011203766
+mamlK_U4_K1,128,0.09742029951264461,0.8220733726024627
+mamlK_U4_K1,129,0.09838224243372679,0.8051702699810267
+mamlK_U4_K1,130,0.10047449295719464,0.8209642623364926
+mamlK_U4_K1,131,0.0995165882135431,0.8328473436832428
+mamlK_U4_K1,132,0.09756886714448532,0.8399988865852356
+mamlK_U4_K1,133,0.09982176166027784,0.8373800277709961
+mamlK_U4_K1,134,0.09614672601222991,0.7943533003330231
+mamlK_U4_K1,135,0.09809338885049025,0.830563662648201
+mamlK_U4_K1,136,0.09748522025843462,0.8175740486383438
+mamlK_U4_K1,137,0.10037818850328525,0.8242804265022278
+mamlK_U4_K1,138,0.09970037418107192,0.8384668493270874
+mamlK_U4_K1,139,0.09720127459615469,0.8469519829750061
+mamlK_U4_K1,140,0.09952644258737564,0.8203377610445023
+mamlK_U4_K1,141,0.09824217007805904,0.8339519834518433
+mamlK_U4_K1,142,0.0983365482588609,0.8353655660152435
+mamlK_U4_K1,143,0.09846711347500484,0.8336063784360885
+mamlK_U4_K1,144,0.09600669844696919,0.838597549200058
+mamlK_U4_K1,145,0.09839047902574141,0.8190236341953278
+mamlK_U4_K1,146,0.09458484131842852,0.7950071096420288
+mamlK_U4_K1,147,0.10206967469304801,0.8337981808185577
+mamlK_U4_K1,148,0.09619337748736143,0.8229763522744179
+mamlK_U4_K1,149,0.09837168955554565,0.8226958364248276
+mamlK_U4_K1,150,0.09784457499782244,0.831935510635376
+mamlK_U4_K1,151,0.09839328055580457,0.8018084388971328
+mamlK_U4_K1,152,0.10174448204537233,0.8154962623119354
+mamlK_U4_K1,153,0.09933581923445066,0.8247149229049683
+mamlK_U4_K1,154,0.09851899307221174,0.8396154713630676
+mamlK_U4_K1,155,0.0967815853158633,0.8192743968963623
+mamlK_U4_K1,156,0.0967003645375371,0.8307345020771026
+mamlK_U4_K1,157,0.09744728475809097,0.8354449117183685
+mamlK_U4_K1,158,0.09778129361569882,0.8469332373142242
+mamlK_U4_K1,159,0.0973689887051781,0.8357069301605224
+mamlK_U4_K1,160,0.09487996938327949,0.8366256988048554
+mamlK_U4_K1,161,0.09986218032737573,0.8537843728065491
+mamlK_U4_K1,162,0.09857570384939511,0.8117210727185011
+mamlK_U4_K1,163,0.09914655891557535,0.8150099718570709
+mamlK_U4_K1,164,0.09809189323335886,0.8190731909871102
+mamlK_U4_K1,165,0.09726417265832424,0.8113209700584412
+mamlK_U4_K1,166,0.09697653084993363,0.7949187976121902
+mamlK_U4_K1,167,0.0962723487491409,0.8570070743560791
+mamlK_U4_K1,168,0.09573295542349418,0.8191429078578949
+mamlK_U4_K1,169,0.10149526163935661,0.8467233288288116
+mamlK_U4_K1,170,0.10138127674659093,0.805179414153099
+mamlK_U4_K1,171,0.09879167282332976,0.8121675479412079
+mamlK_U4_K1,172,0.09812746625393629,0.8377763235569
+mamlK_U4_K1,173,0.09515141988794008,0.7970901311933994
+mamlK_U4_K1,174,0.09954407181590795,0.8092442405223846
+mamlK_U4_K1,175,0.099028791214029,0.8327612978219986
+mamlK_U4_K1,176,0.0947954143707951,0.8233170545101166
+mamlK_U4_K1,177,0.10073009827484687,0.8353170520067215
+mamlK_U4_K1,178,0.09687755049516757,0.8225724085792899
+mamlK_U4_K1,179,0.09585505502919356,0.8360891532897949
+mamlK_U4_K1,180,0.095084415388604,0.8301138612627983
+mamlK_U4_K1,181,0.09646117344498634,0.8068984220921993
+mamlK_U4_K1,182,0.09664699154595534,0.8370879560708999
+mamlK_U4_K1,183,0.09913663035879533,0.8427578961849213
+mamlK_U4_K1,184,0.09319478750228882,0.8245357871055603
+mamlK_U4_K1,185,0.09237765906999508,0.8484940003603697
+mamlK_U4_K1,186,0.09722080772121747,0.8101367428898811
+mamlK_U4_K1,187,0.09665202200412751,0.8398332393169403
+mamlK_U4_K1,188,0.09336812485009433,0.8260139811038971
+mamlK_U4_K1,189,0.09813577774912119,0.7999353009462357
+mamlK_U4_K1,190,0.09862468458712101,0.8128549668937921
+mamlK_U4_K1,191,0.0958941849321127,0.8338201177120209
+mamlK_U4_K1,192,0.0979670520250996,0.8215850901603698
+mamlK_U4_K1,193,0.09594314058621724,0.844558732509613
+mamlK_U4_K1,194,0.09298188497622807,0.793527118563652
+mamlK_U4_K1,195,0.09657523507873217,0.8037195234373212
+mamlK_U4_K1,196,0.09581249800821146,0.8372018289193511
+mamlK_U4_K1,197,0.09729957985381285,0.8372089326381683
+mamlK_U4_K1,198,0.09797621207932632,0.8609340286254883
+mamlK_U4_K1,199,0.09215858279416958,0.8411007606983185
+mamlK_U4_K1,200,0.10175504104544719,0.8155054910480977
+mamlK_U4_K2,1,0.33009643415609996,0.6404661571979523
+mamlK_U4_K2,2,0.19751283938686054,0.6994542908668518
+mamlK_U4_K2,3,0.17039189050594966,0.7177034470438958
+mamlK_U4_K2,4,0.14683493509888648,0.7549881333112717
+mamlK_U4_K2,5,0.14214098391433558,0.7775750946998596
+mamlK_U4_K2,6,0.13506576031446457,0.7752245557308197
+mamlK_U4_K2,7,0.12746123112738134,0.7501543098688126
+mamlK_U4_K2,8,0.11961887220541637,0.7510023427009582
+mamlK_U4_K2,9,0.11707525449494521,0.7949222242832183
+mamlK_U4_K2,10,0.1160093462963899,0.8069861221313477
+mamlK_U4_K2,11,0.11613710142672062,0.8104732394218445
+mamlK_U4_K2,12,0.11103422440588474,0.7845612713694572
+mamlK_U4_K2,13,0.10783838329215845,0.829844833612442
+mamlK_U4_K2,14,0.1055389762793978,0.8013944083452225
+mamlK_U4_K2,15,0.10058609920243422,0.825480352640152
+mamlK_U4_K2,16,0.10422575173278649,0.8074200689792633
+mamlK_U4_K2,17,0.0977033347884814,0.8080903881788254
+mamlK_U4_K2,18,0.09779747154563666,0.8424500906467438
+mamlK_U4_K2,19,0.10029875294615825,0.8373576498031616
+mamlK_U4_K2,20,0.09697070773690938,0.822427898645401
+mamlK_U4_K2,21,0.09771630429973205,0.8044733768701553
+mamlK_U4_K2,22,0.09742746957888206,0.8173106171935797
+mamlK_U4_K2,23,0.0940728797763586,0.8494027149677277
+mamlK_U4_K2,24,0.09212705266972383,0.8311388707160949
+mamlK_U4_K2,25,0.09275115575641393,0.8395859718322753
+mamlK_U4_K2,26,0.09503940892716249,0.8576833415031433
+mamlK_U4_K2,27,0.09258263846238454,0.8396793757379055
+mamlK_U4_K2,28,0.08518289295335611,0.8477391874790192
+mamlK_U4_K2,29,0.0926529020195206,0.8371598333120346
+mamlK_U4_K2,30,0.08894754163920879,0.838513525724411
+mamlK_U4_K2,31,0.09006083675970634,0.8333994972705842
+mamlK_U4_K2,32,0.08352234294017157,0.8553407979011536
+mamlK_U4_K2,33,0.08576047949492932,0.8528991091251373
+mamlK_U4_K2,34,0.08683417117844025,0.8335630869865418
+mamlK_U4_K2,35,0.08950441027681033,0.8431726503372192
+mamlK_U4_K2,36,0.08654742788523435,0.8442901051044465
+mamlK_U4_K2,37,0.08113688422987858,0.8236390700936318
+mamlK_U4_K2,38,0.08492758976916472,0.8210196077823639
+mamlK_U4_K2,39,0.08577215957144896,0.8526832580566406
+mamlK_U4_K2,40,0.08500203839192788,0.8752001440525055
+mamlK_U4_K2,41,0.0875444091608127,0.832539399266243
+mamlK_U4_K2,42,0.08181945122778415,0.8507491916418075
+mamlK_U4_K2,43,0.0819054234897097,0.855202659368515
+mamlK_U4_K2,44,0.08617788020521402,0.8713641655445099
+mamlK_U4_K2,45,0.08566913985957703,0.8247881694883108
+mamlK_U4_K2,46,0.08179564539343119,0.845501013994217
+mamlK_U4_K2,47,0.08488825548440218,0.8631465661525727
+mamlK_U4_K2,48,0.08409984057148298,0.8472438031435012
+mamlK_U4_K2,49,0.08584492423882087,0.8509540104866028
+mamlK_U4_K2,50,0.08346907168626785,0.8511415147781372
+mamlK_U4_K2,51,0.07990209377060334,0.8689575326442719
+mamlK_U4_K2,52,0.08410337423284849,0.8508306980133057
+mamlK_U4_K2,53,0.0876126375173529,0.8162707450985909
+mamlK_U4_K2,54,0.08224932204931974,0.8585407197475433
+mamlK_U4_K2,55,0.07941148596505324,0.8515629267692566
+mamlK_U4_K2,56,0.08050316243122022,0.8528003656864166
+mamlK_U4_K2,57,0.08418187294155359,0.8606536877155304
+mamlK_U4_K2,58,0.07984441542377074,0.8503201460838318
+mamlK_U4_K2,59,0.08024106806765,0.8378407073020935
+mamlK_U4_K2,60,0.08427959077060222,0.8442935156822204
+mamlK_U4_K2,61,0.08412512136002381,0.8403443485498429
+mamlK_U4_K2,62,0.08018926820407311,0.8648817265033721
+mamlK_U4_K2,63,0.0827678702150782,0.8695954430103302
+mamlK_U4_K2,64,0.07892433275779089,0.8678577411174774
+mamlK_U4_K2,65,0.0809398095185558,0.875778557062149
+mamlK_U4_K2,66,0.08101528149098158,0.8603648030757904
+mamlK_U4_K2,67,0.07788739221791427,0.8478634390234947
+mamlK_U4_K2,68,0.08084647183616957,0.8469989037513733
+mamlK_U4_K2,69,0.07827158911774555,0.8807501482963562
+mamlK_U4_K2,70,0.08120915131022532,0.8573072373867034
+mamlK_U4_K2,71,0.08105391882359982,0.8508509695529938
+mamlK_U4_K2,72,0.07951286915689706,0.8748018336296082
+mamlK_U4_K2,73,0.07970122794310251,0.8358339044451714
+mamlK_U4_K2,74,0.0810572030643622,0.8612137591838837
+mamlK_U4_K2,75,0.07919702704995871,0.8776061081886292
+mamlK_U4_K2,76,0.07858887599160273,0.86496661901474
+mamlK_U4_K2,77,0.07765222957978646,0.8753225308656692
+mamlK_U4_K2,78,0.07947905781368414,0.8770309418439866
+mamlK_U4_K2,79,0.07928254247953494,0.8619640278816223
+mamlK_U4_K2,80,0.07918823627134164,0.8512284314632416
+mamlK_U4_K2,81,0.08322223893056313,0.8404453146457672
+mamlK_U4_K2,82,0.07693830855190754,0.8610380899906158
+mamlK_U4_K2,83,0.07837418059508006,0.8755573546886444
+mamlK_U4_K2,84,0.07821022428572177,0.8421213680505752
+mamlK_U4_K2,85,0.07899662643671036,0.8438133424520493
+mamlK_U4_K2,86,0.07688808182875316,0.8383115620538593
+mamlK_U4_K2,87,0.07651500377804041,0.8694952100515365
+mamlK_U4_K2,88,0.08036992385983467,0.8497046792507171
+mamlK_U4_K2,89,0.0797459103539586,0.8506973469257355
+mamlK_U4_K2,90,0.07704815251131852,0.814814225435257
+mamlK_U4_K2,91,0.07920575883239507,0.8628109717369079
+mamlK_U4_K2,92,0.0758451631044348,0.8538785624504089
+mamlK_U4_K2,93,0.08011396041760842,0.8848290908336639
+mamlK_U4_K2,94,0.07990490927050511,0.8457126104831696
+mamlK_U4_K2,95,0.07785357461621364,0.8530737908184528
+mamlK_U4_K2,96,0.07866809281210105,0.8682119965553283
+mamlK_U4_K2,97,0.07645941035201152,0.8568860089033842
+mamlK_U4_K2,98,0.08080260435740153,0.8890300059318542
+mamlK_U4_K2,99,0.07903780496368805,0.8393355929851531
+mamlK_U4_K2,100,0.07707939996073643,0.8576977205276489
+mamlK_U4_K2,101,0.07986088172843059,0.8742614844441414
+mamlK_U4_K2,102,0.07917260184884072,0.8708767062425613
+mamlK_U4_K2,103,0.07859754203508297,0.8767391210794448
+mamlK_U4_K2,104,0.0729678421964248,0.8789809787273407
+mamlK_U4_K2,105,0.078183617045482,0.8899980449676513
+mamlK_U4_K2,106,0.07746515375872454,0.8696281227469445
+mamlK_U4_K2,107,0.0752659889558951,0.8551996064186096
+mamlK_U4_K2,108,0.07916913042465845,0.8740159738063812
+mamlK_U4_K2,109,0.0784177461018165,0.865906138420105
+mamlK_U4_K2,110,0.07712566965570053,0.8549001354724168
+mamlK_U4_K2,111,0.07774128833164771,0.8428320151567459
+mamlK_U4_K2,112,0.07541980938365062,0.8340257841348648
+mamlK_U4_K2,113,0.07555310793220997,0.8776209282875062
+mamlK_U4_K2,114,0.07783369682729244,0.8660740208625793
+mamlK_U4_K2,115,0.07674313404907783,0.8622547125816346
+mamlK_U4_K2,116,0.07566199239343405,0.8766952967643737
+mamlK_U4_K2,117,0.07742926287154357,0.8505650591850281
+mamlK_U4_K2,118,0.07415519341826439,0.8777812373638153
+mamlK_U4_K2,119,0.07849369635184605,0.8740108346939087
+mamlK_U4_K2,120,0.07369030458231766,0.8489554125070572
+mamlK_U4_K2,121,0.0749422255034248,0.8669265341758728
+mamlK_U4_K2,122,0.07500049248337745,0.861528360247612
+mamlK_U4_K2,123,0.07508466145644585,0.866158322095871
+mamlK_U4_K2,124,0.07766974025716385,0.8837520587444305
+mamlK_U4_K2,125,0.07510182210554679,0.8593252754211426
+mamlK_U4_K2,126,0.07917135852078597,0.877312958240509
+mamlK_U4_K2,127,0.07660577376683553,0.8634454041719437
+mamlK_U4_K2,128,0.07532547718534867,0.8676647818088532
+mamlK_U4_K2,129,0.07596221605936686,0.8548863589763641
+mamlK_U4_K2,130,0.077189445545276,0.8642340287566185
+mamlK_U4_K2,131,0.07637575346976519,0.8782050967216491
+mamlK_U4_K2,132,0.07474295294533173,0.8849943315982819
+mamlK_U4_K2,133,0.07758577205240727,0.8829876577854157
+mamlK_U4_K2,134,0.07335151422768832,0.8453819990158081
+mamlK_U4_K2,135,0.07516057658940553,0.8734569084644318
+mamlK_U4_K2,136,0.07502908387531837,0.8600116789340972
+mamlK_U4_K2,137,0.07770987803737323,0.8648132121562958
+mamlK_U4_K2,138,0.07721029867728552,0.8802397286891938
+mamlK_U4_K2,139,0.07497594498097897,0.887419992685318
+mamlK_U4_K2,140,0.07795365696152051,0.8670073223114013
+mamlK_U4_K2,141,0.0765503795693318,0.8800798547267914
+mamlK_U4_K2,142,0.07600562581171592,0.8807691311836243
+mamlK_U4_K2,143,0.07625699379791816,0.8786227405071259
+mamlK_U4_K2,144,0.07385005053132772,0.8826266646385192
+mamlK_U4_K2,145,0.07578502754370371,0.8639318192005158
+mamlK_U4_K2,146,0.07244726891318957,0.8444139909744263
+mamlK_U4_K2,147,0.08025744455556075,0.8742389309406281
+mamlK_U4_K2,148,0.07382677593578894,0.858665382862091
+mamlK_U4_K2,149,0.07600895341485739,0.8650531363487244
+mamlK_U4_K2,150,0.07478892865280311,0.8782731914520263
+mamlK_U4_K2,151,0.07528852264086405,0.8503567552566529
+mamlK_U4_K2,152,0.07859414044767618,0.8611944818496704
+mamlK_U4_K2,153,0.07693977219363053,0.8736291658878327
+mamlK_U4_K2,154,0.07658144281556209,0.8795509481430054
+mamlK_U4_K2,155,0.07420840689291557,0.8625108706951141
+mamlK_U4_K2,156,0.07445351575811704,0.8700329601764679
+mamlK_U4_K2,157,0.07533411675443252,0.8796775019168854
+mamlK_U4_K2,158,0.07505279827862978,0.8864823198318481
+mamlK_U4_K2,159,0.07462280741582314,0.8799738252162933
+mamlK_U4_K2,160,0.07364192470908165,0.8728257191181182
+mamlK_U4_K2,161,0.07715789119402568,0.8933019423484803
+mamlK_U4_K2,162,0.0766900130485495,0.8530915887653827
+mamlK_U4_K2,163,0.07709434696783622,0.8557748764753341
+mamlK_U4_K2,164,0.07601463935027519,0.8647226530313492
+mamlK_U4_K2,165,0.07520459307978551,0.8626968514919281
+mamlK_U4_K2,166,0.07480562787503003,0.8410029348731041
+mamlK_U4_K2,167,0.07382521180436015,0.8970024859905243
+mamlK_U4_K2,168,0.0741474213451147,0.8644079852104187
+mamlK_U4_K2,169,0.07877997777114312,0.8915906190872193
+mamlK_U4_K2,170,0.07819596990942955,0.8531449621915818
+mamlK_U4_K2,171,0.07584197665254275,0.8599755465984344
+mamlK_U4_K2,172,0.07572295269618431,0.8826698207855225
+mamlK_U4_K2,173,0.07274133364359538,0.8454445844888687
+mamlK_U4_K2,174,0.07673519194126129,0.8589300870895386
+mamlK_U4_K2,175,0.07668255116790533,0.8670554399490357
+mamlK_U4_K2,176,0.07312167560060819,0.864880884885788
+mamlK_U4_K2,177,0.07731563272575537,0.8784602761268616
+mamlK_U4_K2,178,0.07467003023872773,0.8690685838460922
+mamlK_U4_K2,179,0.07420870902637641,0.8789830446243286
+mamlK_U4_K2,180,0.07308677614976962,0.8737964344024658
+mamlK_U4_K2,181,0.0745140562703212,0.85428745418787
+mamlK_U4_K2,182,0.07427270623544852,0.8767592340707779
+mamlK_U4_K2,183,0.07721575987835726,0.8856483566761016
+mamlK_U4_K2,184,0.07093844663351774,0.8691560482978821
+mamlK_U4_K2,185,0.0701368560642004,0.8931281465291977
+mamlK_U4_K2,186,0.0739590199291706,0.856842908859253
+mamlK_U4_K2,187,0.07421348863591751,0.8778711783885956
+mamlK_U4_K2,188,0.07115227452168862,0.8655005168914794
+mamlK_U4_K2,189,0.07617760819693406,0.8469596752524375
+mamlK_U4_K2,190,0.07654514133930207,0.8594996654987335
+mamlK_U4_K2,191,0.07330102030187845,0.878177763223648
+mamlK_U4_K2,192,0.07693664040416479,0.8629058760404587
+mamlK_U4_K2,193,0.07394562887648741,0.8856277394294739
+mamlK_U4_K2,194,0.07082576231410107,0.842761322259903
+mamlK_U4_K2,195,0.07486165312429269,0.8504951947927475
+mamlK_U4_K2,196,0.07434852339327336,0.8827377158403397
+mamlK_U4_K2,197,0.0752689757073919,0.8782028257846832
+mamlK_U4_K2,198,0.07601615959157547,0.900384577512741
+mamlK_U4_K2,199,0.07087323567519585,0.8825874209403992
+mamlK_U4_K2,200,0.07997377313052614,0.8654782837629318
+mamlK_U4_K8,1,0.4779631220300992,0.5218560743331909
+mamlK_U4_K8,2,0.23905222594738007,0.6792358481884002
+mamlK_U4_K8,3,0.18147014014422894,0.7208914625644683
+mamlK_U4_K8,4,0.15055276423692704,0.7708174192905426
+mamlK_U4_K8,5,0.14128380725781123,0.7926760315895081
+mamlK_U4_K8,6,0.12824171476066112,0.8032137858867645
+mamlK_U4_K8,7,0.11776311251024406,0.7746306386590004
+mamlK_U4_K8,8,0.1074277855704228,0.7891612917184829
+mamlK_U4_K8,9,0.10303358559807142,0.8299821317195892
+mamlK_U4_K8,10,0.10054248961309592,0.8459873366355896
+mamlK_U4_K8,11,0.0977603208522002,0.8454595196247101
+mamlK_U4_K8,12,0.09262214314192534,0.8343739348649979
+mamlK_U4_K8,13,0.088804429123799,0.8629938220977783
+mamlK_U4_K8,14,0.08515530495593945,0.8525386583805085
+mamlK_U4_K8,15,0.07906328241030375,0.8669246089458466
+mamlK_U4_K8,16,0.08032574063787858,0.8604840934276581
+mamlK_U4_K8,17,0.07496412508189679,0.8630585432052612
+mamlK_U4_K8,18,0.07406545748313267,0.8816358673572541
+mamlK_U4_K8,19,0.07546724513173103,0.8858630764484405
+mamlK_U4_K8,20,0.07205935560166836,0.8764482045173645
+mamlK_U4_K8,21,0.07199544588724772,0.8631847333908081
+mamlK_U4_K8,22,0.07193882702539364,0.8703910311311484
+mamlK_U4_K8,23,0.0686386434858044,0.8941591203212738
+mamlK_U4_K8,24,0.06663852225989103,0.8849314951896667
+mamlK_U4_K8,25,0.06567058954387903,0.8925490248203277
+mamlK_U4_K8,26,0.06764999195933342,0.9016448211669922
+mamlK_U4_K8,27,0.06502218319724004,0.8826518581807613
+mamlK_U4_K8,28,0.05909692148367564,0.9007911098003387
+mamlK_U4_K8,29,0.06351759045074383,0.888796900510788
+mamlK_U4_K8,30,0.060910760474701724,0.8955352973937988
+mamlK_U4_K8,31,0.06196829771002134,0.8874075281620025
+mamlK_U4_K8,32,0.05644836450616519,0.9074052202701569
+mamlK_U4_K8,33,0.057740512217084566,0.9028492844104767
+mamlK_U4_K8,34,0.05792104292660952,0.8965217685699463
+mamlK_U4_K8,35,0.06055275437732537,0.9030590569972992
+mamlK_U4_K8,36,0.05747922111302614,0.8954496139287949
+mamlK_U4_K8,37,0.054461800654729206,0.8852898293733596
+mamlK_U4_K8,38,0.05669976758460204,0.8828799104690552
+mamlK_U4_K8,39,0.057326951970656716,0.9069823884963989
+mamlK_U4_K8,40,0.05562142616758744,0.9228259885311126
+mamlK_U4_K8,41,0.056953598024944464,0.8979138338565826
+mamlK_U4_K8,42,0.05238298699259758,0.9023919695615769
+mamlK_U4_K8,43,0.05281001061201095,0.9102864873409271
+mamlK_U4_K8,44,0.056227827581266564,0.9165967273712158
+mamlK_U4_K8,45,0.05671533782655994,0.8842040574550629
+mamlK_U4_K8,46,0.05140675840899348,0.911913492679596
+mamlK_U4_K8,47,0.053315665225187936,0.9172633159160614
+mamlK_U4_K8,48,0.054122454139093557,0.9081482481956482
+mamlK_U4_K8,49,0.056235977640996374,0.9098136830329895
+mamlK_U4_K8,50,0.05336583575854699,0.909479022026062
+mamlK_U4_K8,51,0.050722224302589894,0.922106202840805
+mamlK_U4_K8,52,0.052740548557291426,0.9128444647789001
+mamlK_U4_K8,53,0.05585971401383479,0.8837545025348663
+mamlK_U4_K8,54,0.05109009997919202,0.9184091424942017
+mamlK_U4_K8,55,0.04981609096750617,0.9129302978515625
+mamlK_U4_K8,56,0.05034565056363741,0.9072384810447693
+mamlK_U4_K8,57,0.05392729749282201,0.915323349237442
+mamlK_U4_K8,58,0.04984411620224516,0.9051778745651246
+mamlK_U4_K8,59,0.04943579879278938,0.9060387516021728
+mamlK_U4_K8,60,0.05210168012107412,0.9042724931240081
+mamlK_U4_K8,61,0.053020734402040644,0.9040648138523102
+mamlK_U4_K8,62,0.0493498490874966,0.9204268443584442
+mamlK_U4_K8,63,0.05151050047948957,0.9245637631416321
+mamlK_U4_K8,64,0.048734364062547685,0.9229525899887085
+mamlK_U4_K8,65,0.04999003152052561,0.9255816066265106
+mamlK_U4_K8,66,0.04980439253772299,0.9184465742111206
+mamlK_U4_K8,67,0.04705699571718772,0.9034612339735031
+mamlK_U4_K8,68,0.04975722283124924,0.9102222228050232
+mamlK_U4_K8,69,0.047271586464097105,0.9334056138992309
+mamlK_U4_K8,70,0.04922019510840376,0.9129670470952987
+mamlK_U4_K8,71,0.049509449706723295,0.9152740627527237
+mamlK_U4_K8,72,0.04765419605498512,0.928230996131897
+mamlK_U4_K8,73,0.04799282111848394,0.9038844287395478
+mamlK_U4_K8,74,0.048781947984049716,0.9238899147510529
+mamlK_U4_K8,75,0.04753747931371133,0.9296437633037568
+mamlK_U4_K8,76,0.047252054599424206,0.9271022891998291
+mamlK_U4_K8,77,0.04558431272705396,0.9272428321838379
+mamlK_U4_K8,78,0.0481410486313204,0.929426521062851
+mamlK_U4_K8,79,0.04766047046830257,0.9206611275672912
+mamlK_U4_K8,80,0.047961000899473825,0.9129423344135285
+mamlK_U4_K8,81,0.05075534423813224,0.9032941746711731
+mamlK_U4_K8,82,0.04508847988521059,0.9260913872718811
+mamlK_U4_K8,83,0.04695217610026399,0.931098209619522
+mamlK_U4_K8,84,0.04728463528056939,0.902416033744812
+mamlK_U4_K8,85,0.046226587016135454,0.9134788656234741
+mamlK_U4_K8,86,0.04504619709526499,0.904334981366992
+mamlK_U4_K8,87,0.043947319140036904,0.9281575644016266
+mamlK_U4_K8,88,0.04702356739590565,0.9173953318595887
+mamlK_U4_K8,89,0.04712517554561297,0.9085967606306076
+mamlK_U4_K8,90,0.045631353799253704,0.8883070302009582
+mamlK_U4_K8,91,0.04667507576445738,0.9227060890197754
+mamlK_U4_K8,92,0.04412580339858929,0.9164861834049225
+mamlK_U4_K8,93,0.04830271106213331,0.937560864686966
+mamlK_U4_K8,94,0.04687190885345141,0.9109290826320648
+mamlK_U4_K8,95,0.04599330607180794,0.9103593727946282
+mamlK_U4_K8,96,0.04639992384240031,0.9260409581661224
+mamlK_U4_K8,97,0.045589470819880566,0.9152871699631214
+mamlK_U4_K8,98,0.048632444112251205,0.9368037819862366
+mamlK_U4_K8,99,0.04776907954365015,0.9071453016996384
+mamlK_U4_K8,100,0.045159862879663705,0.9187269639968872
+mamlK_U4_K8,101,0.04775585522254308,0.9269299256801605
+mamlK_U4_K8,102,0.0464935635526975,0.9279921305179596
+mamlK_U4_K8,103,0.04451344801733891,0.9344207990169525
+mamlK_U4_K8,104,0.042567297207812466,0.9329907190799713
+mamlK_U4_K8,105,0.045497030957291525,0.9426866602897644
+mamlK_U4_K8,106,0.04576344070956111,0.921606302857399
+mamlK_U4_K8,107,0.042682510353624824,0.9218176829814911
+mamlK_U4_K8,108,0.04616001067683101,0.9318635451793671
+mamlK_U4_K8,109,0.046299802145610254,0.920188130736351
+mamlK_U4_K8,110,0.044982517628620065,0.9136863873898983
+mamlK_U4_K8,111,0.044354827615122,0.9123714852333069
+mamlK_U4_K8,112,0.04368219742551446,0.9059731781482696
+mamlK_U4_K8,113,0.04377598489324252,0.9350841248035431
+mamlK_U4_K8,114,0.045482099012782176,0.9279284679889679
+mamlK_U4_K8,115,0.04554533720016479,0.9237250006198883
+mamlK_U4_K8,116,0.044231869392096994,0.9316341328620911
+mamlK_U4_K8,117,0.045082571376115085,0.9117023973166942
+mamlK_U4_K8,118,0.04259504518782099,0.9364819550514221
+mamlK_U4_K8,119,0.045883758161216974,0.9326616275310516
+mamlK_U4_K8,120,0.04125504024947683,0.9134474474191666
+mamlK_U4_K8,121,0.041810687780380246,0.9241221788525581
+mamlK_U4_K8,122,0.04282815216730038,0.9292815673351288
+mamlK_U4_K8,123,0.04266041820247968,0.9280487847328186
+mamlK_U4_K8,124,0.044364120395233235,0.936419312953949
+mamlK_U4_K8,125,0.04247118879109621,0.9227976202964783
+mamlK_U4_K8,126,0.0460307758487761,0.9341438019275665
+mamlK_U4_K8,127,0.04377921528493365,0.924741443991661
+mamlK_U4_K8,128,0.043116927767793335,0.9314820396900177
+mamlK_U4_K8,129,0.04339456543947259,0.9138414144515992
+mamlK_U4_K8,130,0.043798081732044615,0.9210628312826157
+mamlK_U4_K8,131,0.043559580196936926,0.9359981536865234
+mamlK_U4_K8,132,0.04170446819315354,0.9426365578174591
+mamlK_U4_K8,133,0.04446362294877569,0.9384375298023224
+mamlK_U4_K8,134,0.0418021728284657,0.9175786828994751
+mamlK_U4_K8,135,0.043493542969226834,0.9279124981164932
+mamlK_U4_K8,136,0.042993830156823,0.9264187860488892
+mamlK_U4_K8,137,0.044605811287959415,0.9323660790920257
+mamlK_U4_K8,138,0.044286446180194616,0.9380956745147705
+mamlK_U4_K8,139,0.04319346609835823,0.942953290939331
+mamlK_U4_K8,140,0.04432633345325788,0.929705913066864
+mamlK_U4_K8,141,0.04371677356461684,0.9349844694137573
+mamlK_U4_K8,142,0.04353654883181055,0.9383136737346649
+mamlK_U4_K8,143,0.04367546576385697,0.9354643368721008
+mamlK_U4_K8,144,0.041613030085961025,0.9381922364234925
+mamlK_U4_K8,145,0.04262268448248505,0.9285154962539672
+mamlK_U4_K8,146,0.04042875016729037,0.9156563115119934
+mamlK_U4_K8,147,0.046729983209321896,0.9331570887565612
+mamlK_U4_K8,148,0.04209206994002064,0.9224640035629272
+mamlK_U4_K8,149,0.043427394926548006,0.9270243394374847
+mamlK_U4_K8,150,0.04198032721877098,0.9402234518527984
+mamlK_U4_K8,151,0.04226738051821788,0.9176333004236221
+mamlK_U4_K8,152,0.04550106109430393,0.9295529711246491
+mamlK_U4_K8,153,0.04412522895882527,0.9327342891693116
+mamlK_U4_K8,154,0.04346378943572442,0.9387084555625915
+mamlK_U4_K8,155,0.040683036719759307,0.9233161008358002
+mamlK_U4_K8,156,0.042999583793183166,0.9294557863473892
+mamlK_U4_K8,157,0.04285053016617894,0.9395448267459869
+mamlK_U4_K8,158,0.042279991923520964,0.9420728731155396
+mamlK_U4_K8,159,0.04184378054613869,0.938912742137909
+mamlK_U4_K8,160,0.040890439618378877,0.9331023383140564
+mamlK_U4_K8,161,0.044424817965676384,0.9469376182556153
+mamlK_U4_K8,162,0.04358690325791637,0.9232855385541916
+mamlK_U4_K8,163,0.04441141473129392,0.9210169994831086
+mamlK_U4_K8,164,0.04287119815746943,0.9287175559997558
+mamlK_U4_K8,165,0.04223649861291051,0.9247390687465668
+mamlK_U4_K8,166,0.04204685707266132,0.9069620609283447
+mamlK_U4_K8,167,0.041341771067430574,0.9463892436027527
+mamlK_U4_K8,168,0.041193387092401584,0.9297560715675354
+mamlK_U4_K8,169,0.0442957843405505,0.9429472196102142
+mamlK_U4_K8,170,0.04473894990359743,0.9180112385749817
+mamlK_U4_K8,171,0.04344633239631852,0.923888647556305
+mamlK_U4_K8,172,0.04251364936431249,0.9378248107433319
+mamlK_U4_K8,173,0.04013625531767805,0.9099926733970642
+mamlK_U4_K8,174,0.04395431150992712,0.922145824432373
+mamlK_U4_K8,175,0.04366889546935757,0.927090163230896
+mamlK_U4_K8,176,0.04034995252887408,0.93624183177948
+mamlK_U4_K8,177,0.044224687373886504,0.933515704870224
+mamlK_U4_K8,178,0.04161312356591225,0.9275222307443619
+mamlK_U4_K8,179,0.04161462208256125,0.9307364004850388
+mamlK_U4_K8,180,0.04066770110279322,0.9321164637804031
+mamlK_U4_K8,181,0.040599294907102984,0.9210462868213654
+mamlK_U4_K8,182,0.04146114056929946,0.9348333179950714
+mamlK_U4_K8,183,0.043211357481777665,0.942536209821701
+mamlK_U4_K8,184,0.039732915591448544,0.9329590368270874
+mamlK_U4_K8,185,0.03888906336079041,0.9380114656686783
+mamlK_U4_K8,186,0.04069843170543512,0.9172812688350678
+mamlK_U4_K8,187,0.041107887911299865,0.9397376418113709
+mamlK_U4_K8,188,0.03884282003467281,0.9309276950359344
+mamlK_U4_K8,189,0.04263716956600547,0.914151092171669
+mamlK_U4_K8,190,0.042940374420334895,0.9162731644511223
+mamlK_U4_K8,191,0.04099056159456571,0.9358823013305664
+mamlK_U4_K8,192,0.04398662489528457,0.9257796490192414
+mamlK_U4_K8,193,0.04205015392974019,0.9392344427108764
+mamlK_U4_K8,194,0.03937658442805211,0.9096033501625062
+mamlK_U4_K8,195,0.04244757450496157,0.9171342733502388
+mamlK_U4_K8,196,0.04186845818534493,0.9388355338573455
+mamlK_U4_K8,197,0.04185678826024135,0.9393337917327881
+mamlK_U4_K8,198,0.04370603165278832,0.9497280025482178
+mamlK_U4_K8,199,0.03947611791392167,0.9407294797897339
+mamlK_U4_K8,200,0.046147463197509446,0.923610799908638
+mamlD_U4_K4,1,0.33226974586645763,0.7072442746162415
+mamlD_U4_K4,2,0.17677475623786448,0.7602711629867553
+mamlD_U4_K4,3,0.1448475058376789,0.783854731619358
+mamlD_U4_K4,4,0.12020382655163606,0.814984410405159
+mamlD_U4_K4,5,0.11537383700410525,0.8354198861122132
+mamlD_U4_K4,6,0.10766624535123508,0.8278951597213745
+mamlD_U4_K4,7,0.10021830345193546,0.8006813091039657
+mamlD_U4_K4,8,0.09247000811000665,0.8177136993408203
+mamlD_U4_K4,9,0.09013969005395969,0.8477715253829956
+mamlD_U4_K4,10,0.0891475497931242,0.8643319392204285
+mamlD_U4_K4,11,0.08907465686400731,0.8655763745307923
+mamlD_U4_K4,12,0.08367027290165424,0.8450695098564028
+mamlD_U4_K4,13,0.08100369604925314,0.8799751842021942
+mamlD_U4_K4,14,0.07926372083524863,0.8626924604177475
+mamlD_U4_K4,15,0.07365076714505751,0.8779079747200013
+mamlD_U4_K4,16,0.0767112746834755,0.8699885833263398
+mamlD_U4_K4,17,0.07051228248824676,0.8677393686771393
+mamlD_U4_K4,18,0.07126029013345639,0.8892756295204163
+mamlD_U4_K4,19,0.07396258503198623,0.8958798789978027
+mamlD_U4_K4,20,0.0701787693053484,0.8781686514616013
+mamlD_U4_K4,21,0.07021890625357628,0.8641251504421235
+mamlD_U4_K4,22,0.07097932344923417,0.8709613773971796
+mamlD_U4_K4,23,0.067776012532413,0.8977204287052154
+mamlD_U4_K4,24,0.06593359860281149,0.8864236354827881
+mamlD_U4_K4,25,0.06577742870897055,0.8942761540412902
+mamlD_U4_K4,26,0.0682281036178271,0.9049929404258727
+mamlD_U4_K4,27,0.0659653755525748,0.8859848852455616
+mamlD_U4_K4,28,0.0599904407809178,0.9027950048446656
+mamlD_U4_K4,29,0.0653015545134743,0.8889790588617325
+mamlD_U4_K4,30,0.062404386351505914,0.8966039460897446
+mamlD_U4_K4,31,0.06378314279019832,0.8865257000923157
+mamlD_U4_K4,32,0.05806770576785008,0.906207126379013
+mamlD_U4_K4,33,0.059646516144275664,0.9038380932807922
+mamlD_U4_K4,34,0.0600526828939716,0.8928085041046142
+mamlD_U4_K4,35,0.06303705995281537,0.8979040801525116
+mamlD_U4_K4,36,0.06020684272671739,0.8944093811511994
+mamlD_U4_K4,37,0.056072589127967754,0.8780849593877792
+mamlD_U4_K4,38,0.0591437874486049,0.8754855984449387
+mamlD_U4_K4,39,0.06000196353842815,0.9038444465398788
+mamlD_U4_K4,40,0.05908978711813688,0.9190565812587738
+mamlD_U4_K4,41,0.0600906153023243,0.8876453137397766
+mamlD_U4_K4,42,0.055646294547865786,0.8961232960224151
+mamlD_U4_K4,43,0.05668414675320188,0.9031804275512695
+mamlD_U4_K4,44,0.06053298554072777,0.9184056341648101
+mamlD_U4_K4,45,0.059651808571070435,0.8761727607250214
+mamlD_U4_K4,46,0.055535307048509515,0.9027179086208343
+mamlD_U4_K4,47,0.05750930075223247,0.9118513488769531
+mamlD_U4_K4,48,0.05781642417733868,0.8970184171199799
+mamlD_U4_K4,49,0.059838524299363295,0.9061286163330078
+mamlD_U4_K4,50,0.05751658910885453,0.9048182320594788
+mamlD_U4_K4,51,0.054772061283389725,0.9153175806999206
+mamlD_U4_K4,52,0.057227188299099604,0.9023577749729157
+mamlD_U4_K4,53,0.06031815850486358,0.8746447360515595
+mamlD_U4_K4,54,0.055270860698074104,0.9127678370475769
+mamlD_U4_K4,55,0.05397566540166736,0.906368271112442
+mamlD_U4_K4,56,0.05474784299110373,0.8978208255767822
+mamlD_U4_K4,57,0.05862275324140986,0.9143995618820191
+mamlD_U4_K4,58,0.05436739023774862,0.9001333135366439
+mamlD_U4_K4,59,0.054555159453302624,0.8980947136878967
+mamlD_U4_K4,60,0.05685729818418622,0.8991078412532807
+mamlD_U4_K4,61,0.058151018271843595,0.8931859922409058
+mamlD_U4_K4,62,0.05398393329853813,0.9139244389533997
+mamlD_U4_K4,63,0.056122340777268014,0.9154566299915313
+mamlD_U4_K4,64,0.05301577487339576,0.9189777481555939
+mamlD_U4_K4,65,0.054918188334753114,0.9212599790096283
+mamlD_U4_K4,66,0.05467476099729538,0.9101110601425171
+mamlD_U4_K4,67,0.05194011902436614,0.8963859722018241
+mamlD_U4_K4,68,0.0549555604532361,0.9001881390810013
+mamlD_U4_K4,69,0.05250753067433834,0.9276944887638092
+mamlD_U4_K4,70,0.05503080276151498,0.9016196215152741
+mamlD_U4_K4,71,0.05488684472317497,0.9066729021072387
+mamlD_U4_K4,72,0.05359344453240434,0.9201527678966522
+mamlD_U4_K4,73,0.05427974117298921,0.8956168949604034
+mamlD_U4_K4,74,0.05475098236153523,0.9159560787677765
+mamlD_U4_K4,75,0.05281189353515704,0.9215204071998596
+mamlD_U4_K4,76,0.05264789244780938,0.9185412907600403
+mamlD_U4_K4,77,0.051409392865995565,0.9221062177419662
+mamlD_U4_K4,78,0.05349850337331494,0.9248423945903778
+mamlD_U4_K4,79,0.05382979394868016,0.9127719509601593
+mamlD_U4_K4,80,0.053457854880640907,0.9004097282886505
+mamlD_U4_K4,81,0.056950522201756636,0.8939985719323158
+mamlD_U4_K4,82,0.05090698417276144,0.914024121761322
+mamlD_U4_K4,83,0.0529921709621946,0.922695838212967
+mamlD_U4_K4,84,0.053284227320303516,0.8929305797815323
+mamlD_U4_K4,85,0.05285409294068813,0.9010648596286773
+mamlD_U4_K4,86,0.05130229050914446,0.8942721292749047
+mamlD_U4_K4,87,0.05001533610746264,0.9206917119026184
+mamlD_U4_K4,88,0.05392462734753887,0.9077650117874145
+mamlD_U4_K4,89,0.05362904659161965,0.9001771813631058
+mamlD_U4_K4,90,0.052035900683452686,0.8782391160726547
+mamlD_U4_K4,91,0.052584297036131225,0.9124891722202301
+mamlD_U4_K4,92,0.05022508302082618,0.9077244758605957
+mamlD_U4_K4,93,0.054565017335116865,0.9335999476909638
+mamlD_U4_K4,94,0.0531883321578304,0.9036381077766419
+mamlD_U4_K4,95,0.05216884396970272,0.9015415945649147
+mamlD_U4_K4,96,0.0530705667535464,0.9171244978904725
+mamlD_U4_K4,97,0.05148339337358872,0.9067597711086273
+mamlD_U4_K4,98,0.05486183729643623,0.931991959810257
+mamlD_U4_K4,99,0.053760130659987526,0.8953824180364609
+mamlD_U4_K4,100,0.05132714407518506,0.9088386845588684
+mamlD_U4_K4,101,0.053888792774329584,0.9230603194236755
+mamlD_U4_K4,102,0.0527850770081083,0.9184340858459472
+mamlD_U4_K4,103,0.05152679332221548,0.9252682280540466
+mamlD_U4_K4,104,0.04825870852296551,0.9282627916336059
+mamlD_U4_K4,105,0.05150640400747458,0.9349008071422577
+mamlD_U4_K4,106,0.051715812385082244,0.9155999025702477
+mamlD_U4_K4,107,0.04935547518233458,0.909106433391571
+mamlD_U4_K4,108,0.052696935342003905,0.9248205316066742
+mamlD_U4_K4,109,0.05243582926069697,0.9151817715167999
+mamlD_U4_K4,110,0.05094705957919359,0.9041129250079394
+mamlD_U4_K4,111,0.05081009749944011,0.8941559112071991
+mamlD_U4_K4,112,0.05004351894681652,0.8896460205316543
+mamlD_U4_K4,113,0.050028850734233854,0.928802660703659
+mamlD_U4_K4,114,0.05225728334859014,0.9190279865264892
+mamlD_U4_K4,115,0.05163899037986994,0.9149557113647461
+mamlD_U4_K4,116,0.05058057485769192,0.9194704449176788
+mamlD_U4_K4,117,0.05200697081784407,0.905641396343708
+mamlD_U4_K4,118,0.048949986242999635,0.9267030274868011
+mamlD_U4_K4,119,0.052872367488841214,0.9211409950256347
+mamlD_U4_K4,120,0.04799026660621166,0.899388080239296
+mamlD_U4_K4,121,0.048778135298440856,0.9122915583848953
+mamlD_U4_K4,122,0.049206985756754876,0.9172151899337768
+mamlD_U4_K4,123,0.04927736043309172,0.9171838593482972
+mamlD_U4_K4,124,0.05120278758307298,0.9308539128303528
+mamlD_U4_K4,125,0.04889334943766395,0.9104605150222779
+mamlD_U4_K4,126,0.052975892921288806,0.9274392080307007
+mamlD_U4_K4,127,0.050311327235152324,0.9167815577983857
+mamlD_U4_K4,128,0.049772387879590194,0.9209587621688843
+mamlD_U4_K4,129,0.04997918299088876,0.9006694430857897
+mamlD_U4_K4,130,0.05016263517240683,0.912883588373661
+mamlD_U4_K4,131,0.05020913464327653,0.9251600801944733
+mamlD_U4_K4,132,0.04885625268643101,0.9323220777511597
+mamlD_U4_K4,133,0.051198460465917986,0.9299926042556763
+mamlD_U4_K4,134,0.04823922702421745,0.9025299048423767
+mamlD_U4_K4,135,0.049459049670646585,0.9139180135726929
+mamlD_U4_K4,136,0.049267774193237225,0.9145679724216461
+mamlD_U4_K4,137,0.05096803734699885,0.9186458110809326
+mamlD_U4_K4,138,0.05099628301337361,0.9309629034996033
+mamlD_U4_K4,139,0.04935644599298636,0.9355896592140198
+mamlD_U4_K4,140,0.05138297356665134,0.9187753987312317
+mamlD_U4_K4,141,0.05071673834696412,0.926981908082962
+mamlD_U4_K4,142,0.05012833488484224,0.9287077867984772
+mamlD_U4_K4,143,0.050881257249663275,0.9253663563728333
+mamlD_U4_K4,144,0.0484694933022062,0.9285207271575928
+mamlD_U4_K4,145,0.0493666319300731,0.9173754668235778
+mamlD_U4_K4,146,0.047217747842272124,0.9045787739753723
+mamlD_U4_K4,147,0.05380128918215633,0.9247326457500458
+mamlD_U4_K4,148,0.04834152360757192,0.9107429003715515
+mamlD_U4_K4,149,0.0503358512185514,0.9167406404018402
+mamlD_U4_K4,150,0.04861355886484186,0.9314720213413239
+mamlD_U4_K4,151,0.049152215557793776,0.9025949084758759
+mamlD_U4_K4,152,0.05237987481678526,0.9191000699996948
+mamlD_U4_K4,153,0.050817638095468284,0.924338185787201
+mamlD_U4_K4,154,0.05072446197271347,0.9293682527542114
+mamlD_U4_K4,155,0.04761107598741849,0.9084386062622071
+mamlD_U4_K4,156,0.04906454727674524,0.9223668110370636
+mamlD_U4_K4,157,0.0496505764623483,0.9320311737060547
+mamlD_U4_K4,158,0.049232835943500204,0.9339154553413391
+mamlD_U4_K4,159,0.04919609226907293,0.9278384900093078
+mamlD_U4_K4,160,0.04731551618004839,0.9251616835594177
+mamlD_U4_K4,161,0.051343967095017436,0.9402533411979676
+mamlD_U4_K4,162,0.050502766985446215,0.9112370407581329
+mamlD_U4_K4,163,0.051261143249770005,0.9096662175655365
+mamlD_U4_K4,164,0.04977377268796166,0.9198521399497985
+mamlD_U4_K4,165,0.048813525419682265,0.9133789455890655
+mamlD_U4_K4,166,0.04894803042834004,0.8936040103435516
+mamlD_U4_K4,167,0.04804897318904599,0.9391674268245697
+mamlD_U4_K4,168,0.047860090658068656,0.9183463680744172
+mamlD_U4_K4,169,0.05172237353399396,0.9353018832206726
+mamlD_U4_K4,170,0.0518186297826469,0.907518447637558
+mamlD_U4_K4,171,0.050250552849223216,0.9118054795265198
+mamlD_U4_K4,172,0.04976588887472948,0.9315401470661163
+mamlD_U4_K4,173,0.04685487166047096,0.9027909225225449
+mamlD_U4_K4,174,0.05097919645408789,0.9141061782836915
+mamlD_U4_K4,175,0.05025861306115985,0.9179960542917251
+mamlD_U4_K4,176,0.04739398056020339,0.9242080414295196
+mamlD_U4_K4,177,0.05126929888501763,0.9251568830013275
+mamlD_U4_K4,178,0.04801142251739899,0.9206536984443665
+mamlD_U4_K4,179,0.048808847920348244,0.9248807525634766
+mamlD_U4_K4,180,0.04759013945857684,0.9204864507913589
+mamlD_U4_K4,181,0.047790721617639066,0.9091754364967346
+mamlD_U4_K4,182,0.04788981263215343,0.9251405346393585
+mamlD_U4_K4,183,0.05014867844680945,0.9331622576713562
+mamlD_U4_K4,184,0.04662734099353353,0.9213172328472138
+mamlD_U4_K4,185,0.04500006351619959,0.933356506228447
+mamlD_U4_K4,186,0.047374907185633974,0.9065024596452713
+mamlD_U4_K4,187,0.04821119980265697,0.9290335690975189
+mamlD_U4_K4,188,0.04545490994428595,0.9162960052490234
+mamlD_U4_K4,189,0.0501812063343823,0.9009342265129089
+mamlD_U4_K4,190,0.04982624230906367,0.9044142286479473
+mamlD_U4_K4,191,0.048000499351571004,0.9249812185764312
+mamlD_U4_K4,192,0.05098871215557059,0.9133920872211456
+mamlD_U4_K4,193,0.04835366445283095,0.931778039932251
+mamlD_U4_K4,194,0.04584052532290419,0.8967518651485443
+mamlD_U4_K4,195,0.04918509343639016,0.901038418263197
+mamlD_U4_K4,196,0.04879093502337734,0.927699345946312
+mamlD_U4_K4,197,0.04918769733980298,0.9293132257461548
+mamlD_U4_K4,198,0.050241120532155036,0.9447884798049927
+mamlD_U4_K4,199,0.04578717742115259,0.930838119983673
+mamlD_U4_K4,200,0.05384820915137728,0.911318576335907

fig_cl/cl_results.json

@@ -0,0 +1,619 @@
+{
+ "meta": {
+  "epochs": 200,
+  "steps": 300,
+  "trials": 500
+ },
+ "probe_clean_acc": 0.8554999828338623,
+ "baseline_U1_K1": {
+  "U": 1,
+  "K": 1,
+  "train_s": 239.5449607372284,
+  "snr": {
+   "0": {
+    "cos": 0.7512048875018954,
+    "mse": 0.009406678444473073
+   },
+   "5": {
+    "cos": 0.8374274200350046,
+    "mse": 0.005473443141905591
+   },
+   "10": {
+    "cos": 0.8977560202479362,
+    "mse": 0.0038072720784693955
+   },
+   "15": {
+    "cos": 0.9240585275888443,
+    "mse": 0.0030504610685165973
+   },
+   "20": {
+    "cos": 0.9306978814601898,
+    "mse": 0.0030041839454788715
+   },
+   "25": {
+    "cos": 0.9346830936670303,
+    "mse": 0.002839639469049871
+   },
+   "30": {
+    "cos": 0.9361000318527222,
+    "mse": 0.0027582109675277026
+   }
+  },
+  "probe_acc": {
+   "0": 0.7480000257492065,
+   "5": 0.8080000281333923,
+   "10": 0.8659999966621399,
+   "15": 0.8339999914169312,
+   "20": 0.8299999833106995,
+   "25": 0.7900000214576721,
+   "30": 0.8240000009536743
+  }
+ },
+ "prop_U1_K4": {
+  "U": 1,
+  "K": 4,
+  "train_s": 246.5999619960785,
+  "snr": {
+   "0": {
+    "cos": 0.8532368051446975,
+    "mse": 0.014056407508905976
+   },
+   "5": {
+    "cos": 0.9038518134951592,
+    "mse": 0.009546010008081795
+   },
+   "10": {
+    "cos": 0.9347490702867508,
+    "mse": 0.0072207471719011665
+   },
+   "15": {
+    "cos": 0.9476060789823532,
+    "mse": 0.006647482709959149
+   },
+   "20": {
+    "cos": 0.9499228476285935,
+    "mse": 0.006673556070774794
+   },
+   "25": {
+    "cos": 0.9511101233959198,
+    "mse": 0.00651326646655798
+   },
+   "30": {
+    "cos": 0.951739949464798,
+    "mse": 0.006585568169131875
+   }
+  }
+ },
+ "prop_U2_K4": {
+  "U": 2,
+  "K": 4,
+  "train_s": 294.072158575058,
+  "snr": {
+   "0": {
+    "cos": 0.8004015162587166,
+    "mse": 0.013665408468805254
+   },
+   "5": {
+    "cos": 0.870693371757865,
+    "mse": 0.008788753495551646
+   },
+   "10": {
+    "cos": 0.9140427639484405,
+    "mse": 0.007043784702196717
+   },
+   "15": {
+    "cos": 0.9326149935722351,
+    "mse": 0.0064183887476101514
+   },
+   "20": {
+    "cos": 0.9359902501106262,
+    "mse": 0.006283330081962049
+   },
+   "25": {
+    "cos": 0.9408227092027664,
+    "mse": 0.006187855323776603
+   },
+   "30": {
+    "cos": 0.941265830874443,
+    "mse": 0.006170148870907724
+   }
+  }
+ },
+ "prop_U3_K4": {
+  "U": 3,
+  "K": 4,
+  "train_s": 352.04336524009705,
+  "snr": {
+   "0": {
+    "cos": 0.7608834460247308,
+    "mse": 0.014268206578679382
+   },
+   "5": {
+    "cos": 0.8446127345263958,
+    "mse": 0.010725745330564678
+   },
+   "10": {
+    "cos": 0.8995597721934319,
+    "mse": 0.008194744511507451
+   },
+   "15": {
+    "cos": 0.9227433396577835,
+    "mse": 0.0068385992012918
+   },
+   "20": {
+    "cos": 0.9272037045955658,
+    "mse": 0.0067242950573563574
+   },
+   "25": {
+    "cos": 0.9324239077568054,
+    "mse": 0.006562483542598784
+   },
+   "30": {
+    "cos": 0.9339433960914612,
+    "mse": 0.0065560071440413595
+   }
+  }
+ },
+ "latency": {
+  "proposed_gpu_ms": 1.8540966510772705,
+  "proposed_cpu_ms": 19.482388496398926,
+  "params": 4759296
+ },
+ "prop_U4_K4": {
+  "U": 4,
+  "K": 4,
+  "train_s": 872.98774933815,
+  "snr": {
+   "0": {
+    "cos": 0.7291872679814696,
+    "mse": 0.013695541681256146
+   },
+   "5": {
+    "cos": 0.8177445989996195,
+    "mse": 0.009565219173207878
+   },
+   "10": {
+    "cos": 0.8780294983685016,
+    "mse": 0.006982134721241892
+   },
+   "15": {
+    "cos": 0.9053358047008514,
+    "mse": 0.006403609288856387
+   },
+   "20": {
+    "cos": 0.9108110672235489,
+    "mse": 0.006068491332698613
+   },
+   "25": {
+    "cos": 0.9174709552526474,
+    "mse": 0.0060051574409008025
+   },
+   "30": {
+    "cos": 0.9188009135723114,
+    "mse": 0.005959624953567982
+   }
+  },
+  "probe_acc": {
+   "0": 0.7459999918937683,
+   "5": 0.7699999809265137,
+   "10": 0.8234999775886536,
+   "15": 0.8180000185966492,
+   "20": 0.8234999775886536,
+   "25": 0.8399999737739563,
+   "30": 0.8335000276565552
+  }
+ },
+ "prop_U5_K4": {
+  "U": 5,
+  "K": 4,
+  "train_s": 940.9560332298279,
+  "snr": {
+   "0": {
+    "cos": 0.7099829956488684,
+    "mse": 0.015077491921372711
+   },
+   "5": {
+    "cos": 0.8048962750434876,
+    "mse": 0.010662849036511034
+   },
+   "10": {
+    "cos": 0.8720338128209114,
+    "mse": 0.008510463847778737
+   },
+   "15": {
+    "cos": 0.9013502452373504,
+    "mse": 0.007372538112103939
+   },
+   "20": {
+    "cos": 0.9082419496178628,
+    "mse": 0.007131525727920234
+   },
+   "25": {
+    "cos": 0.914760999917984,
+    "mse": 0.0069032206255942585
+   },
+   "30": {
+    "cos": 0.916708040356636,
+    "mse": 0.0068538802796974775
+   }
+  }
+ },
+ "prop_U6_K4": {
+  "U": 6,
+  "K": 4,
+  "train_s": 1006.8338630199432,
+  "snr": {
+   "0": {
+    "cos": 0.6902393801975996,
+    "mse": 0.01464361715503037
+   },
+   "5": {
+    "cos": 0.7882059656456113,
+    "mse": 0.01061347191175446
+   },
+   "10": {
+    "cos": 0.8572778242230416,
+    "mse": 0.00793193681165576
+   },
+   "15": {
+    "cos": 0.8888761663436889,
+    "mse": 0.0066969672827981415
+   },
+   "20": {
+    "cos": 0.8959532424807548,
+    "mse": 0.006571302498690784
+   },
+   "25": {
+    "cos": 0.9033272238969803,
+    "mse": 0.006413094263523817
+   },
+   "30": {
+    "cos": 0.9050234014987946,
+    "mse": 0.006374428950250149
+   }
+  }
+ },
+ "ksweep_U4_K1": {
+  "U": 4,
+  "K": 1,
+  "train_s": 901.9444651603699,
+  "snr": {
+   "0": {
+    "cos": 0.6006318819746375,
+    "mse": 0.00866046295966953
+   },
+   "5": {
+    "cos": 0.7159863247089088,
+    "mse": 0.006941811306402087
+   },
+   "10": {
+    "cos": 0.8087207083404064,
+    "mse": 0.005576504059601575
+   },
+   "15": {
+    "cos": 0.8521278169155121,
+    "mse": 0.004726723590865731
+   },
+   "20": {
+    "cos": 0.8647244926095009,
+    "mse": 0.004565435856580734
+   },
+   "25": {
+    "cos": 0.8762238830327987,
+    "mse": 0.00435680990666151
+   },
+   "30": {
+    "cos": 0.8790061377286911,
+    "mse": 0.004332918418571353
+   }
+  }
+ },
+ "ksweep_U4_K2": {
+  "U": 4,
+  "K": 2,
+  "train_s": 801.3562304973602,
+  "snr": {
+   "0": {
+    "cos": 0.6663209554627538,
+    "mse": 0.011440564267802983
+   },
+   "5": {
+    "cos": 0.7732463547363877,
+    "mse": 0.008832189400680363
+   },
+   "10": {
+    "cos": 0.8522137620449066,
+    "mse": 0.006787573641166091
+   },
+   "15": {
+    "cos": 0.8869951583147049,
+    "mse": 0.005796302331611514
+   },
+   "20": {
+    "cos": 0.8962614781260491,
+    "mse": 0.005636646617669612
+   },
+   "25": {
+    "cos": 0.9053579796552658,
+    "mse": 0.005484837215393782
+   },
+   "30": {
+    "cos": 0.9076521228551865,
+    "mse": 0.005444107189774513
+   }
+  }
+ },
+ "ksweep_U4_K8": {
+  "U": 4,
+  "K": 8,
+  "train_s": 960.7533371448517,
+  "snr": {
+   "0": {
+    "cos": 0.7968653709590435,
+    "mse": 0.014677034198772162
+   },
+   "5": {
+    "cos": 0.8642902764230966,
+    "mse": 0.009218778028152883
+   },
+   "10": {
+    "cos": 0.9079774358868599,
+    "mse": 0.007102536340244115
+   },
+   "15": {
+    "cos": 0.9249372535943985,
+    "mse": 0.006434439655393362
+   },
+   "20": {
+    "cos": 0.9286348958015442,
+    "mse": 0.006367257353849709
+   },
+   "25": {
+    "cos": 0.9328467948436737,
+    "mse": 0.006306198381818831
+   },
+   "30": {
+    "cos": 0.9333295357227326,
+    "mse": 0.006291192831471563
+   }
+  }
+ },
+ "randmask_U4_K4": {
+  "U": 4,
+  "K": 4,
+  "train_s": 790.7998886108398,
+  "snr": {
+   "0": {
+    "cos": 0.7173908124007284,
+    "mse": 0.010884988505393267
+   },
+   "5": {
+    "cos": 0.8113118888139724,
+    "mse": 0.012465010555461049
+   },
+   "10": {
+    "cos": 0.8754324036836624,
+    "mse": 0.013991043128073215
+   },
+   "15": {
+    "cos": 0.9036176422834397,
+    "mse": 0.014899637151509524
+   },
+   "20": {
+    "cos": 0.9104479736089707,
+    "mse": 0.015265570061281323
+   },
+   "25": {
+    "cos": 0.9167852708101273,
+    "mse": 0.015525816094130278
+   },
+   "30": {
+    "cos": 0.9185707560777664,
+    "mse": 0.01563316000625491
+   }
+  },
+  "probe_acc": {
+   "0": 0.7615000009536743,
+   "5": 0.7950000166893005,
+   "10": 0.8374999761581421,
+   "15": 0.8314999938011169,
+   "20": 0.8410000205039978,
+   "25": 0.8489999771118164,
+   "30": 0.843999981880188
+  }
+ },
+ "maml_U4_K4": {
+  "U": 4,
+  "K": 4,
+  "train_s": 5938.119814634323,
+  "snr": {
+   "0": {
+    "cos": 0.7272935093110428,
+    "mse": 0.006946617619832978
+   },
+   "5": {
+    "cos": 0.8484958949685096,
+    "mse": 0.004622220577439293
+   },
+   "10": {
+    "cos": 0.8977697676718235,
+    "mse": 0.0038188065083231775
+   },
+   "15": {
+    "cos": 0.9313238598108292,
+    "mse": 0.0032185151416342706
+   },
+   "20": {
+    "cos": 0.9433529702425003,
+    "mse": 0.0029843107901979236
+   },
+   "25": {
+    "cos": 0.9491406964063644,
+    "mse": 0.002911557617597282
+   },
+   "30": {
+    "cos": 0.9507425274848939,
+    "mse": 0.002883736375719309
+   }
+  }
+ },
+ "mask_corr": {
+  "prop_U2_K4": [
+   [
+    1.0000003576278687,
+    -0.171196848154068
+   ],
+   [
+    -0.17119678854942322,
+    0.9999998807907104
+   ]
+  ],
+  "prop_U3_K4": [
+   [
+    1.0,
+    -0.07354956120252609,
+    -0.09823843091726303
+   ],
+   [
+    -0.07354956865310669,
+    1.0,
+    -0.06813394278287888
+   ],
+   [
+    -0.09823843091726303,
+    -0.0681338906288147,
+    1.0
+   ]
+  ],
+  "prop_U4_K4": [
+   [
+    0.9999999403953552,
+    -0.04680539295077324,
+    -0.03882935643196106,
+    -0.04847832769155502
+   ],
+   [
+    -0.04680539295077324,
+    0.9999999403953552,
+    -0.017869999632239342,
+    -0.027729595080018044
+   ],
+   [
+    -0.03882935643196106,
+    -0.017869999632239342,
+    0.9999998807907104,
+    -0.030613459646701813
+   ],
+   [
+    -0.04847832769155502,
+    -0.027729595080018044,
+    -0.030613459646701813,
+    1.0000001192092896
+   ]
+  ]
+ },
+ "bert_tx_ms": 8.949885368347168,
+ "todma_T24_L128": {
+  "0": {
+   "cos": 0.493185225520283,
+   "token_err": 0.4854690374003679
+  },
+  "5": {
+   "cos": 0.7722916670888662,
+   "token_err": 0.19098860990497765
+  },
+  "10": {
+   "cos": 0.8822443547844887,
+   "token_err": 0.06283830025508617
+  },
+  "15": {
+   "cos": 0.9289134788513184,
+   "token_err": 0.018709073900841908
+  },
+  "20": {
+   "cos": 0.939444392323494,
+   "token_err": 0.0020551784268543313
+  },
+  "25": {
+   "cos": 0.9456337448954583,
+   "token_err": 0.0013560993650989337
+  },
+  "30": {
+   "cos": 0.9398069840669632,
+   "token_err": 0.0003694126339120798
+  },
+  "omp_ms_per_frame": 69.23341853278023,
+  "probe_acc": {
+   "0": 0.6487500071525574,
+   "5": 0.762499988079071,
+   "10": 0.831250011920929,
+   "15": 0.8274999856948853,
+   "20": 0.856249988079071,
+   "25": 0.8525000214576721,
+   "30": 0.8237500190734863
+  }
+ },
+ "todma_T16_L192": {
+  "0": {
+   "cos": 0.5508923250064254,
+   "token_err": 0.33421926910299005
+  },
+  "5": {
+   "cos": 0.7354670177400112,
+   "token_err": 0.11904961800016792
+  },
+  "10": {
+   "cos": 0.7986631008982659,
+   "token_err": 0.038033937975424224
+  },
+  "15": {
+   "cos": 0.8236862942576408,
+   "token_err": 0.013450292397660818
+  },
+  "20": {
+   "cos": 0.824865009188652,
+   "token_err": 0.0007554772097708386
+  },
+  "25": {
+   "cos": 0.8318010360002518,
+   "token_err": 0.0009913258983890955
+  },
+  "30": {
+   "cos": 0.8285451126098633,
+   "token_err": 0.0004998750312421895
+  },
+  "omp_ms_per_frame": 53.34201097488403
+ },
+ "distil_U4_K4": {
+  "snr": {
+   "0": {
+    "cos": 0.7609358094548807,
+    "mse": 0.012706214756704868
+   },
+   "5": {
+    "cos": 0.8429884244352579,
+    "mse": 0.008787638427689672
+   },
+   "10": {
+    "cos": 0.8978586344122886,
+    "mse": 0.006501799292862416
+   },
+   "15": {
+    "cos": 0.9221130377054214,
+    "mse": 0.005962589378003031
+   },
+   "20": {
+    "cos": 0.9269556359052659,
+    "mse": 0.005698614472988993
+   },
+   "25": {
+    "cos": 0.9324832957983017,
+    "mse": 0.005604706801474095
+   },
+   "30": {
+    "cos": 0.93326731467247,
+    "mse": 0.005592345166951418
+   }
+  }
+ }
+}

fig_cl/cl_results_maml.json

@@ -0,0 +1,367 @@
+{
+ "probe_clean_acc": 0.8544999957084656,
+ "mamlB_U1_K1": {
+  "U": 1,
+  "K": 1,
+  "train_s": 1855.3961975574493,
+  "snr": {
+   "0": {
+    "cos": 0.7410974535308779,
+    "mse": 0.00536057359946426
+   },
+   "5": {
+    "cos": 0.8605051371753216,
+    "mse": 0.003974304080475122
+   },
+   "10": {
+    "cos": 0.9055965428799391,
+    "mse": 0.003153211650787853
+   },
+   "15": {
+    "cos": 0.9398714020252228,
+    "mse": 0.0025944132450968025
+   },
+   "20": {
+    "cos": 0.9511017026901245,
+    "mse": 0.0024232296019326897
+   },
+   "25": {
+    "cos": 0.955735426068306,
+    "mse": 0.002307979795150459
+   },
+   "30": {
+    "cos": 0.9574335722923278,
+    "mse": 0.002284204211551696
+   }
+  },
+  "probe_acc": {
+   "0": 0.7360000014305115,
+   "5": 0.843999981880188,
+   "10": 0.8619999885559082,
+   "15": 0.828000009059906,
+   "20": 0.8500000238418579,
+   "25": 0.7979999780654907,
+   "30": 0.8240000009536743
+  }
+ },
+ "mask_corr": {
+  "mamlP_U2_K4": [
+   [
+    1.0000003576278687,
+    0.061798855662345886
+   ],
+   [
+    0.061798885464668274,
+    0.9999996423721313
+   ]
+  ],
+  "mamlP_U3_K4": [
+   [
+    1.0,
+    0.11703632026910782,
+    0.08484122902154922
+   ],
+   [
+    0.11703631281852722,
+    0.9999997615814209,
+    0.12813597917556763
+   ],
+   [
+    0.08484122902154922,
+    0.12813599407672882,
+    1.0
+   ]
+  ],
+  "mamlP_U4_K4": [
+   [
+    1.0,
+    0.0902513712644577,
+    0.09627597779035568,
+    0.12736007571220398
+   ],
+   [
+    0.0902513712644577,
+    0.9999998211860657,
+    0.09915776550769806,
+    0.12352747470140457
+   ],
+   [
+    0.09627597779035568,
+    0.09915776550769806,
+    0.9999999403953552,
+    0.15109454095363617
+   ],
+   [
+    0.12736007571220398,
+    0.12352747470140457,
+    0.15109454095363617,
+    0.9999997615814209
+   ]
+  ]
+ },
+ "mamlP_U1_K4": {
+  "U": 1,
+  "K": 4,
+  "train_s": 1703.1989748477936,
+  "snr": {
+   "0": {
+    "cos": 0.8594144794344902,
+    "mse": 0.0069277614718303085
+   },
+   "5": {
+    "cos": 0.9325430425405502,
+    "mse": 0.0036945449772756546
+   },
+   "10": {
+    "cos": 0.9527349365949631,
+    "mse": 0.0032820978502277284
+   },
+   "15": {
+    "cos": 0.9693417336940765,
+    "mse": 0.0027846451993100347
+   },
+   "20": {
+    "cos": 0.974255983710289,
+    "mse": 0.0026865204190835356
+   },
+   "25": {
+    "cos": 0.9761006777286529,
+    "mse": 0.00262830908736214
+   },
+   "30": {
+    "cos": 0.9766125748157501,
+    "mse": 0.0026144605481531473
+   }
+  }
+ },
+ "mamlP_U2_K4": {
+  "U": 2,
+  "K": 4,
+  "train_s": 2099.9137415885925,
+  "snr": {
+   "0": {
+    "cos": 0.7969576192647219,
+    "mse": 0.005527409416157752
+   },
+   "5": {
+    "cos": 0.8958459490537644,
+    "mse": 0.003535830914741382
+   },
+   "10": {
+    "cos": 0.929745109051466,
+    "mse": 0.003008644887479022
+   },
+   "15": {
+    "cos": 0.9538345046043396,
+    "mse": 0.0025697590378113092
+   },
+   "20": {
+    "cos": 0.9618748840093613,
+    "mse": 0.0023491571710910646
+   },
+   "25": {
+    "cos": 0.9661516258716584,
+    "mse": 0.0023275921714957805
+   },
+   "30": {
+    "cos": 0.9667309571504593,
+    "mse": 0.0023136503512505443
+   }
+  }
+ },
+ "mamlP_U3_K4": {
+  "U": 3,
+  "K": 4,
+  "train_s": 2672.6384410858154,
+  "snr": {
+   "0": {
+    "cos": 0.7566024445956573,
+    "mse": 0.0063944466987159105
+   },
+   "5": {
+    "cos": 0.8714750450849533,
+    "mse": 0.004172216270584613
+   },
+   "10": {
+    "cos": 0.9123313600271941,
+    "mse": 0.003467886578524485
+   },
+   "15": {
+    "cos": 0.9431116962432862,
+    "mse": 0.002887097867205739
+   },
+   "20": {
+    "cos": 0.9531054661273957,
+    "mse": 0.002762469650944695
+   },
+   "25": {
+    "cos": 0.9579436681270599,
+    "mse": 0.0026892934129573404
+   },
+   "30": {
+    "cos": 0.9595861222743988,
+    "mse": 0.0026592298224568365
+   }
+  }
+ },
+ "mamlP_U5_K4": {
+  "U": 5,
+  "K": 4,
+  "train_s": 5819.801905632019,
+  "snr": {
+   "0": {
+    "cos": 0.7050216964315623,
+    "mse": 0.008047915536677466
+   },
+   "5": {
+    "cos": 0.8337775056660175,
+    "mse": 0.00538398580555804
+   },
+   "10": {
+    "cos": 0.8850797078460455,
+    "mse": 0.004388278966536745
+   },
+   "15": {
+    "cos": 0.9219333533644676,
+    "mse": 0.0036538032251410184
+   },
+   "20": {
+    "cos": 0.9351386456489563,
+    "mse": 0.003277393272612244
+   },
+   "25": {
+    "cos": 0.9412116003036499,
+    "mse": 0.003101464889012277
+   },
+   "30": {
+    "cos": 0.9433053629398346,
+    "mse": 0.0030744528616778555
+   }
+  }
+ },
+ "mamlP_U6_K4": {
+  "U": 6,
+  "K": 4,
+  "train_s": 6192.80019235611,
+  "snr": {
+   "0": {
+    "cos": 0.6876412417516112,
+    "mse": 0.008159141696058215
+   },
+   "5": {
+    "cos": 0.819275195479393,
+    "mse": 0.005689024343388155
+   },
+   "10": {
+    "cos": 0.8724823503941298,
+    "mse": 0.004490903354482725
+   },
+   "15": {
+    "cos": 0.9126055588126183,
+    "mse": 0.003712299307342619
+   },
+   "20": {
+    "cos": 0.9261461035013199,
+    "mse": 0.0033560030788648875
+   },
+   "25": {
+    "cos": 0.9330184719562531,
+    "mse": 0.0032503474755212662
+   },
+   "30": {
+    "cos": 0.9347505280971528,
+    "mse": 0.003245274756103754
+   }
+  }
+ },
+ "mamlR_U4_K4": {
+  "U": 4,
+  "K": 4,
+  "train_s": 5354.718959569931,
+  "snr": {
+   "0": {
+    "cos": 0.7151452112868428,
+    "mse": 0.005541059164330364
+   },
+   "5": {
+    "cos": 0.8414680245518684,
+    "mse": 0.0062078876094892625
+   },
+   "10": {
+    "cos": 0.8914026174843311,
+    "mse": 0.006805360369384289
+   },
+   "15": {
+    "cos": 0.9260668660402298,
+    "mse": 0.007245949216187
+   },
+   "20": {
+    "cos": 0.9384899387359619,
+    "mse": 0.0074955790508538485
+   },
+   "25": {
+    "cos": 0.9446654134988784,
+    "mse": 0.007596960405819118
+   },
+   "30": {
+    "cos": 0.9462161396741867,
+    "mse": 0.007674253049306572
+   }
+  },
+  "probe_acc": {
+   "0": 0.7509999871253967,
+   "5": 0.7875000238418579,
+   "10": 0.8324999809265137,
+   "15": 0.8184999823570251,
+   "20": 0.8335000276565552,
+   "25": 0.8389999866485596,
+   "30": 0.8395000100135803
+  }
+ },
+ "mamlP_U4_K4": {
+  "U": 4,
+  "K": 4,
+  "train_s": 5796.766438961029,
+  "snr": {
+   "0": {
+    "cos": 0.7272935093110428,
+    "mse": 0.006946617619832978
+   },
+   "5": {
+    "cos": 0.8484958949685096,
+    "mse": 0.004622220577439293
+   },
+   "10": {
+    "cos": 0.8977697676718235,
+    "mse": 0.0038188065083231775
+   },
+   "15": {
+    "cos": 0.9313238598108292,
+    "mse": 0.0032185151416342706
+   },
+   "20": {
+    "cos": 0.9433529702425003,
+    "mse": 0.0029843107901979236
+   },
+   "25": {
+    "cos": 0.9491406964063644,
+    "mse": 0.002911557617597282
+   },
+   "30": {
+    "cos": 0.9507425274848939,
+    "mse": 0.002883736375719309
+   }
+  },
+  "probe_acc": {
+   "0": 0.753000020980835,
+   "5": 0.8054999709129333,
+   "10": 0.8395000100135803,
+   "15": 0.8320000171661377,
+   "20": 0.8385000228881836,
+   "25": 0.8500000238418579,
+   "30": 0.8475000262260437
+  },
+  "lat_gpu_ms": 1.7452812194824219,
+  "params": 4759296
+ }
+}

fig_cl/cl_results_maml2.json

@@ -0,0 +1,142 @@
+{
+ "mamlK_U4_K1": {
+  "U": 4,
+  "K": 1,
+  "train_s": 5965.1762001514435,
+  "snr": {
+   "0": {
+    "cos": 0.5903875235728919,
+    "mse": 0.006068825869821012
+   },
+   "5": {
+    "cos": 0.7422410520464182,
+    "mse": 0.003918564808322117
+   },
+   "10": {
+    "cos": 0.8164008051753044,
+    "mse": 0.0027814168038312347
+   },
+   "15": {
+    "cos": 0.8704769560098649,
+    "mse": 0.002142983589321375
+   },
+   "20": {
+    "cos": 0.8900961854457855,
+    "mse": 0.0018683849333319812
+   },
+   "25": {
+    "cos": 0.9010164388418198,
+    "mse": 0.0017202156076673418
+   },
+   "30": {
+    "cos": 0.9042909728288651,
+    "mse": 0.0016732445545494556
+   }
+  }
+ },
+ "mamlK_U4_K2": {
+  "U": 4,
+  "K": 2,
+  "train_s": 5568.518344163895,
+  "snr": {
+   "0": {
+    "cos": 0.6585480758547783,
+    "mse": 0.00562618494220078
+   },
+   "5": {
+    "cos": 0.8004514102339745,
+    "mse": 0.004138905008789152
+   },
+   "10": {
+    "cos": 0.8616232509315014,
+    "mse": 0.0032424702036660162
+   },
+   "15": {
+    "cos": 0.9067922315597534,
+    "mse": 0.002654184835962951
+   },
+   "20": {
+    "cos": 0.9229051151275635,
+    "mse": 0.0024960036822594704
+   },
+   "25": {
+    "cos": 0.93115289914608,
+    "mse": 0.002353294101310894
+   },
+   "30": {
+    "cos": 0.9336031366586686,
+    "mse": 0.0023293261982034893
+   }
+  }
+ },
+ "mamlK_U4_K8": {
+  "U": 4,
+  "K": 8,
+  "train_s": 5635.996988534927,
+  "snr": {
+   "0": {
+    "cos": 0.7966103934645653,
+    "mse": 0.007616082121618092
+   },
+   "5": {
+    "cos": 0.8945015166401863,
+    "mse": 0.004124689696356655
+   },
+   "10": {
+    "cos": 0.9269100804030895,
+    "mse": 0.003506762736942619
+   },
+   "15": {
+    "cos": 0.9509689708948136,
+    "mse": 0.0027781075756065548
+   },
+   "20": {
+    "cos": 0.959079176902771,
+    "mse": 0.00257474225317128
+   },
+   "25": {
+    "cos": 0.9628741838932038,
+    "mse": 0.0025569569268263878
+   },
+   "30": {
+    "cos": 0.9636240524053573,
+    "mse": 0.002519237624946982
+   }
+  }
+ },
+ "mamlD_U4_K4": {
+  "U": 4,
+  "K": 4,
+  "train_s": 5619.015917301178,
+  "snr": {
+   "0": {
+    "cos": 0.7611450293697417,
+    "mse": 0.006763041405472904
+   },
+   "5": {
+    "cos": 0.8720456777811051,
+    "mse": 0.00445777553319931
+   },
+   "10": {
+    "cos": 0.9139666106104851,
+    "mse": 0.0036739176262635736
+   },
+   "15": {
+    "cos": 0.9426191251277923,
+    "mse": 0.00309066718025133
+   },
+   "20": {
+    "cos": 0.9524768965244294,
+    "mse": 0.0028845382735598834
+   },
+   "25": {
+    "cos": 0.9571917120218277,
+    "mse": 0.002803497422719374
+   },
+   "30": {
+    "cos": 0.9582184610366822,
+    "mse": 0.002791161079891026
+   }
+  }
+ }
+}

fig_cl/cl_results_todma_u.json

@@ -0,0 +1,152 @@
+{
+ "todma_U1_T24_L128": {
+  "0": {
+   "cos": 0.8074489551107399,
+   "token_err": 0.14848412508952016
+  },
+  "5": {
+   "cos": 0.8736505889799446,
+   "token_err": 0.0687116564417178
+  },
+  "10": {
+   "cos": 0.9246965700667351,
+   "token_err": 0.010946241790318657
+  },
+  "15": {
+   "cos": 0.9398762492835522,
+   "token_err": 0.006066734074823054
+  },
+  "20": {
+   "cos": 0.9469921693205834,
+   "token_err": 0.0009987515605493133
+  },
+  "25": {
+   "cos": 0.9429717653989792,
+   "token_err": 0.0
+  },
+  "30": {
+   "cos": 0.9374454534053802,
+   "token_err": 0.0
+  }
+ },
+ "todma_U2_T24_L128": {
+  "0": {
+   "cos": 0.7007968422397971,
+   "token_err": 0.2686438592173271
+  },
+  "5": {
+   "cos": 0.8507629196345806,
+   "token_err": 0.1031242062484125
+  },
+  "10": {
+   "cos": 0.8946104854345321,
+   "token_err": 0.048921749845964264
+  },
+  "15": {
+   "cos": 0.931503138691187,
+   "token_err": 0.010676156583629894
+  },
+  "20": {
+   "cos": 0.9400034978985786,
+   "token_err": 0.0031005829095870022
+  },
+  "25": {
+   "cos": 0.9471021571755409,
+   "token_err": 0.0013839959738298944
+  },
+  "30": {
+   "cos": 0.9430845794081688,
+   "token_err": 0.0003755633450175263
+  }
+ },
+ "todma_U3_T24_L128": {
+  "0": {
+   "cos": 0.5810406875486175,
+   "token_err": 0.3917525773195876
+  },
+  "5": {
+   "cos": 0.8211166375875473,
+   "token_err": 0.13069732814955745
+  },
+  "10": {
+   "cos": 0.8936332259575526,
+   "token_err": 0.047603305785123964
+  },
+  "15": {
+   "cos": 0.923269739151001,
+   "token_err": 0.02220045706823376
+  },
+  "20": {
+   "cos": 0.9388238374392192,
+   "token_err": 0.003470787538219982
+  },
+  "25": {
+   "cos": 0.9452669457594554,
+   "token_err": 8.306337735692334e-05
+  },
+  "30": {
+   "cos": 0.9416227678457896,
+   "token_err": 8.228420966016621e-05
+  }
+ },
+ "todma_U5_T24_L128": {
+  "0": {
+   "cos": 0.42701429841667415,
+   "token_err": 0.5537061371489755
+  },
+  "5": {
+   "cos": 0.7187287476658821,
+   "token_err": 0.2355310262529833
+  },
+  "10": {
+   "cos": 0.8738067576885223,
+   "token_err": 0.08148368836585729
+  },
+  "15": {
+   "cos": 0.9239599657058716,
+   "token_err": 0.021345568799561117
+  },
+  "20": {
+   "cos": 0.9326754882335663,
+   "token_err": 0.007691549156887881
+  },
+  "25": {
+   "cos": 0.9385586471557618,
+   "token_err": 0.005969412925505673
+  },
+  "30": {
+   "cos": 0.9386945986747741,
+   "token_err": 0.0015876953609526173
+  }
+ },
+ "todma_U6_T24_L128": {
+  "0": {
+   "cos": 0.34397646331538756,
+   "token_err": 0.6302765647743813
+  },
+  "5": {
+   "cos": 0.6786150354146957,
+   "token_err": 0.2800496688741722
+  },
+  "10": {
+   "cos": 0.8405428379774094,
+   "token_err": 0.10923335657738217
+  },
+  "15": {
+   "cos": 0.9074154017368953,
+   "token_err": 0.0349873293550233
+  },
+  "20": {
+   "cos": 0.9348968795935313,
+   "token_err": 0.008653014133256417
+  },
+  "25": {
+   "cos": 0.9384897446632385,
+   "token_err": 0.008099842962228283
+  },
+  "30": {
+   "cos": 0.9415062765280405,
+   "token_err": 0.0011555922410235245
+  }
+ }
+}

probe_vs_cosine.py

@@ -0,0 +1,92 @@
+# probe_vs_cosine.py - supplementary analysis for the letter.
+#
+# Scatter of downstream probe accuracy (AG News topic classification,
+# linear probe trained on clean training-pool embeddings) against the
+# cosine similarity of the recovered embeddings, across schemes and
+# SNRs, with the Pearson correlation. Shows that the cosine metric used
+# in the letter is consistent with downstream perception.
+import json
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.size': 14, 'axes.linewidth': 1.2})
+
+with open("fig_cl/cl_results.json") as f:
+    RJ = json.load(f)
+with open("fig_cl/cl_results_maml.json") as f:
+    RM = json.load(f)
+
+SNRS = ["0", "5", "10", "15", "20", "25", "30"]
+
+# (label, cos-source, acc-source, marker, color)
+def sweep_pairs(entry, todma=False):
+    cos, acc = [], []
+    for s in SNRS:
+        a = entry.get("probe_acc", {}).get(s)
+        if a is None:
+            continue
+        c = entry[s]["cos"] if todma else entry["snr"][s]["cos"]
+        cos.append(c)
+        acc.append(a)
+    return cos, acc
+
+
+SCHEMES = [
+    ("Proposed (MAML)", RM["mamlP_U4_K4"], False, "v", "#d62728"),
+    ("Training w/o MAML [5]", RJ["prop_U4_K4"], False, "x", "#8c564b"),
+    ("Random-projection mask (MAML)", RM["mamlR_U4_K4"], False, "s",
+     "#984ea3"),
+    ("Conventional orthogonal (MAML)", RM["mamlB_U1_K1"], False, "o",
+     "#1a1a1a"),
+    ("Conventional orthogonal (joint)", RJ["baseline_U1_K1"], False, "P",
+     "#7f7f7f"),
+    ("Random-projection mask (joint)", RJ["randmask_U4_K4"], False, "D",
+     "#c994c7"),
+    ("ToDMA 24x128", RJ["todma_T24_L128"], True, "^", "#4393c3"),
+]
+
+all_cos, all_acc = [], []
+fig = plt.figure(figsize=(7.0, 5.4))
+ax = fig.add_axes([0.12, 0.12, 0.83, 0.83])
+for lab, entry, todma, mk, col in SCHEMES:
+    cos, acc = sweep_pairs(entry, todma)
+    ax.scatter(cos, acc, marker=mk, s=70, color=col, label=lab,
+               zorder=3, alpha=0.9)
+    all_cos += cos
+    all_acc += acc
+
+all_cos = np.array(all_cos)
+all_acc = np.array(all_acc)
+r = np.corrcoef(all_cos, all_acc)[0, 1]
+b, a = np.polyfit(all_cos, all_acc, 1)
+xg = np.linspace(all_cos.min(), all_cos.max(), 50)
+ax.plot(xg, b * xg + a, color="#888888", linewidth=1.5, linestyle="--",
+        zorder=2, label=f"Linear fit (Pearson $r$={r:.3f})")
+clean = RM.get("probe_clean_acc", RJ.get("probe_clean_acc"))
+ax.axhline(clean, color="#bbbbbb", linewidth=1.2, linestyle=":",
+           zorder=1)
+ax.text(all_cos.min(), clean + 0.004,
+        f"Clean-embedding reference ({clean:.3f})", fontsize=11,
+        color="#888888")
+ax.set_xlabel("Cosine similarity of recovered embeddings", fontsize=15)
+ax.set_ylabel("Downstream probe accuracy", fontsize=15)
+ax.grid(True, alpha=0.3)
+ax.legend(fontsize=10.5, loc="lower right")
+fig.savefig("fig_cl/probe_vs_cosine.png", dpi=150)
+fig.savefig("fig_cl/probe_vs_cosine.pdf", dpi=200)
+print(f"Saved probe_vs_cosine.(png|pdf)  Pearson r = {r:.4f} "
+      f"over {len(all_cos)} scheme-SNR points")
+
+# Markdown table for the repository README
+print("\n| Scheme | CosSim 5 dB | Acc 5 dB | CosSim 20 dB | Acc 20 dB |")
+print("|---|---|---|---|---|")
+for lab, entry, todma, _, _ in SCHEMES:
+    def get(s):
+        c = entry[s]["cos"] if todma else entry["snr"][s]["cos"]
+        return c, entry.get("probe_acc", {}).get(s, float("nan"))
+    c5, a5 = get("5")
+    c20, a20 = get("20")
+    print(f"| {lab} | {c5:.3f} | {a5:.3f} | {c20:.3f} | {a20:.3f} |")
+
+

replot_cl.py

@@ -0,0 +1,183 @@
+# Plot CL-letter figures from fig_cl/cl_results*.json
+#
+# Geometry rule (paper_requirement): every result figure uses the same
+# fixed canvas and the same 8:6 axes box, and no tight bounding box is
+# applied at save time. Scheme names avoid the banned word "baseline".
+#
+# Figure set (single large graph per figure):
+#   Fig. 2 (cl_fig_mux.pdf)   : one SNR sweep merging the load sweep
+#                               (conventional + proposed U=1..4) and the
+#                               matched-budget comparison (random mask,
+#                               ToDMA x2) at U=4.
+#   Fig. 3 (cl_fig_agg.pdf)   : aggregate fidelity bars for U=1..6 with
+#                               per-user CosSim and the fully loaded
+#                               orthogonal reference.
+import json
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.size': 15, 'axes.linewidth': 1.2})
+
+with open("fig_cl/cl_results.json") as f:
+    R = json.load(f)
+# MAML-trained results (reported default protocol) overlay the joint
+# runs: every reported transceiver key is remapped to its MAML twin.
+with open("fig_cl/cl_results_maml.json") as f:
+    R.update(json.load(f))
+try:
+    with open("fig_cl/cl_results_maml2.json") as f:
+        R.update(json.load(f))
+except FileNotFoundError:
+    pass
+KEYMAP = {
+    "baseline_U1_K1": "mamlB_U1_K1",
+    "prop_U1_K4": "mamlP_U1_K4", "prop_U2_K4": "mamlP_U2_K4",
+    "prop_U3_K4": "mamlP_U3_K4", "prop_U4_K4": "mamlP_U4_K4",
+    "prop_U5_K4": "mamlP_U5_K4", "prop_U6_K4": "mamlP_U6_K4",
+    "randmask_U4_K4": "mamlR_U4_K4",
+    "ksweep_U4_K1": "mamlK_U4_K1", "ksweep_U4_K2": "mamlK_U4_K2",
+    "ksweep_U4_K8": "mamlK_U4_K8",
+}
+# Preserve the joint-trained runs before remapping: they appear in the
+# figures as the joint-training ablation (same architecture, no MAML).
+JOINT = {k: R[k] for k in list(KEYMAP.keys()) if k in R}
+for old, new in KEYMAP.items():
+    if new in R:
+        R[old] = R[new]
+
+SNRS = [0, 5, 10, 15, 20, 25, 30]
+
+# Single-graph geometry shared by both result figures: canvas
+# 7.5 x 5.55 in, axes box 6.0 x 4.5 in (exactly 8:6).
+FIGSIZE = (7.5, 5.55)
+AX_RECT = [0.105, 0.115, 0.77, 0.7804]
+
+
+def one_panel():
+    fig = plt.figure(figsize=FIGSIZE)
+    return fig, fig.add_axes(AX_RECT)
+
+
+def cos_curve(key):
+    return [R[key]["snr"][str(s)]["cos"] for s in SNRS]
+
+
+# ============================================================
+# Fig 2: merged SNR sweep (load sweep + matched-budget comparison)
+# ============================================================
+fig, ax = one_panel()
+
+curves = [
+    ("prop_U1_K4", "Proposed $U$=1", "s", "-", "#1a9641", 2),
+    ("prop_U2_K4", "Proposed $U$=2", "^", "-", "#2166ac", 2),
+    ("prop_U3_K4", "Proposed $U$=3", "D", "-", "#d95f02", 2),
+    ("prop_U4_K4", "Proposed $U$=4", "v", "-", "#d62728", 2.5),
+    ("JOINT:prop_U4_K4", "Training w/o MAML [5]", "x",
+     (0, (5, 2)), "#8c564b", 2),
+    ("baseline_U1_K1", "Conventional orthogonal", "o", "--", "#1a1a1a", 2),
+    ("randmask_U4_K4", "Random-projection mask", "s", "-.", "#984ea3", 2),
+    ("todma_T24_L128", "ToDMA $24\\times128$", "^", ":",
+     "#4393c3", 2),
+    ("todma_T16_L192", "ToDMA $16\\times192$", "D", ":",
+     "#92c5de", 2),
+]
+for key, lab, mk, ls, col, lw in curves:
+    if key.startswith("todma"):
+        vals = [R[key][str(s)]["cos"] for s in SNRS]
+    elif key.startswith("JOINT:"):
+        vals = [JOINT[key[6:]]["snr"][str(s)]["cos"] for s in SNRS]
+    else:
+        vals = cos_curve(key)
+    ax.plot(SNRS, vals, marker=mk, linestyle=ls, color=col,
+            linewidth=lw, markersize=8, label=lab)
+ax.set_xlabel("SNR (dB)", fontsize=17)
+ax.set_ylabel("Cosine Similarity", fontsize=17)
+ax.set_ylim([0.45, 1.0])
+ax.legend(fontsize=12.5, loc="lower right", ncol=1)
+ax.grid(True, alpha=0.3)
+fig.savefig("fig_cl/cl_fig_mux.pdf", dpi=200)
+fig.savefig("fig_cl/cl_fig_mux.png", dpi=150)
+plt.close(fig)
+print("Saved cl_fig_mux.pdf")
+
+# ============================================================
+# Fig 3: aggregate fidelity across load (bars + per-user line)
+# ============================================================
+fig, ax2 = one_panel()
+
+from matplotlib.patches import Patch
+
+snr_show = "10"
+conv_cos = R["baseline_U1_K1"]["snr"][snr_show]["cos"]
+per_user = [R[f"prop_U{U}_K4"]["snr"][snr_show]["cos"] for U in range(1, 7)]
+joint_pu = [JOINT[f"prop_U{U}_K4"]["snr"][snr_show]["cos"]
+            for U in range(1, 7)]
+thr = [U * c for U, c in zip(range(1, 7), per_user)]
+thr_j = [U * c for U, c in zip(range(1, 7), joint_pu)]
+xs = np.arange(1, 7)
+# Single color per scheme so the bars match the legend patches.
+C_PROP = "#d62728"
+with open("fig_cl/cl_results_todma_u.json") as f:
+    RT = json.load(f)
+todma_pu = [RT[f"todma_U{U}_T24_L128"][snr_show]["cos"] if U != 4
+            else R["todma_T24_L128"][snr_show]["cos"] for U in range(1, 7)]
+thr_t = [U * c for U, c in zip(range(1, 7), todma_pu)]
+ax2.bar([0], [conv_cos], width=0.55, color="#1a1a1a", alpha=0.85)
+ax2.text(0, conv_cos + 0.08, f"{conv_cos:.2f}", ha="center",
+         va="bottom", fontsize=12)
+ax2.bar(xs - 0.27, thr, width=0.26, color=C_PROP, alpha=0.9)
+ax2.bar(xs, thr_j, width=0.26, color=C_PROP, alpha=0.4,
+        hatch="//", edgecolor="#555555", linewidth=0.5)
+ax2.bar(xs + 0.27, thr_t, width=0.26, color="#4393c3", alpha=0.75,
+        hatch="..", edgecolor="#1f5f8b", linewidth=0.5)
+for x, val in zip(xs, thr):
+    ax2.text(x - 0.27, val + 0.08, f"{val:.2f}", ha="center",
+             va="bottom", fontsize=11)
+# Fully loaded orthogonal aggregate (4 blocks x 768 uses = same budget)
+ax2.axhline(4 * conv_cos, linestyle="-.", color="#555555", linewidth=2)
+ax2.text(-0.45, 4 * conv_cos + 0.13, "Fully loaded orthogonal",
+         fontsize=12.5, color="#555555")
+ax2.set_xticks([0] + list(xs))
+ax2.set_xticklabels(["Conv.\n$U$=1"] + [f"Multi.\n$U$={U}"
+                    for U in range(1, 7)], fontsize=12)
+ax2.set_ylabel(r"Aggregate fidelity ($U \!\cdot\! \mathrm{CosSim}$)",
+               fontsize=16)
+ax2.grid(True, alpha=0.3, axis="y")
+ax2.set_ylim([0, max(thr) * 1.22])
+handles = [Patch(facecolor=C_PROP, alpha=0.9, label="Proposed"),
+           Patch(facecolor=C_PROP, alpha=0.4, hatch="//",
+                 edgecolor="#555555", label="Training w/o MAML [5]"),
+           Patch(facecolor="#4393c3", alpha=0.75, hatch="..",
+                 edgecolor="#1f5f8b", label="ToDMA $24\\times128$")]
+ax2.legend(handles=handles, fontsize=11, loc="center left",
+           bbox_to_anchor=(0.02, 0.44))
+fig.savefig("fig_cl/cl_fig_agg.pdf", dpi=200)
+fig.savefig("fig_cl/cl_fig_agg.png", dpi=150)
+plt.close(fig)
+print("Saved cl_fig_agg.pdf")
+
+# ============================================================
+# Print the numbers quoted in the letter
+# ============================================================
+print("\n===== NUMBERS FOR TEXT (MAML default, held-out) =====")
+print("conv per-user@20:", round(conv_cos, 3),
+      " fully loaded aggregate:", round(4 * conv_cos, 2))
+for U in range(1, 7):
+    v = R[f"prop_U{U}_K4"]["snr"]["20"]["cos"]
+    print(f"U={U}: per-user {v:.3f} aggregate {U*v:.2f}")
+print("overload ratio:",
+      round(6 * R["prop_U6_K4"]["snr"]["20"]["cos"] / (4 * conv_cos), 2))
+print("randmask@20:", round(R["randmask_U4_K4"]["snr"]["20"]["cos"], 3))
+for s in ["0", "5", "15", "20", "30"]:
+    print(f"todma24@{s}: {R['todma_T24_L128'][s]['cos']:.3f} "
+          f"prop@{s}: {R['prop_U4_K4']['snr'][s]['cos']:.3f}")
+for k in ["ksweep_U4_K1", "ksweep_U4_K2", "prop_U4_K4", "ksweep_U4_K8"]:
+    print(k, "0dB:", round(R[k]["snr"]["0"]["cos"], 3),
+          "20dB:", round(R[k]["snr"]["20"]["cos"], 3))
+if "mamlD_U4_K4" in R:
+    print("distil(MAML)@20:", round(R["mamlD_U4_K4"]["snr"]["20"]["cos"], 3))
+
+
+
+