#!/usr/bin/env python """Build edit pairs for the orbit-alpha LoRA from metadata.jsonl + split.json of ysharma/gso-orbit-rgba. Grammar (relative azimuth, absolute elevation; 23 instructions): azimuth moves x elevations (21): " rotate the camera {45|90|135} degrees to the {left|right}, {low angle|eye level|elevated}" 180 (3): " rotate the camera 180 degrees, {low angle|eye level|elevated}" elevation-only (2): " keep the camera angle, {low angle|elevated}" Convention: "to the right" means the camera moves clockwise seen from above, i.e. target azimuth = source azimuth - move (mod 360); "left" is +move. Train: 4 pairs per non-rejected train object, instructions drawn round-robin from a shuffled 23-list (balanced). Source is always eye level at a random azimuth. Eval: 4 pairs per held-out object with fixed buckets {45, 90, 180, elevation-only} so results can be broken down by rotation size and elevation change. Outputs: pairs_train.jsonl, pairs_eval.jsonl """ import json, os, random from collections import Counter, defaultdict REPO = 'ysharma/gso-orbit-rgba' META = os.environ.get('META', 'metadata.jsonl') SPLIT = os.environ.get('SPLIT', 'split.json') ELEV_NAME = {'low': 'low angle', 'eye': 'eye level', 'high': 'elevated'} AZS = list(range(0, 360, 45)) SEED = 20260923 def instruction(move_deg, side, elev_key): if move_deg == 0: # elevation-only assert elev_key in ('low', 'high') return f" keep the camera angle, {ELEV_NAME[elev_key]}" if move_deg == 180: return f" rotate the camera 180 degrees, {ELEV_NAME[elev_key]}" return (f" 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 target_azimuth(src_az, move_deg, side): sign = -1 if side == 'right' else 1 # right = camera clockwise = -az if move_deg == 180: return (src_az + 180) % 360 return (src_az + sign * move_deg) % 360 def make_pair(object_id, move_deg, side, elev_key, src_az, idx): tgt_az = src_az if move_deg == 0 else target_azimuth(src_az, move_deg, side) src_el = 'eye' # elevation-only pairs: target elevation differs from eye; azimuth stays assert src_az in AZS 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': f'renders/{object_id}/az{src_az:03d}_el_eye.png', 'target_file': f'renders/{object_id}/az{tgt_az:03d}_el_{elev_key}.png', 'pair_id': f'{object_id}_{idx}', } def main(): split = json.load(open(SPLIT)) meta = [json.loads(l) for l in open(META)] have = {(r['object_id'], r['azimuth_deg'], r['elevation_name']) for r in meta} rng = random.Random(SEED) train_objs = sorted(split['train_objects']) heldout = sorted(split['heldout_40']) # ---- train pairs: 4/object, balanced over the 23 instructions ---- 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_objs: 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) if (p['object_id'], p['src_azimuth'], 'eye') not in have or \ (p['object_id'], p['tgt_azimuth'], p['elevation']) not in have: continue train_pairs.append(p) print(f'train pairs: {len(train_pairs)} from {len(train_objs)} objects') print(' instruction balance (min/max per instruction):', min(Counter(p['instruction'] for p in train_pairs).values()), max(Counter(p['instruction'] for p in train_pairs).values())) # ---- eval pairs: 40 x 4, fixed buckets {45, 90, 180, elev-only} ---- eval_pairs = [] for obj in heldout: src_az = rng.choice(AZS) buckets = [(45, None, None), (90, None, None), (180, None, None), (0, None, None)] for k, (d, _, _) in enumerate(buckets): s = rng.choice(['left', 'right']) if d not in (0, 180) else '' e = rng.choice(['low', 'eye', 'high']) if d not in (0,) else \ rng.choice(['low', 'high']) p = make_pair(obj, d, s, e, src_az, k) assert (p['object_id'], p['src_azimuth'], 'eye') in have, p assert (p['object_id'], p['tgt_azimuth'], p['elevation']) in have, p eval_pairs.append(p) print(f'eval pairs: {len(eval_pairs)} from {len(heldout)} heldout objects') 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') n = len(train_pairs) print(f'expected ~3900 train pairs; got {n}') from huggingface_hub import HfApi api = HfApi(token=os.environ.get('HF_TOKEN')) api.upload_file(repo_id=REPO, repo_type='dataset', path_in_repo='pairs_train.jsonl', path_or_fileobj='pairs_train.jsonl') api.upload_file(repo_id=REPO, repo_type='dataset', path_in_repo='pairs_eval.jsonl', path_or_fileobj='pairs_eval.jsonl') print('uploaded pair lists') if __name__ == '__main__': main()