dashboard: tabs layout + extraction-generations view

Layout: per-question cards now use tabs instead of side-by-side
columns, so each answer renders full-width and reads naturally.
Applies to baseline-vs-steered cards and to the
extraction-method-comparison view.

New view: "extraction generations (pos vs neg)" — walks
data/model_responses/extract/<model>/<rev>/<vec>_{pos,neg}_instruct.csv
and shows the persona+ vs persona- generations that defined each
vector, sortable by pos-neg trait gap. Includes the 4 evil
extraction-method pairs on Olmo-3-1025-7B/main.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

analysis/dashboard.py

@@ -28,6 +28,7 @@ import streamlit as st
 
 REPO = Path(__file__).resolve().parents[1]
 EVAL_ROOT = REPO / "data/model_responses/eval"
+EXTRACT_ROOT = REPO / "data/model_responses/extract"
 
 # Known persona-vector trait prefixes. Judge-score columns inside CSVs
 # take the form "<prefix>_character_neutral_q", "<prefix>_stories_neutral_q",
@@ -313,6 +314,64 @@ def load_csv(path: Path) -> pd.DataFrame:
     return pd.read_csv(path)
 
 
+@dataclass(frozen=True)
+class Extract:
+    """One extraction-time pair (positive- and negative-persona generations
+    that defined a persona vector)."""
+    extract_model: str
+    extract_rev: str
+    trait: str
+    vec: str             # extraction method id, e.g. evil_character_neutral_q
+    pos_path: Path
+    neg_path: Path
+    trait_col: str
+
+    def title(self) -> str:
+        return (f"extraction method: **{self.vec}**  ·  "
+                f"**{self.extract_model}** @ **{self.extract_rev}**")
+
+
+@st.cache_data(show_spinner="Discovering extraction CSVs…")
+def discover_extracts() -> list[Extract]:
+    """Walk EXTRACT_ROOT for paired `<vec>_pos_instruct.csv` /
+    `<vec>_neg_instruct.csv` files and keep only those whose CSV header
+    contains a recognizable trait-score column."""
+    out: list[Extract] = []
+    if not EXTRACT_ROOT.exists():
+        return out
+    for model_dir in sorted(EXTRACT_ROOT.iterdir()):
+        if not model_dir.is_dir():
+            continue
+        for rev_dir in sorted(model_dir.iterdir()):
+            if not rev_dir.is_dir():
+                continue
+            pos_files = {p.name[:-len("_pos_instruct.csv")]: p
+                         for p in rev_dir.glob("*_pos_instruct.csv")}
+            for vec, pos_path in pos_files.items():
+                neg_path = rev_dir / f"{vec}_neg_instruct.csv"
+                if not neg_path.exists():
+                    continue
+                cols = _read_header(pos_path)
+                if cols is None:
+                    continue
+                tc = find_trait_column(cols)
+                if tc is None:
+                    continue
+                trait_col, trait = tc
+                if trait_col not in (_read_header(neg_path) or []):
+                    continue
+                out.append(Extract(
+                    extract_model=model_dir.name,
+                    extract_rev=rev_dir.name,
+                    trait=trait,
+                    vec=vec,
+                    pos_path=pos_path,
+                    neg_path=neg_path,
+                    trait_col=trait_col,
+                ))
+    return out
+
+
 def _safe_mean(s: pd.Series) -> float:
     return float(s.dropna().mean()) if len(s.dropna()) else float("nan")
 
@@ -324,54 +383,70 @@ def _sparse_tail(path: Path | None) -> str:
     return "…/" + "/".join(parts[-5:]) if len(parts) >= 5 else str(path)
 
 
+def _answer_text(row: pd.Series | None) -> str:
+    if row is None:
+        return "_(no row)_"
+    txt = str(row.get("answer", "")).strip()
+    return txt or "_(empty)_"
+
+
+def _fmt_num(x) -> str:
+    return f"{x:.1f}" if pd.notna(x) else "—"
+
+
 def _render_pair(question: str, base_row: pd.Series | None, steer_row: pd.Series,
                  trait_col: str) -> None:
+    """Per-question card: tabs for baseline / steered, full-width text."""
     st.markdown(f"**Q:** {question}")
-    c1, c2 = st.columns(2)
     bt = base_row.get(trait_col, float("nan")) if base_row is not None else float("nan")
     bc = base_row.get("coherence", float("nan")) if base_row is not None else float("nan")
     st_t = steer_row.get(trait_col, float("nan"))
     st_c = steer_row.get("coherence", float("nan"))
-    with c1:
-        st.markdown("*baseline*")
+    dt = (st_t - bt) if pd.notna(bt) else float("nan")
+    dt_str = f"  Δ={dt:+.1f}" if pd.notna(dt) else ""
+
+    base_label = f"baseline   trait={_fmt_num(bt)}  coh={_fmt_num(bc)}"
+    steer_label = f"steered    trait={_fmt_num(st_t)}{dt_str}  coh={_fmt_num(st_c)}"
+    tab_b, tab_s = st.tabs([base_label, steer_label])
+    with tab_b:
         if base_row is None:
             st.info("no baseline row for this question_id")
         else:
-            st.caption(f"trait={bt:.1f}   coh={bc:.1f}")
-            st.write(str(base_row.get("answer", "")).strip() or "_(empty)_")
-    with c2:
-        dt = (st_t - bt) if pd.notna(bt) else float("nan")
-        st.markdown("*steered*")
-        dt_str = f" (Δ={dt:+.1f})" if pd.notna(dt) else ""
-        st.caption(f"trait={st_t:.1f}{dt_str}   coh={st_c:.1f}")
-        st.write(str(steer_row.get("answer", "")).strip() or "_(empty)_")
+            st.write(_answer_text(base_row))
+    with tab_s:
+        st.write(_answer_text(steer_row))
     st.divider()
 
 
 def _render_compare(question: str, base_row: pd.Series | None,
                     method_runs: list[tuple[str, pd.Series]],
                     trait_col: str) -> None:
-    """Side-by-side rendering: baseline + one column per extraction method."""
+    """Tabs across baseline + each extraction method; full-width answer text."""
     st.markdown(f"**Q:** {question}")
-    columns = st.columns(1 + len(method_runs))
     bt = base_row.get(trait_col, float("nan")) if base_row is not None else float("nan")
     bc = base_row.get("coherence", float("nan")) if base_row is not None else float("nan")
-    with columns[0]:
-        st.markdown("*baseline*")
+
+    tab_labels: list[str] = [
+        f"baseline   trait={_fmt_num(bt)}  coh={_fmt_num(bc)}"
+    ]
+    for method, s_row in method_runs:
+        st_t = s_row.get(trait_col, float("nan"))
+        st_c = s_row.get("coherence", float("nan"))
+        dt = (st_t - bt) if pd.notna(bt) else float("nan")
+        dt_str = f"  Δ={dt:+.1f}" if pd.notna(dt) else ""
+        tab_labels.append(
+            f"{method}   trait={_fmt_num(st_t)}{dt_str}  coh={_fmt_num(st_c)}"
+        )
+
+    tabs = st.tabs(tab_labels)
+    with tabs[0]:
         if base_row is None:
             st.info("no baseline row")
         else:
-            st.caption(f"trait={bt:.1f}   coh={bc:.1f}")
-            st.write(str(base_row.get("answer", "")).strip() or "_(empty)_")
-    for col, (method, s_row) in zip(columns[1:], method_runs):
-        with col:
-            st_t = s_row.get(trait_col, float("nan"))
-            st_c = s_row.get("coherence", float("nan"))
-            dt = (st_t - bt) if pd.notna(bt) else float("nan")
-            dt_str = f" (Δ={dt:+.1f})" if pd.notna(dt) else ""
-            st.markdown(f"*{method}*")
-            st.caption(f"trait={st_t:.1f}{dt_str}   coh={st_c:.1f}")
-            st.write(str(s_row.get("answer", "")).strip() or "_(empty)_")
+            st.write(_answer_text(base_row))
+    for tab, (_method, s_row) in zip(tabs[1:], method_runs):
+        with tab:
+            st.write(_answer_text(s_row))
     st.divider()
 
 
@@ -649,34 +724,146 @@ def _render_compare_view(runs_c: list[Run]) -> None:
         _render_compare(question, b_row, method_rows, trait_col)
 
 
+def _extraction_sidebar(extracts: list[Extract]) -> Extract | None:
+    st.sidebar.header("model")
+    models = sorted({e.extract_model for e in extracts})
+    default_idx = (models.index("Olmo-3-1025-7B")
+                   if "Olmo-3-1025-7B" in models else 0)
+    model = st.sidebar.selectbox("model", models, index=default_idx)
+    e_m = [e for e in extracts if e.extract_model == model]
+
+    revs = sorted({e.extract_rev for e in e_m}, key=_rev_sort_key)
+    if len(revs) > 1:
+        rev = st.sidebar.selectbox("checkpoint", revs, index=len(revs) - 1)
+    else:
+        rev = revs[0]
+        st.sidebar.caption(f"checkpoint **{rev}** (only option)")
+    e_r = [e for e in e_m if e.extract_rev == rev]
+
+    st.sidebar.header("persona vector")
+    traits = sorted({e.trait for e in e_r})
+    trait = st.sidebar.selectbox("trait", traits)
+    e_t = [e for e in e_r if e.trait == trait]
+
+    methods = sorted({e.vec for e in e_t})
+    if len(methods) > 1:
+        method = st.sidebar.selectbox("extraction method", methods)
+    else:
+        method = methods[0]
+        st.sidebar.caption(f"extraction method **{method}** (only option)")
+    matches = [e for e in e_t if e.vec == method]
+    return matches[0] if matches else None
+
+
+def _render_extraction_view(extract: Extract) -> None:
+    st.markdown(extract.title())
+    st.caption(f"pos: `{_sparse_tail(extract.pos_path)}`"
+               f"   ·   neg: `{_sparse_tail(extract.neg_path)}`")
+
+    pos_df = load_csv(extract.pos_path)
+    neg_df = load_csv(extract.neg_path)
+    trait_col = extract.trait_col
+
+    pos_mean = _safe_mean(pos_df[trait_col])
+    neg_mean = _safe_mean(neg_df[trait_col])
+    pos_coh = _safe_mean(pos_df["coherence"]) if "coherence" in pos_df else float("nan")
+    neg_coh = _safe_mean(neg_df["coherence"]) if "coherence" in neg_df else float("nan")
+    cols = st.columns(4)
+    cols[0].metric("pos persona trait", f"{pos_mean:.2f}")
+    cols[1].metric("neg persona trait", f"{neg_mean:.2f}",
+                   delta=f"{neg_mean - pos_mean:+.2f}")
+    cols[2].metric("pos persona coherence", f"{pos_coh:.2f}")
+    cols[3].metric("neg persona coherence", f"{neg_coh:.2f}")
+
+    order = st.radio("sort per-question cards by",
+                     ("pos − neg trait gap (most-polarizing first)",
+                      "pos persona trait (descending)",
+                      "neg persona trait (descending)",
+                      "question text"),
+                     horizontal=True)
+
+    # group all generations (pos & neg) by question text
+    questions = sorted(set(pos_df["question"]).union(neg_df["question"]))
+    cards: list[tuple[str, pd.DataFrame, pd.DataFrame, float, float]] = []
+    for q in questions:
+        p = pos_df[pos_df["question"] == q]
+        n = neg_df[neg_df["question"] == q]
+        pm = _safe_mean(p[trait_col]) if len(p) else float("nan")
+        nm = _safe_mean(n[trait_col]) if len(n) else float("nan")
+        cards.append((q, p, n, pm, nm))
+
+    def _gap(c):
+        _, _, _, pm, nm = c
+        if pd.isna(pm) or pd.isna(nm):
+            return 0.0
+        return float(pm - nm)
+
+    if order.startswith("pos − neg"):
+        cards.sort(key=lambda c: -_gap(c))
+    elif order.startswith("pos persona"):
+        cards.sort(key=lambda c: -(c[3] if pd.notna(c[3]) else float("-inf")))
+    elif order.startswith("neg persona"):
+        cards.sort(key=lambda c: -(c[4] if pd.notna(c[4]) else float("-inf")))
+    else:
+        cards.sort(key=lambda c: c[0])
+
+    top_k = st.slider("show top-N questions", 5, len(cards),
+                      min(20, len(cards)))
+    for question, p, n, pm, nm in cards[:top_k]:
+        st.markdown(f"**Q:** {question}")
+        pos_label = f"pos persona  trait={_fmt_num(pm)}  ({len(p)} gens)"
+        neg_label = f"neg persona  trait={_fmt_num(nm)}  ({len(n)} gens)"
+        tab_p, tab_n = st.tabs([pos_label, neg_label])
+        with tab_p:
+            _render_gens(p, trait_col)
+        with tab_n:
+            _render_gens(n, trait_col)
+        st.divider()
+
+
+def _render_gens(df: pd.DataFrame, trait_col: str) -> None:
+    if df.empty:
+        st.info("no generations for this question on this side")
+        return
+    df = df.sort_values(trait_col, ascending=False, na_position="last")
+    for i, (_, row) in enumerate(df.iterrows(), start=1):
+        t = row.get(trait_col, float("nan"))
+        c = row.get("coherence", float("nan"))
+        st.caption(f"gen {i}   trait={_fmt_num(t)}  coh={_fmt_num(c)}")
+        st.write(_answer_text(row))
+        if i < len(df):
+            st.markdown("---")
+
+
 def main() -> None:
     st.set_page_config(page_title="Steered-output explorer", layout="wide")
     st.title("Steered-output explorer")
 
     runs = discover()
-    if not runs:
-        st.error(f"No steering CSVs found under {EVAL_ROOT}")
+    extracts = discover_extracts()
+    if not runs and not extracts:
+        st.error(f"No CSVs found under {EVAL_ROOT} or {EXTRACT_ROOT}")
         return
 
     st.sidebar.header("view")
-    view_options: list[str] = ["checkpoint sweep"]
+    view_options: list[str] = []
+    if runs:
+        view_options.append("checkpoint sweep")
     if any(r.run_kind == "ablation" for r in runs):
         view_options.append("vector extraction ablation")
+    if extracts:
+        view_options.append("extraction generations (pos vs neg)")
     view = st.sidebar.radio("data view", view_options, index=0,
                             label_visibility="collapsed")
-    view_kind = "ablation" if view.startswith("vector extraction") else "sweep"
-
-    runs_v = [r for r in runs if r.run_kind == view_kind]
-    if not runs_v:
-        st.warning(f"No runs available for view '{view}'.")
-        return
 
-    if view_kind == "sweep":
+    if view == "checkpoint sweep":
+        runs_v = [r for r in runs if r.run_kind == "sweep"]
         run = _sweep_sidebar(runs_v)
         if run is None:
             return
         _render_single(run)
-    else:
+    elif view == "vector extraction ablation":
+        runs_v = [r for r in runs if r.run_kind == "ablation"]
         runs_c, compare = _ablation_sidebar(runs_v)
         if not runs_c:
             st.warning("No run matches the current filters.")
@@ -684,14 +871,18 @@ def main() -> None:
         if compare and len({r.extract_rev for r in runs_c}) > 1:
             _render_compare_view(runs_c)
         else:
-            # single method (or only one method available) — fall back to the
-            # single-run view, picking a deterministic representative
             if len(runs_c) > 1:
                 run = st.sidebar.selectbox("run file (disambiguate)", runs_c,
                                            format_func=lambda r: _sparse_tail(r.steered_path))
             else:
                 run = runs_c[0]
             _render_single(run)
+    else:  # extraction generations
+        ext = _extraction_sidebar(extracts)
+        if ext is None:
+            st.warning("No extraction pair matches the current filters.")
+            return
+        _render_extraction_view(ext)
 
 
 if __name__ == "__main__":