LidaSafety/incidentbench-silver-training

IncidentBench silver training data

Provenance and reuse terms are in LICENSE_NOTE.md: the records derive from public incident databases that carry their own terms, and the training labels are model-generated.

Every training set behind the IncidentBench results tables, with the model-generated label store they are built from and the human-annotated targets they are scored against.

The training labels are model-generated. Claude Opus 5 produced them, which is why they are called silver. They are training labels only: every reported score is measured against human-assigned golden targets, which are in output/golden_human/.

Read data_guidelines.md before using this. It carries the record format, the training and prediction contracts, which scorer belongs to which task, and the mistakes that have cost this project results — including the one where silver outscores every model trained on it and must not be mistaken for a ceiling.

Three cutoffs, one fixed test split

Each task ships at three training cutoffs: <2024, <2025 and <2026, meaning the training records are dated before that year. All three are scored on the same test split, which is what makes the columns comparable; the three cutoff files of a task share one sha256 for their test split, and FILE_MANIFEST.json lets you verify that.

A backbone released after a cutoff leaks: the whole Qwen3 family postdates 2025-04-27, so no Qwen3 model is admissible below <2026. Check a model's release date against the cutoff before training.

What each file reproduces

task	training files	rows	published cells
incident classification, 8-class	output/incident_mit8_lt{2024,2025,2026}/train.jsonl	4,397 / 5,917 / 8,414	detection 68.40, 67.75, 70.87 macro-F1; category 53.67, 52.60, 57.58
incident description	output/incident_gen{,_lt2025,_lt2026}/train.jsonl	4,397 / 5,916 / 8,413	76.92, 81.95, 81.95 cosine win rate
policy generation	output/policy_gen_lt{2024,2025,2026}/train.jsonl	3,443 / 4,430 / 6,240	63.37, 62.03, 63.10 cosine win rate
policy stage / RMF	output/policy_category_lt{2024,2025,2026}/train.jsonl	2,434 / 2,689 / 3,143	53.18, 51.86, 53.76 stage micro-F1

output/multilabel_domains/ holds the label store, one file per labeller over the same 11,088 records: Claude Opus 5 (used for every published number), GPT-6 Astra, Claude Opus 5.5, and a stricter prompt variant. Swapping the labeller is what makes the robustness check reproducible. output/incident_mit_full/ is the upstream cohort every task builder reads.

Evaluation targets and cohorts

output/golden_human/ holds the human-assigned references. The scored cohorts are intersections, not samples: golden incidents dated 2026 onward that appear in none of the three training splits. 416 cases for detection, the 261 of those marked real for category, 338 for description, 187 for policy. Assert the count before reporting, because a cohort that changes size invalidates any comparison against a published cell.

Generation scores are masked contrastive win rates against a same-class decoy, where 50.00 is chance. Report the masked figure: echoing the input back scores 94.78 cosine unmasked and 63.33 masked. Cosine and Jaccard are reported separately and must never be averaged, because they disagree systematically and the disagreement is itself the result.

Two documented discrepancies

The description cohorts are one row short of the published Training records row at <2025 and <2026 (5,916 and 8,413 against 5,917 and 8,414). That row is counted on the classification cohorts, which match exactly.

The <2024 description arm's test split is a larger 6,688-row file rather than the 2,672-row fixed split, because that cutoff predates the move to a fixed test set. It is a superset containing every scored case, so the score is comparable, but the file is not interchangeable with the other two.

Reproducibility caution

Retraining these arms at identical seed and hyperparameters on different hardware and library versions moved two published cells by several points (<2024 description 76.92 to 81.66, <2025 81.95 to 84.02). That is the same magnitude as the differences between cutoffs, so a single run is not evidence that one cutoff outperforms another.

Retrieved-example (shot) manifests

shots/ declares exactly what the in-context arms were given, because those arms outscore every fine-tuned arm on both generation tasks and what went into their context was never recorded. The arm's own manifest saved K and the selection rule but not the rows it picked.

Selection is deterministic and was recomputed rather than guessed: the K nearest train rows to each test row by cosine over sentence-transformers/all-MiniLM-L6-v2 embeddings of the prompt field, with the most similar example placed last, nearest the question.

file	task	K	scored cases	train pool
shots/incident_gen_k250.jsonl	incident description	250	338	4,397
shots/incident_gen_lt2025_k64.jsonl	incident description	64	338	5,916
shots/incident_gen_lt2026_k64.jsonl	incident description	64	338	8,413
shots/policy_gen_lt2024_k64.jsonl	policy generation	64	187	3,443
shots/policy_gen_lt2025_k64.jsonl	policy generation	64	187	4,430
shots/policy_gen_lt2026_k64.jsonl	policy generation	64	187	6,240

Each row is one scored test case:

{"incident_id": "oecd:2026-...", "task": "policy_generation", "cohort": "output/policy_gen_lt2025",
 "K": 64, "shot_selection": "knn_minilm_cosine_over_prompt", "shot_order": "most_similar_last",
 "shot_incident_ids": ["aiid:...", "..."]}

Verified against the arms' own response caches

The selection was recomputed, not recorded, so it was checked rather than assumed. Each arm caches its API responses under a sha1 of the exact prompt string it sent. Rebuilding the prompt from a manifest and hashing it should therefore land on an existing cache entry, and it does for 119 of 120 spot-checked cases across three arms (40/40 Kimi K2 policy, 40/40 Kimi K2 description, 39/40 Qwen3-Next description).

The single exception, aiid:1503, differs by one shot. Its cosine values at the K=64 boundary are 0.759072 and 0.759048, a gap of 2.4e-5, so floating-point differences in the embedding computation between runs swap two near-identical candidates. That is the expected precision limit of reconstruction, not a defect in the record, and it is why the manifests are shipped rather than left to be regenerated by each user.

shots/export_shot_manifests.py is the exporter, so the reconstruction can be re-run and re-checked.

Order is part of the arm. A consumer that reverses shot_incident_ids is not running the same configuration. Look each id up in the cohort's train.jsonl to rebuild the context: the prompt is the concatenated shot blocks, then the task instruction, then the test case's own prompt.

What these shots achieved

Masked contrastive win rate on the same golden cases as every other number here.

arm	K	incident description	policy generation
Kimi K2 0905	64	86.39 / 77.81	70.05 / 63.10
Qwen3-Next-80B	64	83.73 / 75.15	66.84 / 62.57
gpt-4o-mini	250 / 64	85.50 / 71.89	66.31 / 58.29
best fine-tuned LoRA, for comparison	—	84.02 / 69.82	66.84 / 60.70
unadapted Qwen2.5-7B	0	82.84 / 66.72	60.96 / 58.56

There is no 500-shot arm. Only K=64 and K=250 were run, and only those are declared. K=250 was used once, for the gpt-4o-mini description arm; everything else is K=64. On the classification task, per-case K=64 retrieval beat class-stratified K=250, which is why the later arms use the smaller K.

What this comparison does and does not show

Three things differ at once between the shot arms and the LoRA adapters, so this is not a clean method comparison. The shot models are far larger (Kimi K2 is a large mixture-of-experts model against 7B and 8B adapters); they receive per-case retrieval at inference while the adapters receive none; and their pretraining is more recent than the earlier training cutoffs, though all of them fully predate the 2026-onward test window, so none is contaminated.

The defensible statement is that a much larger model with per-case retrieval outscores a 7-8B LoRA on both generation tasks. Whether in-context adaptation beats fine-tuning as a method needs the backbone held fixed, and that run does not exist yet.