Upload folder using huggingface_hub

README.md

@@ -0,0 +1,25 @@
+# Pentabrid 27B — Reproducibility Package
+
+Artifacts supporting the Nature Medicine Matters Arising response to Oermann & Vishwanath (2026), "General-purpose LLMs outperform specialized clinical AI tools on medical benchmarks" (s41591-026-04431-5).
+
+## Core finding
+At fixed scale and offline (no retrieval), the specialization procedure determines medical reasoning performance. A short-CoT fine-tune (V13) collapsed the base model's reasoning (about 3,100 to about 760 tokens) and dropped MedXpertQA accuracy by 16.9 points; a corrected long-CoT approach (V14) restored reasoning length and recovered accuracy to near-parity. Framing: recovery to near-parity (41.7 vs 43.8), reversing the regression, not superiority over the base model.
+
+## Results (MedXpertQA, full 2,450 questions; scorer-verified)
+See results_summary.csv. Base 43.76, V13 26.90, V14 41.67, V15 41.35, V16 (alpha=64) 42.20. V15 and V16 are two independent null ablations confirming the recovery is robust to configuration.
+
+## Contents
+- scripts/merge_medxpertqa.py — the scorer (exact match on 'Answer: X'; audit this for the no-inflation claim)
+- scripts/eval_generic_medxpertqa.slurm, eval_mcq_hf.* — evaluation harnesses
+- scripts/train_v14.py + .sbatch, merge_lora_v14.py — training and adapter merge
+- scripts/probe_*.py — reasoning-structure probes
+- results_summary.csv — the locked results table
+
+## Base model and benchmarks (not redistributed here)
+Base: Qwen3.6-27B (official Qwen repository). Benchmarks: MedXpertQA, MedQA, MedMCQA, used under their own licenses, not included here.
+
+## Authors
+Prof. Adnan Agha (ORCID 0000-0002-2704-8931) and Eram Anwar (ORCID 0009-0006-9335-9208), UAEU College of Medicine and Health Sciences / Tawam Hospital. IP: UAEU Application #2442.
+
+## License
+CC-BY-NC-ND-4.0

results_summary.csv

@@ -0,0 +1,6 @@
+model,mix,medxpertqa_2450,medqa_500,medmcqa_500,median_think_tokens
+Base,-,43.76,86.8,73.8,3100
+V13,curated-heavy short-CoT,26.90,84.4,71.6,760
+V14,74pct RFT / 26pct curated,41.67,84.4,76.0,3700
+V15,50/50,41.35,84.4,74.6,3738
+V16,50/50 alpha=64,42.20,83.8,73.4,4000

scripts/eval_generic_medxpertqa.slurm

@@ -0,0 +1,38 @@
+#!/bin/bash
+# PENTABRID - generic MedXpertQA-Text eval (reusable for ANY model).
+# Pass MODEL_DIR and OUT_DIR at submit time; num-shards auto-matches the array width.
+#
+#   # V13 re-run (finishes fast - it stops early):
+#   sbatch --array=0-3 --job-name=v13_8k \
+#     --export=ALL,MODEL_DIR=$HOME/pentabrid/runs/V13_27B_merged,OUT_DIR=$HOME/pentabrid/runs/V13_eval_8k \
+#     ~/pentabrid/scripts/eval_generic_medxpertqa.slurm
+#
+#   # BASE re-run (the slow one - it reasons long; use more shards):
+#   sbatch --array=0-7 --job-name=base_8k \
+#     --export=ALL,MODEL_DIR=/home/adnanagha/pentabrid/base_models/Qwen3.6-27B,OUT_DIR=$HOME/pentabrid/runs/BASE_eval_8k \
+#     ~/pentabrid/scripts/eval_generic_medxpertqa.slurm
+#
+#SBATCH --partition=gpuq
+#SBATCH --gres=gpu:1
+#SBATCH --array=0-3
+#SBATCH --time=24:00:00
+#SBATCH --mem=120G
+#SBATCH --job-name=medx_gen
+#SBATCH --output=medx_%x_%A_%a.out
+
+module load cuda/12.2
+source ~/miniforge3/bin/activate pentabrid
+
+: "${MODEL_DIR:?set MODEL_DIR via --export}"
+: "${OUT_DIR:?set OUT_DIR via --export}"
+export MEDX_DIR=${MEDX_DIR:-$HOME/pentabrid/datasets/MedXpertQA}
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+mkdir -p "$OUT_DIR"
+
+echo "host=$(hostname)  task=$SLURM_ARRAY_TASK_ID/$SLURM_ARRAY_TASK_COUNT  model=$MODEL_DIR  out=$OUT_DIR  $(date)"
+nvidia-smi --query-gpu=name,memory.total --format=csv,noheader
+
+python ~/pentabrid/scripts/eval_medxpertqa_hf_v2.py \
+    --shard-id "$SLURM_ARRAY_TASK_ID" --num-shards "$SLURM_ARRAY_TASK_COUNT" --batch-size 8
+
+echo "task=$SLURM_ARRAY_TASK_ID done  $(date)"

scripts/eval_mcq_hf.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+PENTABRID - generation-based MCQ evaluator (MedMCQA / MedQA), fixed parser.
+===========================================================================
+Same HF-generation method and v2 parser as the MedXpert evaluator, so V13 and
+base are scored identically and the "answer is" -> "I" trap is gone. Saves the
+full answer text per question (re-analysable) and writes a score json.
+
+Run on a single A100 (these sets are small). Cache the dataset on the LOGIN node
+first (compute nodes are offline), then run with HF_DATASETS_OFFLINE=1.
+
+SMOKE FIRST (verify the schema parsed correctly before the full run):
+    MODEL_DIR=$HOME/pentabrid/runs/V13_27B_merged OUT_DIR=$HOME/pentabrid/runs/V13_mcq \
+    python eval_mcq_hf.py --dataset medmcqa --limit 3 --batch-size 1
+  -> prints the detected (question, options, gold) for the first few rows. If gold
+     letters and option text look right, drop --limit and run for real.
+
+FULL RUNS (examples):
+    # MedMCQA, 1000 questions, V13:
+    MODEL_DIR=$HOME/pentabrid/runs/V13_27B_merged OUT_DIR=$HOME/pentabrid/runs/V13_mcq \
+    python eval_mcq_hf.py --dataset medmcqa --limit 1000 --seed 62
+    # MedQA-500 (seed 62), base:
+    MODEL_DIR=/home/adnanagha/pentabrid/base_models/Qwen3.6-27B OUT_DIR=$HOME/pentabrid/runs/BASE_mcq \
+    python eval_mcq_hf.py --dataset medqa --limit 500 --seed 62
+
+Data source: by default loads the dataset from the HF cache (set the id with --hf
+if yours differs). Or point --jsonl at a local file you already downloaded.
+"""
+import os, re, json, argparse, random
+from pathlib import Path
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+ap = argparse.ArgumentParser()
+ap.add_argument("--dataset", choices=["medmcqa", "medqa"], help="built-in schema + default HF id/split")
+ap.add_argument("--hf", default=None, help="override HF dataset id")
+ap.add_argument("--config", default=None, help="HF dataset config name (if any)")
+ap.add_argument("--split", default=None, help="override split (medmcqa->validation, medqa->test)")
+ap.add_argument("--jsonl", default=None, help="load from a local jsonl instead of HF")
+ap.add_argument("--limit", type=int, default=0, help="cap number of questions (0 = all)")
+ap.add_argument("--seed", type=int, default=62, help="seed for the subsample shuffle")
+ap.add_argument("--batch-size", type=int, default=8)
+args = ap.parse_args()
+
+MODEL = os.environ["MODEL_DIR"]
+OUTDIR = Path(os.environ.get("OUT_DIR", MODEL)); OUTDIR.mkdir(parents=True, exist_ok=True)
+tag = args.dataset or "custom"
+OUT = OUTDIR / f"{tag}_results.jsonl"
+SCORE = OUTDIR / f"{tag}_score.json"
+
+# ---------------------------------------------------------------------------
+# schema registry: (default HF id, default split, row->(question, options{}, gold))
+# ---------------------------------------------------------------------------
+def _med_mcqa(r):
+    opts = {"A": r.get("opa",""), "B": r.get("opb",""), "C": r.get("opc",""), "D": r.get("opd","")}
+    cop = r.get("cop", r.get("answer", ""))
+    gold = ""
+    if isinstance(cop, int): gold = "ABCD"[cop] if 0 <= cop < 4 else ""
+    elif isinstance(cop, str):
+        s = cop.strip()
+        if s.isdigit() and 0 <= int(s) < 4: gold = "ABCD"[int(s)]
+        elif s[:1].upper() in "ABCD": gold = s[:1].upper()
+    return r.get("question",""), opts, gold
+
+def _med_qa(r):
+    q = r.get("question","")
+    o = r.get("options")
+    if isinstance(o, dict):    options = {k.upper(): v for k, v in o.items()}
+    elif isinstance(o, list):  options = {chr(65+i): v for i, v in enumerate(o)}
+    else:                      options = {}
+    a = r.get("answer_idx", r.get("answer", r.get("answer_letter","")))
+    gold = ""
+    if isinstance(a, int):                          gold = chr(65+a)
+    elif isinstance(a, str) and len(a.strip()) <= 2 and a.strip()[:1].upper() in "ABCDEFGHIJ":
+        gold = a.strip()[:1].upper()
+    elif isinstance(a, str):                        # answer given as full text -> match option
+        na = re.sub(r"\s+"," ",a.lower()).strip()
+        for k, v in options.items():
+            if re.sub(r"\s+"," ",str(v).lower()).strip() == na: gold = k; break
+    return q, options, gold
+
+REGISTRY = {
+    "medmcqa": ("openlifescienceai/medmcqa", "validation", _med_mcqa),
+    "medqa":   ("GBaker/MedQA-USMLE-4-options", "test",     _med_qa),
+}
+
+# ---------------------------------------------------------------------------
+# load rows
+# ---------------------------------------------------------------------------
+if args.jsonl:
+    rows = [json.loads(l) for l in open(args.jsonl) if l.strip()]
+    extract = REGISTRY[args.dataset][2] if args.dataset else None
+    if extract is None:
+        raise SystemExit("With --jsonl you must also pass --dataset for the schema (medmcqa/medqa).")
+    src = args.jsonl
+else:
+    if not args.dataset and not args.hf:
+        raise SystemExit("Pass --dataset medmcqa|medqa (or --hf <id> with --dataset for schema).")
+    hf_id, split, extract = REGISTRY[args.dataset]
+    hf_id = args.hf or hf_id
+    split = args.split or split
+    from datasets import load_dataset
+    ds = load_dataset(hf_id, args.config, split=split) if args.config else load_dataset(hf_id, split=split)
+    rows = [dict(x) for x in ds]
+    src = f"{hf_id}:{split}"
+print(f"Loaded {len(rows)} rows from {src}", flush=True)
+
+# reproducible subsample
+if args.limit and args.limit > 0 and args.limit < len(rows):
+    rnd = random.Random(args.seed); idx = list(range(len(rows))); rnd.shuffle(idx)
+    rows = [rows[i] for i in idx[:args.limit]]
+    print(f"Subsampled to {len(rows)} (seed {args.seed})", flush=True)
+
+# ---------------------------------------------------------------------------
+# prompt + v2 parser (identical to eval_medxpertqa_hf_v2.py)
+# ---------------------------------------------------------------------------
+def build_prompt(q, options):
+    lines = [q, ""]
+    for k in sorted(options): lines.append(f"{k}. {options[k]}")
+    lines += ["", "Think step by step, then end with exactly: 'Answer: X' where X is the letter."]
+    return "\n".join(lines)
+
+_PATS = [
+    r"\bfinal\s+answer\b\s*(?:is|:|=|-)?\s*\(?\*{0,2}([A-J])\b",
+    r"\bcorrect\s+(?:answer|option|choice)\b\s*(?:is|:|=|-)?\s*\(?\*{0,2}([A-J])\b",
+    r"\banswer\s*(?:is|:|=|-)\s*\(?\*{0,2}([A-J])\b",
+    r"\bthe answer is\b\s*\(?\*{0,2}([A-J])\b",
+    r"\banswer\s+\(?\*{0,2}([A-J])\b",
+    r"\b(?:option|choice)\s*(?:is|:|=|-)?\s*\(?\*{0,2}([A-J])\b",
+]
+def parse_letter(text):
+    if not text: return ""
+    seg = text.rsplit("</think>", 1)[-1]; seg = seg if seg.strip() else text
+    for pat in _PATS:
+        m = re.findall(pat, seg, re.IGNORECASE)
+        if m: return m[-1].upper()
+    m = re.findall(r"\banswer\s*(?:is|:|=|-)?\s*\(?\*{0,2}([A-J])\b", text, re.IGNORECASE)
+    if m: return m[-1].upper()
+    m = re.findall(r"\*\*\s*([A-J])\s*\*\*|\(\s*([A-J])\s*\)", seg)
+    flat=[x for p in m for x in p if x]
+    if flat: return flat[-1].upper()
+    m = re.findall(r"\b([A-J])\b", seg)
+    return m[-1].upper() if m else ""
+
+# parse all rows up front; show a sample so schema errors are caught immediately
+parsed = []
+for i, r in enumerate(rows):
+    q, options, gold = extract(r)
+    parsed.append((str(r.get("id", i)), q, options, gold))
+print("\n--- schema check (first up to 3 rows) ---", flush=True)
+for rid, q, options, gold in parsed[:3]:
+    print(f"  id={rid}  gold={gold!r}  #opts={len(options)}  q[:80]={q[:80]!r}", flush=True)
+    for k in sorted(options): print(f"      {k}. {str(options[k])[:60]}", flush=True)
+bad_gold = sum(1 for _,_,_,g in parsed if not g)
+if bad_gold: print(f"  WARNING: {bad_gold}/{len(parsed)} rows have no parseable gold - check the schema/split.", flush=True)
+print("--- end schema check ---\n", flush=True)
+
+# ---------------------------------------------------------------------------
+# load model
+# ---------------------------------------------------------------------------
+print(f"Loading model from {MODEL} ...", flush=True)
+tok = AutoTokenizer.from_pretrained(MODEL); tok.padding_side = "left"
+if tok.pad_token is None: tok.pad_token = tok.eos_token
+model = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.bfloat16, device_map="cuda").eval()
+print("model loaded.", flush=True)
+
+# ---------------------------------------------------------------------------
+# batched greedy generation (section-5 return_dict fix)
+# ---------------------------------------------------------------------------
+B = max(1, args.batch_size); correct = run = 0
+with open(OUT, "w") as fout:
+    for start in range(0, len(parsed), B):
+        batch = parsed[start:start+B]
+        msgs = [[{"role":"user","content":build_prompt(q, o)}] for _,q,o,_ in batch]
+        enc = tok.apply_chat_template(msgs, add_generation_prompt=True,
+                                      return_tensors="pt", return_dict=True, padding=True).to(model.device)
+        with torch.no_grad():
+            out = model.generate(**enc, max_new_tokens=2048, do_sample=False, pad_token_id=tok.pad_token_id)
+        gen = out[:, enc["input_ids"].shape[1]:]
+        texts = tok.batch_decode(gen, skip_special_tokens=True)
+        for (rid,q,o,gold), text in zip(batch, texts):
+            pred = parse_letter(text); ok = bool(pred) and pred == gold
+            correct += int(ok); run += 1
+            fout.write(json.dumps({"id":rid,"pred":pred,"gold":gold,"correct":ok,"text":text})+"\n")
+        fout.flush()
+        print(f"  {run}/{len(parsed)} done  acc {100.0*correct/max(1,run):.1f}%", flush=True)
+
+acc = 100.0*correct/max(1,len(parsed))
+SCORE.write_text(json.dumps({"dataset":tag,"raw":correct,"total":len(parsed),
+                             "accuracy_pct":round(acc,2),"parser":"fixed_v2"}, indent=2))
+print(f"\n{tag}  raw={correct}/{len(parsed)}  accuracy={acc:.2f}%\nWrote {SCORE}", flush=True)

scripts/measure_reasoning_v14.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+PENTABRID V14 — MEASURE REASONING LENGTH (Gate G1)
+==================================================
+Reads MedXpertQA eval result shards (medxpertqa_results_shard*.jsonl, each row
+{id, pred, gold, correct, text}) and reports the distribution of REASONING
+tokens, so you can compare V14 vs base.
+Target: V14 median ~= base (~3,000), far above V13's collapsed ~760.
+
+Tokens are counted with the base model's tokenizer (CPU only, no GPU needed).
+The "reasoning" is the text inside <think>...</think> if present, else everything
+before the final 'Answer:' line.
+
+USAGE:
+    python3 measure_reasoning_v14.py <results_dir>
+e.g.
+    python3 measure_reasoning_v14.py ~/pentabrid/runs/BASE_eval_8k
+    python3 measure_reasoning_v14.py ~/pentabrid/runs/V14_27B_merged
+"""
+import sys, os, re, json, glob, statistics
+
+TOKENIZER_SRC = os.environ.get("TOKENIZER_SRC",
+                               "/home/adnanagha/pentabrid/base_models/Qwen3.6-27B")
+
+
+def reasoning_part(text):
+    m = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
+    if m:
+        return m.group(1)
+    idx = text.rfind("Answer:")
+    return text[:idx] if idx > 0 else text
+
+
+def main(results_dir):
+    files = glob.glob(os.path.join(results_dir, "medxpertqa_results_shard*.jsonl"))
+    if not files:
+        sys.exit(f"No medxpertqa_results_shard*.jsonl found in {results_dir}")
+
+    try:
+        from transformers import AutoTokenizer
+        tok = AutoTokenizer.from_pretrained(TOKENIZER_SRC)
+        count = lambda s: len(tok.encode(s, add_special_tokens=False))
+        method = "tokenizer"
+    except Exception as e:
+        print(f"(tokenizer unavailable: {e}\n using chars/4 estimate instead)")
+        count = lambda s: len(s) // 4
+        method = "chars/4"
+
+    lengths = []
+    for fp in files:
+        for line in open(fp):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                r = json.loads(line)
+            except Exception:
+                continue
+            lengths.append(count(reasoning_part(r.get("text", ""))))
+
+    lengths.sort()
+    n = len(lengths)
+    if n == 0:
+        sys.exit("no records found")
+    pct = lambda q: lengths[min(n - 1, int(q * n))]
+    print(f"results dir : {results_dir}")
+    print(f"records     : {n}   (token method: {method})")
+    print(f"reasoning tokens  median={statistics.median(lengths):.0f}  "
+          f"mean={statistics.mean(lengths):.0f}  p25={pct(0.25)}  p75={pct(0.75)}  "
+          f"min={lengths[0]}  max={lengths[-1]}")
+    print(f"  long (>=1500 tok): {sum(1 for x in lengths if x >= 1500)}/{n}    "
+          f"short (<800 tok): {sum(1 for x in lengths if x < 800)}/{n}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        sys.exit("usage: python3 measure_reasoning_v14.py <results_dir>")
+    main(sys.argv[1])

scripts/merge_lora_v14.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""
+PENTABRID V14 — MERGE LoRA ADAPTER INTO BASE
+============================================
+Produces a standalone merged model the eval script can load directly
+(same loader as eval_medxpertqa_hf.py, no trust_remote_code).
+
+Run on ONE GPU (fits a 27B bf16 copy on an 80 GB A100). USAGE:
+    srun --partition=gpuq --gres=gpu:1 --time=01:00:00 --pty bash
+    # then on the node:
+    module load cuda/12.6
+    source /home/adnanagha/miniforge3/etc/profile.d/conda.sh && conda activate pentabrid
+    python3 ~/pentabrid/scripts/merge_lora_v14.py
+"""
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+
+BASE    = os.environ.get("BASE",    "/home/adnanagha/pentabrid/base_models/Qwen3.6-27B")
+ADAPTER = os.environ.get("ADAPTER", "/home/adnanagha/pentabrid/runs/V14_lora")
+OUT     = os.environ.get("OUT",     "/home/adnanagha/pentabrid/runs/V14_27B_merged")
+
+print(f"loading base from {BASE} ...", flush=True)
+base = AutoModelForCausalLM.from_pretrained(BASE, torch_dtype=torch.bfloat16)
+print(f"applying adapter from {ADAPTER} ...", flush=True)
+model = PeftModel.from_pretrained(base, ADAPTER)
+print("merging adapter into weights ...", flush=True)
+model = model.merge_and_unload()
+print(f"saving merged model -> {OUT} ...", flush=True)
+model.save_pretrained(OUT, safe_serialization=True)
+AutoTokenizer.from_pretrained(BASE).save_pretrained(OUT)
+print(f"DONE. For evaluation, set  MODEL_DIR={OUT}", flush=True)

scripts/merge_medxpertqa.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""
+PENTABRID V13 (27B) - merge sharded MedXpertQA-Text results into one score.
+Run AFTER every array task has finished.
+
+    MODEL_DIR=$HOME/pentabrid/runs/V13_27B_merged \
+    MEDX_DIR=$HOME/pentabrid/datasets/MedXpertQA \
+    python merge_medxpertqa.py
+
+Writes medxpertqa_text_score.json with the same schema as the original vLLM
+script: {"raw": int, "total": int, "accuracy_pct": float}.
+De-dupes by question id, so a re-run shard cannot double-count, and sanity-checks
+the total against the test-set size to catch a missing or still-running shard.
+NOTE: only reads medxpertqa_results_shard*.jsonl - smoke files
+(medxpertqa_smoketest_*.jsonl) are deliberately ignored.
+"""
+import os, json, glob
+from pathlib import Path
+
+MODEL = os.environ["MODEL_DIR"]
+MEDX  = os.environ.get("MEDX_DIR", f"{os.environ['HOME']}/pentabrid/datasets/MedXpertQA")
+
+# expected total = number of questions in the Text test set
+cands = glob.glob(f"{MEDX}/**/Text/**/test*.jsonl", recursive=True) + \
+        glob.glob(f"{MEDX}/**/test*.jsonl", recursive=True)
+expected = None
+if cands:
+    test_file = sorted(cands)[0]
+    expected = sum(1 for l in open(test_file) if l.strip())
+
+# gather every real shard file (NOT the smoke files)
+shard_files = sorted(glob.glob(f"{MODEL}/medxpertqa_results_shard*.jsonl"))
+if not shard_files:
+    raise SystemExit(f"No shard result files found under {MODEL}")
+print(f"Merging {len(shard_files)} shard file(s):")
+for f in shard_files:
+    print("  -", f)
+
+seen = {}                       # id -> correct(bool); de-dupes across/within shards
+for f in shard_files:
+    for line in open(f):
+        line = line.strip()
+        if not line:
+            continue
+        rec = json.loads(line)
+        seen[rec["id"]] = bool(rec["correct"])
+
+total   = len(seen)
+correct = sum(1 for v in seen.values() if v)
+acc     = 100.0 * correct / max(1, total)
+
+print(f"\nMedXpertQA-Text  raw={correct}/{total}  accuracy={acc:.2f}%")
+if expected is not None:
+    if total == expected:
+        print(f"OK: counted all {expected} questions.")
+    else:
+        print(f"WARNING: expected {expected} questions but merged {total}. "
+              f"A shard may be missing, failed, or still running.")
+
+out = Path(MODEL) / "medxpertqa_text_score.json"
+out.write_text(json.dumps(
+    {"raw": correct, "total": total, "accuracy_pct": round(acc, 2)}, indent=2))
+print(f"\nWrote {out}")

scripts/prep_mcr_baseline.py

@@ -0,0 +1,33 @@
+import re, json, os
+from datasets import load_dataset
+HOME=os.environ["HOME"]
+MEDX=f"{HOME}/pentabrid/datasets/MedXpertQA/Text/test.jsonl"
+OUT=f"{HOME}/pentabrid/datasets/mcr_clinician_baseline.jsonl"
+def dequote(s):
+    s=str(s)
+    for ch in ['\u201c','\u201d','\u201e','\u201f','\u2033','"']: s=s.replace(ch,'')
+    return re.sub(r'[ \t]+',' ',s).strip()
+def words(s): return re.findall(r"[a-z0-9]+", str(s).lower())
+def grams(t,n): return set(tuple(t[i:i+n]) for i in range(len(t)-n+1)) if len(t)>=n else set()
+G13=set(); nref=0
+with open(MEDX) as f:
+    for line in f:
+        line=line.strip()
+        if not line: continue
+        r=json.loads(line); parts=[str(v) for v in r.values() if isinstance(v,str)]
+        for v in r.values():
+            if isinstance(v,dict): parts+=[str(x) for x in v.values()]
+        G13|=grams(words(" ".join(parts)),13); nref+=1
+print(f"decontam ref: {nref} MedXpertQA questions, {len(G13)} 13-grams")
+mcr=load_dataset("zou-lab/MedCaseReasoning",split="train")
+kept=[]; dc=0
+for ex in mcr:
+    cp=str(ex.get("case_prompt","")).strip(); dr=dequote(ex.get("diagnostic_reasoning","")); dx=str(ex.get("final_diagnosis","")).strip()
+    if not cp or not dr or not dx: continue
+    if grams(words(cp),13)&G13: dc+=1; continue
+    instr=cp+"\n\nReason through the differential diagnosis step by step, then give the single most likely diagnosis on a final line as 'Diagnosis: <name>'."
+    output="<think>\n"+dr+"\n</think>\n\nDiagnosis: "+dx
+    kept.append({"instruction":instr,"input":"","output":output,"source":"medcasereasoning"})
+with open(OUT,"w") as f:
+    for r in kept: f.write(json.dumps(r,ensure_ascii=False)+"\n")
+print(f"kept={len(kept)} dropped_contam={dc} -> {OUT} ({os.path.getsize(OUT)/1e6:.1f} MB)")

scripts/probe_bayesian_v14.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+PENTABRID — ZERO-COST LATENT-CAPABILITY PROBE (V14)
+====================================================
+Question: does V14 ALREADY know how to reason in likelihood ratios, and we just
+never asked it to on MedXpertQA? The golden cases were TRAINED with the instruction
+"Analyze this clinical case using systematic Bayesian reasoning. Apply likelihood
+ratios where possible..." but the MedXpertQA eval prompt only says "Think step by
+step." So the capability may be latent — present but not triggered by the eval prompt.
+
+This runs V14 on the SAME small slice of MedXpertQA TWICE:
+  PROMPT A (neutral)  : the exact eval prompt ("Think step by step...")
+  PROMPT B (bayesian) : explicitly asks for pre-test probability + likelihood ratios
+
+Then it compares, for each arm:
+  - accuracy on the slice
+  - how many answers contain LR / Bayesian markers, and how dense they are
+
+INTERPRETATION
+  - If B shows MANY more LR markers than A  -> the capability is LATENT. You can get
+    Bayesian reasoning for FREE by changing the eval/inference prompt. No V16 needed
+    to elicit the BEHAVIOR (though scoring it is a separate question).
+  - If B shows roughly the SAME (near-zero) LR markers as A -> the capability is NOT
+    really there; prompting won't summon it, and only a stronger teacher / RL would
+    instil it. That tells you a data-mix V16 is the wrong tool.
+  - Watch accuracy too: if B reasons in LRs but accuracy DROPS, the LR style isn't
+    helping the answer (important to know before building a whole model around it).
+
+ONE GPU, ~20 min for the default 60-question slice.
+
+USAGE (on a GPU node):
+    module load cuda/12.6
+    source /home/adnanagha/miniforge3/etc/profile.d/conda.sh && conda activate pentabrid
+    MODEL_DIR=$HOME/pentabrid/runs/V14_27B_merged python3 ~/pentabrid/scripts/probe_bayesian_v14.py --limit 60
+"""
+import os, re, json, glob, time, argparse
+from pathlib import Path
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+MODEL = os.environ["MODEL_DIR"]
+MEDX  = os.environ.get("MEDX_DIR", f"{os.environ['HOME']}/pentabrid/datasets/MedXpertQA")
+OUTDIR = Path(os.environ.get("OUTDIR", f"{os.environ['HOME']}/pentabrid/runs/bayesian_probe"))
+
+# ---- the two prompts. Only the final instruction line differs. ----
+NEUTRAL_TAIL  = "Think step by step, then end with exactly: 'Answer: X' where X is the letter."
+BAYESIAN_TAIL = (
+    "Reason as a diagnostician using EXPLICIT Bayesian logic: state the pre-test "
+    "probability of the leading diagnoses, cite approximate likelihood ratios (LR+ / LR-) "
+    "for the key findings, update to a post-test probability, and rule alternatives in or "
+    "out using pertinent positives and negatives. Then end with exactly: 'Answer: X' "
+    "where X is the letter."
+)
+
+# ---- markers that indicate genuine Bayesian / LR reasoning ----
+LR_PATTERNS = [
+    r"likelihood ratio", r"\bLR[+\-]?\b", r"pre-?test", r"post-?test",
+    r"prior probability", r"posterior", r"\bbayes", r"pertinent (?:positive|negative)",
+    r"\bodds\b", r"sensitivity", r"specificity",
+]
+_lr_re = re.compile("|".join(LR_PATTERNS), re.IGNORECASE)
+
+
+def build_prompt(r, tail):
+    q = r.get("question", "")
+    opts = r.get("options")
+    lines = [q, ""]
+    if isinstance(opts, dict):
+        for k in sorted(opts): lines.append(f"{k}. {opts[k]}")
+    elif isinstance(opts, list):
+        for i, o in enumerate(opts): lines.append(f"{chr(65+i)}. {o}")
+    lines += ["", tail]
+    return "\n".join(lines)
+
+
+def gold_letter(r):
+    g = str(r.get("label", r.get("answer", ""))).strip()
+    m = re.search(r"[A-Z]", g.upper())
+    return m.group(0) if m else g.upper()
+
+
+def parse_letter(text):
+    m = re.findall(r"[Aa]nswer\s*[:\-]?\s*([A-Za-z])", text)
+    if m: return m[-1].upper()
+    m = re.findall(r"\b([A-J])\b", text)
+    return m[-1].upper() if m else ""
+
+
+def lr_markers(text):
+    return len(_lr_re.findall(text or ""))
+
+
+def run_arm(model, tok, rows, tail, label):
+    correct = 0
+    total_markers = 0
+    answers_with_markers = 0
+    recs = []
+    for i, r in enumerate(rows):
+        msgs = [{"role": "user", "content": build_prompt(r, tail)}]
+        enc = tok.apply_chat_template(
+            [msgs], add_generation_prompt=True,
+            return_tensors="pt", return_dict=True, padding=True).to(model.device)
+        with torch.no_grad():
+            out = model.generate(**enc, max_new_tokens=1536,
+                                  do_sample=False, pad_token_id=tok.pad_token_id)
+        gen = out[:, enc["input_ids"].shape[1]:]
+        text = tok.batch_decode(gen, skip_special_tokens=True)[0]
+        pred, gold = parse_letter(text), gold_letter(r)
+        ok = bool(pred) and pred == gold
+        mk = lr_markers(text)
+        correct += int(ok)
+        total_markers += mk
+        answers_with_markers += int(mk > 0)
+        recs.append({"id": r.get("id"), "pred": pred, "gold": gold, "correct": ok,
+                     "lr_markers": mk, "text": text})
+        print(f"  [{label}] {i+1}/{len(rows)}  acc={100*correct/(i+1):.0f}%  "
+              f"lr_markers_so_far={total_markers}", flush=True)
+    return {
+        "label": label, "n": len(rows),
+        "accuracy_pct": round(100 * correct / max(1, len(rows)), 1),
+        "answers_with_any_lr_marker": answers_with_markers,
+        "total_lr_markers": total_markers,
+        "mean_lr_markers_per_answer": round(total_markers / max(1, len(rows)), 2),
+    }, recs
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--limit", type=int, default=60, help="questions to test (same set for both arms)")
+    args = ap.parse_args()
+
+    cands = glob.glob(f"{MEDX}/**/Text/**/test*.jsonl", recursive=True) + \
+            glob.glob(f"{MEDX}/**/test*.jsonl", recursive=True)
+    if not cands:
+        raise SystemExit(f"Could not find MedXpertQA Text test.jsonl under {MEDX}")
+    rows = [json.loads(l) for l in open(sorted(cands)[0]) if l.strip()][:args.limit]
+
+    OUTDIR.mkdir(parents=True, exist_ok=True)
+    tok = AutoTokenizer.from_pretrained(MODEL)
+    tok.padding_side = "left"
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    print(f"loading {MODEL} ...", flush=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL, torch_dtype=torch.bfloat16, device_map="cuda").eval()
+
+    t0 = time.perf_counter()
+    sa, ra = run_arm(model, tok, rows, NEUTRAL_TAIL,  "neutral")
+    sb, rb = run_arm(model, tok, rows, BAYESIAN_TAIL, "bayesian")
+    mins = (time.perf_counter() - t0) / 60
+
+    (OUTDIR / "neutral_records.jsonl").write_text(
+        "\n".join(json.dumps(x, ensure_ascii=False) for x in ra), encoding="utf-8")
+    (OUTDIR / "bayesian_records.jsonl").write_text(
+        "\n".join(json.dumps(x, ensure_ascii=False) for x in rb), encoding="utf-8")
+    summary = {"model": MODEL, "n": len(rows), "minutes": round(mins, 1),
+               "neutral": sa, "bayesian": sb}
+    (OUTDIR / "probe_summary.json").write_text(json.dumps(summary, indent=2))
+
+    print("\n" + "=" * 60)
+    print("BAYESIAN LATENT-CAPABILITY PROBE — V14")
+    print("=" * 60)
+    print(f"{'arm':10}{'acc%':>8}{'ans w/LR':>11}{'total LR':>11}{'LR/ans':>9}")
+    for s in (sa, sb):
+        print(f"{s['label']:10}{s['accuracy_pct']:>8}{s['answers_with_any_lr_marker']:>11}"
+              f"{s['total_lr_markers']:>11}{s['mean_lr_markers_per_answer']:>9}")
+    print("-" * 60)
+    dm = sb["mean_lr_markers_per_answer"] - sa["mean_lr_markers_per_answer"]
+    da = sb["accuracy_pct"] - sa["accuracy_pct"]
+    print(f"LR-marker change (bayesian - neutral): {dm:+.2f} per answer")
+    print(f"accuracy change   (bayesian - neutral): {da:+.1f} pts")
+    if dm >= 1.0:
+        print("\n=> Bayesian reasoning is LATENT: the model produces far more LR reasoning")
+        print("   when asked. You can elicit the BEHAVIOR for free via the prompt.")
+        if da < -2:
+            print("   BUT accuracy dropped — the LR style isn't improving answers here.")
+    else:
+        print("\n=> Prompting did NOT summon LR reasoning. The capability isn't really")
+        print("   present; a data-mix V16 won't instil it (would need a stronger teacher/RL).")
+    print(f"\nWrote -> {OUTDIR}/probe_summary.json (+ per-answer records)")
+
+
+if __name__ == "__main__":
+    main()

scripts/probe_protocol_base.py

@@ -0,0 +1,217 @@
+"""
+PROTOCOL PROBE  --  BASE MODEL, 100 IDENTICAL QUESTIONS
+=======================================================
+Prof. Adnan's 9-step diagnostic protocol vs the base model's natural reasoning.
+
+WHY THIS IS A REAL TEST (not another reword):
+  The four prior arms all LOST to neutral (21% on 100 base Q). But those were loose
+  "flag pathognomonic features + note LRs" nudges. THIS prompt is a structured MCQ
+  protocol with techniques none of them had:
+    - options-first (build the differential from the answers before the vignette)
+    - explicit red-herring / distractor naming
+    - a bias audit (anchoring, premature closure, confirmation, availability, framing)
+    - "the answer must BEAT every alternative, not merely fit"
+  That last one attacks the specific MCQ failure mode (plausible-but-not-best answer)
+  that none of the prior arms addressed. So this could genuinely differ.
+
+TWO ARMS ONLY (no forced-Bayesian -- confirmed dead 3x; no gated -- superseded):
+  1. neutral   : base's natural reasoning  (CONTROL -- compare to the 21% we measured)
+  2. protocol  : the 9-step diagnostic protocol
+
+RAISED TOKEN CAP (2600 vs 1536): the protocol is long; it must reach 'Answer: X'
+before being cut off, or accuracy is measuring truncation, not reasoning.
+
+VERDICT = ACCURACY vs neutral.
+  - protocol > neutral by >3 pts on 100Q => the structured protocol genuinely helps.
+    THEN it's worth testing on V15, and worth reporting.
+  - protocol ~= neutral => structure doesn't help even done well; natural reasoning wins.
+  - protocol < neutral => consistent with the prior pattern; structure hurts.
+
+Run (fire-and-forget; 2 arms x 100 q x 2600 tok ~ 4-5h -> sbatch):
+    MODEL_DIR=$HOME/pentabrid/base_models/Qwen3.6-27B \
+      python3 ~/pentabrid/scripts/probe_protocol_base.py --limit 100
+"""
+import os, re, json, glob, time, argparse
+from pathlib import Path
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+MODEL  = os.environ["MODEL_DIR"]
+MEDX   = os.environ.get("MEDX_DIR", f"{os.environ['HOME']}/pentabrid/datasets/MedXpertQA")
+OUTDIR = Path(os.environ.get("OUTDIR", f"{os.environ['HOME']}/pentabrid/runs/protocol_probe"))
+
+NEUTRAL_TAIL = "Think step by step, then end with exactly: 'Answer: X' where X is the letter."
+
+# Prof. Adnan's 9-step protocol, verbatim (only the closing-line instruction is shared).
+PROTOCOL_TAIL = (
+    "You are answering a clinical multiple-choice question. Follow this protocol:\n"
+    "1. OPTIONS FIRST - Before reading the vignette, read every answer option. For each, "
+    "recall its classic presentation and the 1-2 findings that would best rule it in or out. "
+    "These options are your working differential.\n"
+    "2. PRETEST PROBABILITY - From demographics, risk factors, and setting alone, rank the "
+    "options by baseline likelihood (avoid base-rate neglect: common things are common; rare "
+    "diagnoses need strong evidence).\n"
+    "3. EXTRACT ALL DATA - Read the vignette line by line. List every positive finding AND "
+    "pertinent negative (history, vitals, exam, labs, imaging, time course). Tag each as: "
+    "supports / opposes / discriminates between options / non-specific.\n"
+    "4. BAYESIAN UPDATE - Revise your ranking finding by finding. Cite a likelihood ratio ONLY "
+    "where it is genuinely well established; never invent numbers. If no reliable LR exists, "
+    "update qualitatively ('markedly raises / slightly lowers probability'). Highly specific "
+    "findings shift probability most; sensitive-but-nonspecific findings shift it little.\n"
+    "5. PATHOGNOMONIC CHECK - Flag any pathognomonic or highly specific feature, then verify the "
+    "rest of the picture (demographics, tempo, associated findings) is consistent with it. A "
+    "buzzword contradicted by other data is a trap, not an answer.\n"
+    "6. RED HERRINGS - Explicitly name any distractor findings (incidental, non-specific, "
+    "explained by a comorbidity, or planted to suggest a wrong option) and state why each does "
+    "not change your ranking.\n"
+    "7. ELIMINATE - Address every option one by one. Reject an option only by citing the specific "
+    "finding(s) that make it incompatible or improbable. The chosen answer must beat every "
+    "alternative, not merely fit the case.\n"
+    "8. BIAS AUDIT - One line each before finalizing: Anchoring: am I stuck on my first "
+    "impression? Premature closure: did I check ALL options against ALL findings before stopping? "
+    "Confirmation bias: did I weigh contradictory evidence as seriously as supporting evidence? "
+    "Availability / representativeness: am I choosing this because it is memorable or 'looks "
+    "typical,' rather than because the data fit? Framing / diagnosis momentum: am I accepting a "
+    "label given in the stem without verifying it?\n"
+    "9. FINAL CHECK - The answer must explain the chief complaint, the key positives, AND the "
+    "pertinent negatives better than every rejected option. If two options remain close, name the "
+    "single discriminating finding that decides between them.\n"
+    "End your entire response with this final line and nothing after it (no punctuation, no text):\n"
+    "Answer: X\n"
+    "where X is the letter of the chosen option."
+)
+
+ARMS = [("neutral", NEUTRAL_TAIL), ("protocol", PROTOCOL_TAIL)]
+
+LR_PATTERNS = [r"likelihood ratio", r"\bLR[+\-]?\b", r"pre-?test", r"post-?test",
+               r"prior probability", r"posterior", r"\bbayes", r"pertinent (?:positive|negative)",
+               r"\bodds\b", r"sensitivity", r"specificity"]
+_lr_re = re.compile("|".join(LR_PATTERNS), re.IGNORECASE)
+PATHO_PATTERNS = [r"pathognomonic", r"highly specific", r"hallmark", r"classic(?:ally)?\b",
+                  r"diagnostic of", r"characteristic of"]
+_patho_re = re.compile("|".join(PATHO_PATTERNS), re.IGNORECASE)
+
+
+def build_prompt(r, tail, protocol=False):
+    q = r.get("question", "")
+    opts = r.get("options")
+    olines = []
+    if isinstance(opts, dict):
+        for k in sorted(opts): olines.append(f"{k}. {opts[k]}")
+    elif isinstance(opts, list):
+        for i, o in enumerate(opts): olines.append(f"{chr(65+i)}. {o}")
+    # For the protocol arm, put the protocol FIRST so 'options first' is followed,
+    # then the question + options. For neutral, question first then the tail.
+    if protocol:
+        return tail + "\n\nQUESTION:\n" + q + "\n\nOPTIONS:\n" + "\n".join(olines)
+    return "\n".join([q, ""] + olines + ["", tail])
+
+
+def gold_letter(r):
+    g = str(r.get("label", r.get("answer", ""))).strip()
+    m = re.search(r"[A-Z]", g.upper())
+    return m.group(0) if m else g.upper()
+
+
+def parse_letter(text):
+    m = re.findall(r"[Aa]nswer\s*[:\-]?\s*([A-Za-z])", text)
+    if m: return m[-1].upper()
+    m = re.findall(r"\b([A-J])\b", text)
+    return m[-1].upper() if m else ""
+
+
+def run_arm(model, tok, rows, tail, label):
+    is_proto = (label == "protocol")
+    correct = 0; total_lr = 0; total_patho = 0; truncated = 0; recs = []
+    for i, r in enumerate(rows):
+        msgs = [{"role": "user", "content": build_prompt(r, tail, protocol=is_proto)}]
+        enc = tok.apply_chat_template(
+            [msgs], add_generation_prompt=True,
+            return_tensors="pt", return_dict=True, padding=True).to(model.device)
+        with torch.no_grad():
+            out = model.generate(**enc, max_new_tokens=2600,
+                                  do_sample=False, pad_token_id=tok.pad_token_id)
+        gen = out[:, enc["input_ids"].shape[1]:]
+        text = tok.batch_decode(gen, skip_special_tokens=True)[0]
+        pred, gold = parse_letter(text), gold_letter(r)
+        ok = bool(pred) and pred == gold
+        # did it run out of room before writing an answer line?
+        no_answer_line = ("nswer" not in text)
+        lr = len(_lr_re.findall(text or "")); pa = len(_patho_re.findall(text or ""))
+        correct += int(ok); total_lr += lr; total_patho += pa; truncated += int(no_answer_line)
+        recs.append({"id": r.get("id"), "pred": pred, "gold": gold, "correct": ok,
+                     "lr_markers": lr, "patho_markers": pa, "no_answer_line": no_answer_line,
+                     "text": text})
+        print(f"  [{label}] {i+1}/{len(rows)}  acc={100*correct/(i+1):.0f}%  "
+              f"lr={total_lr}  patho={total_patho}  no_ans={truncated}", flush=True)
+    return {
+        "label": label, "n": len(rows),
+        "accuracy_pct": round(100 * correct / max(1, len(rows)), 1),
+        "total_lr_markers": total_lr,
+        "mean_lr_markers_per_answer": round(total_lr / max(1, len(rows)), 2),
+        "mean_pathognomonic_per_answer": round(total_patho / max(1, len(rows)), 2),
+        "answers_missing_answer_line": truncated,
+    }, recs
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--limit", type=int, default=100)
+    args = ap.parse_args()
+
+    cands = glob.glob(f"{MEDX}/**/Text/**/test*.jsonl", recursive=True) + \
+            glob.glob(f"{MEDX}/**/test*.jsonl", recursive=True)
+    if not cands:
+        raise SystemExit(f"Could not find MedXpertQA Text test.jsonl under {MEDX}")
+    rows = [json.loads(l) for l in open(sorted(cands)[0]) if l.strip()][:args.limit]
+
+    OUTDIR.mkdir(parents=True, exist_ok=True)
+    tok = AutoTokenizer.from_pretrained(MODEL)
+    tok.padding_side = "left"
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    print(f"loading {MODEL} ...", flush=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL, torch_dtype=torch.bfloat16, device_map="cuda").eval()
+
+    t0 = time.perf_counter()
+    summaries = {}
+    for label, tail in ARMS:
+        s, recs = run_arm(model, tok, rows, tail, label)
+        summaries[label] = s
+        (OUTDIR / f"{label}_records.jsonl").write_text(
+            "\n".join(json.dumps(x, ensure_ascii=False) for x in recs), encoding="utf-8")
+    mins = (time.perf_counter() - t0) / 60
+
+    out = {"model": MODEL, "n": len(rows), "minutes": round(mins, 1), **summaries}
+    (OUTDIR / "protocol_summary.json").write_text(json.dumps(out, indent=2))
+
+    base = summaries["neutral"]["accuracy_pct"]
+    proto = summaries["protocol"]["accuracy_pct"]
+    print("\n" + "=" * 70)
+    print("PROTOCOL PROBE  --  BASE MODEL, 100 IDENTICAL QUESTIONS")
+    print("=" * 70)
+    print(f"{'arm':10}{'acc%':>8}{'vs neutral':>12}{'LR/ans':>9}{'patho/ans':>11}{'no-ans':>8}")
+    for label, _ in ARMS:
+        s = summaries[label]
+        d = "(control)" if label == "neutral" else f"{s['accuracy_pct']-base:+.1f} pts"
+        print(f"{s['label']:10}{s['accuracy_pct']:>8}{d:>12}{s['mean_lr_markers_per_answer']:>9}"
+              f"{s['mean_pathognomonic_per_answer']:>11}{s['answers_missing_answer_line']:>8}")
+    print("-" * 70)
+    dd = proto - base
+    if dd > 3:
+        print(f"=> PROTOCOL HELPS: {dd:+.1f} pts over natural reasoning. Worth testing on V15,")
+        print("   and worth reporting. Your structured protocol beat the plain prompt.")
+    elif dd >= -3:
+        print(f"=> PROTOCOL ~= neutral ({dd:+.1f} pts, within noise). Even a well-built protocol")
+        print("   doesn't beat the base's natural reasoning here.")
+    else:
+        print(f"=> PROTOCOL WORSE ({dd:+.1f} pts). Consistent with the prior pattern: structure hurts.")
+    if summaries["protocol"]["answers_missing_answer_line"] > 8:
+        print(f"   NOTE: {summaries['protocol']['answers_missing_answer_line']}/100 protocol answers "
+              f"had no answer line (truncation) -- raise max_new_tokens and rerun if this is high.")
+    print(f"\nWrote -> {OUTDIR}/protocol_summary.json (+ per-arm records)")
+
+
+if __name__ == "__main__":
+    main()

scripts/probe_twopronged_base.py

@@ -0,0 +1,214 @@
+"""
+TWO-PRONGED REASONING PROBE  --  BASE MODEL, 100 IDENTICAL QUESTIONS
+====================================================================
+Prof. Adnan's refinement, done properly:
+
+WHY BASE, NOT A V-MODEL:
+  We are testing whether a REASONING PROMPT helps -- so we want the cleanest
+  substrate, with no fine-tuning effects tangled in. The untuned base isolates
+  the prompt's effect. (Also: this is exactly the controlled-contrast spirit of
+  the Matters Arising -- base model, offline, no retrieval.)
+
+WHY 100 QUESTIONS (not 30):
+  30 was too noisy (each Q = 3.3 pts). 100 halves the noise so a 3-4 pt effect
+  is real, not sampling wobble. Same 100 for every arm -> paired comparison.
+
+THE KEY NEW IDEA -- "TWO-PRONGED" (augment, don't replace):
+  Every prior intervention (forced-Bayesian, gated-replace) SUPPRESSED the model's
+  natural chain-of-thought and accuracy DROPPED. The natural reasoning was carrying
+  the accuracy. So this arm KEEPS the natural reasoning and ADDS the clinical
+  scaffolding on top -- pathognomonic-features-first + note LRs where genuinely
+  known -- as a SUPPLEMENT, not a substitute.
+
+FOUR ARMS, all on the same 100 questions:
+  1. neutral        : the base's own natural reasoning  (CONTROL -- the number to beat)
+  2. two_pronged    : natural reasoning + pathognomonic/LR overlay  (THE NEW IDEA)
+  3. gated_replace  : the replace-style gate (to prove augment beats replace)
+  4. bayesian_force : force full Bayesian on everything (to confirm it still hurts)
+
+THE VERDICT IS ACCURACY.
+  - two_pronged > neutral by a clear margin (~+3 pts on 100Q) => real, promptable gain.
+    Worth reporting, and a candidate reasoning policy.
+  - two_pronged ~= neutral => the base's natural reasoning can't be improved by
+    prompting; reasoning quality is intrinsic (this SUPPORTS the paper's thesis).
+  - two_pronged < neutral => augmenting still hurts; keep it plain.
+
+Run (fire-and-forget; ~5-6h for 4 arms x 100 q at 1536 tok -> sbatch):
+    MODEL_DIR=$HOME/pentabrid/base_models/Qwen3.6-27B \
+      python3 ~/pentabrid/scripts/probe_twopronged_base.py --limit 100
+"""
+import os, re, json, glob, time, argparse
+from pathlib import Path
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+MODEL  = os.environ["MODEL_DIR"]
+MEDX   = os.environ.get("MEDX_DIR", f"{os.environ['HOME']}/pentabrid/datasets/MedXpertQA")
+OUTDIR = Path(os.environ.get("OUTDIR", f"{os.environ['HOME']}/pentabrid/runs/twopronged_probe"))
+
+# ---- the prompts. Only the final instruction line differs. ----
+NEUTRAL_TAIL = "Think step by step, then end with exactly: 'Answer: X' where X is the letter."
+
+# THE NEW IDEA: keep natural reasoning, ADD the clinical overlay on top.
+TWO_PRONGED_TAIL = (
+    "Work the case in your own natural clinical reasoning, and IN ADDITION do two things "
+    "as you go. First, explicitly flag any pathognomonic or highly specific feature that "
+    "points strongly to one diagnosis. Second, where a likelihood ratio for a key finding "
+    "is genuinely well established, note it briefly to support your reasoning -- but do NOT "
+    "invent likelihood-ratio values, and do NOT force Bayesian arithmetic where it doesn't "
+    "fit; if you don't know an LR, reason qualitatively. Let your normal step-by-step "
+    "reasoning drive the conclusion, with these as support. Then end with exactly: "
+    "'Answer: X' where X is the letter."
+)
+
+# The replace-style gate from the last probe (kept, to prove augment beats replace).
+GATED_REPLACE_TAIL = (
+    "Reason like an expert clinician, in this order. STEP 1: Identify any pathognomonic or "
+    "highly specific features that point directly to one diagnosis; if present, commit to it "
+    "without likelihood-ratio calculation. STEP 2: Only if still uncertain, weigh discriminating "
+    "findings using established likelihood ratios only -- do not invent LR values. STEP 3: Rule "
+    "alternatives in/out with pertinent positives and negatives. Then end with exactly: "
+    "'Answer: X' where X is the letter."
+)
+
+# Force full Bayesian on everything (to confirm on the base that it still hurts).
+BAYESIAN_FORCE_TAIL = (
+    "Reason using EXPLICIT Bayesian logic: state the pre-test probability of the leading "
+    "diagnoses, cite approximate likelihood ratios (LR+ / LR-) for the key findings, update "
+    "to a post-test probability, and rule alternatives in or out. Then end with exactly: "
+    "'Answer: X' where X is the letter."
+)
+
+ARMS = [
+    ("neutral",        NEUTRAL_TAIL),
+    ("two_pronged",    TWO_PRONGED_TAIL),
+    ("gated_replace",  GATED_REPLACE_TAIL),
+    ("bayesian_force", BAYESIAN_FORCE_TAIL),
+]
+
+LR_PATTERNS = [
+    r"likelihood ratio", r"\bLR[+\-]?\b", r"pre-?test", r"post-?test",
+    r"prior probability", r"posterior", r"\bbayes", r"pertinent (?:positive|negative)",
+    r"\bodds\b", r"sensitivity", r"specificity",
+]
+_lr_re = re.compile("|".join(LR_PATTERNS), re.IGNORECASE)
+PATHO_PATTERNS = [r"pathognomonic", r"highly specific", r"hallmark", r"classic(?:ally)?\b",
+                  r"diagnostic of", r"characteristic of"]
+_patho_re = re.compile("|".join(PATHO_PATTERNS), re.IGNORECASE)
+
+
+def build_prompt(r, tail):
+    q = r.get("question", "")
+    opts = r.get("options")
+    lines = [q, ""]
+    if isinstance(opts, dict):
+        for k in sorted(opts): lines.append(f"{k}. {opts[k]}")
+    elif isinstance(opts, list):
+        for i, o in enumerate(opts): lines.append(f"{chr(65+i)}. {o}")
+    lines += ["", tail]
+    return "\n".join(lines)
+
+
+def gold_letter(r):
+    g = str(r.get("label", r.get("answer", ""))).strip()
+    m = re.search(r"[A-Z]", g.upper())
+    return m.group(0) if m else g.upper()
+
+
+def parse_letter(text):
+    m = re.findall(r"[Aa]nswer\s*[:\-]?\s*([A-Za-z])", text)
+    if m: return m[-1].upper()
+    m = re.findall(r"\b([A-J])\b", text)
+    return m[-1].upper() if m else ""
+
+
+def run_arm(model, tok, rows, tail, label):
+    correct = 0; total_lr = 0; total_patho = 0; with_lr = 0; recs = []
+    for i, r in enumerate(rows):
+        msgs = [{"role": "user", "content": build_prompt(r, tail)}]
+        enc = tok.apply_chat_template(
+            [msgs], add_generation_prompt=True,
+            return_tensors="pt", return_dict=True, padding=True).to(model.device)
+        with torch.no_grad():
+            out = model.generate(**enc, max_new_tokens=1536,
+                                  do_sample=False, pad_token_id=tok.pad_token_id)
+        gen = out[:, enc["input_ids"].shape[1]:]
+        text = tok.batch_decode(gen, skip_special_tokens=True)[0]
+        pred, gold = parse_letter(text), gold_letter(r)
+        ok = bool(pred) and pred == gold
+        lr = len(_lr_re.findall(text or "")); pa = len(_patho_re.findall(text or ""))
+        correct += int(ok); total_lr += lr; total_patho += pa; with_lr += int(lr > 0)
+        recs.append({"id": r.get("id"), "pred": pred, "gold": gold, "correct": ok,
+                     "lr_markers": lr, "patho_markers": pa, "text": text})
+        print(f"  [{label}] {i+1}/{len(rows)}  acc={100*correct/(i+1):.0f}%  "
+              f"lr={total_lr}  patho={total_patho}", flush=True)
+    return {
+        "label": label, "n": len(rows),
+        "accuracy_pct": round(100 * correct / max(1, len(rows)), 1),
+        "answers_with_any_lr_marker": with_lr,
+        "total_lr_markers": total_lr,
+        "mean_lr_markers_per_answer": round(total_lr / max(1, len(rows)), 2),
+        "total_pathognomonic_markers": total_patho,
+        "mean_pathognomonic_per_answer": round(total_patho / max(1, len(rows)), 2),
+    }, recs
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--limit", type=int, default=100, help="questions (same set for all arms)")
+    args = ap.parse_args()
+
+    cands = glob.glob(f"{MEDX}/**/Text/**/test*.jsonl", recursive=True) + \
+            glob.glob(f"{MEDX}/**/test*.jsonl", recursive=True)
+    if not cands:
+        raise SystemExit(f"Could not find MedXpertQA Text test.jsonl under {MEDX}")
+    rows = [json.loads(l) for l in open(sorted(cands)[0]) if l.strip()][:args.limit]
+
+    OUTDIR.mkdir(parents=True, exist_ok=True)
+    tok = AutoTokenizer.from_pretrained(MODEL)
+    tok.padding_side = "left"
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    print(f"loading {MODEL} ...", flush=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL, torch_dtype=torch.bfloat16, device_map="cuda").eval()
+
+    t0 = time.perf_counter()
+    summaries = {}
+    for label, tail in ARMS:
+        s, recs = run_arm(model, tok, rows, tail, label)
+        summaries[label] = s
+        (OUTDIR / f"{label}_records.jsonl").write_text(
+            "\n".join(json.dumps(x, ensure_ascii=False) for x in recs), encoding="utf-8")
+    mins = (time.perf_counter() - t0) / 60
+
+    out = {"model": MODEL, "n": len(rows), "minutes": round(mins, 1), **summaries}
+    (OUTDIR / "twopronged_summary.json").write_text(json.dumps(out, indent=2))
+
+    base = summaries["neutral"]["accuracy_pct"]
+    print("\n" + "=" * 70)
+    print("TWO-PRONGED REASONING PROBE  --  BASE MODEL, 100 IDENTICAL QUESTIONS")
+    print("=" * 70)
+    print(f"{'arm':16}{'acc%':>8}{'vs neutral':>12}{'LR/ans':>9}{'patho/ans':>12}")
+    for label, _ in ARMS:
+        s = summaries[label]
+        d = s["accuracy_pct"] - base
+        dstr = "(control)" if label == "neutral" else f"{d:+.1f} pts"
+        print(f"{s['label']:16}{s['accuracy_pct']:>8}{dstr:>12}"
+              f"{s['mean_lr_markers_per_answer']:>9}{s['mean_pathognomonic_per_answer']:>12}")
+    print("-" * 70)
+    tp = summaries["two_pronged"]["accuracy_pct"] - base
+    if tp > 3:
+        print(f"=> TWO-PRONGED helps: {tp:+.1f} pts over the base's natural reasoning.")
+        print("   A promptable reasoning gain. Worth reporting + a candidate policy.")
+    elif tp >= -3:
+        print(f"=> TWO-PRONGED ~= neutral ({tp:+.1f} pts, within noise on 100Q).")
+        print("   The base's natural reasoning can't be improved by prompting here --")
+        print("   consistent with the paper's thesis that reasoning quality is intrinsic.")
+    else:
+        print(f"=> TWO-PRONGED WORSE ({tp:+.1f} pts). Even augmenting hurts; keep it plain.")
+    print(f"\nWrote -> {OUTDIR}/twopronged_summary.json (+ per-arm records)")
+
+
+if __name__ == "__main__":
+    main()

scripts/train_v14.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+"""
+PENTABRID V14 — LoRA TRAINER (27B, attention-only, ZeRO-2)
+==========================================================
+Locked config: LoRA r16 / alpha16, attention-only, 1 epoch, LR 1.5e-5 cosine +
+3% warmup, MAX_SEQ_LEN 8192, bf16, DeepSpeed ZeRO-2 (NOT ZeRO-3: no NVLink on
+these A100s). Loss is masked to the answer only (the prompt is not trained on).
+
+** SMOKE FIRST **  Launch once with  SMOKE=1  -> trains ~20 steps on 64 rows to
+prove it loads, fits in memory, and steps without crashing. Only then do the full
+run. This is the single riskiest step (future transformers/PEFT API + Qwen3.6
+chat template), so we validate cheaply before committing hours.
+
+Three things to VERIFY on the smoke (Claude will check the smoke log with you):
+  1. target_modules names are right for Qwen3.6 (q_proj/k_proj/v_proj/o_proj).
+  2. the chat template doesn't double-wrap the <think> tags already in `output`.
+  3. no CUDA OOM at seq 8192 (if OOM: drop MAXLEN to 6144, or set LOAD_4BIT=1).
+
+USAGE (via train_v14.sbatch; do not run by hand on the login node):
+    SMOKE=1 torchrun --standalone --nproc_per_node=2 train_v14.py   # smoke
+    torchrun --standalone --nproc_per_node=2 train_v14.py           # full
+"""
+import os
+import torch
+from transformers import (AutoModelForCausalLM, AutoTokenizer,
+                          TrainingArguments, Trainer)
+from peft import LoraConfig, get_peft_model
+from datasets import load_dataset
+
+MODEL_DIR = os.environ.get("MODEL_DIR", "/home/adnanagha/pentabrid/base_models/Qwen3.6-27B")
+DATA      = os.environ.get("DATA",      "/home/adnanagha/pentabrid/scripts/v14_train_final.jsonl")
+OUT       = os.environ.get("OUT",       "/home/adnanagha/pentabrid/runs/V14_lora")
+MAXLEN    = int(os.environ.get("MAXLEN", "8192"))
+SMOKE     = os.environ.get("SMOKE", "") not in ("", "0", "false")
+RESUME    = bool(os.environ.get("RESUME"))
+if os.path.isdir(OUT) and os.listdir(OUT) and not RESUME:
+    raise SystemExit("REFUSING to overwrite non-empty OUT dir: " + OUT + "  (use a new OUT=... or set RESUME=1)")
+
+# DeepSpeed ZeRO-2 (full frozen base kept on each GPU; only optimizer/grads sharded)
+DS_CONFIG = {
+    "bf16": {"enabled": True},
+    "zero_optimization": {
+        "stage": 2,
+        "overlap_comm": True,
+        "contiguous_gradients": True,
+        "reduce_bucket_size": 2e8,
+        "allgather_bucket_size": 2e8,
+    },
+    "gradient_accumulation_steps": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "gradient_clipping": "auto",
+}
+
+tok = AutoTokenizer.from_pretrained(MODEL_DIR)
+if tok.pad_token is None:
+    tok.pad_token = tok.eos_token
+
+
+def _ids(out):
+    """Return a plain list[int] of token ids from apply_chat_template, regardless
+    of whether this transformers version returns a list, a tensor, or an Encoding/
+    BatchEncoding (the latter triggers an Arrow OverflowError if passed through)."""
+    if hasattr(out, "input_ids"):           # BatchEncoding / Encoding
+        out = out.input_ids
+    if hasattr(out, "ids"):                  # tokenizers.Encoding
+        out = out.ids
+    if hasattr(out, "tolist"):               # tensor / numpy
+        out = out.tolist()
+    if out and isinstance(out[0], list):     # nested [[...]] -> first row
+        out = out[0]
+    return [int(t) for t in out]
+
+
+def to_example(row):
+    """Tokenize one row; mask the prompt so loss falls only on the answer."""
+    user = row["instruction"] + (("\n\n" + row["input"]) if row.get("input") else "")
+    msgs = [{"role": "user", "content": user}]
+    prompt_ids = _ids(tok.apply_chat_template(msgs, add_generation_prompt=True, tokenize=True))
+    full_ids = _ids(tok.apply_chat_template(
+        msgs + [{"role": "assistant", "content": row["output"]}],
+        add_generation_prompt=False, tokenize=True))
+    input_ids = full_ids[:MAXLEN]
+    labels = list(input_ids)
+    for i in range(min(len(prompt_ids), len(labels))):
+        labels[i] = -100
+    return {"input_ids": input_ids, "labels": labels, "attention_mask": [1] * len(input_ids)}
+
+
+ds = load_dataset("json", data_files=DATA, split="train")
+if SMOKE:
+    ds = ds.select(range(min(64, len(ds))))
+ds = ds.map(to_example, remove_columns=ds.column_names, desc="tokenizing")
+
+
+def collate(batch):
+    m = max(len(b["input_ids"]) for b in batch)
+    pad = lambda s, v: s + [v] * (m - len(s))
+    return {
+        "input_ids":      torch.tensor([pad(b["input_ids"], tok.pad_token_id) for b in batch]),
+        "labels":         torch.tensor([pad(b["labels"], -100) for b in batch]),
+        "attention_mask": torch.tensor([pad(b["attention_mask"], 0) for b in batch]),
+    }
+
+
+load_kwargs = dict(torch_dtype=torch.bfloat16)
+if os.environ.get("LOAD_4BIT"):
+    from transformers import BitsAndBytesConfig
+    load_kwargs["quantization_config"] = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_quant_type="nf4")
+
+model = AutoModelForCausalLM.from_pretrained(MODEL_DIR, **load_kwargs)
+model.config.use_cache = False
+model.gradient_checkpointing_enable()
+model.enable_input_require_grads()   # required for PEFT + gradient checkpointing
+
+lora = LoraConfig(
+    r=16, lora_alpha=int(os.environ.get("ALPHA", "16")), lora_dropout=0.0, bias="none", task_type="CAUSAL_LM",
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],   # attention-only
+)
+model = get_peft_model(model, lora)
+model.print_trainable_parameters()
+
+args = TrainingArguments(
+    output_dir=OUT,
+    num_train_epochs=1,
+    max_steps=(20 if SMOKE else -1),
+    per_device_train_batch_size=1,
+    gradient_accumulation_steps=16,
+    learning_rate=1.5e-5,
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.03,
+    bf16=True,
+    logging_steps=5,
+    save_strategy="steps",
+    save_steps=200,
+    save_total_limit=4,
+    eval_strategy="no",
+    report_to="none",
+    gradient_checkpointing=True,
+    deepspeed=DS_CONFIG,
+)
+
+trainer = Trainer(model=model, args=args, train_dataset=ds, data_collator=collate)
+trainer.train(resume_from_checkpoint=RESUME)
+trainer.save_model(OUT)     # saves the LoRA adapter (not the full model)
+tok.save_pretrained(OUT)
+print(f"DONE -> LoRA adapter saved at {OUT}")

scripts/train_v14.sbatch

@@ -0,0 +1,39 @@
+#!/bin/bash
+#SBATCH --job-name=v14_train
+#SBATCH --partition=gpuq
+#SBATCH --nodes=1
+#SBATCH --gres=gpu:2
+#SBATCH --time=2-00:00:00
+#SBATCH --output=/home/adnanagha/pentabrid/runs/v14_train.log
+# Single node, 2 GPUs (data-parallel + ZeRO-2). ~half a day for the full mix;
+# 2-day walltime gives margin. If a node drops, resubmit with RESUME=1 (below).
+
+module load cuda/12.6
+export TORCH_CUDA_ARCH_LIST="8.0"
+source /home/adnanagha/miniforge3/etc/profile.d/conda.sh
+conda activate pentabrid
+cd /home/adnanagha/pentabrid/scripts
+
+export MODEL_DIR=/home/adnanagha/pentabrid/base_models/Qwen3.6-27B
+export DATA=/home/adnanagha/pentabrid/scripts/v14_train_final.jsonl
+export OUT=/home/adnanagha/pentabrid/runs/V14_lora
+
+# --- toggles (uncomment as needed) ---
+# export SMOKE=1     # 20-step smoke on 64 rows -> ALWAYS run this first
+# export RESUME=1    # resume full run from newest checkpoint after a node drop
+# export LOAD_4BIT=1 # only if the smoke hits CUDA OOM at seq 8192
+# export MAXLEN=6144 # alternative OOM fix
+
+# --- Triton kernel-cache fix (the .ptx FileNotFoundError) ---
+# A shared cache makes the 2 GPUs race to compile/read the same kernel file.
+# 1) Give this job a private cache dir...
+export TRITON_CACHE_DIR=/tmp/triton_cache_${SLURM_JOB_ID}
+mkdir -p "$TRITON_CACHE_DIR"
+# 2) ...and pre-compile the kernels on ONE GPU first, so the file exists before
+#    the 2-GPU run ever looks for it (a few SMOKE steps, output discarded).
+echo "[$(date)] pre-warming Triton kernels on 1 GPU ..."
+SMOKE=1 CUDA_VISIBLE_DEVICES=0 python3 train_v14.py > /home/adnanagha/pentabrid/runs/v14_prewarm.log 2>&1 || true
+
+echo "[$(date)] V14 train starting on $(hostname)  (SMOKE=${SMOKE:-0})"
+torchrun --standalone --nproc_per_node=2 train_v14.py
+echo "[$(date)] V14 train finished (exit $?)"