#!/usr/bin/env python3 """ Experiment 2-A Swap Analysis: Minimal Pair Probing for Spatial Representations Creates minimal pairs by swapping obj1↔obj2 in spatial questions: Original: "Is A to the left or right of B?" → left Swapped: "Is B to the left or right of A?" → right Analyses: 1. Difference vectors: Δ = feature(swapped) - feature(original) 2. Within-group Δ consistency (do all left→right swaps point same direction?) 3. Cross-group Δ alignment (Δ_vertical vs Δ_distance) for perspective bias 4. PCA visualization of per-sample embeddings 5. Scaling effects on all of the above Cross-group analysis (perspective bias hypothesis): For far/close samples, use bbox to determine vertical relationship. Create vertical swap pairs for the same image+objects. Measure cos(Δ_vertical, Δ_distance) — high = entangled, low = disentangled. Expect: vanilla = high alignment, scaled = lower alignment. Usage: # Single scale (for parallel execution) python exp2a_swap_analysis.py --model_type molmo --scales vanilla --device cuda # Merge after all scales finish python exp2a_swap_analysis.py --model_type molmo --merge """ import os import sys import json import argparse import base64 import logging import random import re from io import BytesIO from collections import defaultdict from typing import Dict, List, Tuple, Optional, Any from abc import ABC, abstractmethod import torch import numpy as np import pandas as pd from PIL import Image from tqdm import tqdm import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt import seaborn as sns from sklearn.metrics.pairwise import cosine_similarity from sklearn.decomposition import PCA logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # ============================================================================ # Constants # ============================================================================ CATEGORY_ORDER = ['left', 'right', 'above', 'under', 'far', 'close'] OPPOSITE_MAP = { 'left': 'right', 'right': 'left', 'above': 'under', 'under': 'above', 'far': 'close', 'close': 'far', } GROUP_MAP = { 'left': 'horizontal', 'right': 'horizontal', 'above': 'vertical', 'under': 'vertical', 'far': 'distance', 'close': 'distance', } GROUP_ORDER = ['horizontal', 'vertical', 'distance'] SCALE_COLORS = { 'vanilla': '#1f77b4', '80k': '#ff7f0e', '400k': '#2ca02c', '800k': '#d62728', '2m': '#9467bd', 'roborefer': '#8c564b', } MODEL_CONFIGS = { 'molmo': { 'vanilla': 'allenai/Molmo-7B-O-0924', '80k': '/data/shared/Qwen/molmo/outputs/data_scale_exp_80k/unshared', '400k': '/data/shared/Qwen/molmo/outputs/data_scale_exp_400k/unshared', '800k': '/data/shared/Qwen/molmo/outputs/data_scale_exp_800k/unshared', '2m': '/data/shared/Qwen/molmo/outputs/data_scale_exp_2m/unshared', }, 'nvila': { 'vanilla': '/data/shared/Qwen/mydisk/NVILA-Lite-2B', '80k': '/data/shared/Qwen/mydisk/output/DATA/NVILA-Lite-2B-DATA_SCALE_EXP_80K-20251108_180221', '400k': '/data/shared/Qwen/mydisk/output/DATA/NVILA-Lite-2B-DATA_SCALE_EXP_400K-20251108_180221', '800k': '/data/shared/Qwen/mydisk/output/DATA/NVILA-Lite-2B-DATA_SCALE_EXP_800K-20251108_180221', '2m': '/data/shared/Qwen/mydisk/output/DATA/NVILA-Lite-2B-DATA_SCALE_EXP_2M-20260205_003632', 'roborefer': '/data/shared/Qwen/mydisk/RoboRefer_model', }, 'qwen': { 'vanilla': 'Qwen/Qwen2.5-VL-3B-Instruct', '80k': '/data/shared/Qwen/mydisk/output/Qwen/Qwen2.5-VL-3B-Instruct-data_scale_exp_80k-20251114_120221', '400k': '/data/shared/Qwen/mydisk/output/Qwen/Qwen2.5-VL-3B-Instruct-data_scale_exp_400k-20251114_120221', '800k': '/data/shared/Qwen/mydisk/output/Qwen/Qwen2.5-VL-3B-Instruct-data_scale_exp_800k-20251114_120221', '2m': '/data/shared/Qwen/mydisk/output/Qwen/Qwen2.5-VL-3B-Instruct-data_scale_exp_2m-20260109_120517', }, } # ============================================================================ # Data Loading & Swap Pair Creation # ============================================================================ OBJECT_PATTERNS = [ re.compile(r'between\s+(.+?)\s+and\s+(.+?)\s+in', re.IGNORECASE), re.compile(r'of\s+(.+?)\s+and\s+(.+?)\s+in', re.IGNORECASE), re.compile(r'positions\s+of\s+(.+?)\s+and\s+(.+?)\s+interact', re.IGNORECASE), re.compile(r'How\s+are\s+(.+?)\s+and\s+(.+?)\s+positioned', re.IGNORECASE), re.compile(r'arrangement\s+of\s+(.+?)\s+and\s+(.+?)\s+in', re.IGNORECASE), ] def extract_objects(question: str) -> Tuple[str, str]: for pattern in OBJECT_PATTERNS: m = pattern.search(question) if m: return m.group(1).strip(), m.group(2).strip() raise ValueError(f"Could not extract objects from: {question}") def decode_base64_image(base64_str: str) -> Image.Image: image_data = base64.b64decode(base64_str) return Image.open(BytesIO(image_data)).convert('RGB') def check_answer(generated_text: str, expected_category: str) -> bool: if not generated_text or not generated_text.strip(): return False text = generated_text.strip().lower() expected = expected_category.lower() opposite = OPPOSITE_MAP[expected] pos_exp = text.find(expected) pos_opp = text.find(opposite) if pos_exp == -1: return False if pos_opp == -1: return True return pos_exp < pos_opp def load_swap_pairs(tsv_path: str, seed: int = 42) -> List[dict]: """Load EmbSpatialBench TSV and create swap pairs for all samples.""" rng = random.Random(seed) df = pd.read_csv(tsv_path, sep='\t') pairs = [] stats = defaultdict(lambda: {'total': 0, 'success': 0}) for _, row in df.iterrows(): category = row['category'] stats[category]['total'] += 1 try: if category in ['left', 'right', 'above', 'under']: obj1, obj2 = extract_objects(row['question']) if category in ['left', 'right']: template = "Is the {} to the left or right of the {}?" else: template = "Is the {} above or under the {}?" pair = { 'index': row['index'], 'image_base64': row['image'], 'original_question': template.format(obj1, obj2), 'swapped_question': template.format(obj2, obj1), 'original_answer': category, 'swapped_answer': OPPOSITE_MAP[category], 'group': GROUP_MAP[category], 'category': category, 'obj1': obj1, 'obj2': obj2, } elif category in ['far', 'close']: answer_key = row['answer'] options = {k: row[k] for k in ['A', 'B', 'C', 'D']} target_object = options[answer_key] candidates = [v for k, v in options.items() if k != answer_key] reference_object = rng.choice(candidates) pair = { 'index': row['index'], 'image_base64': row['image'], 'original_question': f"Compared to {reference_object}, is {target_object} far or close from you?", 'swapped_question': f"Compared to {target_object}, is {reference_object} far or close from you?", 'original_answer': category, 'swapped_answer': OPPOSITE_MAP[category], 'group': 'distance', 'category': category, 'target_object': target_object, 'reference_object': reference_object, } else: continue pairs.append(pair) stats[category]['success'] += 1 except Exception as e: logger.warning(f"Failed to create swap pair for index {row['index']}: {e}") continue logger.info("Swap pair creation stats:") for cat in CATEGORY_ORDER: s = stats[cat] logger.info(f" {cat}: {s['success']}/{s['total']}") logger.info(f" Total pairs: {len(pairs)}") return pairs def build_hf_bbox_cache(hf_dataset_name: str = 'FlagEval/EmbSpatial-Bench') -> Dict[int, dict]: """Load HF dataset and build bbox lookup cache keyed by question_id.""" from datasets import load_dataset logger.info(f"Loading HF dataset: {hf_dataset_name}") ds = load_dataset(hf_dataset_name, split='test') cache = {} for item in ds: qid = item['question_id'] cache[qid] = { 'objects': item['objects'], 'relation': item['relation'], 'data_source': item['data_source'], 'answer': item['answer'], 'answer_options': item['answer_options'], } logger.info(f"Built bbox cache: {len(cache)} entries") return cache def get_bbox_center_y(bbox: list) -> float: """BBox [x, y, width, height] -> center y coordinate.""" return bbox[1] + bbox[3] / 2 def create_cross_group_quads( swap_pairs: List[dict], hf_cache: Dict[int, dict], threshold_ratio: float = 0.05, ) -> List[dict]: """ For far/close swap pairs, create additional vertical queries using bbox. Returns quads: each has distance swap pair + vertical swap pair for same image/objects. Only includes samples where vertical relationship is unambiguous. """ IMAGE_HEIGHTS = {'ai2thor': 300, 'mp3d': 480, 'scannet': 968} quads = [] stats = {'total': 0, 'matched': 0, 'ambiguous': 0, 'no_bbox': 0} distance_pairs = [p for p in swap_pairs if p['group'] == 'distance'] for pair in distance_pairs: stats['total'] += 1 idx = pair['index'] if idx not in hf_cache: stats['no_bbox'] += 1 continue hf_item = hf_cache[idx] names = hf_item['objects']['name'] bboxes = hf_item['objects']['bbox'] target = pair['target_object'] reference = pair['reference_object'] # Find bbox for target and reference target_bbox_y, ref_bbox_y = None, None for name, bbox in zip(names, bboxes): if name == target: target_bbox_y = get_bbox_center_y(bbox) if name == reference: ref_bbox_y = get_bbox_center_y(bbox) if target_bbox_y is None or ref_bbox_y is None: stats['no_bbox'] += 1 continue # Determine vertical relationship image_height = IMAGE_HEIGHTS.get(hf_item['data_source'], 480) threshold = image_height * threshold_ratio y_diff = target_bbox_y - ref_bbox_y if abs(y_diff) < threshold: stats['ambiguous'] += 1 continue # y increases downward in image coordinates # target_bbox_y < ref_bbox_y → target is above reference if target_bbox_y < ref_bbox_y: vert_original_answer = 'above' else: vert_original_answer = 'under' vert_original_q = f"Is the {target} above or under the {reference}?" vert_swapped_q = f"Is the {reference} above or under the {target}?" quad = { 'index': idx, 'image_base64': pair['image_base64'], # Distance pair (from original swap pair) 'dist_original_q': pair['original_question'], 'dist_swapped_q': pair['swapped_question'], 'dist_original_answer': pair['original_answer'], 'dist_swapped_answer': pair['swapped_answer'], # Vertical pair (newly created from bbox) 'vert_original_q': vert_original_q, 'vert_swapped_q': vert_swapped_q, 'vert_original_answer': vert_original_answer, 'vert_swapped_answer': OPPOSITE_MAP[vert_original_answer], # Metadata 'target_object': target, 'reference_object': reference, 'target_bbox_y': target_bbox_y, 'ref_bbox_y': ref_bbox_y, 'y_diff': y_diff, 'data_source': hf_item['data_source'], } quads.append(quad) stats['matched'] += 1 logger.info(f"Cross-group quads: {stats['matched']}/{stats['total']} " f"(ambiguous={stats['ambiguous']}, no_bbox={stats['no_bbox']})") return quads # ============================================================================ # Base Extractor (identical to exp2a_correct_filter) # ============================================================================ class BaseHiddenStateExtractor(ABC): def __init__(self, model_path: str, device: str = 'cuda', target_layers: List[int] = None): self.model_path = model_path self.device = device self.hidden_states = {} self.hooks = [] self._load_model() num_layers = self._get_num_layers() if target_layers is None: self.target_layers = list(range(num_layers)) logger.info(f"Model has {num_layers} layers. Extracting ALL.") else: self.target_layers = target_layers self._register_hooks() def _register_hooks(self): for layer_idx in self.target_layers: module = self._get_layer_module(layer_idx) if module is not None: hook = module.register_forward_hook(self._make_hook(layer_idx)) self.hooks.append(hook) def _make_hook(self, layer_idx: int): def hook_fn(module, input, output): if isinstance(output, tuple): hidden = output[0] else: hidden = output if hidden.shape[1] > 1: # prefill only last_token = hidden[:, -1, :].detach().cpu().float() self.hidden_states[layer_idx] = last_token.squeeze(0) return hook_fn @abstractmethod def _load_model(self): pass @abstractmethod def _get_num_layers(self) -> int: pass @abstractmethod def _get_layer_module(self, layer_idx: int): pass @abstractmethod def extract_and_predict(self, image: Image.Image, question: str) -> Tuple[Dict[int, torch.Tensor], str]: pass def cleanup(self): for hook in self.hooks: hook.remove() self.hooks = [] if hasattr(self, 'model'): del self.model if hasattr(self, 'processor'): del self.processor torch.cuda.empty_cache() # ============================================================================ # Molmo Extractor # ============================================================================ class MolmoExtractor(BaseHiddenStateExtractor): def _load_model(self): config_path = os.path.join(self.model_path, "config.yaml") checkpoint_path = os.path.join(self.model_path, "model.pt") if os.path.exists(config_path) and os.path.exists(checkpoint_path): self._load_native_model() self.is_native = True else: self._load_hf_model() self.is_native = False def _load_native_model(self): from olmo.config import ModelConfig from olmo.model import Molmo as NativeMolmoModel from olmo.data.model_preprocessor import MultiModalPreprocessor from olmo.data.data_formatter import DataFormatter _original_load = torch.load def _unsafe_load_wrapper(*args, **kwargs): if 'weights_only' not in kwargs: kwargs['weights_only'] = False return _original_load(*args, **kwargs) torch.load = _unsafe_load_wrapper cfg = ModelConfig.load( os.path.join(self.model_path, "config.yaml"), key="model", validate_paths=False ) cfg.init_device = "cpu" self.model = NativeMolmoModel(cfg) state_dict = torch.load(os.path.join(self.model_path, "model.pt"), map_location="cpu") self.model.load_state_dict(state_dict) self.model = self.model.to(self.device, dtype=torch.bfloat16).eval() self.tokenizer = cfg.get_tokenizer() v_cfg = cfg.vision_backbone h, w = cfg.llm_patches_per_crop() image_padding_mask = 2 if cfg.fix_image_padding else (1 if cfg.image_padding_embed else None) class SafeDataFormatter(DataFormatter): def get_system_prompt(self, style, for_inference, messages, rng=None): if style is None: style = "User" return super().get_system_prompt(style, for_inference, messages, rng) self.formatter = SafeDataFormatter( prompt_templates=cfg.prompt_type, message_format=cfg.message_formatting, system_prompt=cfg.system_prompt_kind, always_start_with_space=cfg.always_start_with_space, default_inference_len=cfg.default_inference_len ) self.preprocessor = MultiModalPreprocessor( tokenizer=self.tokenizer, normalize=str(v_cfg.image_model_type), crop_mode=cfg.crop_mode, max_crops=cfg.max_crops, overlap_margins=cfg.overlap_margins, resize=v_cfg.resize_mode, use_col_tokens=cfg.use_col_tokens, base_image_input_size=v_cfg.image_default_input_size, image_pooling_w=cfg.image_pooling_w, image_pooling_h=cfg.image_pooling_h, image_token_length_w=w, image_token_length_h=h, image_patch_size=v_cfg.image_patch_size, image_padding_mask=image_padding_mask, pad_value=cfg.pad_value, loss_token_weighting=cfg.multi_annotation_weighting, ) logger.info(f"Loaded native Molmo from {self.model_path}") def _load_hf_model(self): from transformers import AutoModelForCausalLM, AutoProcessor self.model = AutoModelForCausalLM.from_pretrained( self.model_path, torch_dtype=torch.bfloat16, trust_remote_code=True, device_map=self.device ).eval() self.processor = AutoProcessor.from_pretrained(self.model_path, trust_remote_code=True) logger.info(f"Loaded HF Molmo from {self.model_path}") def _get_num_layers(self) -> int: if self.is_native: return len(self.model.transformer.blocks) if hasattr(self.model, 'model') and hasattr(self.model.model, 'transformer'): return len(self.model.model.transformer.blocks) return 32 def _get_layer_module(self, layer_idx: int): if self.is_native: return self.model.transformer.blocks[layer_idx] return self.model.model.transformer.blocks[layer_idx] def extract_and_predict(self, image, question): self.hidden_states = {} if self.is_native: example = {"messages": [question], "image": image} messages, _ = self.formatter(example, is_training=False, for_inference=True, rng=np.random) batch = self.preprocessor(np.array(image), messages, is_training=False, require_image_features=True) if 'input_ids' not in batch and 'input_tokens' in batch: batch['input_ids'] = batch['input_tokens'] def to_t(x): return torch.from_numpy(x) if isinstance(x, np.ndarray) else x input_ids = to_t(batch['input_ids']).unsqueeze(0).to(self.device).long() images_t = to_t(batch['images']).unsqueeze(0).to(self.device, dtype=torch.bfloat16) image_masks = to_t(batch['image_masks']).unsqueeze(0).to(self.device, dtype=torch.bfloat16) image_input_idx = to_t(batch['image_input_idx']).unsqueeze(0).to(self.device) with torch.inference_mode(), torch.autocast("cuda", dtype=torch.bfloat16): gen = self.model.generate( input_ids=input_ids, images=images_t, image_masks=image_masks, image_input_idx=image_input_idx, max_steps=20, beam_size=1, ) generated_ids = gen.token_ids[0, 0] answer = self.tokenizer.decode(generated_ids.tolist()).strip() for eos in ['<|endoftext|>', '', '<|end|>']: answer = answer.replace(eos, '').strip() else: from transformers import GenerationConfig inputs = self.processor.process(images=[image], text=question) processed = {} for k, v in inputs.items(): v = v.to(self.device).unsqueeze(0) if v.dtype == torch.float32: v = v.to(dtype=torch.bfloat16) processed[k] = v with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16): output = self.model.generate_from_batch( processed, GenerationConfig(max_new_tokens=20, stop_strings="<|endoftext|>"), tokenizer=self.processor.tokenizer, ) input_len = processed['input_ids'].shape[1] answer = self.processor.tokenizer.decode(output[0, input_len:], skip_special_tokens=True).strip() return self.hidden_states.copy(), answer # ============================================================================ # NVILA Extractor # ============================================================================ class NVILAExtractor(BaseHiddenStateExtractor): def _load_model(self): original_sys_path = sys.path.copy() sys.path = [p for p in sys.path if 'RoboRefer' not in p] modules_to_remove = [k for k in list(sys.modules.keys()) if 'llava' in k.lower()] removed = {m: sys.modules.pop(m) for m in modules_to_remove} try: import llava from llava.media import Image as LLaVAImage from llava import conversation as clib except Exception as err: sys.path = original_sys_path for m, mod in removed.items(): sys.modules[m] = mod raise RuntimeError(f"Failed to import llava: {err}") sys.path = original_sys_path self.LLaVAImage = LLaVAImage self.clib = clib self.model = llava.load(self.model_path, model_base=None) self._find_llm_backbone() logger.info(f"Loaded NVILA from {self.model_path}") def _find_llm_backbone(self): candidates = [] if hasattr(self.model, 'llm'): if hasattr(self.model.llm, 'model') and hasattr(self.model.llm.model, 'layers'): candidates.append(self.model.llm.model.layers) if hasattr(self.model.llm, 'layers'): candidates.append(self.model.llm.layers) if hasattr(self.model, 'model'): if hasattr(self.model.model, 'model') and hasattr(self.model.model.model, 'layers'): candidates.append(self.model.model.model.layers) if hasattr(self.model.model, 'layers'): candidates.append(self.model.model.layers) for name, module in self.model.named_modules(): if name.endswith('.layers') and hasattr(module, '__len__') and len(module) > 0: candidates.append(module) if candidates: self.llm_backbone = candidates[0] else: raise ValueError("Could not locate transformer layers in NVILA model") def _get_num_layers(self) -> int: return len(self.llm_backbone) if hasattr(self, 'llm_backbone') else 24 def _get_layer_module(self, layer_idx: int): return self.llm_backbone[layer_idx] def extract_and_predict(self, image, question): self.hidden_states = {} import tempfile with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f: temp_path = f.name image.save(temp_path) try: prompt = [self.LLaVAImage(temp_path), question] from transformers import GenerationConfig response = self.model.generate_content( prompt, generation_config=GenerationConfig(max_new_tokens=20, do_sample=False) ) finally: os.unlink(temp_path) answer = str(response[0] if isinstance(response, list) else response).strip() return self.hidden_states.copy(), answer class RoboReferExtractor(NVILAExtractor): ROBOREFER_PATH = '/data/shared/Qwen/RoboRefer' def _load_model(self): original_sys_path = sys.path.copy() if self.ROBOREFER_PATH not in sys.path: sys.path.insert(0, self.ROBOREFER_PATH) modules_to_remove = [k for k in list(sys.modules.keys()) if 'llava' in k.lower()] removed = {m: sys.modules.pop(m) for m in modules_to_remove} try: import llava from llava.media import Image as LLaVAImage from llava import conversation as clib except Exception as err: sys.path = original_sys_path for m, mod in removed.items(): sys.modules[m] = mod raise RuntimeError(f"Failed to import RoboRefer llava: {err}") sys.path = original_sys_path self.LLaVAImage = LLaVAImage self.clib = clib self.model = llava.load(self.model_path, model_base=None) self._find_llm_backbone() logger.info(f"Loaded RoboRefer from {self.model_path}") # ============================================================================ # Qwen2.5-VL Extractor # ============================================================================ class Qwen25VLExtractor(BaseHiddenStateExtractor): BASE_MODEL = "Qwen/Qwen2.5-VL-3B-Instruct" def _load_model(self): from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor try: self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained( self.model_path, torch_dtype=torch.bfloat16, device_map=self.device ) except ImportError: self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained( self.model_path, torch_dtype=torch.bfloat16 ).to(self.device) self.model.eval() if self.model_path.startswith('/'): self.processor = AutoProcessor.from_pretrained(self.BASE_MODEL) else: self.processor = AutoProcessor.from_pretrained(self.model_path) logger.info(f"Loaded Qwen2.5-VL from {self.model_path}") def _get_num_layers(self) -> int: return len(self.model.model.layers) def _get_layer_module(self, layer_idx: int): return self.model.model.layers[layer_idx] def extract_and_predict(self, image, question): self.hidden_states = {} messages = [{"role": "user", "content": [ {"type": "image", "image": image}, {"type": "text", "text": question} ]}] text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) from qwen_vl_utils import process_vision_info image_inputs, video_inputs = process_vision_info(messages) inputs = self.processor( text=[text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt" ).to(self.device) with torch.no_grad(): output_ids = self.model.generate(**inputs, max_new_tokens=20, do_sample=False) input_len = inputs['input_ids'].shape[1] answer = self.processor.tokenizer.decode(output_ids[0, input_len:], skip_special_tokens=True).strip() return self.hidden_states.copy(), answer def get_extractor(model_type: str, model_path: str, scale: str = None, **kwargs): if model_type == 'nvila' and scale == 'roborefer': return RoboReferExtractor(model_path, **kwargs) extractors = {'molmo': MolmoExtractor, 'nvila': NVILAExtractor, 'qwen': Qwen25VLExtractor} return extractors[model_type](model_path, **kwargs) # ============================================================================ # Feature Extraction Pipeline # ============================================================================ def run_single_query(extractor, image, question): """Run a single forward pass and return (hidden_states_dict, predicted_text).""" hidden_states, predicted = extractor.extract_and_predict(image, question) result = {} for layer_idx in extractor.target_layers: if layer_idx in hidden_states: state = hidden_states[layer_idx].numpy().flatten() if state.size > 0: result[layer_idx] = state return result, predicted def extract_swap_features( extractor: BaseHiddenStateExtractor, swap_pairs: List[dict], max_samples_per_category: int = 0, ) -> List[dict]: """Extract features for all swap pairs. Returns per-sample records with delta vectors.""" rng = random.Random(42) # Optional: limit samples per category if max_samples_per_category > 0: grouped = defaultdict(list) for p in swap_pairs: grouped[p['category']].append(p) limited = [] for cat in CATEGORY_ORDER: samples = grouped[cat] if len(samples) > max_samples_per_category: samples = rng.sample(samples, max_samples_per_category) limited.extend(samples) swap_pairs = limited records = [] for pair in tqdm(swap_pairs, desc="Swap pairs"): try: image = decode_base64_image(pair['image_base64']) hs_orig, pred_orig = run_single_query(extractor, image, pair['original_question']) hs_swap, pred_swap = run_single_query(extractor, image, pair['swapped_question']) is_correct_orig = check_answer(pred_orig, pair['original_answer']) is_correct_swap = check_answer(pred_swap, pair['swapped_answer']) # Compute delta vectors delta = {} for layer_idx in extractor.target_layers: if layer_idx in hs_orig and layer_idx in hs_swap: delta[layer_idx] = hs_swap[layer_idx] - hs_orig[layer_idx] record = { 'index': pair['index'], 'group': pair['group'], 'category': pair['category'], 'original_answer': pair['original_answer'], 'swapped_answer': pair['swapped_answer'], 'pred_orig': pred_orig, 'pred_swap': pred_swap, 'is_correct_orig': is_correct_orig, 'is_correct_swap': is_correct_swap, 'hs_orig': hs_orig, 'hs_swap': hs_swap, 'delta': delta, } records.append(record) mark_o = "O" if is_correct_orig else "X" mark_s = "O" if is_correct_swap else "X" tqdm.write(f" #{pair['index']:<6} {pair['category']:<6} " f"orig[{mark_o}]=\"{pred_orig[:40]}\" swap[{mark_s}]=\"{pred_swap[:40]}\"") except Exception as e: logger.warning(f"Error on index {pair['index']}: {e}") continue logger.info(f"Extracted {len(records)} swap pair records") for group in GROUP_ORDER: n = sum(1 for r in records if r['group'] == group) logger.info(f" {group}: {n}") return records def extract_cross_group_features( extractor: BaseHiddenStateExtractor, quads: List[dict], ) -> List[dict]: """Extract features for cross-group quads (4 forward passes each).""" records = [] for quad in tqdm(quads, desc="Cross-group quads"): try: image = decode_base64_image(quad['image_base64']) hs_d_orig, pred_d_orig = run_single_query(extractor, image, quad['dist_original_q']) hs_d_swap, pred_d_swap = run_single_query(extractor, image, quad['dist_swapped_q']) hs_v_orig, pred_v_orig = run_single_query(extractor, image, quad['vert_original_q']) hs_v_swap, pred_v_swap = run_single_query(extractor, image, quad['vert_swapped_q']) delta_dist, delta_vert = {}, {} for layer_idx in extractor.target_layers: if layer_idx in hs_d_orig and layer_idx in hs_d_swap: delta_dist[layer_idx] = hs_d_swap[layer_idx] - hs_d_orig[layer_idx] if layer_idx in hs_v_orig and layer_idx in hs_v_swap: delta_vert[layer_idx] = hs_v_swap[layer_idx] - hs_v_orig[layer_idx] record = { 'index': quad['index'], 'delta_dist': delta_dist, 'delta_vert': delta_vert, 'pred_d_orig': pred_d_orig, 'pred_d_swap': pred_d_swap, 'pred_v_orig': pred_v_orig, 'pred_v_swap': pred_v_swap, 'is_correct_d_orig': check_answer(pred_d_orig, quad['dist_original_answer']), 'is_correct_d_swap': check_answer(pred_d_swap, quad['dist_swapped_answer']), 'is_correct_v_orig': check_answer(pred_v_orig, quad['vert_original_answer']), 'is_correct_v_swap': check_answer(pred_v_swap, quad['vert_swapped_answer']), 'data_source': quad['data_source'], } records.append(record) tqdm.write(f" #{quad['index']:<6} dist=[{pred_d_orig[:20]}/{pred_d_swap[:20]}] " f"vert=[{pred_v_orig[:20]}/{pred_v_swap[:20]}]") except Exception as e: logger.warning(f"Error on cross-group index {quad['index']}: {e}") continue logger.info(f"Extracted {len(records)} cross-group quad records") return records # ============================================================================ # Analysis Functions # ============================================================================ def compute_delta_consistency(records: List[dict], target_layers: List[int]) -> dict: """ For each group × layer, compute average pairwise cosine similarity among Δ vectors. High consistency = all swaps point in the same direction = model encodes concept linearly. """ results = {} for group in GROUP_ORDER: group_recs = [r for r in records if r['group'] == group] for layer in target_layers: deltas = [r['delta'][layer] for r in group_recs if layer in r['delta']] if len(deltas) < 2: continue deltas_arr = np.array(deltas) sim = cosine_similarity(deltas_arr) upper_tri = sim[np.triu_indices(len(deltas), k=1)] results[(group, layer)] = { 'mean': float(np.mean(upper_tri)), 'std': float(np.std(upper_tri)), 'n': len(deltas), } return results def compute_cross_group_alignment(quad_records: List[dict], target_layers: List[int]) -> dict: """ For each layer, compute cos(Δ_vert, Δ_dist) per sample, then average. High alignment = perspective bias (vertical ≈ distance in representation). Also compute alignment using mean Δ vectors. """ results = {} for layer in target_layers: per_sample = [] delta_verts, delta_dists = [], [] for rec in quad_records: if layer in rec['delta_vert'] and layer in rec['delta_dist']: dv = rec['delta_vert'][layer] dd = rec['delta_dist'][layer] norm_v = np.linalg.norm(dv) norm_d = np.linalg.norm(dd) if norm_v > 1e-10 and norm_d > 1e-10: cos = np.dot(dv, dd) / (norm_v * norm_d) per_sample.append(float(cos)) delta_verts.append(dv) delta_dists.append(dd) if not per_sample: continue # Mean delta vector alignment mean_dv = np.mean(delta_verts, axis=0) mean_dd = np.mean(delta_dists, axis=0) norm_mv = np.linalg.norm(mean_dv) norm_md = np.linalg.norm(mean_dd) mean_alignment = float(np.dot(mean_dv, mean_dd) / (norm_mv * norm_md + 1e-10)) # Permutation control: shuffle delta_dist and recompute rng = np.random.RandomState(42) n_perm = 100 perm_alignments = [] for _ in range(n_perm): shuffled_dd = [delta_dists[i] for i in rng.permutation(len(delta_dists))] perm_cos = [] for dv, dd in zip(delta_verts, shuffled_dd): norm_v = np.linalg.norm(dv) norm_d = np.linalg.norm(dd) if norm_v > 1e-10 and norm_d > 1e-10: perm_cos.append(np.dot(dv, dd) / (norm_v * norm_d)) perm_alignments.append(np.mean(perm_cos)) results[layer] = { 'per_sample_mean': float(np.mean(per_sample)), 'per_sample_std': float(np.std(per_sample)), 'mean_delta_alignment': mean_alignment, 'permutation_mean': float(np.mean(perm_alignments)), 'permutation_std': float(np.std(perm_alignments)), 'n_samples': len(per_sample), } return results def compute_prediction_stats(records: List[dict], scale: str) -> dict: """Compute accuracy stats from swap pair records.""" stats = {'scale': scale} total_correct_orig, total_correct_swap, total_both, total_n = 0, 0, 0, 0 for group in GROUP_ORDER: group_recs = [r for r in records if r['group'] == group] n = len(group_recs) c_orig = sum(1 for r in group_recs if r['is_correct_orig']) c_swap = sum(1 for r in group_recs if r['is_correct_swap']) c_both = sum(1 for r in group_recs if r['is_correct_orig'] and r['is_correct_swap']) stats[f'{group}_n'] = n stats[f'{group}_acc_orig'] = c_orig / n if n > 0 else 0 stats[f'{group}_acc_swap'] = c_swap / n if n > 0 else 0 stats[f'{group}_acc_both'] = c_both / n if n > 0 else 0 total_correct_orig += c_orig total_correct_swap += c_swap total_both += c_both total_n += n stats['overall_acc_orig'] = total_correct_orig / total_n if total_n > 0 else 0 stats['overall_acc_swap'] = total_correct_swap / total_n if total_n > 0 else 0 stats['overall_acc_both'] = total_both / total_n if total_n > 0 else 0 stats['overall_n'] = total_n return stats # ============================================================================ # Saving & Loading Intermediate Results # ============================================================================ def save_scale_results( scale: str, swap_records: List[dict], quad_records: List[dict], delta_consistency: dict, cross_alignment: dict, pred_stats: dict, target_layers: List[int], output_dir: str, ): """Save all per-scale results to disk.""" # 1. Predictions CSV pred_rows = [] for r in swap_records: pred_rows.append({ 'index': r['index'], 'group': r['group'], 'category': r['category'], 'pred_orig': r['pred_orig'], 'pred_swap': r['pred_swap'], 'is_correct_orig': r['is_correct_orig'], 'is_correct_swap': r['is_correct_swap'], }) pd.DataFrame(pred_rows).to_csv( os.path.join(output_dir, f'predictions_{scale}.csv'), index=False ) # 2. Delta consistency JSON consistency_data = {} for (group, layer), vals in delta_consistency.items(): consistency_data[f'{group}_L{layer}'] = vals with open(os.path.join(output_dir, f'delta_consistency_{scale}.json'), 'w') as f: json.dump(consistency_data, f, indent=2) # 3. Cross-group alignment JSON alignment_data = {} for layer, vals in cross_alignment.items(): alignment_data[f'L{layer}'] = vals with open(os.path.join(output_dir, f'cross_alignment_{scale}.json'), 'w') as f: json.dump(alignment_data, f, indent=2) # 4. Prediction stats JSON with open(os.path.join(output_dir, f'pred_stats_{scale}.json'), 'w') as f: json.dump(pred_stats, f, indent=2) # 5. Delta vectors for representative layers (for PCA) — NPZ rep_layers = get_representative_layers(target_layers, n=5) delta_data = {} for layer in rep_layers: groups_list, categories_list, vectors = [], [], [] for r in swap_records: if layer in r['delta']: groups_list.append(r['group']) categories_list.append(r['category']) vectors.append(r['delta'][layer]) if vectors: delta_data[f'delta_L{layer}'] = np.array(vectors) delta_data[f'groups_L{layer}'] = np.array(groups_list) delta_data[f'categories_L{layer}'] = np.array(categories_list) # Also save original/swapped embeddings for PCA orig_vecs, swap_vecs, labels = [], [], [] for r in swap_records: if layer in r['hs_orig'] and layer in r['hs_swap']: orig_vecs.append(r['hs_orig'][layer]) swap_vecs.append(r['hs_swap'][layer]) labels.append(r['category']) if orig_vecs: delta_data[f'orig_L{layer}'] = np.array(orig_vecs) delta_data[f'swap_L{layer}'] = np.array(swap_vecs) delta_data[f'labels_L{layer}'] = np.array(labels) np.savez_compressed(os.path.join(output_dir, f'vectors_{scale}.npz'), **delta_data) # 6. Cross-group delta vectors for representative layers if quad_records: cg_data = {} for layer in rep_layers: dverts, ddists = [], [] for rec in quad_records: if layer in rec['delta_vert'] and layer in rec['delta_dist']: dverts.append(rec['delta_vert'][layer]) ddists.append(rec['delta_dist'][layer]) if dverts: cg_data[f'delta_vert_L{layer}'] = np.array(dverts) cg_data[f'delta_dist_L{layer}'] = np.array(ddists) np.savez_compressed(os.path.join(output_dir, f'cross_group_vectors_{scale}.npz'), **cg_data) logger.info(f"Saved results for scale={scale} to {output_dir}") def load_scale_consistency(output_dir: str, scale: str) -> dict: path = os.path.join(output_dir, f'delta_consistency_{scale}.json') if not os.path.exists(path): return {} with open(path) as f: raw = json.load(f) result = {} for key, vals in raw.items(): # Parse "horizontal_L5" -> ('horizontal', 5) parts = key.rsplit('_L', 1) if len(parts) == 2: group, layer = parts[0], int(parts[1]) result[(group, layer)] = vals return result def load_scale_alignment(output_dir: str, scale: str) -> dict: path = os.path.join(output_dir, f'cross_alignment_{scale}.json') if not os.path.exists(path): return {} with open(path) as f: raw = json.load(f) result = {} for key, vals in raw.items(): layer = int(key.replace('L', '')) result[layer] = vals return result # ============================================================================ # Visualization # ============================================================================ def get_representative_layers(all_layers: List[int], n: int = 5) -> List[int]: if len(all_layers) <= n: return list(all_layers) indices = np.linspace(0, len(all_layers) - 1, n, dtype=int) return [all_layers[i] for i in indices] def plot_delta_consistency_trajectory( delta_consistency: dict, scale: str, model_type: str, save_path: str, ): """Plot Δ consistency (mean pairwise cosine of Δ vectors) across layers, per group.""" fig, ax = plt.subplots(figsize=(12, 6)) colors = {'horizontal': '#2ca02c', 'vertical': '#ff7f0e', 'distance': '#9467bd'} for group in GROUP_ORDER: layers, vals = [], [] for (g, l), v in sorted(delta_consistency.items(), key=lambda x: x[0][1]): if g == group: layers.append(l) vals.append(v['mean']) if layers: ax.plot(layers, vals, '-o', color=colors[group], label=group, linewidth=2, markersize=3) ax.set_xlabel('Layer Index', fontsize=12) ax.set_ylabel('Δ Consistency (mean pairwise cosine)', fontsize=12) ax.set_title(f'{model_type.upper()} ({scale}) - Within-Group Δ Vector Consistency', fontsize=14, fontweight='bold') ax.legend(fontsize=11) ax.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(save_path, dpi=300, bbox_inches='tight') plt.close() logger.info(f"Saved: {save_path}") def plot_cross_group_alignment_trajectory( cross_alignment: dict, scale: str, model_type: str, save_path: str, ): """Plot cos(Δ_vert, Δ_dist) across layers, with permutation baseline.""" fig, ax = plt.subplots(figsize=(12, 6)) layers = sorted(cross_alignment.keys()) actual = [cross_alignment[l]['per_sample_mean'] for l in layers] mean_delta = [cross_alignment[l]['mean_delta_alignment'] for l in layers] perm_mean = [cross_alignment[l]['permutation_mean'] for l in layers] perm_std = [cross_alignment[l]['permutation_std'] for l in layers] ax.plot(layers, actual, '-o', color='#d62728', label='cos(Δ_vert, Δ_dist) per-sample mean', linewidth=2.5, markersize=3) ax.plot(layers, mean_delta, '--s', color='#e377c2', label='cos(mean_Δ_vert, mean_Δ_dist)', linewidth=1.5, markersize=3) ax.plot(layers, perm_mean, ':', color='gray', label='permutation control', linewidth=1.5) ax.fill_between(layers, [m - 2*s for m, s in zip(perm_mean, perm_std)], [m + 2*s for m, s in zip(perm_mean, perm_std)], alpha=0.2, color='gray') ax.set_xlabel('Layer Index', fontsize=12) ax.set_ylabel('Cosine Alignment', fontsize=12) ax.set_title(f'{model_type.upper()} ({scale}) - Cross-Group Δ Alignment (Perspective Bias)', fontsize=14, fontweight='bold') ax.legend(fontsize=9) ax.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(save_path, dpi=300, bbox_inches='tight') plt.close() logger.info(f"Saved: {save_path}") def plot_pca_embeddings( vectors_npz_path: str, scale: str, model_type: str, save_dir: str, ): """PCA visualization for representative layers.""" data = np.load(vectors_npz_path, allow_pickle=True) # Find available layers layer_keys = [k for k in data.files if k.startswith('orig_L')] layers = sorted([int(k.replace('orig_L', '')) for k in layer_keys]) for layer in layers: orig = data.get(f'orig_L{layer}') swap = data.get(f'swap_L{layer}') labels = data.get(f'labels_L{layer}') deltas = data.get(f'delta_L{layer}') groups = data.get(f'groups_L{layer}') cats = data.get(f'categories_L{layer}') if orig is None or swap is None: continue # ---- Plot 1: Original embeddings colored by category ---- fig, axes = plt.subplots(1, 3, figsize=(24, 7)) pca = PCA(n_components=2) all_vecs = np.vstack([orig, swap]) all_pca = pca.fit_transform(all_vecs) orig_pca = all_pca[:len(orig)] swap_pca = all_pca[len(orig):] cat_colors = { 'left': '#1f77b4', 'right': '#aec7e8', 'above': '#ff7f0e', 'under': '#ffbb78', 'far': '#2ca02c', 'close': '#98df8a', } ax = axes[0] for cat in CATEGORY_ORDER: mask = np.array([str(l) == cat for l in labels]) if mask.any(): ax.scatter(orig_pca[mask, 0], orig_pca[mask, 1], c=cat_colors.get(cat, 'gray'), label=f'{cat} (orig)', alpha=0.5, s=15, marker='o') ax.scatter(swap_pca[mask, 0], swap_pca[mask, 1], c=cat_colors.get(cat, 'gray'), alpha=0.5, s=15, marker='x') ax.set_title('Embeddings by Category\n(o=original, x=swapped)', fontsize=11) ax.legend(fontsize=7, ncol=2, loc='best') ax.grid(True, alpha=0.2) # ---- Plot 2: Δ vectors colored by group ---- ax = axes[1] if deltas is not None and groups is not None: pca_d = PCA(n_components=2) delta_pca = pca_d.fit_transform(deltas) group_colors = {'horizontal': '#2ca02c', 'vertical': '#ff7f0e', 'distance': '#9467bd'} for group in GROUP_ORDER: mask = np.array([str(g) == group for g in groups]) if mask.any(): ax.scatter(delta_pca[mask, 0], delta_pca[mask, 1], c=group_colors.get(group, 'gray'), label=group, alpha=0.5, s=15) ax.set_title('Δ Vectors by Group', fontsize=11) ax.legend(fontsize=9) ax.grid(True, alpha=0.2) # ---- Plot 3: Δ vectors colored by specific category ---- ax = axes[2] if deltas is not None and cats is not None: # Reuse delta_pca from above for cat in CATEGORY_ORDER: mask = np.array([str(c) == cat for c in cats]) if mask.any(): ax.scatter(delta_pca[mask, 0], delta_pca[mask, 1], c=cat_colors.get(cat, 'gray'), label=cat, alpha=0.5, s=15) ax.set_title('Δ Vectors by Category', fontsize=11) ax.legend(fontsize=8, ncol=2) ax.grid(True, alpha=0.2) fig.suptitle(f'{model_type.upper()} ({scale}) - Layer {layer} - PCA', fontsize=14, fontweight='bold') plt.tight_layout() plt.savefig(os.path.join(save_dir, f'pca_{scale}_L{layer}.png'), dpi=200, bbox_inches='tight') plt.close() logger.info(f"Saved PCA plots to {save_dir}") def plot_cross_scale_consistency( all_consistency: Dict[str, dict], model_type: str, save_path: str, ): """Compare Δ consistency across scales for each group.""" fig, axes = plt.subplots(1, 3, figsize=(21, 6)) scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer'] for idx, group in enumerate(GROUP_ORDER): ax = axes[idx] for scale in scale_order: if scale not in all_consistency: continue consistency = all_consistency[scale] layers, vals = [], [] for (g, l), v in sorted(consistency.items(), key=lambda x: x[0][1]): if g == group: layers.append(l) vals.append(v['mean']) if layers: color = SCALE_COLORS.get(scale, 'gray') ax.plot(layers, vals, '-', color=color, label=scale, linewidth=2) ax.set_xlabel('Layer Index', fontsize=11) ax.set_ylabel('Δ Consistency', fontsize=11) ax.set_title(f'{group}', fontsize=13, fontweight='bold') ax.legend(fontsize=9) ax.grid(True, alpha=0.3) fig.suptitle(f'{model_type.upper()} - Δ Consistency Across Scales', fontsize=15, fontweight='bold', y=1.02) plt.tight_layout() plt.savefig(save_path, dpi=300, bbox_inches='tight') plt.close() logger.info(f"Saved: {save_path}") def plot_cross_scale_alignment( all_alignment: Dict[str, dict], model_type: str, save_path: str, ): """Compare cross-group alignment across scales.""" fig, ax = plt.subplots(figsize=(12, 6)) scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer'] for scale in scale_order: if scale not in all_alignment: continue alignment = all_alignment[scale] layers = sorted(alignment.keys()) vals = [alignment[l]['per_sample_mean'] for l in layers] color = SCALE_COLORS.get(scale, 'gray') ax.plot(layers, vals, '-', color=color, label=scale, linewidth=2) ax.set_xlabel('Layer Index', fontsize=12) ax.set_ylabel('cos(Δ_vert, Δ_dist)', fontsize=12) ax.set_title(f'{model_type.upper()} - Cross-Group Alignment Across Scales\n' f'(High=entangled, Low=disentangled)', fontsize=14, fontweight='bold') ax.legend(fontsize=10) ax.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(save_path, dpi=300, bbox_inches='tight') plt.close() logger.info(f"Saved: {save_path}") def plot_summary_barplot( all_consistency: Dict[str, dict], all_alignment: Dict[str, dict], model_type: str, save_path: str, ): """Summary bar plot: for the deepest layer, show Δ consistency per group + alignment.""" scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer'] available_scales = [s for s in scale_order if s in all_consistency] if not available_scales: return # Find deepest layer sample_cons = all_consistency[available_scales[0]] max_layer = max(l for (_, l) in sample_cons.keys()) fig, axes = plt.subplots(1, 2, figsize=(16, 6)) # Left: Δ consistency bar chart ax = axes[0] x = np.arange(len(GROUP_ORDER)) width = 0.8 / len(available_scales) for i, scale in enumerate(available_scales): cons = all_consistency[scale] vals = [cons.get((g, max_layer), {}).get('mean', 0) for g in GROUP_ORDER] offset = (i - len(available_scales) / 2 + 0.5) * width color = SCALE_COLORS.get(scale, 'gray') ax.bar(x + offset, vals, width, label=scale, color=color) ax.set_xticks(x) ax.set_xticklabels(GROUP_ORDER) ax.set_ylabel('Δ Consistency') ax.set_title(f'Δ Consistency at Layer {max_layer}', fontweight='bold') ax.legend(fontsize=8) ax.grid(True, alpha=0.3, axis='y') # Right: Cross-group alignment bar chart ax = axes[1] available_align_scales = [s for s in available_scales if s in all_alignment] if available_align_scales: vals = [] colors_list = [] for scale in available_align_scales: alignment = all_alignment[scale] val = alignment.get(max_layer, {}).get('per_sample_mean', 0) vals.append(val) colors_list.append(SCALE_COLORS.get(scale, 'gray')) ax.bar(range(len(vals)), vals, color=colors_list) ax.set_xticks(range(len(vals))) ax.set_xticklabels(available_align_scales, fontsize=10) ax.set_ylabel('cos(Δ_vert, Δ_dist)') ax.set_title(f'Cross-Group Alignment at Layer {max_layer}\n(Lower=more disentangled)', fontweight='bold') ax.grid(True, alpha=0.3, axis='y') fig.suptitle(f'{model_type.upper()} - Summary at Deepest Layer', fontsize=15, fontweight='bold', y=1.02) plt.tight_layout() plt.savefig(save_path, dpi=300, bbox_inches='tight') plt.close() logger.info(f"Saved: {save_path}") # ============================================================================ # Main Pipeline # ============================================================================ def process_scale(args, scale: str, swap_pairs: List[dict], quads: List[dict]): """Process a single scale: extract features, analyze, save.""" model_configs = MODEL_CONFIGS[args.model_type] model_path = model_configs[scale] logger.info(f"\n{'='*60}") logger.info(f"Processing {args.model_type} - {scale}") logger.info(f"Model path: {model_path}") logger.info(f"{'='*60}") extractor = get_extractor(args.model_type, model_path, scale=scale, device=args.device) target_layers = extractor.target_layers # Phase A: Extract swap pair features logger.info("\n--- Phase A: Extracting swap pair features ---") swap_records = extract_swap_features(extractor, swap_pairs, max_samples_per_category=args.max_samples_per_category) # Phase B: Extract cross-group features logger.info("\n--- Phase B: Extracting cross-group features ---") quad_records = extract_cross_group_features(extractor, quads) if quads else [] # Phase C: Analyze logger.info("\n--- Phase C: Analysis ---") delta_consistency = compute_delta_consistency(swap_records, target_layers) cross_alignment = compute_cross_group_alignment(quad_records, target_layers) pred_stats = compute_prediction_stats(swap_records, scale) # Log key results max_layer = max(target_layers) for group in GROUP_ORDER: key = (group, max_layer) if key in delta_consistency: logger.info(f" Δ consistency [{group}, L{max_layer}]: " f"{delta_consistency[key]['mean']:.4f} ± {delta_consistency[key]['std']:.4f}") if max_layer in cross_alignment: ca = cross_alignment[max_layer] logger.info(f" Cross-group alignment L{max_layer}: " f"{ca['per_sample_mean']:.4f} (perm={ca['permutation_mean']:.4f})") logger.info(f" Accuracy orig={pred_stats['overall_acc_orig']:.1%}, " f"swap={pred_stats['overall_acc_swap']:.1%}, " f"both={pred_stats['overall_acc_both']:.1%}") # Phase D: Save results logger.info("\n--- Phase D: Saving results ---") output_dir = os.path.join(args.output_dir, args.model_type) os.makedirs(output_dir, exist_ok=True) save_scale_results( scale, swap_records, quad_records, delta_consistency, cross_alignment, pred_stats, target_layers, output_dir, ) # Phase E: Per-scale plots logger.info("\n--- Phase E: Per-scale plots ---") plots_dir = os.path.join(output_dir, 'plots') os.makedirs(plots_dir, exist_ok=True) plot_delta_consistency_trajectory( delta_consistency, scale, args.model_type, os.path.join(plots_dir, f'delta_consistency_{scale}.png') ) if cross_alignment: plot_cross_group_alignment_trajectory( cross_alignment, scale, args.model_type, os.path.join(plots_dir, f'cross_alignment_{scale}.png') ) npz_path = os.path.join(output_dir, f'vectors_{scale}.npz') if os.path.exists(npz_path): pca_dir = os.path.join(plots_dir, 'pca') os.makedirs(pca_dir, exist_ok=True) plot_pca_embeddings(npz_path, scale, args.model_type, pca_dir) # Cleanup del swap_records, quad_records extractor.cleanup() logger.info(f"\n Scale {scale} complete.") def run_merge(args): """Merge mode: load per-scale results, generate cross-scale comparisons.""" output_dir = os.path.join(args.output_dir, args.model_type) plots_dir = os.path.join(output_dir, 'plots') os.makedirs(plots_dir, exist_ok=True) scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer'] available_scales = [s for s in scale_order if s in args.scales] all_consistency = {} all_alignment = {} for scale in available_scales: cons = load_scale_consistency(output_dir, scale) if cons: all_consistency[scale] = cons logger.info(f"Loaded consistency for {scale}: {len(cons)} entries") align = load_scale_alignment(output_dir, scale) if align: all_alignment[scale] = align logger.info(f"Loaded alignment for {scale}: {len(align)} entries") # Cross-scale plots if len(all_consistency) > 1: plot_cross_scale_consistency( all_consistency, args.model_type, os.path.join(plots_dir, 'cross_scale_consistency.png') ) if len(all_alignment) > 1: plot_cross_scale_alignment( all_alignment, args.model_type, os.path.join(plots_dir, 'cross_scale_alignment.png') ) if all_consistency: plot_summary_barplot( all_consistency, all_alignment, args.model_type, os.path.join(plots_dir, 'summary_barplot.png') ) # Summary CSV summary_rows = [] for scale in available_scales: pred_path = os.path.join(output_dir, f'pred_stats_{scale}.json') if os.path.exists(pred_path): with open(pred_path) as f: row = json.load(f) # Add alignment at deepest layer if scale in all_alignment: max_layer = max(all_alignment[scale].keys()) row['alignment_deepest'] = all_alignment[scale][max_layer]['per_sample_mean'] row['alignment_perm'] = all_alignment[scale][max_layer]['permutation_mean'] summary_rows.append(row) if summary_rows: pd.DataFrame(summary_rows).to_csv( os.path.join(output_dir, 'summary.csv'), index=False ) logger.info(f"Saved summary CSV") logger.info(f"\n=== Merge Complete ===\nResults in: {output_dir}") def main(): parser = argparse.ArgumentParser(description='Exp 2-A Swap Analysis') parser.add_argument('--data_path', type=str, default='/data/shared/Qwen/EmbSpatial-Bench/EmbSpatial-Bench.tsv') parser.add_argument('--model_type', type=str, required=True, choices=['molmo', 'nvila', 'qwen']) parser.add_argument('--scales', type=str, nargs='+', default=['vanilla', '80k', '400k', '800k', '2m']) parser.add_argument('--output_dir', type=str, default='/data/shared/Qwen/experiments/exp2a_swap_analysis/results') 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: read per-scale results and generate cross-scale plots.') parser.add_argument('--no-auto-roborefer', action='store_true', dest='no_auto_roborefer') parser.add_argument('--skip-cross-group', action='store_true', help='Skip cross-group analysis (faster, no HF dataset needed).') parser.add_argument('--max-samples-per-category', type=int, default=200, help='Limit samples per category (default=200). Set 0 for no limit.') args = parser.parse_args() 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 ===") run_merge(args) return # Normal mode logger.info("\n=== Loading & Creating Swap Pairs ===") swap_pairs = load_swap_pairs(args.data_path, args.seed) # Cross-group quads quads = [] if not args.skip_cross_group: try: hf_cache = build_hf_bbox_cache() quads = create_cross_group_quads(swap_pairs, hf_cache) except Exception as e: logger.warning(f"Cross-group setup failed: {e}. Skipping cross-group analysis.") quads = [] 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 model_path = model_configs[scale] if not os.path.exists(model_path) and not model_path.startswith(('Qwen/', 'allenai/')): logger.warning(f"Model path not found: {model_path}, 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 ===") logger.info(f"Results: {os.path.join(args.output_dir, args.model_type)}") logger.info(f"{'='*60}") if __name__ == '__main__': main()