| """Freeze session judgments before separately reading reference labels. No API calls.""" |
| import argparse |
| import hashlib |
| import json |
| import sys |
| from collections import Counter |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[2])) |
| import benchmark_gpt6_astra as runner |
|
|
| ROOT = Path('gpt6-reassemble40/results/codex-session') |
|
|
|
|
| def digest(path): |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def write_new(path, value): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open('x', encoding='utf-8') as f: |
| json.dump(value, f, ensure_ascii=False, indent=2) |
| f.write('\n') |
|
|
|
|
| def freeze(): |
| source = ROOT / 'judgments.json' |
| records = json.loads(source.read_text()) |
| assert sorted(r['n'] for r in records) == list(range(31, 71)) |
| prepared = [] |
| files = {'judgments.json': digest(source)} |
| for r in records: |
| cid = f"case_{r['n']:03d}" |
| instruction, meta, _ = runner.load_case( |
| Path('gpt6-reassemble40/benchmark/cases') / cid |
| ) |
| times, _ = runner.choose_timestamps(meta, 3, 2, 1, 30, 900) |
| overview = [times[i] for i in sorted({round(i*(len(times)-1)/7) for i in range(8)})] |
| viewed = overview + (times[-3:] if r.get('supplement') == 'tail' else []) |
| assert r['verdict'] in ('success', 'failure', 'uncertain') |
| assert 0 <= r['confidence'] <= 1 |
| for ev in r['evidence']: |
| assert ev['camera'] in ('main', 'wrist', 'external_2') |
| assert ev['timestamp_s'] in viewed, (cid, ev, viewed) |
| sheets = [f'evidence/{cid}_overview_00.jpg'] |
| if r.get('supplement') == 'tail': |
| sheets.append(f'evidence/{cid}_tail_00.jpg') |
| for name in sheets: |
| files[name] = digest(ROOT / name) |
| prepared.append((cid, dict(r, case_id=cid, instruction=instruction, |
| evaluation_mode='codex_session_visual_review', |
| overview_timestamps_s=overview, |
| native_tail_timestamps_s=times[-3:] if r.get('supplement') == 'tail' else [], |
| viewed_sheets=sheets))) |
| for cid, record in prepared: |
| name = f'cases/{cid}.json' |
| write_new(ROOT / name, record) |
| files[name] = digest(ROOT / name) |
| manifest = { |
| 'benchmark': 'JudgerBench40', 'case_count': 40, |
| 'evaluation_mode': 'codex_session_visual_review', |
| 'requested_session_model': 'Astra (user-selected Codex session)', |
| 'independently_verified_api_model_snapshot': None, |
| 'external_judgment_api_calls': 0, |
| 'codex_session_cost_and_tokens': None, |
| 'strict_blind_evaluation': False, |
| 'limitations': [ |
| 'Existing conversation contains previous labels/discussions; not an isolated blind evaluation.', |
| 'Judgments use contact sheets extracted from videos, not native continuous-video ingestion.', |
| '8 overview timepoints per case at 320x240 per view; selected cases have 3 native 640x480 tail frames per view; JPEG quality 95.', |
| 'Adaptive review within a shared session differs from independent API requests and their full sampling.', |
| 'Confidence is subjective and uncalibrated. No model training or parameter updates occurred.', |
| 'Within this review, judgments were saved before loading the reference-label file for comparison.' |
| ], |
| 'reference_rubric_sha256': hashlib.sha256(runner.SYSTEM_PROMPT.encode()).hexdigest(), |
| 'rubric_use': 'Session followed the existing rubric; not a verbatim isolated API prompt replay.', |
| 'counts': dict(Counter(r['verdict'] for r in records)), |
| 'frozen_at_utc': datetime.now(timezone.utc).isoformat(), |
| 'sha256': files, |
| } |
| write_new(ROOT / 'freeze_manifest.json', manifest) |
| print(json.dumps({k:v for k,v in manifest.items() if k != 'sha256'}, ensure_ascii=False, indent=2)) |
|
|
|
|
| def compare(): |
| manifest = json.loads((ROOT / 'freeze_manifest.json').read_text()) |
| for name, expected in manifest['sha256'].items(): |
| assert digest(ROOT / name) == expected, f'Frozen artifact changed: {name}' |
| reference = Path('gpt6-reassemble40/benchmark/ground_truth/labels.jsonl') |
| labels = {r['case_id']: r for r in |
| (json.loads(line) for line in reference.read_text().splitlines() if line.strip())} |
| rows = [] |
| for n in range(31, 71): |
| cid = f'case_{n:03d}' |
| r = json.loads((ROOT / f'cases/{cid}.json').read_text()) |
| rows.append(dict(case_id=cid, instruction=r['instruction'], |
| reference_outcome=labels[cid]['outcome'], prediction=r['verdict'], |
| matches_reference=r['verdict'] == labels[cid]['outcome'], |
| confidence=r['confidence'], summary=r['summary'])) |
| counts = Counter((r['reference_outcome'], r['prediction']) for r in rows) |
| tp, fp = counts['success', 'success'], counts['failure', 'success'] |
| tn, fn = counts['failure', 'failure'], counts['success', 'failure'] |
| uncertain = sum(r['prediction'] == 'uncertain' for r in rows) |
| precision = tp / (tp+fp) if tp+fp else None |
| recall = tp / sum(r['reference_outcome'] == 'success' for r in rows) |
| result = dict(case_count=len(rows), exact_matches=tp+tn, |
| overall_reference_agreement=(tp+tn)/len(rows), |
| decided_reference_agreement=(tp+tn)/(len(rows)-uncertain), |
| decision_coverage=(len(rows)-uncertain)/len(rows), |
| success_precision=precision, success_recall=recall, |
| success_f1=2*precision*recall/(precision+recall), |
| tp=tp, tn=tn, fp=fp, fn=fn, uncertain=uncertain, |
| reference_sha256=digest(reference), |
| reference_status_counts=dict(Counter(r['annotation_status'] for r in labels.values())), |
| compared_at_utc=datetime.now(timezone.utc).isoformat(), |
| caveat='Agreement with source labels, not independently adjudicated accuracy; not a strict blind API benchmark.', |
| discrepancies=[r for r in rows if not r['matches_reference']], rows=rows) |
| write_new(ROOT / 'comparison.json', result) |
| print(json.dumps({k:v for k,v in result.items() if k != 'rows'}, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--compare', action='store_true') |
| args = parser.parse_args() |
| compare() if args.compare else freeze() |
|
|
