| """Build public data artifacts from completed RefSeg-CA experiments. |
| |
| No authentication or publication occurs here. Natural-image pixels and natural |
| expression text are reconstructed from their upstream release, not redistributed. |
| """ |
| from pathlib import Path |
| import argparse, collections, csv, gzip, hashlib, json, shutil, tarfile |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| SEEDS = [11, 23, 37, 53, 71] |
|
|
|
|
| def digest(path): |
| h = hashlib.sha256() |
| with path.open('rb') as f: |
| for chunk in iter(lambda: f.read(1024 * 1024), b''): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def write_gz_jsonl(path, rows): |
| with gzip.open(path, 'wt', encoding='utf-8') as f: |
| for row in rows: |
| f.write(json.dumps(row, ensure_ascii=False) + '\n') |
|
|
|
|
| def build(dest): |
| for name in ['data', 'archives', 'manifests', 'results', 'release']: |
| (dest / name).mkdir(parents=True, exist_ok=True) |
| records = [json.loads(s) for s in (ROOT / 'data/rich_synthetic.jsonl').read_text().splitlines()] |
| scenes = [json.loads(s) for s in (ROOT / 'data/rich_scenes.jsonl').read_text().splitlines()] |
| assert len(scenes) == 1200 and len(records) == 28800 |
| groups = collections.defaultdict(list) |
| for r in records: |
| groups[(r['scene_id'], r['render'])].append(r) |
| image_type = pa.struct([('bytes', pa.binary()), ('path', pa.string())]) |
| features = { |
| 'scene_id': {'dtype': 'string', '_type': 'Value'}, |
| 'seed': {'dtype': 'int64', '_type': 'Value'}, |
| 'render': {'dtype': 'string', '_type': 'Value'}, |
| 'image': {'_type': 'Image'}, 'instance_map': {'_type': 'Image'}, |
| 'commands_json': {'dtype': 'string', '_type': 'Value'}, |
| } |
| schema = pa.schema([ |
| ('scene_id', pa.string()), ('seed', pa.int64()), ('render', pa.string()), |
| ('image', image_type), ('instance_map', image_type), ('commands_json', pa.string()) |
| ], metadata={b'huggingface': json.dumps({'info': {'features': features}}).encode()}) |
| for seed in SEEDS: |
| batch = [] |
| selected = sorted([s for s in scenes if s['seed'] == seed], key=lambda s: s['scene_id']) |
| assert len(selected) == 240 |
| for scene in selected: |
| sid = scene['scene_id']; sd = ROOT / 'data/rich' / sid |
| for render in ['flat', 'rich']: |
| qs = groups[(sid, render)] |
| assert len(qs) == 12 |
| commands = [{k: q[k] for k in ['id', 'mode', 'pair_id', 'endpoint', 'query', 'target_instance_ids']} for q in qs] |
| batch.append(dict(scene_id=sid, seed=seed, render=render, |
| image={'bytes': (sd / (render + '.png')).read_bytes(), 'path': sid + '/' + render + '.png'}, |
| instance_map={'bytes': (sd / 'instances.png').read_bytes(), 'path': sid + '/instances.png'}, |
| commands_json=json.dumps(commands))) |
| pq.write_table(pa.Table.from_pylist(batch, schema=schema), dest / 'data' / f'seed-{seed}.parquet', compression='zstd') |
| with tarfile.open(dest / 'archives' / f'rich-seed-{seed}.tar.gz', 'w:gz', compresslevel=4) as archive: |
| for scene in selected: |
| sd = ROOT / 'data/rich' / scene['scene_id'] |
| assert len(list(sd.glob('*.png'))) == 15 |
| for p in sorted(sd.glob('*.png')): |
| archive.add(p, arcname=p.relative_to(ROOT).as_posix(), recursive=False) |
| print(json.dumps({'seed': seed, 'viewer_rows': len(batch), 'scenes': len(selected)}), flush=True) |
| write_gz_jsonl(dest / 'manifests/rich_synthetic.jsonl.gz', records) |
| write_gz_jsonl(dest / 'manifests/rich_scenes.jsonl.gz', scenes) |
| with gzip.open(ROOT / 'results/r3/portable/natural_full_manifest.jsonl.gz', 'rt') as f: |
| natural = [json.loads(s) for s in f] |
| write_gz_jsonl(dest / 'manifests/natural_index.jsonl.gz', [{k: v for k, v in r.items() if k != 'query'} for r in natural]) |
| scratch = dest / '_metric_staging' |
| (scratch / 'results/r3/portable').mkdir(parents=True, exist_ok=True) |
| (scratch / 'results/analysis').mkdir(parents=True, exist_ok=True) |
| for p in (ROOT / 'results/r3/portable').glob('*_primary.csv.gz'): |
| shutil.copy2(p, scratch / 'results/r3/portable' / p.name) |
| for model in ['clipseg', 'groundedsam']: |
| with gzip.open(ROOT / 'results/r3' / f'{model}_replay.jsonl.gz', 'rt') as f: |
| rows = [json.loads(s) for s in f] |
| write_gz_jsonl(scratch / 'results/r3' / f'{model}_replay.jsonl.gz', [{k: v for k, v in r.items() if k != 'query'} for r in rows]) |
| for rel in ['results/r3/review_results.json', 'results/analysis/paper_results.json']: |
| shutil.copy2(ROOT / rel, scratch / rel) |
| with tarfile.open(dest / 'results/primary-and-review-metrics.tar.gz', 'w:gz') as archive: |
| for p in sorted(scratch.rglob('*')): |
| if p.is_file(): archive.add(p, arcname=p.relative_to(scratch).as_posix(), recursive=False) |
| shutil.rmtree(scratch) |
| report = dict(version='R3', scenes=1200, rendered_images=2400, command_image_records=28800, |
| natural_expressions_scored=49492, viewer_rows=2400, seeds=SEEDS, |
| renderer='deterministic Pillow raster renderer', human_validation='not conducted', |
| natural_pixels_and_expression_text='retrieve from the pinned upstream release') |
| report['files'] = {p.relative_to(dest).as_posix(): {'bytes': p.stat().st_size, 'sha256': digest(p)} |
| for p in sorted(dest.rglob('*')) if p.is_file() and p.name != 'DATA_MANIFEST.json'} |
| (dest / 'DATA_MANIFEST.json').write_text(json.dumps(report, indent=2)) |
| print(json.dumps({'status': 'BUILT', 'files': len(report['files']), 'bytes': sum(v['bytes'] for v in report['files'].values())}), flush=True) |
|
|
|
|
| if __name__ == '__main__': |
| ap = argparse.ArgumentParser(); ap.add_argument('--output', type=Path, default=ROOT / 'release_public') |
| build(ap.parse_args().output) |
|
|
