| |
| """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): "<orbit> rotate the camera {45|90|135} degrees |
| to the {left|right}, {low angle|eye level|elevated}" |
| 180 (3): "<orbit> rotate the camera 180 degrees, {low angle|eye level|elevated}" |
| elevation-only (2): "<orbit> 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: |
| assert elev_key in ('low', 'high') |
| 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 target_azimuth(src_az, move_deg, side): |
| sign = -1 if side == 'right' else 1 |
| 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' |
| |
| 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']) |
|
|
| |
| 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 = [] |
| 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() |
