""" swap_analysis_synthetic.py — Swap analysis using synthetic 2-body rendered data. Same experimental pipeline as swap_analysis.py, but uses locally-generated synthetic images instead of EmbSpatial-Bench. Data layout (per category folder): /data/shared/Qwen/synthetic/2body/{above,below,left,right,close,far}/ 0000.png … 0199.png (512×512 rendered scenes) vqa.json (200 entries; each has image path, answer, obj1, obj2) vqa.json entry format: { "image": "output/2body/{category}/{XXXX}.png", "question": "...", "answer": "above" | "below" | "left" | "right" | "closer" | "farther", "obj1": {"color": str, "shape": str, "bbox": [x_min, y_min, x_max, y_max]}, "obj2": {"color": str, "shape": str, "bbox": [x_min, y_min, x_max, y_max]} } Key differences from EmbSpatial-Bench: - Images loaded from disk PNG files, not base64-in-TSV - Object descriptions built from color+shape (e.g. "yellow cube") - Cross-group quads computed directly from stored bounding boxes (no HF cache) - MCQ questions with alternating A/B order (same as swap_analysis.py) - "farther"/"closer" added as synonyms for "far"/"close" in answer matching Usage: # Single model, single scale python swap_analysis_synthetic.py --model_type qwen --scales vanilla python swap_analysis_synthetic.py --model_type qwen_super --scales qwen3_235b # All scales for a model python swap_analysis_synthetic.py --model_type qwen # Merge mode (regenerate cross-scale plots from saved per-scale CSVs) python swap_analysis_synthetic.py --model_type qwen --merge # Skip cross-group quads python swap_analysis_synthetic.py --model_type qwen --skip-cross-group """ import argparse import base64 import json import logging import os import random import sys from collections import defaultdict from typing import List import numpy as np import torch # ── Import pipeline from swap_analysis (sibling directory) ────────────────── _HERE = os.path.dirname(os.path.abspath(__file__)) _SA_DIR = os.path.realpath(os.path.join(_HERE, '..', 'swap_analysis')) if _SA_DIR not in sys.path: sys.path.insert(0, _SA_DIR) import swap_analysis as sa from swap_analysis import ( CATEGORY_ORDER, OPPOSITE_MAP, GROUP_MAP, MCQ_TEMPLATES, MCQ_LETTER, SHORT_TEMPLATES, SHORT_OPPOSITE_MAP, MODEL_CONFIGS, MODEL_CONFIGS_NEW, MERGE_ONLY_CONFIGS, ALL_MODEL_TYPES, process_scale, run_merge, run_merge_extended, logger, ) # ── Patch SYNONYMS so "farther"/"closer" are accepted in answer matching ───── # Synthetic vqa.json labels are "farther"/"closer" but our generated questions # ask "far or close", so the model may answer with either form. if 'farther' not in sa.SYNONYMS.get('far', []): sa.SYNONYMS.setdefault('far', []).append('farther') if 'closer' not in sa.SYNONYMS.get('close', []): sa.SYNONYMS.setdefault('close', []).append('closer') # ── Constants ──────────────────────────────────────────────────────────────── SYNTHETIC_DATA_DIR = '/data/shared/Qwen/synthetic/2body' COUNTER_DATA_DIR = '/data/shared/Qwen/synthetic/2body_bias' DEFAULT_OUTPUT_DIR = os.path.join(_HERE, 'results') DEFAULT_OUTPUT_DIR_COUNTER = os.path.join(_HERE, 'results_counter_only') # Maps folder name → canonical category (keeps CATEGORY_ORDER / OPPOSITE_MAP intact) FOLDER_TO_CATEGORY = { 'above': 'above', 'below': 'below', 'left': 'left', 'right': 'right', 'close': 'close', 'far': 'far', } # Counter-only: folders are prefixed with "counter_" inside 2body_bias/ COUNTER_FOLDER_TO_CATEGORY = { 'counter_above': 'above', 'counter_below': 'below', 'counter_left': 'left', 'counter_right': 'right', 'counter_close': 'close', 'counter_far': 'far', } # Consistent-only: folders are prefixed with "consistent_" inside 2body_bias/ CONSISTENT_FOLDER_TO_CATEGORY = { 'consistent_above': 'above', 'consistent_below': 'below', 'consistent_left': 'left', 'consistent_right': 'right', 'consistent_close': 'close', 'consistent_far': 'far', } # VD-only: vertical (above/below) + distance (far/close) categories only VD_CATEGORIES = {'above', 'below', 'far', 'close'} # Image height for vertical-ambiguity threshold in cross-group quads SYNTHETIC_IMAGE_HEIGHT = 512 # ── Logging setup ──────────────────────────────────────────────────────────── def _setup_file_logging_synthetic( model_type: str, counter_only: bool = False, consistent_ratio: float = None, question_type: str = 'short_answer', ) -> str: """Write to logs[_counter_only|_consistent_ratio_X][_short]/{model_type}_synthetic.log.""" if consistent_ratio is not None: ratio_str = f'{consistent_ratio:g}' log_subdir = f'logs_consistent_ratio_{ratio_str}' elif counter_only: log_subdir = 'logs_counter_only' else: log_subdir = 'logs' if question_type == 'short_answer': log_subdir += '_short' log_dir = os.path.join(_HERE, log_subdir) os.makedirs(log_dir, exist_ok=True) log_path = os.path.join(log_dir, f'{model_type}_synthetic.log') fh = logging.FileHandler(log_path, mode='a', encoding='utf-8') fh.setLevel(logging.INFO) fh.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')) logging.getLogger().addHandler(fh) return log_path # ── Data loading ───────────────────────────────────────────────────────────── def _build_question_pair(group: str, obj1_desc: str, obj2_desc: str, pair_index: int, question_type: str) -> tuple: """Return (orig_q, swap_q, mcq_map, orig_answer_key, swap_answer_key) for a swap pair. For short_answer, mcq_map is None and answer keys are word-form (e.g. 'left'). For mcq, mcq_map is a dict and answer keys are the same word-form category labels. """ if question_type == 'short_answer': if group == 'horizontal': tmpl = SHORT_TEMPLATES['horizontal'] orig_q = tmpl.format(obj1=obj1_desc, obj2=obj2_desc) swap_q = tmpl.format(obj1=obj2_desc, obj2=obj1_desc) elif group == 'vertical': tmpl = SHORT_TEMPLATES['vertical'] orig_q = tmpl.format(obj1=obj1_desc, obj2=obj2_desc) swap_q = tmpl.format(obj1=obj2_desc, obj2=obj1_desc) else: # distance tmpl = SHORT_TEMPLATES['distance'] orig_q = tmpl.format(subj=obj1_desc, ref=obj2_desc) swap_q = tmpl.format(subj=obj2_desc, ref=obj1_desc) return orig_q, swap_q, None else: # mcq if group == 'horizontal': variant = 'left_first' if pair_index % 2 == 0 else 'right_first' orig_q = MCQ_TEMPLATES['horizontal'][variant].format(obj1=obj1_desc, obj2=obj2_desc) swap_q = MCQ_TEMPLATES['horizontal'][variant].format(obj1=obj2_desc, obj2=obj1_desc) mcq_map = MCQ_LETTER['horizontal'][variant] elif group == 'vertical': variant = 'above_first' if pair_index % 2 == 0 else 'below_first' orig_q = MCQ_TEMPLATES['vertical'][variant].format(obj1=obj1_desc, obj2=obj2_desc) swap_q = MCQ_TEMPLATES['vertical'][variant].format(obj1=obj2_desc, obj2=obj1_desc) mcq_map = MCQ_LETTER['vertical'][variant] else: # distance variant = 'far_first' if pair_index % 2 == 0 else 'close_first' orig_q = MCQ_TEMPLATES['distance'][variant].format(subj=obj1_desc, ref=obj2_desc) swap_q = MCQ_TEMPLATES['distance'][variant].format(subj=obj2_desc, ref=obj1_desc) mcq_map = MCQ_LETTER['distance'][variant] return orig_q, swap_q, mcq_map def load_swap_pairs_synthetic( data_dir: str, seed: int = 42, folder_to_category: dict = None, question_type: str = 'short_answer', ) -> List[dict]: """Load synthetic 2-body data and build swap pairs. Returns a list of dicts with the same schema as swap_analysis.load_swap_pairs(), plus extra keys (obj1_bbox, obj2_bbox, obj1_desc, obj2_desc) consumed by create_cross_group_quads_synthetic() and ignored by the rest of the pipeline. Args: data_dir: Root directory containing category sub-folders. seed: Random seed (currently unused; reserved for future subsampling). folder_to_category: Mapping of folder_name → canonical category. Defaults to FOLDER_TO_CATEGORY (standard 2body layout). Pass COUNTER_FOLDER_TO_CATEGORY for counter-only (2body_bias) layout. question_type: 'mcq' (default) or 'short_answer'. """ if folder_to_category is None: folder_to_category = FOLDER_TO_CATEGORY pairs = [] stats = defaultdict(lambda: {'total': 0, 'success': 0}) for folder_name, category in folder_to_category.items(): folder_path = os.path.join(data_dir, folder_name) json_path = os.path.join(folder_path, 'vqa.json') if not os.path.exists(json_path): logger.warning(f'[synthetic] Missing vqa.json: {json_path}') continue with open(json_path, encoding='utf-8') as f: entries = json.load(f) group = GROUP_MAP[category] for i, entry in enumerate(entries): stats[category]['total'] += 1 obj1 = entry['obj1'] obj2 = entry['obj2'] obj1_desc = f"{obj1['color']} {obj1['shape']}" obj2_desc = f"{obj2['color']} {obj2['shape']}" # Load PNG from disk → base64 (same format as EmbSpatialBench TSV) img_filename = os.path.basename(entry['image']) # e.g. "0000.png" img_path = os.path.join(folder_path, img_filename) if not os.path.exists(img_path): logger.warning(f'[synthetic] Image not found: {img_path}') continue with open(img_path, 'rb') as fimg: img_b64 = base64.b64encode(fimg.read()).decode('utf-8') orig_q, swap_q, mcq_map = _build_question_pair( group, obj1_desc, obj2_desc, len(pairs), question_type) orig_ans = category swap_ans = SHORT_OPPOSITE_MAP[category] if question_type == 'short_answer' else OPPOSITE_MAP[category] pair = { # ── Standard swap pair fields (same schema as load_swap_pairs) ── 'index': f'{folder_name}_{i:04d}', 'question_id': f'{folder_name}_{i:04d}', 'image_base64': img_b64, 'original_question': orig_q, 'swapped_question': swap_q, 'original_answer': orig_ans, 'swapped_answer': swap_ans, 'group': group, 'category': category, 'mcq_map': mcq_map, # ── Extra fields for cross-group quad creation ─────────────────── 'obj1_bbox': obj1['bbox'], # [x_min, y_min, x_max, y_max] 'obj2_bbox': obj2['bbox'], 'obj1_desc': obj1_desc, 'obj2_desc': obj2_desc, } pairs.append(pair) stats[category]['success'] += 1 logger.info('Synthetic swap pair creation stats:') for cat in CATEGORY_ORDER: s = stats[cat] if s['total']: logger.info(f' {cat}: {s["success"]}/{s["total"]}') logger.info(f' Total pairs: {len(pairs)}') return pairs def load_swap_pairs_mixed( data_dir: str, consistent_ratio: float, n_per_category: int = 200, seed: int = 42, question_type: str = 'short_answer', ) -> List[dict]: """Load a mix of consistent and counter samples from 2body_bias. For each canonical category, samples n_consistent = round(n_per_category * consistent_ratio) entries from consistent_{cat}/ n_counter = n_per_category - n_consistent entries from counter_{cat}/ The two sets are combined per category and returned as swap pairs using the same schema as load_swap_pairs_synthetic(). Args: data_dir: Root directory (typically COUNTER_DATA_DIR / 2body_bias). consistent_ratio: Fraction of consistent samples (0.0 – 1.0). n_per_category: Target total samples per category (default 200). seed: Random seed for reproducible subsampling. question_type: 'mcq' (default) or 'short_answer'. """ rng = random.Random(seed) n_consistent = round(n_per_category * consistent_ratio) n_counter = n_per_category - n_consistent logger.info( f'[mixed] consistent_ratio={consistent_ratio} ' f'→ {n_consistent} consistent + {n_counter} counter per category ' f'(total {n_per_category})' ) # Helper: load all entries from a single category folder and subsample def _load_folder(folder_name: str, category: str, n: int) -> List[dict]: if n <= 0: return [] folder_path = os.path.join(data_dir, folder_name) json_path = os.path.join(folder_path, 'vqa.json') if not os.path.exists(json_path): logger.warning(f'[mixed] Missing vqa.json: {json_path}') return [] with open(json_path, encoding='utf-8') as f: entries = json.load(f) if len(entries) > n: entries = rng.sample(entries, n) return [(folder_path, folder_name, category, entry) for entry in entries] CATEGORIES = list(FOLDER_TO_CATEGORY.values()) # canonical order pairs = [] stats = defaultdict(lambda: {'total': 0, 'success': 0}) for category in CATEGORIES: consistent_folder = f'consistent_{category}' counter_folder = f'counter_{category}' consistent_items = _load_folder(consistent_folder, category, n_consistent) counter_items = _load_folder(counter_folder, category, n_counter) all_items = consistent_items + counter_items rng.shuffle(all_items) # mix the two sources group = GROUP_MAP[category] for idx, (folder_path, folder_name, cat, entry) in enumerate(all_items): stats[cat]['total'] += 1 obj1 = entry['obj1'] obj2 = entry['obj2'] obj1_desc = f"{obj1['color']} {obj1['shape']}" obj2_desc = f"{obj2['color']} {obj2['shape']}" img_filename = os.path.basename(entry['image']) img_path = os.path.join(folder_path, img_filename) if not os.path.exists(img_path): logger.warning(f'[mixed] Image not found: {img_path}') continue with open(img_path, 'rb') as fimg: img_b64 = base64.b64encode(fimg.read()).decode('utf-8') orig_q, swap_q, mcq_map = _build_question_pair( group, obj1_desc, obj2_desc, len(pairs), question_type) orig_ans = cat swap_ans = SHORT_OPPOSITE_MAP[cat] if question_type == 'short_answer' else OPPOSITE_MAP[cat] pair = { 'index': f'{folder_name}_{idx:04d}', 'question_id': f'{folder_name}_{idx:04d}', 'image_base64': img_b64, 'original_question': orig_q, 'swapped_question': swap_q, 'original_answer': orig_ans, 'swapped_answer': swap_ans, 'group': group, 'category': cat, 'mcq_map': mcq_map, 'obj1_bbox': obj1['bbox'], 'obj2_bbox': obj2['bbox'], 'obj1_desc': obj1_desc, 'obj2_desc': obj2_desc, } pairs.append(pair) stats[cat]['success'] += 1 logger.info('Mixed swap pair creation stats:') for cat in CATEGORY_ORDER: s = stats[cat] if s['total']: logger.info(f' {cat}: {s["success"]}/{s["total"]}') logger.info(f' Total pairs: {len(pairs)}') return pairs def create_cross_group_quads_synthetic( swap_pairs: List[dict], threshold_ratio: float = 0.05, question_type: str = 'short_answer', ) -> List[dict]: """Build cross-group quads directly from bounding boxes stored in swap_pairs. For each far/close swap pair, the vertical relationship (above/under) between the two objects is derived from bbox center-Y coordinates — no HF cache needed. Pairs whose vertical separation is below threshold_ratio × image_height pixels are considered ambiguous and skipped. """ threshold = SYNTHETIC_IMAGE_HEIGHT * threshold_ratio quads = [] stats = {'total': 0, 'matched': 0, 'ambiguous': 0} distance_pairs = [p for p in swap_pairs if p['group'] == 'distance'] for pair in distance_pairs: stats['total'] += 1 bbox1 = pair['obj1_bbox'] # [x_min, y_min, x_max, y_max] bbox2 = pair['obj2_bbox'] cy1 = (bbox1[1] + bbox1[3]) / 2.0 # center Y of obj1 cy2 = (bbox2[1] + bbox2[3]) / 2.0 # center Y of obj2 y_diff = cy1 - cy2 if abs(y_diff) < threshold: stats['ambiguous'] += 1 continue # In image coordinates: smaller Y = higher in frame = "above" vert_orig_answer = 'above' if cy1 < cy2 else 'below' if question_type == 'short_answer': vert_orig_q = SHORT_TEMPLATES['vertical'].format( obj1=pair['obj1_desc'], obj2=pair['obj2_desc']) vert_swap_q = SHORT_TEMPLATES['vertical'].format( obj1=pair['obj2_desc'], obj2=pair['obj1_desc']) vert_mcq_map = None else: # MCQ vert question — alternate option order to cancel A/B positional bias vert_variant = 'above_first' if len(quads) % 2 == 0 else 'below_first' vert_orig_q = MCQ_TEMPLATES['vertical'][vert_variant].format( obj1=pair['obj1_desc'], obj2=pair['obj2_desc']) vert_swap_q = MCQ_TEMPLATES['vertical'][vert_variant].format( obj1=pair['obj2_desc'], obj2=pair['obj1_desc']) vert_mcq_map = MCQ_LETTER['vertical'][vert_variant] quad = { 'index': pair['index'], 'image_base64': pair['image_base64'], 'dist_original_q': pair['original_question'], 'dist_swapped_q': pair['swapped_question'], 'dist_original_answer': pair['original_answer'], 'dist_swapped_answer': pair['swapped_answer'], 'dist_mcq_map': pair['mcq_map'], 'vert_original_q': vert_orig_q, 'vert_swapped_q': vert_swap_q, 'vert_original_answer': vert_orig_answer, 'vert_swapped_answer': OPPOSITE_MAP[vert_orig_answer], 'vert_mcq_map': vert_mcq_map, 'target_object': pair['obj1_desc'], 'reference_object': pair['obj2_desc'], 'target_bbox_y': cy1, 'ref_bbox_y': cy2, 'y_diff': y_diff, 'data_source': 'synthetic', } quads.append(quad) stats['matched'] += 1 logger.info(f"Synthetic cross-group quads: {stats['matched']}/{stats['total']} " f"(ambiguous={stats['ambiguous']})") return quads # ── VD-only merge helpers ──────────────────────────────────────────────────── def _filter_scale_data_vd(data): """Filter {(category, layer): values} dict to VD categories only.""" return {k: v for k, v in data.items() if k[0] in VD_CATEGORIES} def _filter_heatmap_vd(heatmap_dict): """Filter per-layer delta-heatmap DataFrames to VD categories only.""" vd_order = [c for c in sa.CATEGORY_ORDER if c in VD_CATEGORIES] result = {} for layer, df in heatmap_dict.items(): idx = [c for c in vd_order if c in df.index] col = [c for c in vd_order if c in df.columns] result[layer] = df.loc[idx, col] return result def run_merge_vd_only_synthetic(args): """Merge in VD-only mode. Reads per-scale JSON/CSV data from the *full* results directory (all 6 categories), filters to VD categories (above/below/far/close), and writes cross-scale comparison plots to results/vd-only/{model_type}/. args.output_dir : write destination (e.g. results/vd-only/ or results_counter_only/vd-only/) args.counter_only: selects read base (results vs results_counter_only) """ if getattr(args, 'consistent_ratio', None) is not None: ratio_str = f'{args.consistent_ratio:g}' base_full = os.path.join(_HERE, f'results_consistent_ratio_{ratio_str}') elif args.counter_only: base_full = DEFAULT_OUTPUT_DIR_COUNTER else: base_full = DEFAULT_OUTPUT_DIR is_merge_only = args.model_type in sa.MERGE_ONLY_CONFIGS if is_merge_only: mc = sa.MERGE_ONLY_CONFIGS[args.model_type] scale_order = mc['scale_order'] scale_sources = mc['scale_sources'] elif args.model_type in sa.MODEL_CONFIGS_NEW: scale_order = list(sa.MODEL_CONFIGS_NEW[args.model_type].keys()) scale_sources = None else: scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer', '10pct', '20pct', '30pct'] scale_sources = None available_scales = [s for s in scale_order if s in args.scales] default_write = os.path.join(args.output_dir, args.model_type) write_dir = getattr(args, 'merge_output_dir', None) or default_write plots_dir = os.path.join(write_dir, 'plots') os.makedirs(plots_dir, exist_ok=True) logger.info(f'[VD-only merge] Read base : {base_full}') logger.info(f'[VD-only merge] Write dir : {write_dir}') logger.info(f'[VD-only merge] Scales : {available_scales}') all_sc = {} all_sc_bc = {} all_wc = {} all_wc_bc = {} all_align = {} all_dh = {} all_dh_bc = {} phase_b_dirs = {} for scale in available_scales: if is_merge_only: src_model = scale_sources[scale] read_dir = os.path.join(base_full, src_model) else: read_dir = os.path.join(base_full, args.model_type) phase_b_dirs[scale] = read_dir sc = sa.load_scale_consistency(read_dir, scale, 'all_pairs') sc_bc = sa.load_scale_consistency(read_dir, scale, 'both_correct') wc = sa.load_within_cat_consistency(read_dir, scale, 'all_pairs') wc_bc = sa.load_within_cat_consistency(read_dir, scale, 'both_correct') align = sa.load_scale_alignment(read_dir, scale) dh = sa.load_delta_heatmaps(read_dir, scale, 'all_pairs') dh_bc = sa.load_delta_heatmaps(read_dir, scale, 'both_correct') if sc: all_sc[scale] = _filter_scale_data_vd(sc) if sc_bc: all_sc_bc[scale] = _filter_scale_data_vd(sc_bc) if wc: all_wc[scale] = _filter_scale_data_vd(wc) if wc_bc: all_wc_bc[scale] = _filter_scale_data_vd(wc_bc) if align: all_align[scale] = align # no category dim if dh: all_dh[scale] = _filter_heatmap_vd(dh) if dh_bc: all_dh_bc[scale] = _filter_heatmap_vd(dh_bc) logger.info(f' Loaded + VD-filtered: {scale}') # ── Cross-scale trajectory plots ────────────────────────────────────────── for condition, sc_data, wc_data, dh_data, tag_label in [ ('all', all_sc, all_wc, all_dh, 'all pairs'), ('both_correct', all_sc_bc, all_wc_bc, all_dh_bc, 'both-correct'), ]: cond_dir = os.path.join(plots_dir, condition) sc_dir = os.path.join(cond_dir, 'sign_corrected') wc_dir = os.path.join(cond_dir, 'within_cat_consistency') dt_dir = os.path.join(cond_dir, 'delta_trajectory') os.makedirs(sc_dir, exist_ok=True) os.makedirs(wc_dir, exist_ok=True) os.makedirs(dt_dir, exist_ok=True) if len(sc_data) > 1: sa.plot_cross_scale_consistency( sc_data, args.model_type, os.path.join(sc_dir, 'cross_scale_sign_corrected.png'), title_prefix=f'Sign-Corrected ({tag_label}) [VD-only]') if len(wc_data) > 1: sa.plot_cross_scale_within_cat_consistency( wc_data, args.model_type, os.path.join(wc_dir, 'cross_scale_within_cat.png')) if dh_data: sa.plot_delta_trajectory( dh_data, args.model_type, os.path.join(dt_dir, 'delta_trajectory.png')) # ── Cross-scale alignment ───────────────────────────────────────────────── all_cond_dir = os.path.join(plots_dir, 'all') ca_dir = os.path.join(all_cond_dir, 'cross_alignment') os.makedirs(ca_dir, exist_ok=True) has_phase_b = all( sa._has_phase_b_data(phase_b_dirs[s], s) for s in available_scales) if has_phase_b and len(all_align) > 1: sa.plot_cross_scale_alignment( all_align, args.model_type, os.path.join(ca_dir, 'cross_scale_alignment.png')) logger.info(f'\n=== VD-only Merge Complete ===\nResults in: {write_dir}') # ── Main ───────────────────────────────────────────────────────────────────── def main(): _LEGACY_DEFAULT_SCALES = { 'molmo': ['vanilla', '80k', '400k', '800k', '2m'], 'nvila': ['vanilla', '80k', '400k', '800k', '2m'], 'qwen': ['vanilla', '80k', '400k', '800k', '2m'], 'nvila_synthetic': ['80k-5pct', '80k-10pct', '80k-20pct', '80k-30pct', '400k-5pct'], 'nvila_st': ['80k-st', '400k-st', '800k-st'], } parser = argparse.ArgumentParser( description='Swap Analysis — Synthetic 2-body data', formatter_class=argparse.RawDescriptionHelpFormatter, ) parser.add_argument('--data_path', type=str, default=None, help='Root directory containing category folders. ' 'Defaults to SYNTHETIC_DATA_DIR (or COUNTER_DATA_DIR with --counter-only).') parser.add_argument('--counter-only', action='store_true', dest='counter_only', help='Use counter-only data from 2body_bias/ ' '(folders: counter_above, counter_below, …). ' 'Overrides --data_path default to COUNTER_DATA_DIR.') parser.add_argument('--consistent_ratio', type=float, default=None, dest='consistent_ratio', help='Mix consistent and counter samples from 2body_bias/. ' 'Value in [0, 1]: fraction of consistent samples per category. ' 'E.g. 0.8 → 160 consistent + 40 counter out of 200 total. ' 'Results saved under results_consistent_ratio_{value}/ and ' 'logs_consistent_ratio_{value}/.') parser.add_argument('--model_type', type=str, required=True, choices=ALL_MODEL_TYPES, help=( 'Legacy: molmo | nvila | qwen\n' 'New large: molmo_big | qwen_big | qwen_super | big_trio\n' 'Merge-only (--merge required): molmo_all | qwen_all' )) parser.add_argument('--scales', type=str, nargs='+', default=None, help='Scales to process (default: all for the given model_type).') parser.add_argument('--output_dir', type=str, default=None, help='Root output directory. Defaults to results/ (or results/vd-only/ ' 'with --vd-only).') parser.add_argument('--vd-only', action='store_true', dest='vd_only', help='Run only vertical+distance categories (above/below/far/close). ' 'Produces a 4×4 delta-similarity heatmap, 2D PCA only (no 3D). ' 'Results saved under results/vd-only/ by default.') parser.add_argument('--device', type=str, default='cuda') parser.add_argument('--seed', type=int, default=42) parser.add_argument('--merge', action='store_true', help='Merge mode: regenerate cross-scale plots from saved per-scale data.') parser.add_argument('--merge-output-dir', type=str, default=None, dest='merge_output_dir', help='Override output dir for cross-scale plots.') parser.add_argument('--no-auto-roborefer', action='store_true', dest='no_auto_roborefer', help='Disable automatic inclusion of roborefer scale for nvila.') parser.add_argument('--skip-cross-group', action='store_true', help='Skip cross-group quad extraction.') parser.add_argument('--skip-phase-b', action='store_true', dest='skip_phase_b', help='Skip Phase B (cross-group feature extraction). ' 'Phase A inference + analysis + plots still run normally.') parser.add_argument('--max-samples-per-category', type=int, default=200, dest='max_samples_per_category') parser.add_argument('--question-type', type=str, default='short_answer', choices=['mcq', 'short_answer'], dest='question_type', help='Question format: short_answer (default) or mcq.') args = parser.parse_args() # ── Validate mutually exclusive modes ──────────────────────────────────── if args.consistent_ratio is not None and args.counter_only: parser.error('--consistent_ratio and --counter-only are mutually exclusive.') if args.consistent_ratio is not None and not (0.0 <= args.consistent_ratio <= 1.0): parser.error('--consistent_ratio must be in [0.0, 1.0].') # ── Resolve data path and folder mapping ────────────────────────────────── if args.consistent_ratio is not None: # Mixed mode: always read from COUNTER_DATA_DIR (contains both consistent_* and counter_*) folder_map = None # handled by load_swap_pairs_mixed; not used for standard loading if args.data_path is None: args.data_path = COUNTER_DATA_DIR elif args.counter_only: folder_map = COUNTER_FOLDER_TO_CATEGORY if args.data_path is None: args.data_path = COUNTER_DATA_DIR else: folder_map = FOLDER_TO_CATEGORY if args.data_path is None: args.data_path = SYNTHETIC_DATA_DIR # --vd-only: filter folder_map to vertical+distance categories only if args.vd_only and folder_map is not None: folder_map = {k: v for k, v in folder_map.items() if v in VD_CATEGORIES} # ── Resolve output directory ─────────────────────────────────────────────── if args.output_dir is None: if args.consistent_ratio is not None: ratio_str = f'{args.consistent_ratio:g}' base_dir = os.path.join(_HERE, f'results_consistent_ratio_{ratio_str}') elif args.counter_only: base_dir = DEFAULT_OUTPUT_DIR_COUNTER else: base_dir = DEFAULT_OUTPUT_DIR if args.question_type == 'short_answer': base_dir += '_short' if args.vd_only: args.output_dir = os.path.join(base_dir, 'vd-only') else: args.output_dir = base_dir # ── Logging ────────────────────────────────────────────────────────────── log_path = _setup_file_logging_synthetic( args.model_type, counter_only=args.counter_only, consistent_ratio=args.consistent_ratio, question_type=args.question_type, ) logger.info(f'[synthetic] Logging to : {log_path}') logger.info(f'[synthetic] Counter-only : {args.counter_only}') logger.info(f'[synthetic] Consistent ratio : {args.consistent_ratio}') logger.info(f'[synthetic] Question type : {args.question_type}') logger.info(f'[synthetic] VD-only : {args.vd_only}') logger.info(f'[synthetic] Data dir : {args.data_path}') logger.info(f'[synthetic] Output dir : {args.output_dir}') # ── VD-only: disable 3D PCA (monkey-patch sa module before process_scale) ─ if args.vd_only: sa.plot_pca_3d = lambda *_a, **_kw: None # ── Validate merge-only types ───────────────────────────────────────────── if args.model_type in MERGE_ONLY_CONFIGS and not args.merge: parser.error( f"'{args.model_type}' is a merge-only type. Add --merge to run it.\n" f" Example: python swap_analysis_synthetic.py " f"--model_type {args.model_type} --merge" ) # ── Default scales ──────────────────────────────────────────────────────── if args.scales is None: if args.model_type in MERGE_ONLY_CONFIGS: args.scales = MERGE_ONLY_CONFIGS[args.model_type]['scale_order'] elif args.model_type in MODEL_CONFIGS_NEW: args.scales = list(MODEL_CONFIGS_NEW[args.model_type].keys()) else: args.scales = _LEGACY_DEFAULT_SCALES.get( args.model_type, ['vanilla', '80k', '400k', '800k', '2m']) if (args.model_type == 'nvila' and 'roborefer' not in args.scales and not args.no_auto_roborefer): args.scales.append('roborefer') np.random.seed(args.seed) torch.manual_seed(args.seed) random.seed(args.seed) # ── Merge mode ──────────────────────────────────────────────────────────── if args.merge: logger.info('\n=== MERGE MODE (synthetic) ===') if args.vd_only: # Read from full results, filter to VD categories, write to vd-only/ run_merge_vd_only_synthetic(args) elif args.model_type in MODEL_CONFIGS_NEW or args.model_type in MERGE_ONLY_CONFIGS: run_merge_extended(args) else: run_merge(args) return # ── Inference mode ──────────────────────────────────────────────────────── logger.info('\n=== Loading Synthetic Swap Pairs ===') if args.consistent_ratio is not None: swap_pairs = load_swap_pairs_mixed( args.data_path, consistent_ratio=args.consistent_ratio, n_per_category=args.max_samples_per_category, seed=args.seed, question_type=args.question_type, ) else: swap_pairs = load_swap_pairs_synthetic( args.data_path, args.seed, folder_map, question_type=args.question_type, ) quads = [] if not args.skip_cross_group and not getattr(args, 'skip_phase_b', False): quads = create_cross_group_quads_synthetic(swap_pairs, question_type=args.question_type) if args.model_type in MODEL_CONFIGS_NEW: model_configs = MODEL_CONFIGS_NEW[args.model_type] else: model_configs = MODEL_CONFIGS[args.model_type] for scale in args.scales: if scale not in model_configs: logger.warning(f"Scale '{scale}' not in config for '{args.model_type}', skipping.") continue # Validate model path (HF IDs like "Qwen/…" or "allenai/…" are always remote) if args.model_type in MODEL_CONFIGS_NEW: _, raw_path = model_configs[scale] else: raw_path = model_configs[scale] if not os.path.isabs(raw_path) and not raw_path.startswith(('Qwen/', 'allenai/')): if not os.path.exists(raw_path): logger.warning(f'Model path not found: {raw_path} (scale={scale!r}), skipping.') continue try: process_scale(args, scale, swap_pairs, quads) except Exception as e: logger.error(f'Failed {args.model_type} - {scale}: {e}') import traceback traceback.print_exc() continue logger.info(f"\n{'='*60}") logger.info('=== All scales complete (synthetic) ===') logger.info(f"Results: {os.path.join(args.output_dir, args.model_type)}") logger.info(f"{'='*60}") if __name__ == '__main__': main()