| """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": |
| |
| 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 |
| rollout_path=folder/'rollouts/index.parquet';assert hashlib.sha256(rollout_path.read_bytes()).hexdigest()==part['rollout_index_sha256'];rollouts=pq.read_table(rollout_path).to_pylist() |
| 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) |
| 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))) |
|
|
