| """Public CLI for validating and scoring world-model generated videos.""" |
| from pathlib import Path |
| import argparse |
| import hashlib |
| import json |
| import os |
|
|
| from .core import (digest, inside, load_truth, overall_ranking, read_jsonl, |
| read_submission, score, unique, write_json, write_jsonl) |
|
|
|
|
| def checked_submission(data, subset, submission): |
| truth = load_truth(data, subset) |
| parent, videos, metadata = read_submission(submission) |
| allowed = {r['id'] for r in truth} |
| if set(videos) - allowed: |
| raise ValueError('Submission contains ids outside the selected subset') |
| return truth, parent, videos, metadata |
|
|
|
|
| def validate(args): |
| from .media import inspect_video |
| truth, parent, videos, _ = checked_submission(args.data, args.subset, args.submission) |
| rows = [] |
| for item in truth: |
| sid = item['id'] |
| if sid not in videos: |
| rows.append({'id': sid, 'status': 'missing'}) |
| continue |
| path = parent / videos[sid]['video'] |
| try: |
| info = inspect_video(path) |
| info.pop('timestamps_s') |
| rows.append({'id': sid, 'status': 'ok', 'video_sha256': digest(path), **info, |
| 'covers_observation_time': info['last_timestamp_s'] + 0.001 >= item['observation_time_s']}) |
| except Exception as error: |
| rows.append({'id': sid, 'status': 'invalid', 'error_type': type(error).__name__}) |
| result = {'subset': args.subset, 'conditions': len(truth), |
| 'valid': sum(r['status'] == 'ok' for r in rows), |
| 'missing': sum(r['status'] == 'missing' for r in rows), |
| 'invalid': sum(r['status'] == 'invalid' for r in rows), 'videos': rows} |
| write_json(args.out, result) |
| print(json.dumps({k: v for k, v in result.items() if k != 'videos'})) |
| return 1 if result['invalid'] or result['missing'] else 0 |
|
|
|
|
| def judge(args): |
| from .judge import prompt_fingerprint, render_prompt, request_judgment |
| from .media import sample_video |
| truth, parent, videos, metadata = checked_submission(args.data, args.subset, args.submission) |
| previous = unique(read_jsonl(args.out)) if args.out.exists() else {} |
| output = [] |
| fingerprints = prompt_fingerprint() |
| if args.api_key_env not in os.environ and not args.allow_no_key: |
| raise ValueError('Set the judge API key environment variable, or use --allow-no-key for a local server') |
| api_key = os.environ.get(args.api_key_env) |
| if not api_key and not args.allow_no_key: |
| raise ValueError('Judge API key environment variable is empty') |
| for row in truth: |
| sid = row['id'] |
| answer = {'id': sid, 'label': 'uncertain', 'violation': 'uncertain'} |
| try: |
| if sid not in videos: |
| raise FileNotFoundError('Missing submitted video') |
| path = parent / videos[sid]['video'] |
| window = 119/30 if args.profile == 'paper-prefix-8' else max(119/30, row['observation_time_s']) |
| import av |
| import PIL |
| identity = {'video_sha256': digest(path), 'observation_time_s': row['observation_time_s'], |
| 'window_s': window, 'sampler_sha256': digest(Path(__file__).with_name('media.py')), |
| 'transport_sha256': digest(Path(__file__).with_name('judge.py')), |
| 'decoder_version': av.__version__, 'image_library_version': PIL.__version__, 'task': row['task'], 'model': args.model, |
| 'endpoint_sha256': hashlib.sha256(args.base_url.encode()).hexdigest(), |
| 'frames': 8, 'profile': args.profile, **fingerprints} |
| if previous.get(sid, {}).get('identity') == identity and not previous[sid].get('error_type'): |
| output.append(previous[sid]) |
| continue |
| images, info = sample_video(path, count=8, window=window) |
| prompt = render_prompt(row['task'], info['sampled_times_s'][-1], len(images)) |
| |
| if args.profile == 'observation-8' and info['sampled_times_s'][-1] + 0.001 < row['observation_time_s']: |
| answer.update(identity=identity, sampling=info, error_type='InsufficientObservationWindow') |
| else: |
| parsed = request_judgment(args.base_url, args.model, api_key, images, prompt) |
| answer.update(parsed, identity=identity, sampling=info, |
| prompt_sha256=hashlib.sha256(prompt.encode()).hexdigest(), |
| covers_observation_time=info['sampled_times_s'][-1] + 0.001 >= row['observation_time_s']) |
| except Exception as error: |
| |
| answer['error_type'] = type(error).__name__ |
| output.append(answer) |
| write_jsonl(args.out, output) |
| write_jsonl(args.out, output) |
| report = score(truth, output) |
| report.update(subset=args.subset, judge_model=args.model, sampling_profile=args.profile, |
| prompt_fingerprints=fingerprints, |
| errors=sum(bool(r.get('error_type')) for r in output)) |
| write_json(args.out.with_suffix('.report.json'), report) |
| print(json.dumps({k: report[k] for k in ['n', 'event_percent', 'structure_percent', 'errors']})) |
| return int(bool(report['errors'])) |
|
|
|
|
| def scoring(args): |
| truth = load_truth(args.data, args.subset) |
| report = score(truth, read_jsonl(args.predictions)) |
| report.update(subset=args.subset, truth_sha256=digest(args.data / 'evaluation/truth.jsonl'), |
| subset_sha256=digest(args.data / 'splits' / (args.subset + '.json'))) |
| write_json(args.out, report) |
| print(json.dumps({k: report[k] for k in ['n', 'tasks', 'event_percent', 'structure_percent', 'missing']})) |
| return 0 |
|
|
|
|
| def baseline(args): |
| truth = load_truth(args.data, args.subset) |
| rows = read_jsonl(args.data / 'baselines/judgments.jsonl') |
| selected = [r for r in rows if r['subset'] == args.subset and r['judge'] == args.judge] |
| models = sorted({r['model'] for r in selected}) |
| if not models: |
| raise ValueError('No frozen baseline judgments for this subset/judge') |
| results = [{'model': m, **score(truth, [r for r in selected if r['model'] == m])} for m in models] |
| write_json(args.out, {'subset': args.subset, 'judge': args.judge, 'models': results}) |
| print(f'Rescored {len(models)} frozen model results on {len(truth)} conditions.') |
| return 0 |
|
|
|
|
| def similarity(args): |
| from .similarity import compare_videos |
| truth, parent, videos, _ = checked_submission(args.data, args.subset, args.submission) |
| output = [] |
| for row in truth: |
| result = {'id': row['id']} |
| try: |
| if row['id'] not in videos: |
| raise FileNotFoundError('Missing submitted video') |
| result.update(compare_videos(parent / videos[row['id']]['video'], inside(args.data, row['reference_video']))) |
| except Exception as error: |
| result['error_type'] = type(error).__name__ |
| output.append(result) |
| valid = [r for r in output if 'error_type' not in r] |
| write_json(args.out, {'subset': args.subset, 'benchmark': 'geoflip-reference-diagnostic', |
| 'expected': len(truth), 'scored': len(valid), 'errors': len(output) - len(valid), |
| 'mean': {k: sum(r[k] for r in valid) / len(valid) if valid else None for k in ['mse', 'psnr', 'ssim']}, |
| 'per_condition': output}) |
| print(f'Compared {len(valid)}/{len(truth)} conditions. This is separate from paper 40-clip similarity.') |
| return int(len(valid) != len(truth)) |
|
|
|
|
| def main(argv=None): |
| parser = argparse.ArgumentParser(description=__doc__) |
| commands = parser.add_subparsers(dest='command', required=True) |
| for name, callback in [('validate', validate), ('judge', judge), ('score', scoring), ('baselines', baseline), ('similarity', similarity)]: |
| sub = commands.add_parser(name) |
| sub.set_defaults(callback=callback) |
| sub.add_argument('--data', type=Path, required=True) |
| sub.add_argument('--subset', default='paper-main', choices=['core', 'auxiliary', 'paper-main', 'cross-judge', 'paper-pool']) |
| if name in {'validate', 'judge', 'similarity'}: |
| sub.add_argument('--submission', type=Path, required=True) |
| if name in {'validate', 'judge', 'score', 'baselines', 'similarity'}: |
| sub.add_argument('--out', type=Path, required=True) |
| if name == 'judge': |
| sub.add_argument('--base-url', required=True, help='Chat-completions API base, ending in /v1 if applicable') |
| sub.add_argument('--model', required=True, help='Explicit judge model/version served by your endpoint') |
| sub.add_argument('--api-key-env', default='GEOFLIP_JUDGE_API_KEY') |
| sub.add_argument('--allow-no-key', action='store_true') |
| sub.add_argument('--profile', choices=['observation-8', 'paper-prefix-8'], default='observation-8') |
| elif name == 'score': |
| sub.add_argument('--predictions', type=Path, required=True) |
| elif name == 'baselines': |
| sub.add_argument('--judge', choices=['gpt-6-astra', 'Qwen3-VL-32B-Instruct'], default='gpt-6-astra') |
| ranking = commands.add_parser('rank') |
| ranking.add_argument('--results', type=Path, required=True, help='JSON array: model, event, structure, psnr, ssim') |
| ranking.add_argument('--out', type=Path, required=True) |
| ranking.set_defaults(callback=lambda a: write_json(a.out, overall_ranking(json.loads(a.results.read_text()))) or 0) |
| args = parser.parse_args(argv) |
| try: |
| return args.callback(args) |
| except (ValueError, KeyError, FileNotFoundError, ImportError) as error: |
| parser.exit(2, f'{type(error).__name__}: {error}\n') |
|
|
|
|
| if __name__ == '__main__': |
| raise SystemExit(main()) |
|
|
