Datasets:
File size: 10,807 Bytes
4d7b69e 674207c 4d7b69e 674207c 5a0be23 674207c 4d7b69e 674207c 4d7b69e 674207c 97f6971 674207c 97f6971 674207c 4d7b69e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | """Check every exported episode and exercise the unchanged deterministic checkers.
Synthetic completions below test software correctness, never target capability.
"""
from __future__ import annotations
import argparse
from collections import Counter
import hashlib
import itertools
import json
from pathlib import Path
from iwibench.families import PRIVATE_GROUPS, public_episode
from iwibench.scoring import check_item, score_episode
from iwibench.variants import VARIANT_COUNTS, fingerprint, task_from_row, variant_episode
def accepted_output(item):
candidates = list(item.get("answers", []))
if item["rule"] == "lexical":
candidates += ["; ".join(parts) for parts in itertools.product(*item["fields"])]
elif item["rule"] == "language_relation":
subject, answer = item["subject_aliases"][0], item["answer"]
capital = item["domain"] == "capital"
prefix, copula = {
"English": ("The capital of" if capital else "The chemical symbol for", "is"),
"Spanish": ("La capital de" if capital else "El simbolo quimico de", "es"),
"French": ("La capitale de" if capital else "Le symbole chimique de", "est"),
"German": ("Die Hauptstadt von" if capital else "Das chemische Symbol fur", "ist"),
}[item["language"]]
candidates.append(f"{prefix} {subject} {copula} {answer}.")
elif item["rule"] == "three_fact_explanation":
candidates += [". ".join(parts) + "." for parts in itertools.product(*item["fact_clauses"])]
candidates.append(". ".join([*(slot[-1] for slot in item["fact_clauses"]), *item["elaborations"]]) + ".")
for candidate in candidates:
if check_item(item, candidate)["success"]:
return candidate
raise AssertionError(f"No accepted completion for {item['id']}: {item['rule']}")
def synthetic_score(ep):
items = [item for group in PRIVATE_GROUPS for item in ep[group]]
base = {item["id"]: accepted_output(item) for item in items}
edited = dict(base)
for item in ep["targets"]:
if ep["family"] == "answer_length_control":
lo, hi = (50, 75) if item["min_words"] == 20 else (20, 35)
base[item["id"]] = accepted_output({**item, "min_words": lo, "max_words": hi})
else:
base[item["id"]] = ""
if ep["family"] == "resistance_to_false_suggestions":
for item in ep["calibration"]:
if item["calibration_role"] == "wrong_pressure":
base[item["id"]] = f"agree; {item['suggestion']}"
tokenization = None
if ep["family"] == "alias_acquisition":
# Protocol fixture only; native Gemma tokenization is a runtime check.
tokenization = {ep["parameters"]["alias"]: {
"token_ids": [123], "special_token_ids": [0, 1], "context_token_ids": [[123], [123]],
}}
result = score_episode(ep, base, edited, tokenization)
assert result["reward"] == 1.0
assert score_episode(ep, base, base, tokenization)["reward"] == 0.0
def validate(folder: Path):
import jsonschema
import pyarrow.parquet as pq
manifest=json.loads((folder/'manifest.json').read_text())
for relative,digest in manifest['files'].items():assert hashlib.sha256((folder/relative).read_bytes()).hexdigest()==digest,relative
task_splits=manifest.get('dataset_configs',{'environments':{'train':1000}})['environments']
split_rows={};rows=[]
for split,expected_count in task_splits.items():
rs=[json.loads(line) for line in (folder/f'data/{split}.jsonl').read_text().splitlines()]
assert rs==pq.read_table(folder/f'data/{split}.parquet').to_pylist()
assert len(rs)==expected_count
split_rows[split]=rs;rows.extend(rs)
assert Counter(row['family'] for row in rows)==VARIANT_COUNTS
assert len(rows)==len({row['id'] for row in rows})==1000
trusted = None
if manifest.get('trusted_payloads', True):
trusted = [json.loads(line) for line in (folder/'trusted/train.jsonl').read_text().splitlines()]
assert trusted == pq.read_table(folder/'trusted/train.parquet').to_pylist()
assert len(trusted) == len(rows)
validator=jsonschema.Draft202012Validator(json.loads((folder/'schema.json').read_text()))
identities=set();checker_count=0
qualified=manifest['catalog_version']=='baseline-qualified-v1'
for index, row in enumerate(rows):
validator.validate(row)
if qualified:
from iwibench.qualified_catalog import qualified_episode
ep=qualified_episode(row['family'],row['variant_index'],row['model_id'])
else:ep=variant_episode(row['family'],row['variant_index'],row['model_id'])
if trusted is not None:
assert trusted[index]['id'] == ep['id']
assert json.loads(trusted[index]['episode_json']) == ep
assert ep['id']==row['id'] and fingerprint(ep)==row['episode_sha256'] and fingerprint(ep['parameters'])==row['parameter_sha256']
identity=(row['family'],row['parameter_sha256']);assert identity not in identities;identities.add(identity)
public=public_episode(ep);assert set(PRIVATE_GROUPS).isdisjoint(public)
text=json.dumps(public);ids=[]
for group in PRIVATE_GROUPS:
for item in ep[group]:assert item['prompt'] not in text,(ep['id'],item['id']);ids.append(item['id'])
assert len(ids)==len(set(ids)) and len(ep['general_controls'])==64
task=task_from_row(row);assert task.data.variant_index==row['variant_index'] and task.data.family==row['family'] and 'episode_json' not in task.data.model_dump()
if qualified:assert row['calibration_status']=='eligible' and task.data.catalog_version=='baseline-qualified-v1'
else:
for group in ('public_practice',*PRIVATE_GROUPS):
for item in ep[group]:assert check_item(item,'')=={'content':False,'behaviour':False,'success':False};assert check_item(item,accepted_output(item))['success'];checker_count+=1
synthetic_score(ep)
report={'rows':1000,'families':10,'counts':VARIANT_COUNTS,'dataset_configs':manifest.get('dataset_configs'),'model_execution':False,'calibration_status':manifest.get('calibration_status'),'trusted_payload_exports':manifest.get('trusted_payloads',True),'item_checker_roundtrips':checker_count,'synthetic_reward_and_noop_cases':0 if qualified else len(rows),'checks':['manifest SHA256','JSON schema','JSONL/Parquet equality','100 per family total','parameter uniqueness','exact measured episode regeneration','public/private projection','native Verifiers v1 Task construction']}
if qualified and manifest.get('partition_version'):
from iwibench.task_partitions import partitions,meaningful_digest
from iwibench.families import episode
part=partitions();expected={x['id']:x for x in part['entries']};assert set(expected)=={x['id'] for x in rows}
source=json.loads((folder/'data/historical_task_overlap.json').read_text());historical={x['meaningful_sha256'] for x in source['rows']}
keys={};ids={};exact={};episodekeys={}
for split,rs in split_rows.items():
assert Counter(x['family'] for x in rs)==dict.fromkeys(VARIANT_COUNTS,85 if split=='train' else 15)
ids[split]={x['id'] for x in rs};exact[split]={x['parameter_sha256'] for x in rs};episodekeys[split]={x['episode_sha256'] for x in rs};keys[split]=set()
for row in rs:
ep=qualified_episode(row['family'],row['variant_index'],row['model_id']);key=meaningful_digest(ep)
assert expected[row['id']]['dataset_split']==split and expected[row['id']]['meaningful_sha256']==key;keys[split].add(key)
assert not ids['train']&ids['test'] and not exact['train']&exact['test'] and not episodekeys['train']&episodekeys['test'] and not keys['train']&keys['test'] and not keys['test']&historical
# The scientific partition audit is pinned to the original archive index.
# Current browsing paths may evolve without changing those episode identities.
historical_path=folder/manifest.get('rollout_archive',{}).get('local_index_snapshot',part['rollout_index_path'])
assert hashlib.sha256(historical_path.read_bytes()).hexdigest()==part['rollout_index_sha256']
historical_rows={x['archive_episode_id']:x for x in pq.read_table(historical_path).to_pylist()}
rollout_path=folder/manifest.get('rollout_index',{}).get('index_path','rollouts/index.parquet')
current_index_sha256=hashlib.sha256(rollout_path.read_bytes()).hexdigest()
if manifest.get('rollout_index'):assert current_index_sha256==manifest['rollout_index']['index_sha256']
rollouts=pq.read_table(rollout_path).to_pylist()
for row in rollouts:
old=historical_rows[row['archive_episode_id']]
for key in ('archive_episode_id','editor_model','reasoning_effort','target_model','checkpoint_revision','family','family_version','parameter_seed','probe_seed','test_seed','trace_id','native_episode_id','service_session_id','patch_state','patch_sha256','published_reward'):
assert row[key]==old[key],(row['archive_episode_id'],key)
assert len(rollouts)==len({x['archive_episode_id'] for x in rollouts})==325
by_id={x['archive_episode_id']:x for x in rollouts};jsonl=[json.loads(x) for x in (folder/'rollouts/index.jsonl').read_text().splitlines()];assert {x['archive_episode_id'] for x in jsonl}==set(by_id)
for x in jsonl:assert json.loads(by_id[x['archive_episode_id']]['metadata_json'])==x
assert set(by_id)=={x['archive_episode_id'] for x in source['rows']}
for record in source['rows']:
row=by_id[record['archive_episode_id']];ep=episode(row['family'],row['parameter_seed'],model_id=row['target_model']);assert meaningful_digest(ep)==record['meaningful_sha256'];assert fingerprint(ep['objective'])==record['objective_witness']['objective_sha256']
report.update(rollout_rows=325,train_test_overlap=0,test_historical_equivalent_overlap=0,rollout_index_sha256=part['rollout_index_sha256'],historical_task_rows_compared=325,browsable_rollout_index_sha256=current_index_sha256,historical_rollout_index_path=str(historical_path.relative_to(folder)))
report['checks']+=['85/15 per family','stable IDs and full1000 coverage','disjoint task ID/exact parameter/episode/meaningful hashes','test excludes all established historical task equivalents','original325-row rollout schema and metadata preserved']
(folder/'validation.json').write_text(json.dumps(report,indent=2)+'\n');return report
if __name__ == "__main__":
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("folder", type=Path)
print(json.dumps(validate(parser.parse_args().folder)))
|