build_split_and_pairs.py

#!/usr/bin/env python
"""Recompute split.json from metadata.jsonl (no re-render needed), then build pairs.

Rejection rule (same as render_full.py): object rejected if ANY of its 24 views
has alpha coverage < 0.08 or bbox_span > 0.95.
Heldout: 40 objects, stratified by category, drawn from NON-rejected objects only.
Seed 20260923.
Render filenames follow render_full.py: az{000..315}_el{low|eye|high}.png
(no separator: az315_eleye.png, az045_ellow.png, ...). Pair paths are validated
against the metadata.jsonl 'file' fields, so any mismatch fails loudly here.

Uploads split.json + pairs_train.jsonl + pairs_eval.jsonl to
ysharma/gso-orbit-rgba.
"""
import json, os, random
from collections import Counter, defaultdict
from huggingface_hub import HfApi

REPO = 'ysharma/gso-orbit-rgba'
ELEV_NAME = {'low': 'low angle', 'eye': 'eye level', 'high': 'elevated'}
AZS = list(range(0, 360, 45))
SEED = 20260923
HELDOUT_N = 40


def render_file(object_id, az, elev_key):
    return f'renders/{object_id}/az{az:03d}_el{elev_key}.png'


def instruction(move_deg, side, elev_key):
    if move_deg == 0:
        return f"<orbit> keep the camera angle, {ELEV_NAME[elev_key]}"
    if move_deg == 180:
        return f"<orbit> rotate the camera 180 degrees, {ELEV_NAME[elev_key]}"
    return (f"<orbit> rotate the camera {move_deg} degrees to the {side}, "
            f"{ELEV_NAME[elev_key]}")


def plain_instruction(move_deg, side, elev_key):
    e = {'low': 'low-angle', 'eye': 'eye-level', 'high': 'raised'}[elev_key]
    if move_deg == 0:
        return f"Show the same object from a {e} viewpoint."
    if move_deg == 180:
        return f"Show the same object with the camera rotated 180 degrees, from a {e} viewpoint."
    return (f"Show the same object with the camera rotated {move_deg} degrees "
            f"to the {side}, from a {e} viewpoint.")


def make_pair(object_id, move_deg, side, elev_key, src_az, idx):
    sign = -1 if side == 'right' else 1
    tgt_az = src_az if move_deg == 0 else ((src_az + 180) % 360 if move_deg == 180
                                           else (src_az + sign * move_deg) % 360)
    return {
        'object_id': object_id,
        'instruction': instruction(move_deg, side, elev_key),
        'instruction_plain': plain_instruction(move_deg, side, elev_key),
        'move_deg': move_deg, 'side': side, 'elevation': elev_key,
        'src_azimuth': src_az, 'tgt_azimuth': tgt_az,
        'source_file': render_file(object_id, src_az, 'eye'),
        'target_file': render_file(object_id, tgt_az, elev_key),
        'pair_id': f'{object_id}_{idx}',
    }


def main():
    api = HfApi(token=os.environ.get('HF_TOKEN'))
    import urllib.request
    urllib.request.urlretrieve(
        'https://huggingface.co/datasets/ysharma/gso-orbit-rgba/resolve/main/metadata.jsonl',
        'metadata.jsonl')
    print('metadata.jsonl downloaded', flush=True)
    rows = [json.loads(l) for l in open('metadata.jsonl')]

    on_disk = {r['file'] for r in rows}
    by_obj = {}
    cats = defaultdict(set)
    for r in rows:
        by_obj.setdefault(r['object_id'], []).append(r)
        cats[r['category']].add(r['object_id'])
    rejected = {oid for oid, vr in by_obj.items()
                if any(v['coverage'] < 0.08 or v['bbox_span'] > 0.95 for v in vr)}
    n_total = len(by_obj)
    print(f'objects: {n_total} | rejected: {len(rejected)} | usable: {n_total - len(rejected)}',
          flush=True)

    # ---- split ----
    rng = random.Random(SEED)
    pool_by_cat = {c: sorted(ids - rejected) for c, ids in cats.items()}
    pool_by_cat = {c: p for c, p in pool_by_cat.items() if p}
    total_pool = sum(len(p) for p in pool_by_cat.values())
    heldout = []
    for c in sorted(pool_by_cat):
        pool = pool_by_cat[c][:]
        rng.shuffle(pool)
        n = max(1, round(HELDOUT_N * len(pool) / total_pool))
        heldout.extend(pool[:n])
    rng.shuffle(heldout)
    heldout = heldout[:HELDOUT_N]
    hs = set(heldout)
    train = sorted(o for c in pool_by_cat for o in pool_by_cat[c] if o not in hs)
    print(f'split: {len(heldout)} heldout, {len(train)} train', flush=True)
    split = {'heldout_40': heldout, 'train_objects': train,
             'rejected_objects': sorted(rejected), 'failed_objects': [],
             'seed': SEED, 'n_renders': len(rows),
             'instructions_version': 'orbit-relative-v1'}

    # ---- pairs ----
    instr_cycle = []
    for d in (45, 90, 135):
        for s in ('left', 'right'):
            for e in ('low', 'eye', 'high'):
                instr_cycle.append((d, s, e))
    instr_cycle.append((180, '', 'low'))
    instr_cycle.append((180, '', 'eye'))
    instr_cycle.append((180, '', 'high'))
    instr_cycle.append((0, '', 'low'))
    instr_cycle.append((0, '', 'high'))
    assert len(instr_cycle) == 23
    rng.shuffle(instr_cycle)
    qi = 0
    train_pairs = []
    for obj in train:
        src_az = rng.choice(AZS)
        for k in range(4):
            d, s, e = instr_cycle[qi % 23]; qi += 1
            p = make_pair(obj, d, s, e, src_az, k)
            assert p['source_file'] in on_disk, f'missing {p["source_file"]}'
            assert p['target_file'] in on_disk, f'missing {p["target_file"]}'
            train_pairs.append(p)
    cbal = Counter(p['instruction'] for p in train_pairs)
    print(f'train pairs: {len(train_pairs)} from {len(train)} objects | '
          f'instruction balance min/max: {min(cbal.values())}/{max(cbal.values())}', flush=True)

    eval_pairs = []
    for obj in heldout:
        src_az = rng.choice(AZS)
        for k, d in enumerate((45, 90, 180, 0)):
            s = rng.choice(['left', 'right']) if d in (45, 90) else ''
            e = rng.choice(['low', 'eye', 'high']) if d else rng.choice(['low', 'high'])
            p = make_pair(obj, d, s, e, src_az, k)
            assert p['source_file'] in on_disk, f'missing {p["source_file"]}'
            assert p['target_file'] in on_disk, f'missing {p["target_file"]}'
            eval_pairs.append(p)
    print(f'eval pairs: {len(eval_pairs)} from {len(heldout)} heldout objects', flush=True)

    with open('split.json', 'w') as f:
        json.dump(split, f, indent=2)
    api.upload_file(repo_id=REPO, repo_type='dataset', path_in_repo='split.json',
                    path_or_fileobj='split.json')
    print('uploaded split.json', flush=True)
    for name, pairs in (('pairs_train.jsonl', train_pairs), ('pairs_eval.jsonl', eval_pairs)):
        with open(name, 'w') as f:
            for p in pairs:
                f.write(json.dumps(p) + '\n')
        api.upload_file(repo_id=REPO, repo_type='dataset', path_in_repo=name,
                        path_or_fileobj=name)
        print(f'uploaded {name}', flush=True)


if __name__ == '__main__':
    main()