| # duel_corpus — credit-assigned SFT data from SN97 duel artifacts |
| |
| Built from the 200 eval runs the dashboard still exposes. The core idea: the |
| judge answers questions about a whole trajectory, but 81% of its explanations |
| name the `CANDIDATE OUTPUT N` block that satisfied each question. That citation |
| is the only per-turn reward signal SN97 emits, and it is free — other miners' |
| GPU time already paid for it. |
| |
| ## Pipeline |
| |
| | step | script | output | |
| |---|---|---| |
| | 0 | `harvest_all.py` | `raw/` — 400 artifacts, 5.93 GB, 19,811 scored samples | |
| | 1 | `build_turn_corpus.py` | `turns.jsonl` (506,201 turns), `samples.jsonl` (39,622 sides) | |
| | 2 | `select_targets.py` | `sft_duel_credit_v1.jsonl` — 4,751 rows | |
| | 4 | `validate.py` | `sft_duel_credit_v1.clean.jsonl` — **4,664 rows, 22,762 train turns** | |
|
|
| Re-runnable end to end; the harvest resumes if interrupted. |
|
|
| ## Output format |
|
|
| Drop-in for `sft/data.py`: a full `messages` list where assistant turns that |
| should receive gradient carry `train: true`. Everything else stays as context, |
| which is the point — the model must see the states it will generate from, |
| including the failed ones. |
|
|
| Each row also carries `train_meta` (per-turn earned weight, tags, `is_recovery`, |
| `cmd_kind`) so composition can be reweighted at training time without a rebuild. |
|
|
| ## What the corpus says |
|
|
| Turn credit is not uniform. Mean credit earned by a turn, by command: |
|
|
| | command | share of turns | mean credit | % earning | |
| |---|---|---|---| |
| | `cat -n` | 9.8% | 1.350 | 44.3% | |
| | `sed -n` | 14.1% | 1.165 | 40.6% | |
| | `cat` | 14.6% | 0.866 | 37.0% | |
| | edit | 1.9% | 0.716 | 41.3% | |
| | `grep -r` | 4.2% | 0.487 | 30.0% | |
| | `pytest`/`python` | 11.2% | 0.247 | 21.8% | |
| | `find`/`ls` | 10.4% | 0.186 | 18.1% | |
| | submit | 0.4% | 0.153 | 9.5% | |
|
|
| Displaying file content earns 5-7x what `find`/`ls`/`pytest` earn, and those two |
| low-value kinds are 21.6% of all turns in the wild. That is the waste. |
|
|
| Credit is also strongly front-loaded — turn 1 earns 1.523, turn 15 earns 0.186. |
| The first three turns are where a sample is won. |
|
|
| Exposure bias is measurable here: 19.2% of turns get a failed observation, and a |
| turn following a failure earns credit only 18.8% of the time against a 30.3% |
| baseline. A single bad command costs ~40% of the next turn's expected credit. |
|
|
| ## Composition of the built dataset |
|
|
| 24,472 selected train turns before validation, 22,762 after: |
|
|
| - command mix: `cat -n` 18.1%, `sed -n` 16.9%, `cat` 16.2% (51% display), `find`/`ls` down to 5.9% |
| - earned tags: grounding 35.6%, explore 29.6%, claims 20.9% — 86% on the three tags carrying 89% of duel weight |
| - 2,841 recovery turns (earned credit immediately after a failed observation), present in 41% of rows |
| - source sides average 0.941 score, deduped to one side per `sample_id` |
| - 4.2M trainable tokens; mean sequence 9,394 tokens, 0.4% over a 32,768 limit |
|
|
| ## Gates applied |
|
|
| Run with the validator's own `loop_check` and `observation_format`: |
|
|
| - source side must be non-looped, score >= 0.85, `dup_cmd_ratio` <= 0.45, `max_cmd_run` <= 3 |
| (validator kills at 0.65 / 6, so there is margin) |
| - a repeated command never receives gradient |
| - train turns must contain exactly one bash block, no unclosed `<think>`, no |
| duplicate command among targets — violations are demoted to context, not dropped |
| - 100% of train turns tokenize with `sft/data.py` and their label span decodes |
| back to exactly the assistant content |
|
|
| ## The escape set — `build_escape_set.py` |
|
|
| The Phase 2 filter above selects per *side*, and that quietly recreated the |
| problem it was supposed to fix: requiring score >= 0.85 and low repetition threw |
| out every trajectory that demonstrates being stuck. It kept 8,021 of 39,622 |
| sides and captured only 16.8% of the available recovery material (2,805 of |
| 16,650 turns). |
|
|
| `build_escape_set.py` selects per *turn* instead. A turn qualifies when it |
| earned judge credit and the state before it was bad — previous observation |
| failed, or previous commands were repeating. The degenerate prefix is kept |
| verbatim with no gradient; only the escape trains. A side that scored 0.3 |
| overall still contributes its one good escape, because per-turn credit is |
| verified per-question regardless of the side's total. |
|
|
| `sft_escape_v1.jsonl` — 13,979 rows, 7,655 unique samples: |
|
|
| - **73.7% come from sides Phase 2 rejected** — that is the material that matters |
| - 98.3% follow a failed observation, 1.8% follow a repeat run |
| - prior consecutive failures: mean 1.29, max 10 |
| - escapes are mostly reads: `cat` 19.2%, `grep` 18.5%, `cat -n` 14.1%, `sed -n` 13.5% |
| - 100% tokenize clean, median 8,006 tokens, 1.8% over 32,768 |
|
|
| ## Combined output |
|
|
| `sft_final_v1.jsonl` — 18,643 rows, 36,741 gradient-bearing turns, 861 MB. |
| 4,664 credit rows (what winning looks like) + 13,979 escape rows (how to get |
| out of trouble). Rows carry `mix` = `credit` | `escape` for reweighting. |
|
|
| ## Judge-free local scorer |
|
|
| SN97 scores a trajectory by asking an LLM judge yes/no questions. The questions |
| are *in the artifacts* — what we lack is only the judge. So `build_local_scorer.py` |
| featurizes each question against a trajectory and `fit_local_scorer.py` fits a |
| classifier to answer it. Train/test split is by eval run, so evaluation never |
| sees a duel it was fit on. |
|
|
| | step | script | output | |
| |---|---|---| |
| | features | `build_local_scorer.py` | `scorer_features.jsonl` — 39,622 sides, 565k questions | |
| | fit | `fit_local_scorer.py` | `local_scorer.pkl` (gradient boosting) | |
| | use | `score_local.py --build-index` then `--trajectories mine.jsonl` | `local_scores.jsonl` | |
|
|
| Requires the venv at `/root/.venv-tok` (numpy, scikit-learn). |
|
|
| ### Measured accuracy, held out |
|
|
| | what | number | |
| |---|---| |
| | per-question accuracy / AUC | 0.771 / 0.849 | |
| | per-side score correlation | pearson 0.727, **MAE 0.140** | |
| | paired same-sample: picks the better side | 70.0% | |
| | duel margin sign agreement | 73.3% | |
| | per-model ranking (57 models) | spearman 0.561 | |
| | loop detection | **exact** — runs the validator's own `loop_check` | |
| | catastrophic flag at <0.35 | precision 0.820, recall 0.384 | |
|
|
| ### What this is and is not good for |
|
|
| **Trustworthy:** catching loops before you submit (exact, and it is what banned |
| two of your hotkeys); flagging which specific samples the model falls apart on |
| (82% precision), which matters because 70% of the gap to the king lives in |
| samples scoring under 0.34. |
|
|
| **Only with enough samples:** the per-sample error is 0.207, so a 100-sample run |
| gives +/-0.041 at 95% — wider than the 0.025 margin that decides a duel. It takes |
| **500+ paired samples to resolve 0.025**, 1000 to be comfortable. Generate on |
| 500–1000 samples, not 100. |
|
|
| **Not trustworthy:** any single sample's score (MAE 0.140), and ranking two |
| models that are genuinely close. |
|
|
| End-to-end check on a held-out run: predicted 0.5804 against the judge's 0.5779. |
|
|
| ## Window B — `../mini_coder/mine_window_b.py` |
| |
| Duel artifacts stop at turn 16, so they contained only **243** escapes out of a |
| repeat run and nothing at all past the cutoff where pre-eval's tail judge looks. |
| `mini-coder` (`ricdomolm/mini-coder-trajs-400k`, 9.4 GB, 396,382 trajectories) |
| covers exactly that region: mean 33 assistant turns, and 99.9% end in a submit. |
| |
| Two products, suffix-masked the same way: |
| |
| | product | rows | what it teaches | |
| |---|---|---| |
| | `escape` | 6,820 (**28x** the duel corpus; 41.3% past turn 16) | a command repeats, a *different* command breaks out — gradient on the escape only | |
| | `finish` | 177,559 mined, capped to 16,000 | concrete non-repeating tail work on verified tasks, plus the closing submit | |
| |
| `finish` is capped at one row per instance because 177,559 rows come from only |
| 20,267 instances; uncapped it would swamp the duel material and pull the model |
| toward mini-coder's style in the window that decides duels. |
| |
| ## Final mix — `build_final_mix.py` -> `sft_final_v2.jsonl` |
| |
| **41,463 rows, 59,561 gradient-bearing turns, 1.69 GB.** |
| |
| | mix | rows | share | train turns | window | purpose | |
| |---|---|---|---|---|---| |
| | `credit` | 4,664 | 11.2% | 22,762 | 1–16 | what earns judge credit | |
| | `escape_duel` | 13,979 | 33.7% | 13,979 | 1–16 | recovery from a failed command, on-policy | |
| | `escape_mini` | 6,820 | 16.4% | 6,820 | 5–32 | breaking out of a repeat run | |
| | `finish_mini` | 16,000 | 38.6% | 16,000 | 17–32 | surviving to a submit in 32 turns | |
|
|
| Every row carries `mix`, so ratios can be changed without a rebuild. |
|
|
| Tokenizer validation across all four mixes: **100% of sampled train turns |
| encode cleanly and their label spans decode back to exactly the assistant |
| content.** Median sequence 7,798–9,110 tokens; only `escape_duel` has material |
| overflow past 32,768 (2.0%). |
|
|
| ### Coverage against the two gates |
|
|
| | failure | share of chelsea-blue's pre-eval failures | covered by | |
| |---|---|---| |
| | looping | 5/10 | `escape_mini` (6,820, 41% past cutoff) + `escape_duel` | |
| | no submission / no edits in 32 turns | 2/10 | `finish_mini` (16,000, 8,776 submit turns available) | |
| | duel score gap | — | `credit` + `escape_duel` | |
|
|
