Project-Chronos 0.1.1__py3-none-any.whl

ui/presets.py

@@ -0,0 +1,194 @@
+"""
+ui/presets.py
+
+Default + preset configurations matching minimind's MoE defaults.
+
+Each preset is a complete dict that can be:
+  1. Loaded into the Config tab sliders via the "Load Preset" button.
+  2. Used as the initial value when the user clicks "Reset to MiniMind".
+  3. Persisted to / loaded from JSON via the Save/Load Config buttons.
+
+The single source of truth for the *minimind* preset is what
+``MiniMindConfig(use_moe=True)`` actually produces — we mirror those values
+here so the UI shows the same model the trainer would build.
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Dict, List
+
+
+# ── MiniMind MoE — exact defaults from model/model_minimind.py ─────
+# These values match MiniMindConfig(hidden_size=768, num_hidden_layers=8,
+# use_moe=True) field-for-field, with Chronos-specific extensions left at
+# their conservative defaults (no router-anchor by default).
+MINIMIND_MOE_DEFAULTS: Dict = {
+    # MiniMind core
+    "hidden_size":           768,
+    "num_hidden_layers":     8,
+    "num_attention_heads":   8,
+    "num_key_value_heads":   4,
+    "vocab_size":            6400,
+    "intermediate_size":     0,        # 0 = auto: ceil(H·π/64)·64 → 2432
+    "moe_intermediate_size": 0,        # 0 = auto, same value
+    "max_seq_len":           512,      # training sequence length (NOT max_position_embeddings)
+    "tie_word_embeddings":   True,
+
+    # MoE
+    "num_experts":           4,
+    "num_experts_per_tok":   2,        # M8c: top-2 doubles activated params at fixed total params
+    "num_shared_experts":    1,        # Chronos extension; minimind has no shared
+
+    # Attention shape (Chronos hybrid)
+    "kv_latent_dim":         64,
+    "rope_dim":              32,
+    "sliding_window_size":   2048,
+    "use_hybrid_attention":  True,
+
+    # Chronos prediction
+    "lookahead_steps":       2,
+
+    # Loss coefficients
+    "lambda_balance":        5e-4,
+    "lambda_temporal":       1e-3,
+    "lambda_lookahead":      0.1,
+    "lambda_router_anchor":  0.0,
+
+    # Hardware
+    "vram_budget_gb":             4.0,
+    "pinned_memory_max_fraction": 0.25,
+    "storage_format":             "safetensors",
+
+    # Training
+    "learning_rate":         5e-4,
+    "batch_size":            16,
+    "accumulation_steps":    8,
+    "epochs":                2,
+    "save_interval":         1000,
+    "save_dir":              "./out",
+    "dtype":                 "fp16",
+}
+
+
+# Order matches ui/tabs/config_tab.py::all_inputs (used by Apply-Preset
+# to push values back into the slider widgets in the right slots).
+CONFIG_INPUT_ORDER: List[str] = [
+    "hidden_size", "num_hidden_layers", "num_experts", "num_experts_per_tok",
+    "num_shared_experts", "lookahead_steps", "kv_latent_dim", "sliding_window_size",
+    "num_attention_heads", "num_key_value_heads", "rope_dim", "moe_intermediate_size",
+    "vocab_size", "dtype", "tie_word_embeddings",
+    "lambda_balance", "lambda_temporal", "lambda_lookahead", "lambda_router_anchor",
+    "vram_budget_gb", "pinned_memory_max_fraction", "use_hybrid_attention", "storage_format",
+    "learning_rate", "batch_size", "accumulation_steps", "max_seq_len",
+    "epochs", "save_interval", "save_dir",
+]
+
+
+# Named presets — keys are user-facing labels (also used in the dropdown).
+PRESETS: Dict[str, Dict] = {
+    "MiniMind-MoE (default)": dict(MINIMIND_MOE_DEFAULTS),
+
+    # M8c: "Recommended-CN" — sized for the /Users/Fona/Downloads/Hybrid_LLM/Dataset
+    # 1.3 GB pretrain corpus. Previously the default 15M-param model
+    # (H=256, L=4, E=4, topk=1 → ~6M activated) was far below the size
+    # needed for coherent Chinese output (empirically ~100M activated).
+    # This preset targets ~120M total / ~60M activated params at vocab=6400.
+    "Recommended-CN (≈120M)": {
+        **MINIMIND_MOE_DEFAULTS,
+        "hidden_size": 512, "num_hidden_layers": 8, "num_experts": 8,
+        "num_experts_per_tok": 2, "num_shared_experts": 1,
+        "num_attention_heads": 8, "num_key_value_heads": 2,
+        "kv_latent_dim": 64, "rope_dim": 32, "sliding_window_size": 2048,
+        "max_seq_len": 512, "batch_size": 8, "accumulation_steps": 8,
+        "epochs": 1, "save_interval": 500,
+        "learning_rate": 3e-4,
+    },
+
+    "Tiny (smoke / CI)": {
+        **MINIMIND_MOE_DEFAULTS,
+        "hidden_size": 128, "num_hidden_layers": 2, "num_experts": 4,
+        "num_attention_heads": 4, "num_key_value_heads": 4,
+        "kv_latent_dim": 16, "rope_dim": 8, "sliding_window_size": 64,
+        "max_seq_len": 64, "batch_size": 2, "accumulation_steps": 1,
+        "epochs": 1, "save_interval": 100,
+    },
+
+    "Small (256H × 4L × 4E)": {
+        **MINIMIND_MOE_DEFAULTS,
+        "hidden_size": 256, "num_hidden_layers": 4, "num_experts": 4,
+        "max_seq_len": 256, "batch_size": 8,
+    },
+
+    "Medium (512H × 8L × 8E)": {
+        **MINIMIND_MOE_DEFAULTS,
+        "hidden_size": 512, "num_experts": 8,
+        "max_seq_len": 1024, "batch_size": 8,
+    },
+
+    "Large (1024H × 16L × 16E)": {
+        **MINIMIND_MOE_DEFAULTS,
+        "hidden_size": 1024, "num_hidden_layers": 16, "num_experts": 16,
+        "num_attention_heads": 16, "num_key_value_heads": 4,
+        "kv_latent_dim": 128, "rope_dim": 64,
+        "max_seq_len": 2048, "batch_size": 4, "accumulation_steps": 16,
+        "vram_budget_gb": 16.0,
+    },
+}
+
+
+def preset_names() -> List[str]:
+    return list(PRESETS.keys())
+
+
+def get_preset(name: str) -> Dict:
+    """Return a deep-ish copy of the named preset (avoids accidental mutation)."""
+    return dict(PRESETS.get(name, MINIMIND_MOE_DEFAULTS))
+
+
+def values_in_input_order(cfg: Dict) -> List:
+    """Return preset values in the same order as Config tab's all_inputs.
+
+    For keys missing from `cfg`, falls back to MINIMIND_MOE_DEFAULTS. If a
+    value is ``None`` (missing in both), it is replaced by a safe-default
+    per field type so Gradio's slider/number widgets don't reject it.
+    """
+    # Hardcoded fallbacks for fields whose MiniMind default is None or absent.
+    # Values chosen to match the slider minima where applicable.
+    SAFE = {
+        "hidden_size": 768, "num_hidden_layers": 8,
+        "num_experts": 4, "num_experts_per_tok": 2, "num_shared_experts": 1,
+        "lookahead_steps": 2, "kv_latent_dim": 64, "sliding_window_size": 2048,
+        "num_attention_heads": 8, "num_key_value_heads": 4, "rope_dim": 32,
+        "moe_intermediate_size": 0, "vocab_size": 6400,
+        "dtype": "fp16", "tie_word_embeddings": True,
+        "lambda_balance": 5e-4, "lambda_temporal": 1e-3,
+        "lambda_lookahead": 0.1, "lambda_router_anchor": 0.0,
+        "vram_budget_gb": 4.0, "pinned_memory_max_fraction": 0.25,
+        "use_hybrid_attention": True, "storage_format": "safetensors",
+        "learning_rate": 5e-4, "batch_size": 16, "accumulation_steps": 8,
+        "max_seq_len": 512, "epochs": 2, "save_interval": 1000,
+        "save_dir": "./out",
+    }
+    out = []
+    for k in CONFIG_INPUT_ORDER:
+        v = cfg.get(k) if k in cfg else MINIMIND_MOE_DEFAULTS.get(k)
+        if v is None:
+            v = SAFE.get(k, 0)
+        out.append(v)
+    return out
+
+
+def save_config(cfg: Dict, path: str) -> str:
+    """Write cfg as pretty JSON. Returns the absolute path written."""
+    abs_path = os.path.abspath(path)
+    os.makedirs(os.path.dirname(abs_path) or ".", exist_ok=True)
+    with open(abs_path, "w") as f:
+        json.dump(cfg, f, indent=2, sort_keys=True)
+    return abs_path
+
+
+def load_config(path: str) -> Dict:
+    """Read JSON and return the dict. Raises FileNotFoundError if missing."""
+    with open(os.path.abspath(path)) as f:
+        return json.load(f)

ui/tabs/__init__.py

@@ -0,0 +1,3 @@
+"""
+ui/tabs/__init__.py
+"""

ui/tabs/autotune_tab.py

@@ -0,0 +1,210 @@
+"""
+ui/tabs/autotune_tab.py — Optuna search over Chronos hyperparameters.
+
+Improvements over the M5 version:
+
+- **Log accumulation**: events append to a rolling buffer, persisted to
+  ``./auto_tune_cache/tune_log.txt`` so history survives a UI refresh.
+- **Best-params history**: every trial's params + score appended to
+  ``./auto_tune_cache/trials.jsonl``.
+- **Expanded search space**: structural knobs (hidden_size, num_experts,
+  num_shared_experts, kv_latent_dim, λ_lookahead) can be ticked for search.
+- **Apply Best → Config**: one button writes the best params back into
+  the Config tab's slider widgets.
+"""
+import json
+import os
+import time
+
+from ui.gradio_compat import gr
+
+import chronos.deps  # noqa: F401
+from ui.i18n import t, register_translatable
+from chronos.tuning.chronos_auto_tuner import ChronosAutoTuner, ChronosSearchSpaceConfig
+
+
+_tuner = ChronosAutoTuner()
+_CACHE_DIR = os.path.abspath("./auto_tune_cache")
+_LOG_FILE = os.path.join(_CACHE_DIR, "tune_log.txt")
+_TRIALS_FILE = os.path.join(_CACHE_DIR, "trials.jsonl")
+
+
+def _ensure_cache():
+    os.makedirs(_CACHE_DIR, exist_ok=True)
+
+
+def _append_log(text: str):
+    _ensure_cache()
+    with open(_LOG_FILE, "a") as f:
+        f.write(text + ("\n" if not text.endswith("\n") else ""))
+
+
+def _read_log() -> str:
+    if not os.path.exists(_LOG_FILE):
+        return ""
+    with open(_LOG_FILE) as f:
+        return f.read()
+
+
+def _append_trial(record: dict):
+    _ensure_cache()
+    with open(_TRIALS_FILE, "a") as f:
+        f.write(json.dumps(record) + "\n")
+
+
+# Map best-params keys to indices into the Config tab's all_inputs list.
+# IMPORTANT: must stay in sync with ui/tabs/config_tab.py:all_inputs order.
+PARAM_TO_CONFIG_IDX = {
+    "hidden_size":          0,
+    "num_hidden_layers":    1,
+    "num_experts":          2,
+    "num_experts_per_tok":  3,
+    "num_shared_experts":   4,
+    "lookahead_steps":      5,
+    "kv_latent_dim":        6,
+    "sliding_window_size":  7,
+    "lambda_balance":       15,
+    "lambda_temporal":      16,
+    "lambda_lookahead":     17,
+    "lambda_router_anchor": 18,
+    "learning_rate":        23,
+    "batch_size":           24,
+}
+
+
+def build_autotune_tab(config_state: gr.State, config_inputs: list):
+    with gr.Tab(t("tab.autotune")) as tab:
+        register_translatable(tab, "tab.autotune")
+
+        gr.Markdown("### Optuna TPE — search over Chronos hyperparameters")
+
+        with gr.Row():
+            data_path   = gr.Textbox(label=t("autotune.data_path"), scale=3,
+                                     placeholder="./tests/fixtures/tiny_pretrain.jsonl")
+            n_trials    = gr.Slider(2, 200, value=20, step=1,  label=t("autotune.n_trials"))
+            probe_steps = gr.Slider(10, 1000, value=80, step=10, label=t("autotune.probe_steps"))
+            register_translatable(data_path,   "autotune.data_path")
+            register_translatable(n_trials,    "autotune.n_trials")
+            register_translatable(probe_steps, "autotune.probe_steps")
+
+        gr.Markdown(t("autotune.tip"))
+        with gr.Row():
+            t_lb = gr.Checkbox(value=True,  label="λ1 balance")
+            t_lt = gr.Checkbox(value=True,  label="λ2 temporal")
+            t_ll = gr.Checkbox(value=False, label="λ lookahead")
+            t_la = gr.Checkbox(value=False, label="lookahead_steps")
+            t_lr = gr.Checkbox(value=True,  label="learning_rate")
+        with gr.Row():
+            t_hs = gr.Checkbox(value=False, label="hidden_size")
+            t_ne = gr.Checkbox(value=False, label="num_experts")
+            t_ns = gr.Checkbox(value=False, label="num_shared_experts")
+            t_kv = gr.Checkbox(value=False, label="kv_latent_dim")
+
+        with gr.Row():
+            start_btn = gr.Button(t("autotune.start"), variant="primary")
+            stop_btn  = gr.Button(t("autotune.stop"),  variant="stop")
+            clear_btn = gr.Button(t("autotune.clear_log"))
+            apply_btn = gr.Button(t("autotune.apply_best"), variant="secondary")
+            register_translatable(start_btn, "autotune.start")
+            register_translatable(stop_btn,  "autotune.stop")
+            register_translatable(clear_btn, "autotune.clear_log")
+            register_translatable(apply_btn, "autotune.apply_best")
+
+        status_box = gr.Textbox(value="idle", label="Status", interactive=False)
+        best_box   = gr.JSON(label=t("autotune.best"))
+        log_box    = gr.Textbox(label=t("autotune.log"), lines=20,
+                                interactive=False, autoscroll=True,
+                                value=_read_log())
+        register_translatable(log_box,  "autotune.log")
+        register_translatable(best_box, "autotune.best")
+
+        gr.Markdown(f"Log persisted at `{_LOG_FILE}` (survives refresh).")
+
+        def start_tune(dpath, n_tr, p_steps,
+                       tlb, tlt, tll, tla, tlr,
+                       ths, tne, tns, tkv,
+                       cfg):
+            if _tuner.is_running():
+                return "already running", _read_log(), {}
+            if not dpath or not os.path.exists(dpath):
+                return f"error: data_path not found: {dpath!r}", _read_log(), {}
+
+            _append_log(f"\n──── Auto-tune started @ {time.strftime('%Y-%m-%d %H:%M:%S')} ────")
+
+            ss = ChronosSearchSpaceConfig(
+                tune_lambda_balance=bool(tlb),
+                tune_lambda_temporal=bool(tlt),
+                tune_lambda_lookahead=bool(tll),
+                tune_lookahead_steps=bool(tla),
+                tune_lr=bool(tlr),
+                tune_hidden_size=bool(ths),
+                tune_num_experts=bool(tne),
+                tune_num_shared_experts=bool(tns),
+                tune_kv_latent_dim=bool(tkv),
+            )
+            save_dir = (cfg or {}).get("save_dir", "./out")
+            hidden_size = (cfg or {}).get("hidden_size", 256)
+            _tuner.start(
+                model_id=os.path.join(save_dir, f"chronos_{hidden_size}_moe.pth"),
+                dataset_path=dpath, train_ratio=0.95,
+                prompt_template="alpaca", think_mode="keep",
+                search_space=ss, n_trials=int(n_tr),
+                probe_steps=int(p_steps),
+                output_dir=_CACHE_DIR, seed=42,
+            )
+            return "running", _read_log(), {}
+
+        def stop_tune():
+            _tuner.stop()
+            _append_log(f"──── stopped @ {time.strftime('%Y-%m-%d %H:%M:%S')} ────")
+            return "stopped"
+
+        def clear_log_file():
+            if os.path.exists(_LOG_FILE):
+                os.remove(_LOG_FILE)
+            return ""
+
+        def poll_tune():
+            events = _tuner.poll()
+            for ev in events:
+                if ev.get("type") == "log":
+                    _append_log(ev.get("line", ""))
+                elif ev.get("type") == "trial_done":
+                    _append_trial(ev)
+            best = {}
+            if _tuner.result and _tuner.result.best_params:
+                best = _tuner.result.best_params
+            return _tuner.status, _read_log(), best
+
+        def apply_best(best):
+            """Write best_params back into the Config tab's slider widgets.
+            Returns a list of gr.update for every config_input — untouched
+            inputs get gr.update() (no-op). None values are dropped so
+            Gradio's numeric widgets don't reject them."""
+            updates = [gr.update() for _ in config_inputs]
+            if not best:
+                return updates
+            for k, v in best.items():
+                if v is None:
+                    continue
+                idx = PARAM_TO_CONFIG_IDX.get(k)
+                if idx is not None:
+                    updates[idx] = gr.update(value=v)
+            return updates
+
+        start_btn.click(
+            fn=start_tune,
+            inputs=[data_path, n_trials, probe_steps,
+                    t_lb, t_lt, t_ll, t_la, t_lr,
+                    t_hs, t_ne, t_ns, t_kv,
+                    config_state],
+            outputs=[status_box, log_box, best_box],
+        )
+        stop_btn.click(fn=stop_tune, outputs=[status_box])
+        clear_btn.click(fn=clear_log_file, outputs=[log_box])
+        apply_btn.click(fn=apply_best, inputs=[best_box], outputs=config_inputs)
+
+        timer = gr.Timer(value=2.0)
+        timer.tick(fn=poll_tune, outputs=[status_box, log_box, best_box])
+
+    return tab

ui/tabs/benchmark_tab.py

@@ -0,0 +1,196 @@
+"""
+ui/tabs/benchmark_tab.py — MiniMind vs Chronos comparison view.
+
+Renders the comparison_results.json as:
+
+  - a formatted Markdown table (parameters, RAM, tokens/sec)
+  - per-metric bar charts (gr.BarPlot) for visual comparison
+  - the raw JSON (collapsed; for power users)
+  - a streaming log of the comparison subprocess
+"""
+import json
+import os
+
+from ui.gradio_compat import gr
+import pandas as pd
+
+import chronos.deps  # noqa: F401
+from ui.i18n import t, register_translatable
+
+RESULTS_FILE = os.path.join(os.path.dirname(__file__), '../../benchmark_results.json')
+
+
+# Metrics we know how to chart. Order matters — drives the row order of
+# the bar plots. Each entry: (display_name, json_key, unit_label, lower_is_better).
+CHART_METRICS = [
+    ("Parameters",         "params_m",      "M params",  False),
+    ("Model RAM (resident)", "ram_model_gb", "GB",        True),
+    ("Train RAM",          "ram_train_gb",  "GB",        True),
+    ("Inference RAM",      "ram_infer_gb",  "GB",        True),
+    ("Decode tokens/sec",  "tokens_per_sec","tokens/s",  False),
+]
+
+
+def _format_table(data: dict) -> str:
+    """Render comparison results as a Markdown table."""
+    if not data:
+        return "_No benchmark data yet. Click **Run** to start._"
+
+    mm = data.get("minimind", {}) or {}
+    ch = data.get("chronos", {}) or {}
+
+    rows = ["| Metric | MiniMind | Chronos | Δ (Chronos − MiniMind) | Better |",
+            "|---|---|---|---|---|"]
+    for label, key, unit, lower_is_better in CHART_METRICS:
+        mv = mm.get(key)
+        cv = ch.get(key)
+        if mv is None and cv is None:
+            continue
+        mvs = "n/a" if mv is None else f"{mv:.4g} {unit}"
+        cvs = "n/a" if cv is None else f"{cv:.4g} {unit}"
+        if mv is None or cv is None:
+            delta = "n/a"; better = ""
+        else:
+            d = cv - mv
+            sign = "−" if d < 0 else ("+" if d > 0 else "±")
+            delta = f"{sign}{abs(d):.4g} {unit}"
+            if lower_is_better:
+                better = "**Chronos**" if cv < mv else ("MiniMind" if cv > mv else "tie")
+            else:
+                better = "**Chronos**" if cv > mv else ("MiniMind" if cv < mv else "tie")
+        rows.append(f"| {label} | {mvs} | {cvs} | {delta} | {better} |")
+
+    extra = []
+    if "kv_cache_type" in ch:
+        extra.append(f"- **Chronos KV cache**: `{ch['kv_cache_type']}`")
+    cs = ch.get("cache_stats") or {}
+    if cs:
+        extra.append("- **Cache stats**: " + ", ".join(
+            f"`{k}={v}`" for k, v in cs.items()
+            if k in ("vram_experts", "ram_experts", "num_clusters",
+                     "storage_format", "hit_rate", "expert_size_kb",
+                     "pinned_ram_used_gb")
+        ))
+    if extra:
+        rows.append("")
+        rows.extend(extra)
+
+    return "\n".join(rows)
+
+
+def _to_chart_df(data: dict) -> pd.DataFrame:
+    """Convert benchmark JSON into a long-format DataFrame for gr.BarPlot."""
+    rows = []
+    for model_key, label_key in (("minimind", "MiniMind"), ("chronos", "Chronos")):
+        d = data.get(model_key, {}) or {}
+        for label, key, unit, _lower in CHART_METRICS:
+            v = d.get(key)
+            if v is None:
+                continue
+            rows.append({
+                "metric": label,
+                "model":  d.get("name", label_key),
+                "value":  float(v),
+                "unit":   unit,
+            })
+    return pd.DataFrame(rows) if rows else pd.DataFrame(
+        columns=["metric", "model", "value", "unit"]
+    )
+
+
+def _empty_df():
+    return pd.DataFrame(columns=["metric", "model", "value", "unit"])
+
+
+def _load_existing():
+    p = os.path.abspath(RESULTS_FILE)
+    if os.path.exists(p):
+        try:
+            with open(p) as f:
+                d = json.load(f)
+            return d, _format_table(d), _to_chart_df(d), "Loaded previous results."
+        except Exception as e:
+            return {}, f"_Could not parse {p}: {e}_", _empty_df(), str(e)
+    return {}, _format_table({}), _empty_df(), "No results yet. Click Run."
+
+
+def build_benchmark_tab():
+    with gr.Tab(t("tab.benchmark")) as tab:
+        register_translatable(tab, "tab.benchmark")
+
+        run_btn = gr.Button(t("bench.run"), variant="primary")
+        register_translatable(run_btn, "bench.run")
+
+        # Formatted summary
+        summary_md = gr.Markdown(value=_format_table({}))
+
+        # Bar chart — one BarPlot per model so units stack cleanly per metric.
+        chart = gr.BarPlot(
+            value=_empty_df(),
+            x="metric", y="value", color="model",
+            title="MiniMind vs Chronos — comparison metrics",
+            tooltip=["model", "metric", "value", "unit"],
+            height=320,
+        )
+
+        with gr.Accordion("Raw JSON", open=False):
+            results_box = gr.JSON(label=t("bench.results"))
+            register_translatable(results_box, "bench.results")
+
+        log_box = gr.Textbox(
+            label=t("bench.log"), lines=20, interactive=False, autoscroll=True
+        )
+        register_translatable(log_box, "bench.log")
+
+        def run_benchmark():
+            import subprocess, sys
+            script = os.path.join(os.path.dirname(__file__), '../../benchmark_compare.py')
+            log_lines = []
+            yield (
+                {}, _format_table({}), _empty_df(),
+                "Running benchmark... (this takes ~2 minutes)\n",
+            )
+            try:
+                proc = subprocess.Popen(
+                    [sys.executable, script],
+                    stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                    text=True, bufsize=1,
+                )
+                for line in proc.stdout:
+                    log_lines.append(line.rstrip())
+                    yield (
+                        {}, _format_table({}), _empty_df(),
+                        "\n".join(log_lines[-50:]),
+                    )
+                proc.wait()
+                p = os.path.abspath(RESULTS_FILE)
+                if os.path.exists(p):
+                    with open(p) as f:
+                        results = json.load(f)
+                    yield (
+                        results, _format_table(results), _to_chart_df(results),
+                        "\n".join(log_lines),
+                    )
+                else:
+                    yield (
+                        {}, "_Run finished but no results file was produced._",
+                        _empty_df(), "\n".join(log_lines) + "\n[No results file found]",
+                    )
+            except Exception as e:
+                yield (
+                    {}, f"_error: {e}_", _empty_df(), f"Error: {e}",
+                )
+
+        run_btn.click(
+            fn=run_benchmark,
+            outputs=[results_box, summary_md, chart, log_box],
+        )
+
+        # Render existing results on tab open
+        d, md, df, log = _load_existing()
+        results_box.value = d
+        summary_md.value = md
+        chart.value = df
+        log_box.value = log
+
+    return tab