andre930/persona-basis-run21-test-eval

persona-basis — run21 test-evaluation bundle (forward vs reverse KL comparison)

This bundle lets you generate the run22 (reverse-KL) heads on the held-out test split on another server, and compare them with the run21 (forward-KL) heads under exactly the same routing, head-mixing recipes, decoding and judge. run21's test answers and all of its judge verdicts are included, so run21 is not regenerated or re-judged.

Full context, design, caveats and step-by-step instructions: INSTRUCTIONS_run22_vs_run21.md. This README is the short version.

run	training objective	everything else
run21 (in this bundle)	forward KL(teacher ‖ student) on the teacher's top-256	prism_basis_v2: v2.1 cards, critic v9 with the no-change gate, no-mention teacher, 6,400 PRISM prompts, 100 steps, LoRA r 32 / α 64, lr 1e-5, seed 7
run22 (andre930/persona-basis-run22-rkl)	reverse KL(student ‖ teacher) on the student's top-256	identical

run21's evaluated checkpoint is step 60, which was selected on validation.

Contents

path	what it is
data/prism_v2_pref_test.jsonl (+ .manifest.json)	the 500 test prompts: 89 held-out users, one assigned preference each. 499 are usable; one row has no rewrite because the rewriter refused. Fields used: example_id, condition, preference_label (what the judge reads), rewritten_prompt (what the models read).
router/test_pred.jsonl	router v1's pick for every test prompt: prob (sigmoid per pole), selected (chosen poles), label (true poles), weights. The router reads only the base model, so its picks do not depend on the heads and are reused unchanged for run22.
router/router_v1.pt	the router itself, for reference. A 3-layer MLP (2560→512→512→4) on the base Qwen3-4B final-layer hidden state at the last token of the chat-formatted rewritten prompt, standardised with the stored mu/sd, one sigmoid per pole. A pole is on at p > 0.5, and the larger pole wins per axis. Load with torch.load(path, weights_only=False).
run21/systems_test.jsonl	all run21 test answers, one row per prompt, in responses (see below)
run21/judge_test.jsonl	all 5,754 luna verdicts behind run21's tables. It is the cache format judge_compare.py reads, so run21's comparisons re-tally for free.
run21/run21_test_tables.txt	run21's result tables
prompts/pairwise_judge_v11.txt	the judge prompt
cards/basis_cards_v2_1_locked.json	the four persona cards; persona prompting used them as the system prompt
scripts/gen_test_heads.py	builds the mix adapters and generates a checkpoint's answers (standalone)
scripts/judge_compare.py	luna pairwise judging with run21's exact protocol (standalone, resumable)

The systems in run21/systems_test.jsonl → responses:

system	what it is
base	base model, bare prompt
head_warm, head_impersonal, head_concise, head_thorough	each head alone
router_head	the router's pick: pure head, recipe mix, or base
router_persona	persona prompting (card or both cards as the system prompt) for the router's pick
oracle_head, oracle_persona	the same two, but using the true label

Head-mixing recipes. These are weights on (warm, impersonal, concise, thorough), fixed on validation for run21 and used unchanged here. A single pole uses that pure head.

pair	weights
warm+concise	(0.75, −0.25, 0.75, −0.25)
impersonal+concise	(−0.25, 0.75, 0.75, −0.25)
warm+thorough	(0.375, 0.125, −0.25, 0.75)
impersonal+thorough	(0.125, 0.375, −0.25, 0.75)

The mix is built exactly by rank concatenation: each B_k is scaled by its weight, giving one rank-128, α-256 adapter.

0. Requirements

• GPUs: run21's test answers were generated on 8 × A100-SXM4-80GB. Fewer or smaller GPUs work with fewer shards (--nshards) or a lower --gpu_mem.
• Software: Python 3.11. Versions used for run21: vllm 0.20.2, transformers 5.10.2, torch 2.11.0, safetensors 0.8.0, huggingface_hub 1.28.0, openai 3.3.1. Other recent versions should work; greedy outputs can differ slightly across vLLM versions and GPUs, which is fine for this comparison.

python3.11 -m venv ~/pb/venv && source ~/pb/venv/bin/activate
pip install vllm==0.20.2 transformers safetensors huggingface_hub openai
hf auth login                      # a token that can read the private andre930/* repos
export OPENAI_API_KEY=...          # for gpt-6-luna (only needed for step 3)

1. Download

mkdir -p ~/pb && cd ~/pb
hf download andre930/persona-basis-run21-test-eval --repo-type dataset --local-dir bundle
hf download andre930/persona-basis-run22-rkl --local-dir run22              # all three checkpoints, about 1.6 GB
#   one checkpoint only:  hf download andre930/persona-basis-run22-rkl --include "global_step60_hf/*" --local-dir run22
hf download Qwen/Qwen3-4B-Instruct-2507 --local-dir Qwen3-4B-Instruct-2507
export BASE_MODEL=$HOME/pb/Qwen3-4B-Instruct-2507

run22/global_step{60,80,100}_hf/ each hold persona_0..3, where persona_k = warm, impersonal, concise, thorough.

2. Generate run22 test answers (per checkpoint)

cd ~/pb/bundle/scripts
S=60                                   # then 80, 100
CK=$HOME/pb/run22/global_step${S}_hf
OUT=$HOME/pb/out/run22_s${S}

python gen_test_heads.py build --ckpt $CK --out $OUT        # 4 mix adapters, about 505 MB each, CPU only

for i in 0 1 2 3 4 5 6 7; do
  CUDA_VISIBLE_DEVICES=$i VLLM_WORKER_MULTIPROC_METHOD=spawn \
    python gen_test_heads.py gen --ckpt $CK --out $OUT --shard $i --nshards 8 > $OUT.gen$i.log 2>&1 &
done; wait

python gen_test_heads.py merge --ckpt $CK --out $OUT        # -> $OUT/systems.jsonl

• Output. Each prompt gets router_head and oracle_head. Add --all_heads to both gen and merge to also produce the four single-head systems (about 4× the generation).
• Decoding is identical to run21's: greedy, max 2,560 new tokens, max_model_len 4,096, seed 42, the rewritten prompt as the only user turn.
• Sanity check. merge prints each system's median words and cap hits. run21's router_head had a median of 193 words and 6 answers hitting the 2,560-token cap (4 of them repetition loops). Read a few answers before judging, and look into any large difference.
• Time: a few minutes per checkpoint on 8 A100s.

3. Judge against run21 with luna

Always run plan first. It prints how many paid calls are still needed; identical texts are free ties, and cached verdicts are reused. Then run run (resumable, 32 workers, retries), then tally.

cd ~/pb/bundle/scripts
R21=$HOME/pb/bundle/run21/systems_test.jsonl
A=$OUT/systems.jsonl
V=$OUT/verdicts.jsonl

# (a) the direct KL-direction comparison: run22 router heads vs run21 router heads, head to head
python judge_compare.py plan --a $A:router_head --b $R21:router_head --out $V
python judge_compare.py run  --a $A:router_head --b $R21:router_head --out $V

# (b) vs persona prompting for the same pick            (run21: 55% [51,59])
python judge_compare.py run  --a $A:router_head --b $R21:router_persona --out $V

# (c) vs the base model                                   (run21: 64% [60,68])
python judge_compare.py run  --a $A:router_head --b $R21:base --out $V

# optional, true-label routing
python judge_compare.py run  --a $A:oracle_head --b $R21:oracle_persona --out $V   # run21: 57% [53,61]
python judge_compare.py run  --a $A:oracle_head --b $R21:base --out $V             # run21: 70% [66,74]

# print a table again at any time
python judge_compare.py tally --a $A:router_head --b $R21:router_persona --out $V

• Protocol (identical to run21's):
  • the judge sees the prompt's preference_label and rewritten_prompt, and two answers;
  • each pair is judged in both A/B orders; W or L counts only if both orders agree, otherwise T;
  • win rate = (W + T/2) / n, with a 95% bootstrap CI over prompts;
  • tally also breaks results down by the router's pick (one or two poles) and by the true preference type.
• Cost: each comparison is about 2 × 499 ≈ 1,000 calls.
  • (a) + (b) + (c) is about 3,000 per checkpoint, about 9,000 for all three.
  • Cheaper order: run (b) for s60, s80 and s100 first (about 3,000 calls), then (a) and (c) only for the checkpoint you report.
• Reproducing run21's tables for free from the bundled verdicts: python judge_compare.py tally --a $R21:router_head --b $R21:router_persona gives 55% [51,59] with 0 calls.

4. What to compare

run21 (forward KL, s60) on the same 499 test prompts:

comparison	run21 forward	run22 s60	run22 s80	run22 s100
router heads vs persona prompting (same pick)	55% [51,59]
router heads vs base	64% [60,68]
true-label heads vs persona prompting	57% [53,61]
true-label heads vs base	70% [66,74]
run22 router heads vs run21 router heads (head to head)	— (50% by definition)

run21 by true preference type (router heads vs persona prompting | vs base):

type	vs persona	vs base
warm	29%	48%
impersonal	60%	62%
concise	84%	93%
thorough	34%	38%
warm+concise	73%	85%
warm+thorough	41%	48%
impersonal+concise	74%	78%
impersonal+thorough	44%	60%

The full run21 tables, including router heads vs each single head (76–78%), are in run21/run21_test_tables.txt.

5. Notes and caveats

• Only the heads differ. Router picks, mixing recipes, decoding and judge are all fixed. run21's answers and verdicts come from this bundle, so any difference is the training objective, plus small decoding noise from a different vLLM or GPU.
• Checkpoint choice. run21's s60 was selected on validation. Picking the best of run22's s60/s80/s100 on this test set would be optimistic. Report the matched step (s60 vs s60) as the primary comparison and s80/s100 as additional rows, or select run22's checkpoint on validation first.
• Recipe tuning. The mixing-recipe strengths were tuned for run21's heads on validation and are applied unchanged to run22, which slightly favours run21 on two-preference prompts.
• Licence. The test prompts derive from PRISM (Kirk et al., 2024; human-written text CC-BY-4.0). The rewritten prompts were produced with Qwen3.5-27B, and all answers were generated by our Qwen3-4B-based models. The bundle contains no PRISM model responses. It is shared privately, for evaluation only.