Add real model tensor source selection to experiment tabs

app.py

@@ -9,6 +9,7 @@ Patent: UK Application No. 2607132.4, GB2608127.3
 Copyright 2026 Ryan Gillespie / Optitransfer
 """
 
+import os
 import gradio as gr
 import numpy as np
 import time
@@ -18,10 +19,154 @@ from collections import defaultdict
 
 from crdt_merge.model import CRDTMergeState
 
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+
 ALL_STRATEGIES = sorted(CRDTMergeState.KNOWN_STRATEGIES)
 BASE_REQUIRED = CRDTMergeState.BASE_REQUIRED
 NO_BASE_STRATEGIES = sorted(set(ALL_STRATEGIES) - BASE_REQUIRED)
 
+# Architecture-compatible model families for real-weight experiments.
+# Models in the same family share hidden dimensions and can be meaningfully merged.
+MODEL_SOURCES = {
+    "Random (synthetic)": {"models": [], "hidden": 0},
+    "BERT Tiny (128d, 4.4M)": {
+        "models": ["prajjwal1/bert-tiny", "M-FAC/bert-tiny-finetuned-sst2"],
+        "hidden": 128,
+    },
+    "BERT Mini (256d, 11M)": {
+        "models": ["prajjwal1/bert-mini", "M-FAC/bert-mini-finetuned-sst2"],
+        "hidden": 256,
+    },
+    "BERT Small (512d, 29M)": {
+        "models": ["prajjwal1/bert-small", "M-FAC/bert-small-finetuned-sst2"],
+        "hidden": 512,
+    },
+    "BERT Base Uncased (768d, 110M)": {
+        "models": [
+            "google-bert/bert-base-uncased",
+            "textattack/bert-base-uncased-SST-2",
+            "fabriceyhc/bert-base-uncased-ag_news",
+            "nlptown/bert-base-multilingual-uncased-sentiment",
+        ],
+        "hidden": 768,
+    },
+    "DistilBERT Base (768d, 66M)": {
+        "models": [
+            "distilbert/distilbert-base-uncased",
+            "distilbert/distilbert-base-uncased-finetuned-sst-2-english",
+            "distilbert/distilbert-base-cased",
+        ],
+        "hidden": 768,
+    },
+    "GPT-2 Base (768d, 124M)": {
+        "models": [
+            "openai-community/gpt2",
+            "distilbert/distilgpt2",
+        ],
+        "hidden": 768,
+    },
+    "MiniLM-L6 (384d, 22M)": {
+        "models": [
+            "sentence-transformers/all-MiniLM-L6-v2",
+            "nreimers/MiniLM-L6-H384-uncased",
+            "sentence-transformers/paraphrase-MiniLM-L6-v2",
+        ],
+        "hidden": 384,
+    },
+    "RoBERTa Base (768d, 125M)": {
+        "models": [
+            "FacebookAI/roberta-base",
+            "cardiffnlp/twitter-roberta-base-sentiment-latest",
+            "SamLowe/roberta-base-go_emotions",
+        ],
+        "hidden": 768,
+    },
+    "MPNet Base (768d, 109M)": {
+        "models": [
+            "sentence-transformers/all-mpnet-base-v2",
+            "sentence-transformers/paraphrase-mpnet-base-v2",
+        ],
+        "hidden": 768,
+    },
+    "T5 Small (512d, 60M)": {
+        "models": [
+            "google-t5/t5-small",
+            "mrm8488/t5-small-finetuned-quora-for-paraphrasing",
+        ],
+        "hidden": 512,
+    },
+    "BLOOM 560M (1024d)": {
+        "models": ["bigscience/bloom-560m", "bigscience/bloomz-560m"],
+        "hidden": 1024,
+    },
+    "ALBERT Base (768d, 12M)": {
+        "models": ["albert/albert-base-v2", "textattack/albert-base-v2-SST-2"],
+        "hidden": 768,
+    },
+    "XLM-RoBERTa Base (768d, 278M)": {
+        "models": [
+            "FacebookAI/xlm-roberta-base",
+            "cardiffnlp/twitter-xlm-roberta-base-sentiment-multilingual",
+        ],
+        "hidden": 768,
+    },
+}
+
+MODEL_SOURCE_NAMES = list(MODEL_SOURCES.keys())
+
+# Cache to avoid re-downloading the same model
+_weight_cache = {}
+
+
+def _load_model_tensor(model_id: str, target_shape: tuple):
+    """Load a 2D weight tensor from a HF model, sliced to target_shape."""
+    cache_key = (model_id, target_shape)
+    if cache_key in _weight_cache:
+        return _weight_cache[cache_key]
+    try:
+        from crdt_merge.hub.hf import HFMergeHub
+        hub = HFMergeHub(token=HF_TOKEN)
+        sd = hub.pull_weights(model_id)
+        for k, v in sd.items():
+            arr = np.array(v, dtype=np.float64) if not hasattr(v, 'astype') else v.astype(np.float64)
+            if arr.ndim == 2 and arr.shape[0] >= target_shape[0] and arr.shape[1] >= target_shape[1]:
+                result = arr[:target_shape[0], :target_shape[1]].copy()
+                _weight_cache[cache_key] = result
+                return result
+    except Exception:
+        pass
+    return None
+
+
+def _get_tensors(n_nodes, tensor_dim, model_source, seed):
+    """Return (base, tensors_list, source_label) using real or synthetic weights."""
+    shape = (tensor_dim, tensor_dim)
+    rng = np.random.RandomState(seed)
+    family = MODEL_SOURCES.get(model_source, MODEL_SOURCES["Random (synthetic)"])
+    model_list = family.get("models", [])
+
+    base_tensor = None
+    source_label = "synthetic"
+
+    if model_list and HF_TOKEN:
+        base_tensor = _load_model_tensor(model_list[0], shape)
+        if base_tensor is not None:
+            source_label = f"{model_list[0]} (HF safetensors)"
+
+    if base_tensor is None:
+        base = rng.randn(*shape).astype(np.float64)
+        tensors = [rng.randn(*shape).astype(np.float64) for _ in range(n_nodes)]
+    else:
+        base = base_tensor
+        tensors = []
+        for i in range(n_nodes):
+            node_rng = np.random.RandomState(seed + i + 1)
+            t = base + node_rng.randn(*shape).astype(np.float64) * 0.05
+            tensors.append(t)
+        source_label += f" + {n_nodes} node perturbations"
+
+    return base, tensors, source_label
+
 
 def _make_state(strategy, base=None):
     """Create a CRDTMergeState, providing base if the strategy requires it."""
@@ -32,13 +177,12 @@ def _make_state(strategy, base=None):
 
 # ===== Experiment 1: Multi-Node Convergence =====
 
-def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings=5, seed=42):
+def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings=5, seed=42, model_source="Random (synthetic)"):
     n_nodes, tensor_dim, n_random_orderings, seed = int(n_nodes), int(tensor_dim), int(n_random_orderings), int(seed)
     np.random.seed(seed)
     shape = (tensor_dim, tensor_dim)
     total_params = tensor_dim * tensor_dim * n_nodes
-    base = np.random.randn(*shape).astype(np.float64)
-    tensors = [np.random.randn(*shape).astype(np.float64) for _ in range(n_nodes)]
+    base, tensors, src_label = _get_tensors(n_nodes, tensor_dim, model_source, seed)
 
     log = []
     log.append(f"{'='*72}")
@@ -46,6 +190,7 @@ def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings
     log.append(f"{'='*72}")
     log.append(f"  Nodes: {n_nodes}  |  Tensor: {shape}  |  Params: {total_params:,}")
     log.append(f"  Strategy: {strategy}  |  Orderings: {n_random_orderings}")
+    log.append(f"  Tensor source: {src_label}")
     log.append(f"{'='*72}\n")
 
     all_resolved, all_hashes, ordering_times = [], [], []
@@ -173,18 +318,18 @@ def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings
 
 # ===== Experiment 2: Network Partition & Healing =====
 
-def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed=42):
+def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed=42, model_source="Random (synthetic)"):
     n_nodes, tensor_dim, n_partitions, seed = int(n_nodes), int(tensor_dim), int(n_partitions), int(seed)
     np.random.seed(seed)
     shape = (tensor_dim, tensor_dim)
-    base = np.random.randn(*shape).astype(np.float64)
-    tensors = [np.random.randn(*shape).astype(np.float64) for _ in range(n_nodes)]
+    base, tensors, src_label = _get_tensors(n_nodes, tensor_dim, model_source, seed)
 
     log = []
     log.append(f"{'='*72}")
     log.append(f"  NETWORK PARTITION & HEALING EXPERIMENT")
     log.append(f"{'='*72}")
     log.append(f"  Nodes: {n_nodes}  |  Partitions: {n_partitions}  |  Strategy: {strategy}")
+    log.append(f"  Tensor source: {src_label}")
     log.append(f"{'='*72}\n")
 
     nodes = []
@@ -359,12 +504,11 @@ def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed
 
 SLOW_STRATEGIES = {"evolutionary_merge", "genetic_merge"}
 
-def run_strategy_sweep(n_nodes, tensor_dim, seed=42, skip_slow=True, progress=gr.Progress()):
+def run_strategy_sweep(n_nodes, tensor_dim, seed=42, skip_slow=True, model_source="Random (synthetic)", progress=gr.Progress()):
     n_nodes, tensor_dim, seed = int(n_nodes), int(tensor_dim), int(seed)
     np.random.seed(seed)
     shape = (tensor_dim, tensor_dim)
-    base = np.random.randn(*shape).astype(np.float64)
-    tensors = [np.random.randn(*shape).astype(np.float64) for _ in range(n_nodes)]
+    base, tensors, src_label = _get_tensors(n_nodes, tensor_dim, model_source, seed)
 
     strategies = ALL_STRATEGIES
     if skip_slow:
@@ -378,6 +522,7 @@ def run_strategy_sweep(n_nodes, tensor_dim, seed=42, skip_slow=True, progress=gr
     log.append(f"  CROSS-STRATEGY CONVERGENCE SWEEP — ALL 26 STRATEGIES")
     log.append(f"{'='*72}")
     log.append(f"  Nodes: {n_nodes}  |  Tensor: {shape}  |  Testing: {len(strategies)}/{len(ALL_STRATEGIES)}")
+    log.append(f"  Tensor source: {src_label}")
     if skipped:
         log.append(f"  Skipped (slow): {', '.join(skipped)}")
     log.append(f"{'='*72}\n")
@@ -491,17 +636,18 @@ def run_strategy_sweep(n_nodes, tensor_dim, seed=42, skip_slow=True, progress=gr
 
 # ===== Experiment 4: Scalability Benchmark =====
 
-def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, progress=gr.Progress()):
+def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, model_source="Random (synthetic)", progress=gr.Progress()):
     max_nodes, tensor_dim, seed = int(max_nodes), int(tensor_dim), int(seed)
     np.random.seed(seed)
     shape = (tensor_dim, tensor_dim)
-    base = np.random.randn(*shape).astype(np.float64)
+    base, all_tensors_init, src_label = _get_tensors(max_nodes, tensor_dim, model_source, seed)
 
     log = []
     log.append(f"{'='*72}")
     log.append(f"  SCALABILITY BENCHMARK")
     log.append(f"{'='*72}")
     log.append(f"  Max nodes: {max_nodes}  |  Tensor: {shape}  |  Strategy: {strategy}")
+    log.append(f"  Tensor source: {src_label}")
     log.append(f"{'='*72}\n")
 
     header = f"  {'Nodes':>6s}  {'Params':>12s}  {'Gossip':>10s}  {'Resolve':>10s}  {'Merges':>10s}  {'Conv':>5s}"
@@ -512,7 +658,7 @@ def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, progress=gr.Pr
     if max_nodes not in steps and max_nodes >= 2:
         steps.append(max_nodes); steps.sort()
 
-    all_tensors = [np.random.randn(*shape).astype(np.float64) for _ in range(max_nodes)]
+    all_tensors = all_tensors_init if len(all_tensors_init) >= max_nodes else [np.random.randn(*shape).astype(np.float64) for _ in range(max_nodes)]
     node_counts, gossip_times, resolve_times = [], [], []
 
     for si, n in enumerate(steps):
@@ -613,24 +759,24 @@ def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, progress=gr.Pr
 
 # ===== Full Suite =====
 
-def run_full_experiment(n_nodes, tensor_dim, strategy, n_orderings, n_partitions, seed, skip_slow, progress=gr.Progress()):
+def run_full_experiment(n_nodes, tensor_dim, strategy, n_orderings, n_partitions, seed, skip_slow, model_source="Random (synthetic)", progress=gr.Progress()):
     all_logs, summaries = [], {}
 
     progress(0.05, "Running multi-node convergence...")
-    l, s = run_convergence_experiment(n_nodes, tensor_dim, strategy, n_orderings, seed)
+    l, s = run_convergence_experiment(n_nodes, tensor_dim, strategy, n_orderings, seed, model_source)
     all_logs.append(l); summaries["convergence"] = json.loads(s)
 
     progress(0.30, "Running partition experiment...")
-    l, s = run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions, seed)
+    l, s = run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions, seed, model_source)
     all_logs.append(l); summaries["partition"] = json.loads(s)
 
     sweep_n = min(int(n_nodes), 10); sweep_d = min(int(tensor_dim), 64)
     progress(0.55, "Running strategy sweep (all 26)...")
-    l, s = run_strategy_sweep(sweep_n, sweep_d, seed, skip_slow)
+    l, s = run_strategy_sweep(sweep_n, sweep_d, seed, skip_slow, model_source)
     all_logs.append(l); summaries["strategy_sweep"] = json.loads(s)
 
     progress(0.80, "Running scalability benchmark...")
-    l, s = run_scale_benchmark(min(int(n_nodes), 50), sweep_d, strategy, seed)
+    l, s = run_scale_benchmark(min(int(n_nodes), 50), sweep_d, strategy, seed, model_source)
     all_logs.append(l); summaries["scalability"] = json.loads(s)
 
     progress(1.0, "Complete!")
@@ -742,9 +888,10 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
 
     with gr.Tabs():
         with gr.TabItem("Full Suite"):
-            gr.Markdown("### Run all four experiments — tests all 26 merge strategies")
+            gr.Markdown("### Run all four experiments -- tests all 26 merge strategies")
             with gr.Row():
                 with gr.Column(scale=1):
+                    model_src = gr.Dropdown(MODEL_SOURCE_NAMES, value="Random (synthetic)", label="Tensor Source (safetensors)")
                     n_nodes = gr.Slider(3, 100, 30, step=1, label="Nodes")
                     tensor_dim = gr.Slider(16, 512, 128, step=16, label="Tensor Dim (d x d)")
                     strategy = gr.Dropdown(ALL_STRATEGIES, value="weight_average", label="Primary Strategy")
@@ -756,12 +903,13 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
                 with gr.Column(scale=2):
                     out_log = gr.Textbox(label="Experiment Log", lines=35, max_lines=80)
                     out_json = gr.Textbox(label="JSON", lines=10, max_lines=40)
-            run_btn.click(run_full_experiment, [n_nodes, tensor_dim, strategy, n_orderings, n_partitions, seed, skip_slow], [out_log, out_json])
+            run_btn.click(run_full_experiment, [n_nodes, tensor_dim, strategy, n_orderings, n_partitions, seed, skip_slow, model_src], [out_log, out_json])
 
         with gr.TabItem("Convergence"):
-            gr.Markdown("### N nodes merge in different random orderings — all must produce identical results")
+            gr.Markdown("### N nodes merge in different random orderings -- all must produce identical results")
             with gr.Row():
                 with gr.Column(scale=1):
+                    c_src = gr.Dropdown(MODEL_SOURCE_NAMES, value="Random (synthetic)", label="Tensor Source (safetensors)")
                     c_n = gr.Slider(3, 100, 30, step=1, label="Nodes")
                     c_d = gr.Slider(16, 512, 128, step=16, label="Tensor Dim")
                     c_s = gr.Dropdown(ALL_STRATEGIES, value="slerp", label="Strategy")
@@ -771,12 +919,13 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
                 with gr.Column(scale=2):
                     c_log = gr.Textbox(label="Log", lines=30, max_lines=60)
                     c_json = gr.Textbox(label="JSON", lines=8)
-            c_btn.click(run_convergence_experiment, [c_n, c_d, c_s, c_o, c_seed], [c_log, c_json])
+            c_btn.click(run_convergence_experiment, [c_n, c_d, c_s, c_o, c_seed, c_src], [c_log, c_json])
 
         with gr.TabItem("Partition & Healing"):
             gr.Markdown("### Split nodes into isolated partitions, gossip internally, heal, verify convergence")
             with gr.Row():
                 with gr.Column(scale=1):
+                    p_src = gr.Dropdown(MODEL_SOURCE_NAMES, value="Random (synthetic)", label="Tensor Source (safetensors)")
                     p_n = gr.Slider(6, 100, 30, step=1, label="Nodes")
                     p_d = gr.Slider(16, 512, 128, step=16, label="Tensor Dim")
                     p_s = gr.Dropdown(ALL_STRATEGIES, value="ties", label="Strategy")
@@ -786,12 +935,13 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
                 with gr.Column(scale=2):
                     p_log = gr.Textbox(label="Log", lines=30, max_lines=60)
                     p_json = gr.Textbox(label="JSON", lines=8)
-            p_btn.click(run_partition_experiment, [p_n, p_d, p_s, p_p, p_seed], [p_log, p_json])
+            p_btn.click(run_partition_experiment, [p_n, p_d, p_s, p_p, p_seed, p_src], [p_log, p_json])
 
         with gr.TabItem("All 26 Strategies"):
-            gr.Markdown("### Every merge strategy tested for convergence — 13 base-free + 13 base-required")
+            gr.Markdown("### Every merge strategy tested for convergence -- 13 base-free + 13 base-required")
             with gr.Row():
                 with gr.Column(scale=1):
+                    sw_src = gr.Dropdown(MODEL_SOURCE_NAMES, value="Random (synthetic)", label="Tensor Source (safetensors)")
                     sw_n = gr.Slider(3, 30, 10, step=1, label="Nodes")
                     sw_d = gr.Slider(16, 256, 64, step=16, label="Tensor Dim")
                     sw_seed = gr.Number(42, label="Seed", precision=0)
@@ -800,12 +950,13 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
                 with gr.Column(scale=2):
                     sw_log = gr.Textbox(label="Log", lines=30, max_lines=60)
                     sw_json = gr.Textbox(label="JSON", lines=8)
-            sw_btn.click(run_strategy_sweep, [sw_n, sw_d, sw_seed, sw_skip], [sw_log, sw_json])
+            sw_btn.click(run_strategy_sweep, [sw_n, sw_d, sw_seed, sw_skip, sw_src], [sw_log, sw_json])
 
         with gr.TabItem("Scalability"):
             gr.Markdown("### Measure convergence overhead from 2 to N nodes")
             with gr.Row():
                 with gr.Column(scale=1):
+                    sc_src = gr.Dropdown(MODEL_SOURCE_NAMES, value="Random (synthetic)", label="Tensor Source (safetensors)")
                     sc_m = gr.Slider(10, 100, 50, step=5, label="Max Nodes")
                     sc_d = gr.Slider(16, 256, 64, step=16, label="Tensor Dim")
                     sc_s = gr.Dropdown(ALL_STRATEGIES, value="weight_average", label="Strategy")
@@ -814,7 +965,7 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
                 with gr.Column(scale=2):
                     sc_log = gr.Textbox(label="Log", lines=30, max_lines=60)
                     sc_json = gr.Textbox(label="JSON", lines=8)
-            sc_btn.click(run_scale_benchmark, [sc_m, sc_d, sc_s, sc_seed], [sc_log, sc_json])
+            sc_btn.click(run_scale_benchmark, [sc_m, sc_d, sc_s, sc_seed, sc_src], [sc_log, sc_json])
 
     gr.Markdown("---\n**crdt-merge** v0.9.5 | [GitHub](https://github.com/mgillr/crdt-merge) | [PyPI](https://pypi.org/project/crdt-merge/) | Built by Ryan Gillespie / Optitransfer | Patent: UK 2607132.4, GB2608127.3 | E4 Trust-Delta")