Score-based Levenberg Marquardt

.cache/known_methods_snapshot.json

@@ -137,6 +137,32 @@
         "gboed",
         "boed"
       ]
+    },
+    "lm-kgmm": {
+      "abbreviation": "LM-KGMM",
+      "Method": "Score-based Levenberg-Marquardt (KGMM)",
+      "parallelism": "serial",
+      "update_type": "gradient",
+      "method_goal": "optimization",
+      "emulator_use": "none",
+      "aliases": [
+        "lm-kgmm",
+        "score-based lm (gfdt, kgmm) (extended window)",
+        "score-based lm (gfdt, kgmm) (parallel branches)"
+      ]
+    },
+    "lm-dsm": {
+      "abbreviation": "LM-DSM",
+      "Method": "Score-based Levenberg-Marquardt (DSM)",
+      "parallelism": "serial",
+      "update_type": "gradient",
+      "method_goal": "optimization",
+      "emulator_use": "none",
+      "aliases": [
+        "lm-dsm",
+        "score-based lm (gfdt, dsm) (extended window)",
+        "score-based lm (gfdt, dsm) (parallel branches)"
+      ]
     }
   },
   "observed_methods": [
@@ -146,6 +172,8 @@
     "hm",
     "iekf",
     "lm",
+    "lm-dsm",
+    "lm-kgmm",
     "teki",
     "uki"
   ],

CLAUDE.md

@@ -51,7 +51,9 @@ calibration_benchmark/
 │   ├── common/
 │   │   ├── leaderboard.py       render_leaderboard() — shared scored-table + chart pipeline
 │   │   │                        _render_suitability_table() — method × benchmark suitability grid
-│   │   │                        optional budget_store param adds budget/iters chart section
+│   │   │                        optional budget_store param adds budget/iters chart section (UQ)
+│   │   │                        when budget_store is None (Optimization board), instead renders a
+│   │   │                        "Mean Iterations to Reach Target" chart derived as metric/ensemble_size
 │   │   └── method_registry.py   KNOWN_METHODS registry + name canonicalization
 │   └── pages/
 │       ├── UQLeaderboard.py     🎯 UQ Leaderboard — calls render_leaderboard(load_uq_store())
@@ -63,6 +65,8 @@ calibration_benchmark/
 │   ├── UKI_results/             UKI results
 │   ├── adam_results/            ADAM gradient optimizer results (per-benchmark files)
 │   ├── levenberg_marquardt_results/  LM gradient optimizer results (per-benchmark files)
+│   ├── opt_kgmm_score_lm/       Score-based LM (KGMM score estimator) results (per-benchmark files)
+│   ├── opt_dsm_score_lm/        Score-based LM (DSM score estimator) results (per-benchmark files)
 │   ├── ces-eki-dmc_results/     CES-EKI-DMC ensemble-results files (UQ source)
 │   ├── gboed-uq_results/        GBOED ensemble-results files (UQ source)
 │   └── gnki-uq_results/         IEKF (a.k.a GNKI) ensemble-results files (UQ source)
@@ -182,6 +186,8 @@ A quick taxonomy tree is rendered on the home page (`src/streamlit_app.py`).
 | `adam` | ADAM | serial | gradient | optimization | none | — |
 | `lm` | LM | serial | gradient | optimization | none | gradient_descent |
 | `gboed` | GBOED | parallel-interacting | general | uq | within-optimize | boed |
+| `lm-kgmm` | LM-KGMM | serial | gradient | optimization | none | — |
+| `lm-dsm` | LM-DSM | serial | gradient | optimization | none | — |
 
 ## How to extend
 

data/opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l63_2026-08-12.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2feffae1f04a93b97a272ccd5a988fd8fbfea82000584c5ef990ff355e910329
+size 14296

data/opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l96_const-force_2026-08-12.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c88062bfa5fc7430d9792cc33558356042947971dfe7f0901e540ad2ed4609b2
+size 14296

data/opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l96_flux-force_2026-08-12.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8bd767510a24bd7a8d316752b3dc08f39e9eb7a66fd978cfb213574256667d1
+size 14296

data/opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l96_vec-force_2026-08-12.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5846b68470f28ff4b94fe910bba4017b03486ed71a396c6e41dd9218bbc641d
+size 14296

data/opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l63_2026-08-12.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8210335c139334983b3499ed7a2f626194cabf5904991e8b5eeadfcc04403d68
+size 14296

data/opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l96_const-force_2026-08-12.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:018c3f7b5d59d661cb62c7f4f861ecd38f39c7d8eaf0c172dd57e35cfe780a3b
+size 14296

data/opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l96_flux-force_2026-08-12.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c0f44cfcc8107a42a91e71d6cdace8ae718ab83663f84d3c1300bf11b9104f1
+size 14296

data/opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l96_vec-force_2026-08-12.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8038e2250cd08ee938beb19e883a8b29ebcd829a3a03059337b7154c4eff2235
+size 14296

src/common/leaderboard.py

@@ -370,27 +370,35 @@ def render_leaderboard(
         else:
             scored_df["ensemble_score"] = 100.0
 
+        scored_df["_unreliable"] = (
+            scored_df["Mean Failure Rate (%)"].fillna(0.0) >= _RELIABLE_FAILURE_THRESHOLD
+        )
+
         if scoring_mode == "Mean Forward Model Runs":
             scored_df["Score"] = scored_df["mean_runs_score"]
-            sort_columns = ["Mean Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
-            ascending = [True, True, True]
+            sort_columns = ["_unreliable", "Mean Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
+            ascending = [True, True, True, True]
         elif scoring_mode == "Minimum Forward Model Runs":
             scored_df["Score"] = scored_df["minimum_runs_score"]
-            sort_columns = ["Minimum Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
-            ascending = [True, True, True]
+            sort_columns = ["_unreliable", "Minimum Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
+            ascending = [True, True, True, True]
         elif scoring_mode == "Smallest Optimal Ensemble Size":
             scored_df["Score"] = scored_df["ensemble_score"]
-            sort_columns = ["Optimal Ensemble Size", "Mean Forward Model Runs", "abbreviation"]
-            ascending = [True, True, True]
+            sort_columns = ["_unreliable", "Optimal Ensemble Size", "Mean Forward Model Runs", "abbreviation"]
+            ascending = [True, True, True, True]
         else:
             scored_df["Score"] = (
                 fwdruns_weight * scored_df["mean_runs_score"]
                 + ensemble_weight * scored_df["ensemble_score"]
             )
-            sort_columns = ["Score", "Mean Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
-            ascending = [False, True, True, True]
+            sort_columns = ["_unreliable", "Score", "Mean Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
+            ascending = [True, False, True, True, True]
 
-        scored_df = scored_df.sort_values(sort_columns, ascending=ascending).reset_index(drop=True)
+        scored_df = (
+            scored_df.sort_values(sort_columns, ascending=ascending)
+            .drop(columns="_unreliable")
+            .reset_index(drop=True)
+        )
 
         if add_rank:
             scored_df["Rank"] = scored_df.index + 1

src/common/method_registry.py

@@ -143,19 +143,81 @@ KNOWN_METHODS = {
         "emulator_use": "within-optimize",
         "aliases": ["gboed", "boed"],
     },
+    "lm-kgmm": {
+        "abbreviation": "LM-KGMM",
+        "Method": "Score-based Levenberg-Marquardt (KGMM)",
+        "parallelism": "serial",
+        "update_type": "gradient",
+        "method_goal": "optimization",
+        "emulator_use": "none",
+        "aliases": [
+            "lm-kgmm",
+            "score-based lm (gfdt, kgmm) (extended window)",
+            "score-based lm (gfdt, kgmm) (parallel branches)",
+        ],
+    },
+    "lm-dsm": {
+        "abbreviation": "LM-DSM",
+        "Method": "Score-based Levenberg-Marquardt (DSM)",
+        "parallelism": "serial",
+        "update_type": "gradient",
+        "method_goal": "optimization",
+        "emulator_use": "none",
+        "aliases": [
+            "lm-dsm",
+            "score-based lm (gfdt, dsm) (extended window)",
+            "score-based lm (gfdt, dsm) (parallel branches)",
+        ],
+    },
 }
 
 
-# Vega tableau10 palette — one slot per method in KNOWN_METHODS declaration order.
-# New methods appended to KNOWN_METHODS get the next slot; existing colors never shift.
+# One slot per method in KNOWN_METHODS declaration order. New methods appended
+# to KNOWN_METHODS get the next slot.
+#
+# Generated by a greedy farthest-point search in OKLab: each slot was chosen to
+# maximize its minimum distance to every slot before it, simultaneously under
+# normal vision and simulated protan/deutan color-vision deficiency (Machado,
+# Oliveira & Fernandes 2009 severity-1.0 transforms — the same model used by
+# the dataviz skill's validate_palette.js). Because this optimizes the running
+# ALL-PAIRS minimum (not just adjacent-slot pairs), the printed ΔE at slot k
+# below is a genuine worst-case guarantee for any subset of the first k slots
+# shown together — relevant here because any subset of methods can appear
+# together via the "Methods to display in charts" multiselect, not just
+# neighbors in this list.
+#
+# Honest limits (OKLab ΔE x100; CVD = min(protan, deutan)):
+#   - Slots  0-15 (16 colors): CVD >= 8.0  — clears the full colorblind-safety
+#     target for every pair among any subset of these.
+#   - Slots 16-27            : CVD in [6.0, 8.0) — the legal "floor" band per
+#     the skill (secondary encoding required). This app already provides it:
+#     every legend and tooltip in leaderboard.py shows the method abbreviation
+#     as text, so identity is never color-alone even where hue alone is weak.
+#   - Slots 28-29            : CVD ~5.8, just under the 6.0 floor for their
+#     closest pair — weakest two slots, kept only for the requested headroom.
+#   - Normal-vision floor (>=15, a hard gate when checked in isolation): holds
+#     for the first ~6 slots against ALL other slots; beyond that, some pairs
+#     among 30 simultaneously-distinguishable colors are close even for
+#     full-color vision. This is a geometry limit of a finite perceptual
+#     space, not a search-quality issue — the reference palette in the dataviz
+#     skill's own docs states plainly that no ordering clears all-pairs floors
+#     past ~8 categories. 30 slots were requested anyway for growth headroom;
+#     rely on the legend/tooltip text labels (already present) for identity,
+#     not on hue alone, especially past slot ~16.
+# Re-run the search (seeded with all prior slots fixed) if extending further.
 _METHOD_PALETTE = [
-    "#4c78a8", "#f58518", "#e45756", "#72b7b2", "#54a24b",
-    "#eeca3b", "#b279a2", "#ff9da6", "#9d755d", "#bab0ac",
-    "#5254a3", "#8ca252",
+    "#d80065", "#007fff", "#ff9700", "#00cae4", "#6d00b8", "#970f00",
+    "#007ca4", "#de8580", "#00a0d7", "#fa0000", "#0100ff", "#90006d",
+    "#e500a0", "#007656", "#008200", "#006dd1", "#00b7ad", "#47b3ff",
+    "#0087d2", "#e97e00", "#ec9f72", "#4b4589", "#00d0ae", "#c87181",
+    "#5194ff", "#9c5683", "#0058ff", "#892348", "#e2003d", "#00b5d5",
 ]
 
 # Stable abbreviation → hex color mapping.  Import this wherever Altair charts are built
-# so every plot in the app assigns the same color to each method.
+# so every plot in the app assigns the same color to each method.  With 30 palette
+# slots and 14 registered methods, every method gets a unique color — the modulo
+# below only matters as a defensive fallback if KNOWN_METHODS grows past 30 without
+# the palette being extended first (see comment above).
 METHOD_COLORS: dict[str, str] = {
     meta["abbreviation"]: _METHOD_PALETTE[i % len(_METHOD_PALETTE)]
     for i, meta in enumerate(KNOWN_METHODS.values())

src/data_store.py

@@ -35,6 +35,8 @@ DATASET_FILES = {
         "bayesian/l63_hm.nc",
         "adam_results/leaderboard_adam_l63_2026-06-26.nc",
         "levenberg_marquardt_results/leaderboard_lm_l63_2026-06-29.nc",
+        "opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l63_2026-08-12.nc",
+        "opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l63_2026-08-12.nc",
     ],
     "L96": [
         "l96_ensemble_results.nc",
@@ -42,10 +44,14 @@ DATASET_FILES = {
         "bayesian/l96_abc.nc",
         "adam_results/leaderboard_adam_l96_const-force_2026-06-26.nc",
         "levenberg_marquardt_results/leaderboard_lm_l96_const-force_2026-06-29.nc",
+        "opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l96_const-force_2026-08-12.nc",
+        "opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l96_const-force_2026-08-12.nc",
     ],
     "L96_NN_FORCING": [
         "l96_nn_forcing_ensemble_results.nc",
         "UKI_results/uki_l96_nn_forcing_ensemble_results.nc",
+        "opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l96_flux-force_2026-08-12.nc",
+        "opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l96_flux-force_2026-08-12.nc",
     ],
     "L96_SPATIAL_FORCING": [
         "l96_spatial_forcing_ensemble_results.nc",
@@ -53,6 +59,8 @@ DATASET_FILES = {
         "bayesian/l96_varying_abc.nc",
         "adam_results/leaderboard_adam_l96_vec-force_2026-06-26.nc",
         "levenberg_marquardt_results/leaderboard_lm_l96_vec-force_2026-06-29.nc",
+        "opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l96_vec-force_2026-08-12.nc",
+        "opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l96_vec-force_2026-08-12.nc",
     ],
 }
 

src/pages/MethodDetails.py

@@ -22,6 +22,10 @@ st.sidebar.page_link("pages/RawData.py", label="Get Data", icon="🧾")
 
 st.title("Method Details")
 st.caption("Method-level view from NetCDF forward-model-run metrics averaged over random seeds")
+st.markdown(
+    "For the exact implementation of each algorithm, see "
+    "[CalibrationLeaderboard.jl](https://github.com/odunbar/CalibrationLeaderboard.jl)."
+)
 
 # Read selected method from query params
 abbr = st.query_params.get("method")
@@ -99,6 +103,16 @@ method_meta = {
         "url": "https://arxiv.org/abs/2508.13071",
         "summary": "Goal-oriented Bayesian Optimal Experimental Design — selects each batch of forward-model evaluations by maximizing an expected-information-gain criterion targeted at the quantity of interest, refitting the surrogate used by the criterion at every iteration.",
     },
+    "LM-KGMM": {
+        "citation": "Giorgini, Bischoff & Souza, arXiv:2503.18054, 2025",
+        "url": "https://arxiv.org/abs/2503.18054",
+        "summary": "Score-based Levenberg-Marquardt using a K-means Gaussian Mixture Model to estimate the score function, which drives the gradient via the generalized fluctuation-dissipation theorem (GFDT).",
+    },
+    "LM-DSM": {
+        "citation": "Giorgini, Bischoff & Souza, arXiv:2509.19660, 2025",
+        "url": "https://arxiv.org/abs/2509.19660",
+        "summary": "Score-based Levenberg-Marquardt using Denoising Score Matching to estimate the score function, which drives the gradient via the generalized fluctuation-dissipation theorem (GFDT).",
+    },
 }
 
 # Selection UI (defaults to query param if valid)

src/streamlit_app.py

@@ -28,6 +28,10 @@ st.markdown(
     "Methods are ranked by **forward-model run efficiency** — how many forward-model "
     "evaluations are needed, on average across random seeds, to reach a target accuracy."
 )
+st.markdown(
+    "The exact implementations of every algorithm benchmarked here are available at "
+    "[CalibrationLeaderboard.jl](https://github.com/odunbar/CalibrationLeaderboard.jl)."
+)
 
 st.divider()