Add example loader for CV and TPD demo data

- Add dropdown + "Load Example" button in both CV and TPD tabs
so users can try the demo without uploading their own data
- Auto-discovers 6 CV and 6 TPD examples from demo_data/ metadata
- Pre-fills file uploads, scan rates/heating rates, and physical params
- Remove "in milliseconds" from subtitle (demo runs on CPU)

Made-with: Cursor

app.py

@@ -35,6 +35,7 @@ from plotting import (
 # Model paths (relative to repo root)
 # ---------------------------------------------------------------------------
 REPO_ROOT = Path(__file__).resolve().parent
+DEMO_DIR = REPO_ROOT / "demo_data"
 
 EC_CHECKPOINT = REPO_ROOT / "checkpoints" / "ec_best.pt"
 TPD_CHECKPOINT = REPO_ROOT / "checkpoints" / "tpd_best.pt"
@@ -43,6 +44,76 @@ TPD_CHECKPOINT = REPO_ROOT / "checkpoints" / "tpd_best.pt"
 EC_CHECKPOINT = Path(os.environ.get("ECFLOW_EC_CHECKPOINT", str(EC_CHECKPOINT)))
 TPD_CHECKPOINT = Path(os.environ.get("ECFLOW_TPD_CHECKPOINT", str(TPD_CHECKPOINT)))
 
+# ---------------------------------------------------------------------------
+# Demo examples
+# ---------------------------------------------------------------------------
+
+def _discover_examples():
+    """Scan demo_data/ for metadata files and build example catalogs."""
+    cv_examples = {}
+    tpd_examples = {}
+    if not DEMO_DIR.is_dir():
+        return cv_examples, tpd_examples
+    for meta_path in sorted(DEMO_DIR.glob("*_metadata.json")):
+        with open(meta_path) as f:
+            meta = json.load(f)
+        mech = meta["mechanism"]
+        csv_files = [str(DEMO_DIR / fn) for fn in meta["csv_files"]]
+        if meta_path.name.startswith("ec_"):
+            rates = meta.get("scan_rates_Vs", [])
+            rates_str = ", ".join(f"{r:.4g}" for r in rates)
+            phys = meta.get("physical_params", {})
+            cv_examples[f"CV — {mech}"] = {
+                "files": csv_files,
+                "scan_rates": rates_str,
+                "E0_V": phys.get("E0_V"),
+                "T_K": phys.get("T_K", 298.15),
+                "A_cm2": phys.get("A_cm2", 0.0707),
+                "C_mM": phys.get("C_mM", 1.0),
+                "D_cm2s": phys.get("D_cm2s", 1e-5),
+                "n_electrons": phys.get("n_electrons", 1),
+            }
+        elif meta_path.name.startswith("tpd_"):
+            betas = meta.get("betas_Ks", [])
+            betas_str = ", ".join(f"{b:.4g}" for b in betas)
+            tpd_examples[f"TPD — {mech}"] = {
+                "files": csv_files,
+                "heating_rates": betas_str,
+            }
+    return cv_examples, tpd_examples
+
+
+CV_EXAMPLES, TPD_EXAMPLES = _discover_examples()
+
+
+def _load_cv_example(example_name):
+    """Return (files, scan_rates, E0, T, A, C, D, n) for the chosen CV example."""
+    if not example_name or example_name not in CV_EXAMPLES:
+        return [gr.update()] * 8
+    ex = CV_EXAMPLES[example_name]
+    return (
+        ex["files"],
+        ex["scan_rates"],
+        ex["E0_V"],
+        ex["T_K"],
+        ex["A_cm2"],
+        ex["C_mM"],
+        ex["D_cm2s"],
+        ex["n_electrons"],
+    )
+
+
+def _load_tpd_example(example_name):
+    """Return (files, heating_rates) for the chosen TPD example."""
+    if not example_name or example_name not in TPD_EXAMPLES:
+        return [gr.update()] * 2
+    ex = TPD_EXAMPLES[example_name]
+    return (
+        ex["files"],
+        ex["heating_rates"],
+    )
+
+
 predictor = None
 
 
@@ -611,7 +682,7 @@ def build_app():
             "<div class='main-header'>"
             "<h1>⚡ ECFlow</h1>"
             "<p>Upload cyclic voltammetry or TPD data to <strong>identify the reaction mechanism</strong> "
-            "and <strong>infer kinetic parameters</strong> with full Bayesian uncertainty — in milliseconds.</p>"
+            "and <strong>infer kinetic parameters</strong> with full Bayesian uncertainty.</p>"
             "</div>"
         )
 
@@ -631,6 +702,19 @@ def build_app():
                             "If a **Time (s)** column is present, the scan rate is "
                             "detected automatically. Otherwise, enter scan rates below."
                         )
+                        if CV_EXAMPLES:
+                            with gr.Accordion("Try an example (no data needed)", open=True):
+                                with gr.Row():
+                                    cv_example_dd = gr.Dropdown(
+                                        label="Select example",
+                                        choices=list(CV_EXAMPLES.keys()),
+                                        value=None,
+                                        interactive=True,
+                                        scale=3,
+                                    )
+                                    cv_example_btn = gr.Button(
+                                        "Load Example", variant="secondary", scale=1,
+                                    )
                         cv_files = gr.File(
                             label="CSV files (one per scan rate)",
                             file_count="multiple",
@@ -687,6 +771,15 @@ def build_app():
                             inputs=[cv_mech_dd, cv_state],
                             outputs=[cv_posteriors, cv_param_table, cv_recon, cv_conc],
                         )
+                        if CV_EXAMPLES:
+                            cv_example_btn.click(
+                                _load_cv_example,
+                                inputs=[cv_example_dd],
+                                outputs=[
+                                    cv_files, cv_rates, cv_E0, cv_T,
+                                    cv_A, cv_C, cv_D, cv_n,
+                                ],
+                            )
 
                     # --- Image mode ---
                     with gr.Tab("From Image"):
@@ -783,6 +876,19 @@ def build_app():
                             "**You must provide the correct β for each file** — "
                             "the model uses β to condition inference."
                         )
+                        if TPD_EXAMPLES:
+                            with gr.Accordion("Try an example (no data needed)", open=True):
+                                with gr.Row():
+                                    tpd_example_dd = gr.Dropdown(
+                                        label="Select example",
+                                        choices=list(TPD_EXAMPLES.keys()),
+                                        value=None,
+                                        interactive=True,
+                                        scale=3,
+                                    )
+                                    tpd_example_btn = gr.Button(
+                                        "Load Example", variant="secondary", scale=1,
+                                    )
                         tpd_files = gr.File(
                             label="CSV files (one per heating rate)",
                             file_count="multiple",
@@ -818,6 +924,12 @@ def build_app():
                             inputs=[tpd_mech_dd, tpd_state],
                             outputs=[tpd_posteriors, tpd_param_table, tpd_recon],
                         )
+                        if TPD_EXAMPLES:
+                            tpd_example_btn.click(
+                                _load_tpd_example,
+                                inputs=[tpd_example_dd],
+                                outputs=[tpd_files, tpd_betas],
+                            )
 
                     # --- Image mode ---
                     with gr.Tab("From Image"):

multi_mechanism_model.py

@@ -130,6 +130,11 @@ class MultiScanEncoder(nn.Module):
         if aggregation == 'set_transformer':
             self.sab = SAB(d_context, n_heads=n_heads)
             self.pma = PMA(d_context, n_heads=n_heads, n_seeds=1)
+        elif aggregation == 'deepsets':
+            self.phi = nn.Sequential(
+                nn.Linear(d_context, d_context),
+                nn.GELU(),
+            )
         elif aggregation == 'mean_pool':
             pass
         else:
@@ -177,7 +182,9 @@ class MultiScanEncoder(nn.Module):
             h = self.sab(h, key_padding_mask=cv_invalid)
             h = self.pma(h, key_padding_mask=cv_invalid)  # [B, 1, d_context]
             h = h.squeeze(1)  # [B, d_context]
-        elif self.aggregation == 'mean_pool':
+        elif self.aggregation in ('deepsets', 'mean_pool'):
+            if self.aggregation == 'deepsets':
+                h = self.phi(h)
             if cv_invalid is not None:
                 cv_valid = (~cv_invalid).unsqueeze(-1).float()  # [B, N, 1]
                 h = (h * cv_valid).sum(dim=1) / cv_valid.sum(dim=1).clamp(min=1)