Confidence heatmap + drop v1 models from dropdown

- Model dropdown: only the two dataset-4 retrains (bertv2, robertav2)
- model.py: expose per-token softmax confidence, mean over merged entities
- viz.py + Live Parser: 'shade by confidence' heatmap toggle + debug panel
- Persist parse results across reruns

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

config.py

@@ -16,10 +16,7 @@ import os
 # Hugging Face owner + the canonical "best model" repo the app loads by default
 # and that the Manage Model page overwrites.
 HF_OWNER = os.environ.get("HF_OWNER", "Zeqhx")
-# Four published models, selectable in the UI:
-#   v1 = earlier (dataset-2) models, v2 = latest (dataset-4) retrains.
-BERT_V1_ID    = os.environ.get("DASHBOARD_BERT_V1_ID",    f"{HF_OWNER}/cv-parser-bert-v1")
-ROBERTA_V1_ID = os.environ.get("DASHBOARD_ROBERTA_V1_ID", f"{HF_OWNER}/cv-parser-roberta-v1")
+# Two published models, selectable in the UI. Both are dataset-4 retrains.
 BERT_V2_ID    = os.environ.get("DASHBOARD_BERT_V2_ID",    f"{HF_OWNER}/cv-parser-bert-v2")
 ROBERTA_V2_ID = os.environ.get("DASHBOARD_ROBERTA_V2_ID", f"{HF_OWNER}/cv-parser-roberta-v2")
 
@@ -36,8 +33,6 @@ DEMO_LABEL = "Demo — untrained roberta-base"
 # Toggle registry. Each entry: (label, kind, ref). "local" entries are only
 # offered when the folder exists (dev machines); "hub" entries are always offered.
 MODEL_REGISTRY = [
-    ("bertv1",    "hub", BERT_V1_ID),
-    ("robertav1", "hub", ROBERTA_V1_ID),
     ("bertv2",    "hub", BERT_V2_ID),
     ("robertav2", "hub", ROBERTA_V2_ID),
 ]

lib/model.py

@@ -130,6 +130,8 @@ def predict(text: str, lm: LoadedModel):
     attn_dev = attn.to(lm.device)
 
     logits = lm.model(input_ids=input_ids, attention_mask=attn_dev).logits
+    probs = logits.softmax(-1)            # keep the distribution, not just argmax
+    conf_all = probs.max(-1).values.cpu()  # per-token confidence of the chosen label
     preds = logits.argmax(-1).cpu()
 
     # Deduplicate overlapping sliding-window tokens by their global char offset.
@@ -142,15 +144,15 @@ def predict(text: str, lm: LoadedModel):
                 continue  # special token or padding
             if s in seen:
                 continue
-            seen[s] = (s, e, int(preds[w][i]))
+            seen[s] = (s, e, int(preds[w][i]), float(conf_all[w][i]))
 
     tokens = []
     for s in sorted(seen):
-        _, e, pid = seen[s]
+        _, e, pid, conf = seen[s]
         label = lm.id2label.get(pid, "O")
         etype = label.split("-", 1)[1] if "-" in label else None
         tokens.append({"text": text[s:e], "label": label, "type": etype,
-                       "start": s, "end": e})
+                       "start": s, "end": e, "conf": conf})
 
     entities = _merge_bio(tokens, text)
     return tokens, entities
@@ -171,14 +173,18 @@ def _merge_bio(tokens, text):
         if prefix == "B" or cur is None or cur["type"] != etype:
             if cur:
                 entities.append(cur)
-            cur = {"type": etype, "start": t["start"], "end": t["end"]}
+            cur = {"type": etype, "start": t["start"], "end": t["end"],
+                   "confs": [t.get("conf", 1.0)]}
         else:  # I- continuing the same type
             cur["end"] = t["end"]
+            cur["confs"].append(t.get("conf", 1.0))
     if cur:
         entities.append(cur)
 
     for e in entities:
         e["text"] = text[e["start"]:e["end"]].strip()
+        confs = e.pop("confs", []) or [1.0]
+        e["conf"] = sum(confs) / len(confs)  # mean confidence over member tokens
     return [e for e in entities if e["text"]]
 
 

lib/viz.py

@@ -6,6 +6,50 @@ import html
 import config
 
 
+def _hex_to_rgba(hex_color: str, alpha: float) -> str:
+    """'#2a9d8f' + alpha -> 'rgba(42,157,143,0.83)'."""
+    h = hex_color.lstrip("#")
+    r, g, b = (int(h[i:i + 2], 16) for i in (0, 2, 4))
+    return f"rgba({r},{g},{b},{alpha:.2f})"
+
+
+# --- Confidence heatmap ramp: low (red) -> mid (orange) -> high (teal) -------
+_RAMP_LO = (214, 40, 40)     # low confidence
+_RAMP_MID = (244, 162, 97)   # mid
+_RAMP_HI = (42, 157, 143)    # high confidence
+
+
+def _lerp(a: tuple, b: tuple, t: float) -> tuple:
+    return tuple(round(a[i] + (b[i] - a[i]) * t) for i in range(3))
+
+
+def _conf_color(t: float) -> str:
+    """0..1 -> rgb on the red->orange->teal ramp."""
+    t = max(0.0, min(1.0, t))
+    r, g, b = (_lerp(_RAMP_LO, _RAMP_MID, t / 0.5) if t < 0.5
+               else _lerp(_RAMP_MID, _RAMP_HI, (t - 0.5) / 0.5))
+    return f"rgb({r},{g},{b})"
+
+
+def _stretch(conf: float, lo: float, hi: float) -> float:
+    """Contrast-stretch a confidence into 0..1 across the observed [lo, hi]."""
+    if hi - lo < 1e-6:
+        return 1.0
+    return (conf - lo) / (hi - lo)
+
+
+def _conf_legend(lo: float, hi: float) -> str:
+    grad = (f"linear-gradient(to right, rgb{_RAMP_LO}, rgb{_RAMP_MID}, rgb{_RAMP_HI})")
+    return (
+        '<div style="margin-bottom:10px;font-size:0.8rem;color:#444">'
+        f'<span style="margin-right:8px">low ({lo:.0%})</span>'
+        f'<span style="display:inline-block;width:180px;height:12px;background:{grad};'
+        'border-radius:3px;vertical-align:middle"></span>'
+        f'<span style="margin-left:8px">high ({hi:.0%}) — colour stretched across this CV</span>'
+        '</div>'
+    )
+
+
 def _legend() -> str:
     items = []
     for t in config.ENTITY_TYPES:
@@ -17,48 +61,75 @@ def _legend() -> str:
     return '<div style="margin-bottom:10px">' + "".join(items) + "</div>"
 
 
-def render_entities_html(text: str, entities: list[dict]) -> str:
-    """Original text with entity spans wrapped in coloured marks."""
+def render_entities_html(text: str, entities: list[dict],
+                         shade_by_conf: bool = False) -> str:
+    """Original text with entity spans wrapped in coloured marks.
+
+    When ``shade_by_conf`` is set, each mark's background opacity reflects the
+    model's mean confidence for that entity, and the % is shown in the tooltip.
+    """
     ents = sorted((e for e in entities if e["type"] in config.ENTITY_COLORS),
                   key=lambda e: e["start"])
+    cvals = [e.get("conf", 1.0) for e in ents] or [1.0]
+    lo, hi = min(cvals), max(cvals)
     out, cursor = [], 0
     for e in ents:
         if e["start"] < cursor:  # skip any overlap defensively
             continue
         out.append(html.escape(text[cursor:e["start"]]))
-        color = config.ENTITY_COLORS[e["type"]]
+        hex_color = config.ENTITY_COLORS[e["type"]]
         label = config.ENTITY_LABELS[e["type"]]
+        conf = e.get("conf", 1.0)
+        if shade_by_conf:
+            bg = _conf_color(_stretch(conf, lo, hi))
+            title = f"{label} · {conf:.0%} confidence"
+        else:
+            bg = hex_color
+            title = label
         out.append(
-            f'<mark style="background:{color};color:#fff;padding:1px 4px;'
-            f'border-radius:4px" title="{label}">'
+            f'<mark style="background:{bg};color:#fff;padding:1px 4px;'
+            f'border-radius:4px" title="{title}">'
             f'{html.escape(text[e["start"]:e["end"]])}'
             f'<sub style="font-size:0.6em;opacity:.85"> {label}</sub></mark>'
         )
         cursor = e["end"]
     out.append(html.escape(text[cursor:]))
     body = "".join(out).replace("\n", "<br>")
-    return (_legend() +
+    return ((_conf_legend(lo, hi) if shade_by_conf else _legend()) +
             f'<div style="line-height:2.1;font-family:system-ui;font-size:0.95rem;'
             f'border:1px solid #ddd;border-radius:8px;padding:16px;'
             f'max-height:520px;overflow:auto">{body}</div>')
 
 
-def render_tokens_html(tokens: list[dict], limit: int = 400) -> str:
-    """Sub-word token chips, coloured by predicted label — the 'tokenization view'."""
+def render_tokens_html(tokens: list[dict], limit: int = 400,
+                       shade_by_conf: bool = False) -> str:
+    """Sub-word token chips, coloured by predicted label — the 'tokenization view'.
+
+    When ``shade_by_conf`` is set, each chip's background opacity reflects the
+    model's confidence in that token's label (low-confidence chips fade out),
+    and the exact % shows on hover.
+    """
+    shown = tokens[:limit]
+    cvals = [t.get("conf", 1.0) for t in shown] or [1.0]
+    lo, hi = min(cvals), max(cvals)
     chips = []
-    for t in tokens[:limit]:
+    for t in shown:
         txt = html.escape(t["text"]) or "·"
-        if t["type"] in config.ENTITY_COLORS:
-            color = config.ENTITY_COLORS[t["type"]]
-            style = f"background:{color};color:#fff"
+        conf = t.get("conf", 1.0)
+        title = f"{t['label']} · {conf:.0%}"
+        if shade_by_conf:
+            # Pure confidence heatmap: every token coloured on the ramp.
+            style = f"background:{_conf_color(_stretch(conf, lo, hi))};color:#fff"
+        elif t["type"] in config.ENTITY_COLORS:
+            style = f"background:{config.ENTITY_COLORS[t['type']]};color:#fff"
         else:
             style = "background:#eee;color:#555"
         chips.append(
-            f'<span style="{style};padding:2px 6px;border-radius:4px;margin:2px;'
-            f'display:inline-block;font-family:monospace;font-size:0.8rem">{txt}</span>'
+            f'<span title="{title}" style="{style};padding:2px 6px;border-radius:4px;'
+            f'margin:2px;display:inline-block;font-family:monospace;font-size:0.8rem">{txt}</span>'
         )
     more = "" if len(tokens) <= limit else f'<div style="color:#888;margin-top:8px">… +{len(tokens)-limit} more tokens</div>'
-    return (_legend() +
+    return ((_conf_legend(lo, hi) if shade_by_conf else _legend()) +
             f'<div style="border:1px solid #ddd;border-radius:8px;padding:12px;'
             f'max-height:420px;overflow:auto">{"".join(chips)}{more}</div>')
 

pages/1_Live_Parser.py

@@ -35,11 +35,15 @@ else:
 
 run = st.button("Parse CV", type="primary", disabled=not text.strip())
 
-# ---- Output -----------------------------------------------------------------
 if run and text.strip():
     with st.spinner("Tokenizing and classifying…"):
         tokens, entities = predict(text, lm)
+    st.session_state["parse"] = {"text": text, "tokens": tokens, "entities": entities}
 
+# ---- Output (persists across reruns, e.g. when flipping the toggle) ---------
+parse = st.session_state.get("parse")
+if parse:
+    text, tokens, entities = parse["text"], parse["tokens"], parse["entities"]
     grouped = group_entities(entities)
     c1, c2, c3, c4 = st.columns(4)
     c1.metric("Sub-word tokens", len(tokens))
@@ -47,16 +51,41 @@ if run and text.strip():
     c3.metric("Skills", len(grouped["SKILL"]))
     c4.metric("Education", len(grouped["EDUCATION"]))
 
+    shade = st.toggle(
+        "🌡️ Shade by confidence",
+        value=False,
+        help="Fade each entity / token by how confident the model is in its label "
+             "(softmax probability). Hover any span to see the exact %.",
+    )
+
+    with st.expander("🐞 Debug — toggle state & confidence distribution"):
+        confs = [t.get("conf", 1.0) for t in tokens]
+        st.write({
+            "toggle `shade` value": shade,
+            "n_tokens": len(tokens),
+            "conf min": round(min(confs), 4) if confs else None,
+            "conf mean": round(sum(confs) / len(confs), 4) if confs else None,
+            "conf max": round(max(confs), 4) if confs else None,
+        })
+        st.caption("If min≈max≈1.0, the model is uniformly confident and shading is "
+                   "visually subtle by design — not a bug. Entity confidences:")
+        st.table([
+            {"entity": e["text"], "type": e["type"], "conf %": f"{e.get('conf', 1.0):.1%}"}
+            for e in entities
+        ])
+
     tab_ent, tab_tok, tab_card = st.tabs(
         ["🏷️ Highlighted entities", "🔢 Tokenization view", "🗂️ Structured summary"])
 
     with tab_ent:
-        st.markdown(viz.render_entities_html(text, entities), unsafe_allow_html=True)
+        st.markdown(viz.render_entities_html(text, entities, shade_by_conf=shade),
+                    unsafe_allow_html=True)
 
     with tab_tok:
         st.caption("Each chip is one sub-word token produced by the tokenizer, "
                    "coloured by its predicted label.")
-        st.markdown(viz.render_tokens_html(tokens), unsafe_allow_html=True)
+        st.markdown(viz.render_tokens_html(tokens, shade_by_conf=shade),
+                    unsafe_allow_html=True)
 
     with tab_card:
         cols = st.columns(3)