Heavy ML on HF; variant match % via librosa; Validate vs Gemini button on Analysis

app.py

@@ -779,15 +779,20 @@ def regenerate_variants(prompt_text: str, last_run_state, api_key: str = ""):
     # filepath strings in a streaming generator was leaving v1..v5 with
     # paths the browser couldn't fetch (Audio rendered the slot but no
     # file URL was wired up).
-    def _slot(p: str | None):
-        if p:
-            return gr.update(value=p, visible=True)
-        return gr.update(value=None, visible=True)
-
     paths: list[str | None] = [None, None, None, None, None]
+    matches: list[int | None] = [None, None, None, None, None]
+
+    def _slot(idx: int):
+        """Build the gr.update for slot idx. Label encodes match % when
+        we've scored the variant against the anchor."""
+        m = matches[idx]
+        label = f"v{idx+1}" if m is None else f"V{idx+1} · {m}% match"
+        if paths[idx]:
+            return gr.update(value=paths[idx], visible=True, label=label)
+        return gr.update(value=None, visible=True, label=label)
 
     def _emit(status: str):
-        return (*(_slot(p) for p in paths), status)
+        return (*(_slot(i) for i in range(5)), status)
 
     if not (prompt_text or "").strip():
         yield _emit("_❌ Enter a prompt to regenerate from._")
@@ -796,16 +801,25 @@ def regenerate_variants(prompt_text: str, last_run_state, api_key: str = ""):
         yield _emit("_❌ Connect a Pollinations wallet first (click the pollen pill, top right)._")
         return
 
-    # Try to thread parent lineage from last_run state (set when the user
-    # routed in via "Use for analysis" — `audio_path` is the source tile's
-    # audio_path, and we can resolve it back to its crate tile.id).
+    # Try to thread parent lineage + anchor measurements from last_run.
+    # parent_id sets the crate-tile lineage; anchor_bpm/anchor_key power
+    # the per-variant match % readout. last_run_state is populated by
+    # run_brief on analysis-complete.
     parent_id: str | None = None
+    anchor_bpm: float | None = None
+    anchor_key: str | None = None
     if isinstance(last_run_state, dict):
         src_path = last_run_state.get("audio_path", "")
         for t in crate.list_tiles():
             if t.audio_path == src_path:
                 parent_id = t.id
                 break
+        an = last_run_state.get("analysis")
+        if an is not None:
+            anchor_bpm = getattr(an, "bpm", None)
+            # Compose "F minor" style key string to match anchor_key format.
+            k_root = getattr(an, "key", None)
+            anchor_key = k_root if k_root else None
 
     duration = 15  # fixed for v1 — variants are short clips
     model = sa3.DEFAULT_MODEL
@@ -842,7 +856,11 @@ def regenerate_variants(prompt_text: str, last_run_state, api_key: str = ""):
         except Exception:
             pass
         paths[i] = tile.audio_path
-        print(f"[regen v{i+1}] tile={tile.id} bytes={info.get('bytes')} path={tile.audio_path}",
+        # Quick match — librosa-only BPM+key on the variant vs anchor.
+        # Adds ~1-2s per variant; total regen wall time stays ~25s for 5.
+        matches[i] = _quick_match(tile.audio_path, anchor_bpm, anchor_key)
+        print(f"[regen v{i+1}] tile={tile.id} bytes={info.get('bytes')} "
+              f"match={matches[i]} path={tile.audio_path}",
               file=_sys.stderr, flush=True)
 
     parent_note = ""
@@ -912,6 +930,56 @@ def delete_tile(tile_id: str | None):
             _crate_header_html())
 
 
+def _quick_match(variant_path: str, anchor_bpm: float | None, anchor_key: str | None) -> int | None:
+    """Fast match score (0-100) for a regenerated variant against the
+    analysed anchor. BPM weight 60% · key weight 40%.
+
+    Uses librosa directly — skips demucs/basic-pitch/pyloudnorm so it adds
+    only ~1-2s per variant on top of the gen call. Returns None if the
+    anchor's BPM/key are missing (uploaded-without-analysis case) or if
+    librosa fails (bad audio file)."""
+    if not (anchor_bpm and anchor_key):
+        return None
+    try:
+        import librosa
+        import numpy as np
+        y, sr = librosa.load(variant_path, sr=22050, mono=True, duration=15.0)
+        # BPM with anchor as the prior so dnb half-tempo lock can't lie.
+        tempo, _ = librosa.beat.beat_track(
+            y=y, sr=sr, start_bpm=float(anchor_bpm), tightness=100,
+        )
+        v_bpm = float(np.asarray(tempo).item())
+        # Krumhansl-Schmuckler key (same procedure as pipeline._stage_bpm_key).
+        chroma = librosa.feature.chroma_cqt(y=y, sr=sr)
+        chroma_mean = np.mean(chroma, axis=1)
+        KEY_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+        major = np.array([6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88])
+        minor = np.array([6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17])
+        best_corr, v_key = -1.0, "C"
+        for i in range(12):
+            for prof in (major, minor):
+                rolled = np.roll(prof, i)
+                corr = float(np.corrcoef(chroma_mean, rolled)[0, 1])
+                if corr > best_corr:
+                    best_corr, v_key = corr, KEY_NAMES[i]
+        # Score: BPM within ±2% → 100, ±10% → 50, ±25% → 0 (linear-ish).
+        bpm_ratio = abs(v_bpm - float(anchor_bpm)) / max(float(anchor_bpm), 1.0)
+        bpm_score = max(0.0, 100.0 - bpm_ratio * 500.0)
+        # Key: exact match → 100, semitone away → 67, whole-tone → 33, else 0.
+        if anchor_key in KEY_NAMES:
+            a_idx = KEY_NAMES.index(anchor_key)
+            v_idx = KEY_NAMES.index(v_key)
+            delta = min((a_idx - v_idx) % 12, (v_idx - a_idx) % 12)
+            key_score = max(0.0, 100.0 - delta * 33.0)
+        else:
+            key_score = 0.0
+        return int(round(bpm_score * 0.6 + key_score * 0.4))
+    except Exception as e:
+        print(f"[_quick_match] {type(e).__name__}: {e}",
+              file=sys.stderr, flush=True)
+        return None
+
+
 _BPM_RE = __import__("re").compile(r"(\d{2,3})\s*BPM", __import__("re").IGNORECASE)
 
 
@@ -1180,6 +1248,15 @@ def build_ui() -> gr.Blocks:
         # confirms what the LLM heard.
         with gr.Tab("Analysis"):
             caption = gr.Markdown()
+            # Validate-vs-Gemini button — promoted from the Compare tab so
+            # the wedge demo is one click away after analysis lands. Hidden
+            # until last_run flips to a populated dict; on click it
+            # programmatically switches to Compare and fires run_compare.
+            validate_btn = gr.Button(
+                "Validate vs Gemini ▸",
+                size="sm", interactive=False,
+                elem_classes=["dc-validate-btn"],
+            )
             # 6-up metric tile grid: BPM / KEY / LUFS / TRUE PK / LRA / LENGTH.
             # Empty placeholder shown until the pipeline fills it in.
             metrics_html = gr.HTML(_metrics_html(None))
@@ -1347,6 +1424,43 @@ def build_ui() -> gr.Blocks:
             api_name="compare",
         )
 
+        # Enable Validate-vs-Gemini button only after analysis lands.
+        last_run.change(
+            fn=lambda lr: gr.update(interactive=isinstance(lr, dict)),
+            inputs=[last_run],
+            outputs=[validate_btn],
+        )
+
+        # Validate button on Analysis: switch to Compare tab (via JS) and
+        # fire run_compare with the current analysis state. Same outputs
+        # as compare_btn — populates the Compare tab's columns directly.
+        validate_btn.click(
+            fn=run_compare,
+            inputs=[last_run, model_a_dd, model_b_dd, model_c_dd, api_key_state],
+            outputs=[
+                a_header, a_brief,
+                b_header, b_brief,
+                c_header, c_brief,
+                comparison_table,
+                a_timing, b_timing, c_timing,
+                compare_state,
+            ],
+            js="""
+            () => {
+                // Find and click the "Compare with Gemini" tab button so
+                // the user lands on the side-by-side as the comparison runs.
+                const tabs = document.querySelectorAll('[role="tab"]');
+                for (const t of tabs) {
+                    if ((t.innerText || '').trim().startsWith('Compare')) {
+                        t.click();
+                        break;
+                    }
+                }
+                return [];  // no input mutation
+            }
+            """,
+        )
+
         scorecard_btn.click(
             fn=export_scorecard,
             inputs=[compare_state],

requirements.txt

@@ -29,14 +29,15 @@ pyloudnorm>=0.1.1
 # LLM narrative + SA3 audio gen — both via Pollinations HTTP API.
 requests>=2.31
 
-# ── OPTIONAL HEAVY ML ──────────────────────────────────────────────────
-# Uncomment to enable stem split + bass-MIDI. Adds ~2 GB and ~8 min to
-# the build on HF Spaces free CPU; basic-pitch's latest PyPI version is
-# 0.4.0 (NOT 0.5 — that was an internal aspirational pin).
-#
-# demucs>=4.0
-# basic-pitch[onnx]>=0.4,<0.5
-# torchcodec>=0.14       # demucs uses torchaudio which moved file I/O here
+# ── HEAVY ML — stem split + bass-MIDI ─────────────────────────────────
+# These pull torch + torchaudio + onnxruntime — together ~2 GB and a
+# first-build cost of 8-12 min on HF Spaces free CPU. Subsequent builds
+# reuse the layer cache. The pipeline's per-stage try/except means a
+# failed install here still leaves Generate + Analysis + Regenerate
+# working on librosa-only stages.
+demucs>=4.0
+basic-pitch[onnx]>=0.4,<0.5     # 0.4.0 is latest on PyPI; 0.5+ doesn't exist
+torchcodec>=0.14                # demucs uses torchaudio's new file IO
 
 # ── DEFERRED v2 ────────────────────────────────────────────────────────
 # essentia-tensorflow      # tagging (stage 7) — Linux wheels only

theme.py

@@ -335,6 +335,34 @@ h3 { font-size: 13px; color: #C9CDD4; }
     background: #14171D;
 }
 .dc-var-hold .chips { display: flex; gap: 6px; }
+/* ---- Validate-vs-Gemini button (Analysis tab) — outline style so it
+       reads as a secondary CTA next to the brief, not a primary action.
+       Mint border = measured-grounding promise; flips to coral on hover. */
+.dc-validate-btn button, button.dc-validate-btn {
+    background: transparent !important;
+    border: 1px solid rgba(91,224,200,0.45) !important;
+    color: #5BE0C8 !important;
+    font-family: 'Space Grotesk', sans-serif !important;
+    font-weight: 600 !important;
+    font-size: 12px !important;
+    padding: 6px 14px !important;
+    border-radius: 8px !important;
+    height: auto !important;
+    min-height: 32px !important;
+    width: fit-content !important;
+    max-width: 220px !important;
+    margin: 4px 0 12px !important;
+}
+.dc-validate-btn button:hover, button.dc-validate-btn:hover {
+    background: rgba(255,106,61,0.08) !important;
+    border-color: #FF8C5A !important;
+    color: #FF8C5A !important;
+}
+.dc-validate-btn button:disabled, button.dc-validate-btn:disabled {
+    opacity: 0.35 !important;
+    cursor: not-allowed !important;
+}
+
 .dc-var-hold .chip {
     flex: 1;
     text-align: center;