Add files using upload-large-folder tool

correct_filter/correct_filter_analysis.py

@@ -0,0 +1,1583 @@
+#!/usr/bin/env python3
+"""
+Correct Filter Analysis: Correctness-Filtered Representation Analysis
+
+Extends the original experiment by:
+- Generating model predictions to determine correctness
+- Filtering samples into correct/incorrect groups with balanced sampling
+- Running similarity analysis on each group separately
+- Recording per-scale, per-category accuracy
+- Comparing correct-only vs incorrect-only vs all to check whether
+  scaling effects on similarity are genuine or just accuracy-driven
+
+Fixes applied:
+- Fix 1: "Answer with only one word." appended to all prompts
+- Fix 2: Synonym handling (below/beneath->under, near/nearby->close, distant->far)
+- Fix 3: Overlay trajectory plots (correct+all, correct+incorrect, all three)
+         plus cross-scale versions for correct-only and all-samples
+"""
+
+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
+
+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',
+}
+
+# Fix 2: Synonyms for answer matching
+SYNONYMS = {
+    'under': ['below', 'beneath'],
+    'close': ['near', 'nearby'],
+    'far': ['distant'],
+}
+
+TRAJECTORY_PAIRS = {
+    'hypothesis': [
+        ('above', 'far', 'above-far', '#d62728'),
+        ('under', 'close', 'under-close', '#1f77b4'),
+    ],
+    'within_axis': [
+        ('left', 'right', 'left-right', '#2ca02c'),
+        ('above', 'under', 'above-under', '#ff7f0e'),
+        ('far', 'close', 'far-close', '#9467bd'),
+    ],
+    'counter_hypothesis': [
+        ('above', 'close', 'above-close', '#e377c2'),
+        ('under', 'far', 'under-far', '#17becf'),
+    ],
+}
+
+# Key pairs for overlay trajectory plots (Fix 3)
+KEY_PAIRS = [
+    ('above', 'far', 'above-far'),
+    ('under', 'close', 'under-close'),
+    ('left', 'right', 'left-right'),
+    ('above', 'under', 'above-under'),
+    ('far', 'close', 'far-close'),
+]
+
+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',
+        '80k': '/data/shared/Qwen/mydisk/output/SINGLE/NVILA-Lite-2B-SINGLE_REFSPATIAL_16M-20260217_035008/checkpoint-1250',
+        '400k': '/data/shared/Qwen/mydisk/output/SINGLE/NVILA-Lite-2B-SINGLE_REFSPATIAL_16M-20260217_035008/checkpoint-6250',
+        '800k': '/data/shared/Qwen/mydisk/output/SINGLE/NVILA-Lite-2B-SINGLE_REFSPATIAL_16M-20260217_035008/checkpoint-12500',
+        '2m': '/data/shared/Qwen/mydisk/output/SINGLE/NVILA-Lite-2B-SINGLE_REFSPATIAL_16M-20260217_035008/checkpoint-31250',        
+        '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 & Modification
+# ============================================================================
+
+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 modify_pairwise_sample(sample: dict) -> dict:
+    obj1, obj2 = extract_objects(sample['question'])
+    category = sample['category']
+
+    # Fix 1: Add "Answer with only one word."
+    if category in ['left', 'right']:
+        new_question = f"Is the {obj1} to the left or right of the {obj2}? Answer with only one word."
+    else:  # above, under
+        new_question = f"Is the {obj1} above or under the {obj2}? Answer with only one word."
+
+    return {
+        'index': sample['index'],
+        'image_base64': sample['image_base64'],
+        'question': new_question,
+        'answer': category,
+        'category': category,
+    }
+
+
+def modify_distance_sample(sample: dict, rng: random.Random) -> dict:
+    category = sample['category']
+    answer_key = sample['answer']
+    options = sample['options']
+
+    target_object = options[answer_key]
+    candidates = [v for k, v in options.items() if k != answer_key]
+    reference_object = rng.choice(candidates)
+
+    # Fix 1: Add "Answer with only one word."
+    new_question = f"Compared to {reference_object}, is {target_object} far or close from you? Answer with only one word."
+
+    return {
+        'index': sample['index'],
+        'image_base64': sample['image_base64'],
+        'question': new_question,
+        'answer': category,
+        'category': category,
+    }
+
+
+def load_and_modify_data(tsv_path: str, seed: int = 42) -> Dict[str, List[dict]]:
+    """Load ALL samples (no per-category limit) to maximize data for correct/incorrect filtering."""
+    rng = random.Random(seed)
+    np.random.seed(seed)
+
+    df = pd.read_csv(tsv_path, sep='\t')
+
+    raw_grouped = defaultdict(list)
+    for _, row in df.iterrows():
+        category = row['category']
+        sample = {
+            'index': row['index'],
+            'image_base64': row['image'],
+            'question': row['question'],
+            'answer': row['answer'],
+            'category': category,
+            'options': {'A': row['A'], 'B': row['B'], 'C': row['C'], 'D': row['D']}
+        }
+        raw_grouped[category].append(sample)
+
+    modified_data = defaultdict(list)
+    stats = {'total': 0, 'success': 0, 'failed': 0}
+
+    for category in CATEGORY_ORDER:
+        samples = raw_grouped[category]
+        for sample in samples:
+            stats['total'] += 1
+            try:
+                if category in ['left', 'right', 'above', 'under']:
+                    modified = modify_pairwise_sample(sample)
+                else:
+                    modified = modify_distance_sample(sample, rng)
+                assert modified['answer'] == modified['category']
+                modified_data[category].append(modified)
+                stats['success'] += 1
+            except Exception as e:
+                stats['failed'] += 1
+                logger.warning(f"  Failed to modify sample {sample['index']}: {e}")
+
+    logger.info(f"Data modification: {stats['success']}/{stats['total']} success, {stats['failed']} failed")
+    for cat in CATEGORY_ORDER:
+        if cat in modified_data:
+            logger.info(f"  {cat}: {len(modified_data[cat])} samples")
+            ex = modified_data[cat][0]
+            logger.info(f"    Example Q: {ex['question']}")
+            logger.info(f"    Example A: {ex['answer']}")
+
+    return dict(modified_data)
+
+
+def decode_base64_image(base64_str: str) -> Image.Image:
+    image_data = base64.b64decode(base64_str)
+    return Image.open(BytesIO(image_data)).convert('RGB')
+
+
+# ============================================================================
+# Answer Matching (Fix 2: synonym support)
+# ============================================================================
+
+def find_earliest_position(text: str, word: str) -> int:
+    """Find earliest position of word or any of its synonyms in text."""
+    positions = []
+    pos = text.find(word)
+    if pos != -1:
+        positions.append(pos)
+    for syn in SYNONYMS.get(word, []):
+        pos = text.find(syn)
+        if pos != -1:
+            positions.append(pos)
+    return min(positions) if positions else -1
+
+
+def check_answer(generated_text: str, expected_category: str) -> bool:
+    """Check if model's generated text matches the expected category.
+
+    Uses synonym-aware matching: finds which of the two options
+    (expected vs opposite, including synonyms) appears first.
+    """
+    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 = find_earliest_position(text, expected)
+    pos_opp = find_earliest_position(text, opposite)
+
+    if pos_exp == -1:
+        return False
+    if pos_opp == -1:
+        return True
+    return pos_exp < pos_opp
+
+
+# ============================================================================
+# Base Extractor (prefill-only hooks + extract_and_predict)
+# ============================================================================
+
+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 layers (0..{num_layers-1})")
+        else:
+            self.target_layers = target_layers
+            logger.info(f"Model has {num_layers} layers. Target layers: {self.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|>', '</s>', '<|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)
+
+
+# ============================================================================
+# Extraction with Per-Sample Recording
+# ============================================================================
+
+def extract_all_with_predictions(
+    extractor: BaseHiddenStateExtractor,
+    data: Dict[str, List[dict]],
+) -> Dict[str, List[dict]]:
+    """Extract hidden states and predictions for all samples."""
+    sample_records = defaultdict(list)
+
+    for category in CATEGORY_ORDER:
+        if category not in data:
+            continue
+        samples = data[category]
+        logger.info(f"Processing category: {category} ({len(samples)} samples)")
+        success_count = 0
+
+        for sample in tqdm(samples, desc=f"  {category}"):
+            try:
+                image = decode_base64_image(sample['image_base64'])
+                hidden_states, predicted = extractor.extract_and_predict(image, sample['question'])
+
+                is_correct = check_answer(predicted, category)
+                mark = "O" if is_correct else "X"
+                tqdm.write(f"    [{mark}] #{sample['index']:<6} expected={category:<8} | predicted=\"{predicted[:80]}\"")
+
+                record = {
+                    'hidden_states': {},
+                    'is_correct': is_correct,
+                    'predicted': predicted,
+                    'index': sample['index'],
+                }
+
+                for layer_idx in extractor.target_layers:
+                    if layer_idx in hidden_states:
+                        state = hidden_states[layer_idx].numpy().flatten()
+                        if state.size > 0:
+                            record['hidden_states'][layer_idx] = state
+
+                if record['hidden_states']:
+                    sample_records[category].append(record)
+                    success_count += 1
+                else:
+                    logger.warning(f"    No hidden states for sample {sample['index']}")
+            except Exception as e:
+                logger.warning(f"    Error processing sample {sample['index']}: {e}")
+                continue
+
+        correct_n = sum(1 for r in sample_records[category] if r['is_correct'])
+        incorrect_n = sum(1 for r in sample_records[category] if not r['is_correct'])
+        acc = correct_n / (correct_n + incorrect_n) * 100 if (correct_n + incorrect_n) > 0 else 0
+        logger.info(f"  {category}: {success_count}/{len(samples)} extracted | "
+                     f"correct={correct_n}, incorrect={incorrect_n}, accuracy={acc:.1f}%")
+
+    total_correct = sum(1 for cat in sample_records for r in sample_records[cat] if r['is_correct'])
+    total_all = sum(len(sample_records[cat]) for cat in sample_records)
+    overall_acc = total_correct / total_all * 100 if total_all > 0 else 0
+    logger.info(f"\n  === Category Accuracy Summary ===")
+    for cat in CATEGORY_ORDER:
+        if cat in sample_records:
+            c = sum(1 for r in sample_records[cat] if r['is_correct'])
+            n = len(sample_records[cat])
+            a = c / n * 100 if n > 0 else 0
+            logger.info(f"    {cat:>6s}: {c:>4d}/{n:<4d} = {a:5.1f}%")
+    logger.info(f"    {'TOTAL':>6s}: {total_correct:>4d}/{total_all:<4d} = {overall_acc:5.1f}%")
+    logger.info(f"  ================================\n")
+
+    return dict(sample_records)
+
+
+# ============================================================================
+# Balanced Sampling
+# ============================================================================
+
+def compute_balanced_size(sample_records: Dict[str, List[dict]], filter_correct: bool) -> int:
+    counts = []
+    for cat in CATEGORY_ORDER:
+        if cat not in sample_records:
+            return 0
+        n = sum(1 for s in sample_records[cat] if s['is_correct'] == filter_correct)
+        counts.append(n)
+
+    min_count = min(counts)
+    if min_count == 0:
+        return 0
+
+    balanced = (min_count // 50) * 50
+    if balanced == 0:
+        balanced = min_count
+    return balanced
+
+
+def balanced_sample_and_average(
+    sample_records: Dict[str, List[dict]],
+    filter_correct: bool,
+    n_samples: int,
+    target_layers: List[int],
+    seed: int = 42,
+) -> Dict[int, Dict[str, np.ndarray]]:
+    rng = random.Random(seed)
+    result = defaultdict(dict)
+
+    for category in CATEGORY_ORDER:
+        filtered = [s for s in sample_records[category] if s['is_correct'] == filter_correct]
+        if len(filtered) < n_samples:
+            logger.warning(f"  {category}: only {len(filtered)} samples, need {n_samples}")
+            continue
+        sampled = rng.sample(filtered, n_samples)
+        for layer_idx in target_layers:
+            vectors = [record['hidden_states'][layer_idx]
+                       for record in sampled if layer_idx in record['hidden_states']]
+            if vectors:
+                result[layer_idx][category] = np.mean(vectors, axis=0)
+
+    return dict(result)
+
+
+def compute_all_samples_reps(
+    sample_records: Dict[str, List[dict]],
+    target_layers: List[int],
+) -> Dict[int, Dict[str, np.ndarray]]:
+    """Compute average representations using ALL samples (no filtering)."""
+    result = defaultdict(dict)
+    for category in CATEGORY_ORDER:
+        records = sample_records.get(category, [])
+        if not records:
+            continue
+        for layer_idx in target_layers:
+            vectors = [r['hidden_states'][layer_idx]
+                       for r in records if layer_idx in r['hidden_states']]
+            if vectors:
+                result[layer_idx][category] = np.mean(vectors, axis=0)
+    return dict(result)
+
+
+# ============================================================================
+# Accuracy
+# ============================================================================
+
+def compute_accuracy_stats(sample_records, scale, model_type):
+    stats = {'model': model_type, 'scale': scale}
+    total_correct, total_count = 0, 0
+    for cat in CATEGORY_ORDER:
+        records = sample_records.get(cat, [])
+        n = len(records)
+        correct = sum(1 for r in records if r['is_correct'])
+        stats[f'{cat}_total'] = n
+        stats[f'{cat}_correct'] = correct
+        stats[f'{cat}_accuracy'] = correct / n if n > 0 else 0.0
+        total_correct += correct
+        total_count += n
+    stats['overall_total'] = total_count
+    stats['overall_correct'] = total_correct
+    stats['overall_accuracy'] = total_correct / total_count if total_count > 0 else 0.0
+    return stats
+
+
+def save_per_sample_predictions(sample_records, scale, save_path):
+    rows = []
+    for cat in CATEGORY_ORDER:
+        for record in sample_records.get(cat, []):
+            rows.append({
+                'index': record['index'], 'category': cat, 'scale': scale,
+                'predicted': record['predicted'], 'expected': cat,
+                'is_correct': record['is_correct'],
+            })
+    pd.DataFrame(rows).to_csv(save_path, index=False)
+    logger.info(f"Saved {len(rows)} per-sample predictions to {save_path}")
+
+
+def save_per_sample_norms(sample_records, scale, save_path):
+    """Save L2 norm of each sample's hidden state at each layer."""
+    rows = []
+    for cat in CATEGORY_ORDER:
+        for record in sample_records.get(cat, []):
+            row = {
+                'index': record['index'],
+                'category': cat,
+                'scale': scale,
+                'is_correct': record['is_correct'],
+            }
+            for layer_idx, state in record['hidden_states'].items():
+                row[f'norm_L{layer_idx}'] = float(np.linalg.norm(state))
+            rows.append(row)
+    pd.DataFrame(rows).to_csv(save_path, index=False)
+    logger.info(f"Saved {len(rows)} per-sample norms to {save_path}")
+
+
+# ============================================================================
+# Analysis Functions
+# ============================================================================
+
+def compute_similarity_matrix(representations: Dict[str, np.ndarray]) -> pd.DataFrame:
+    available = [c for c in CATEGORY_ORDER if c in representations]
+    vectors = np.array([representations[cat] for cat in available])
+    sim_matrix = cosine_similarity(vectors)
+    return pd.DataFrame(sim_matrix, index=available, columns=available)
+
+
+def analyze_hypothesis(sim_df, model_name):
+    results = {'model': model_name}
+    pairs_to_check = {
+        'above_far': ('above', 'far'), 'under_close': ('under', 'close'),
+        'left_right': ('left', 'right'),
+    }
+    for pair_name, (cat1, cat2) in pairs_to_check.items():
+        if cat1 in sim_df.index and cat2 in sim_df.columns:
+            results[f'sim_{pair_name}'] = sim_df.loc[cat1, cat2]
+        else:
+            results[f'sim_{pair_name}'] = None
+    return results
+
+
+# ============================================================================
+# Visualization
+# ============================================================================
+
+def plot_similarity_heatmap(sim_df, title, save_path):
+    plt.figure(figsize=(10, 8))
+    available_order = [c for c in CATEGORY_ORDER if c in sim_df.index]
+    sim_df_ordered = sim_df.loc[available_order, available_order]
+    sns.heatmap(sim_df_ordered, annot=True, fmt='.4f', cmap='RdYlBu_r',
+                center=0.5, vmin=0, vmax=1, square=True, linewidths=0.5,
+                cbar_kws={'label': 'Cosine Similarity'})
+    plt.title(title, fontsize=14, fontweight='bold')
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved heatmap: {save_path}")
+
+
+def _extract_pair_trajectory(all_layer_sims, cat1, cat2):
+    layers = sorted(all_layer_sims.keys())
+    valid_layers, values = [], []
+    for l in layers:
+        df = all_layer_sims[l]
+        if cat1 in df.index and cat2 in df.columns:
+            valid_layers.append(l)
+            values.append(df.loc[cat1, cat2])
+    return valid_layers, values
+
+
+def get_representative_layers(all_layers, n=5):
+    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_similarity_trajectories(all_layer_sims, title, save_path):
+    fig, axes = plt.subplots(1, 2, figsize=(20, 7))
+
+    ax = axes[0]
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, '-', color=color, label=label, linewidth=2.5)
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['within_axis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, '--', color=color, label=label, linewidth=1.8)
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['counter_hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, ':', color=color, label=label, linewidth=1.5, alpha=0.8)
+    ax.set_xlabel('Layer Index')
+    ax.set_ylabel('Cosine Similarity')
+    ax.set_title(f'{title}\nPairwise Similarity Across Layers')
+    ax.legend(fontsize=9, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    ax = axes[1]
+    lr_layers, lr_vals = _extract_pair_trajectory(all_layer_sims, 'left', 'right')
+    lr_dict = dict(zip(lr_layers, lr_vals))
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, '-', color=color, label=f'{label} - left-right', linewidth=2.5)
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['counter_hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, ':', color=color, label=f'{label} - left-right', linewidth=1.5, alpha=0.8)
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['within_axis']:
+        if label == 'left-right':
+            continue
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, '--', color=color, label=f'{label} - left-right', linewidth=1.5, alpha=0.7)
+    ax.axhline(y=0, color='gray', linestyle='-', linewidth=1, alpha=0.5)
+    ax.set_xlabel('Layer Index')
+    ax.set_ylabel('Similarity Difference (pair - left-right)')
+    ax.set_title(f'{title}\nRelative to Left-Right Baseline')
+    ax.legend(fontsize=8, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved trajectory: {save_path}")
+
+
+def plot_cross_scale_trajectories(cross_scale_data, model_type, save_path):
+    pairs = [
+        ('above', 'far', 'above-far (hypothesis)'),
+        ('under', 'close', 'under-close (hypothesis)'),
+        ('left', 'right', 'left-right (control)'),
+    ]
+    fig, axes = plt.subplots(1, len(pairs), figsize=(7 * len(pairs), 6))
+    if len(pairs) == 1:
+        axes = [axes]
+    for idx, (cat1, cat2, label) in enumerate(pairs):
+        ax = axes[idx]
+        for scale in ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']:
+            if scale not in cross_scale_data:
+                continue
+            layers, vals = _extract_pair_trajectory(cross_scale_data[scale], cat1, cat2)
+            ax.plot(layers, vals, '-', color=SCALE_COLORS.get(scale, 'gray'), label=scale, linewidth=2)
+        ax.set_xlabel('Layer Index')
+        ax.set_ylabel('Cosine Similarity')
+        ax.set_title(label, fontweight='bold')
+        ax.legend(fontsize=10)
+        ax.grid(True, alpha=0.3)
+    fig.suptitle(f'{model_type.upper()} - Similarity Trajectory 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 cross-scale trajectory: {save_path}")
+
+
+def plot_similarity_evolution_heatmap(cross_scale_data, model_type, save_path):
+    pairs = [
+        ('above', 'far', 'above-far'), ('under', 'close', 'under-close'),
+        ('left', 'right', 'left-right'), ('above', 'under', 'above-under'),
+        ('far', 'close', 'far-close'),
+    ]
+    scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']
+    available_scales = [s for s in scale_order if s in cross_scale_data]
+    first_scale = available_scales[0]
+    all_layers = sorted(cross_scale_data[first_scale].keys())
+
+    fig, axes = plt.subplots(len(pairs), 1, figsize=(max(14, len(all_layers) * 0.5), 3 * len(pairs)))
+    if len(pairs) == 1:
+        axes = [axes]
+    for idx, (cat1, cat2, label) in enumerate(pairs):
+        ax = axes[idx]
+        matrix = np.full((len(available_scales), len(all_layers)), np.nan)
+        for si, scale in enumerate(available_scales):
+            layer_sims = cross_scale_data[scale]
+            for li, layer in enumerate(all_layers):
+                if layer in layer_sims:
+                    df = layer_sims[layer]
+                    if cat1 in df.index and cat2 in df.columns:
+                        matrix[si, li] = df.loc[cat1, cat2]
+        im = ax.imshow(matrix, aspect='auto', cmap='RdYlBu_r', vmin=0.5, vmax=1.0)
+        ax.set_yticks(range(len(available_scales)))
+        ax.set_yticklabels(available_scales, fontsize=10)
+        step = max(1, len(all_layers) // 15)
+        ax.set_xticks(range(0, len(all_layers), step))
+        ax.set_xticklabels([str(all_layers[i]) for i in range(0, len(all_layers), step)], fontsize=8)
+        ax.set_title(label, fontweight='bold')
+        ax.set_xlabel('Layer Index')
+        fig.colorbar(im, ax=ax, label='Cosine Similarity', shrink=0.8)
+    fig.suptitle(f'{model_type.upper()} - Similarity Evolution (Layer x Scale)',
+                 fontsize=15, fontweight='bold', y=1.01)
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved evolution heatmap: {save_path}")
+
+
+# ============================================================================
+# Fix 3: Overlay Trajectory Plots
+# ============================================================================
+
+def plot_overlay_trajectories(
+    datasets: Dict[str, Dict[int, pd.DataFrame]],
+    styles: Dict[str, Tuple[str, str, float]],
+    title: str,
+    save_path: str,
+):
+    """Plot overlay trajectory for multiple datasets (correct, incorrect, all).
+
+    datasets: {name -> {layer -> sim_df}}
+    styles: {name -> (linestyle, color, linewidth)}
+    """
+    n_pairs = len(KEY_PAIRS)
+    fig, axes = plt.subplots(1, n_pairs, figsize=(5.5 * n_pairs, 5.5))
+    if n_pairs == 1:
+        axes = [axes]
+
+    for idx, (cat1, cat2, label) in enumerate(KEY_PAIRS):
+        ax = axes[idx]
+        for name, layer_sims in datasets.items():
+            ls, color, lw = styles[name]
+            layers, vals = _extract_pair_trajectory(layer_sims, cat1, cat2)
+            if layers:
+                ax.plot(layers, vals, linestyle=ls, color=color, label=name, linewidth=lw)
+        ax.set_xlabel('Layer Index', fontsize=10)
+        ax.set_ylabel('Cosine Similarity', fontsize=10)
+        ax.set_title(label, fontsize=11, fontweight='bold')
+        ax.legend(fontsize=8)
+        ax.grid(True, alpha=0.3)
+
+    fig.suptitle(title, fontsize=14, fontweight='bold', y=1.02)
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved overlay trajectory: {save_path}")
+
+
+def generate_overlay_plots(
+    correct_sims, incorrect_sims, all_sims,
+    scale, model_type, save_dir,
+):
+    """Generate all 3 overlay trajectory variants for a single scale."""
+    prefix = f'{model_type.upper()} ({scale})'
+
+    # 1. correct + all
+    if correct_sims and all_sims:
+        plot_overlay_trajectories(
+            {'correct': correct_sims, 'all': all_sims},
+            {'correct': ('-', '#2ca02c', 2.5), 'all': ('--', '#7f7f7f', 1.8)},
+            f'{prefix} - Correct vs All Samples',
+            os.path.join(save_dir, f'overlay_correct_all_{scale}.png'),
+        )
+
+    # 2. correct + incorrect
+    if correct_sims and incorrect_sims:
+        plot_overlay_trajectories(
+            {'correct': correct_sims, 'incorrect': incorrect_sims},
+            {'correct': ('-', '#2ca02c', 2.5), 'incorrect': ('-', '#d62728', 2.5)},
+            f'{prefix} - Correct vs Incorrect',
+            os.path.join(save_dir, f'overlay_correct_incorrect_{scale}.png'),
+        )
+
+    # 3. correct + incorrect + all
+    if correct_sims and all_sims:
+        ds = {'correct': correct_sims, 'all': all_sims}
+        st = {'correct': ('-', '#2ca02c', 2.5), 'all': ('--', '#7f7f7f', 1.8)}
+        if incorrect_sims:
+            ds['incorrect'] = incorrect_sims
+            st['incorrect'] = ('-', '#d62728', 2.0)
+        plot_overlay_trajectories(
+            ds, st,
+            f'{prefix} - Correct vs Incorrect vs All',
+            os.path.join(save_dir, f'overlay_all_{scale}.png'),
+        )
+
+
+# ============================================================================
+# Accuracy & Ablation Visualization
+# ============================================================================
+
+def plot_accuracy_chart(accuracy_records, model_type, save_path):
+    fig, ax = plt.subplots(figsize=(14, 6))
+    scales = [r['scale'] for r in accuracy_records]
+    x = np.arange(len(CATEGORY_ORDER) + 1)
+    width = 0.8 / len(scales)
+    for i, record in enumerate(accuracy_records):
+        values = [record.get(f'{cat}_accuracy', 0) for cat in CATEGORY_ORDER]
+        values.append(record.get('overall_accuracy', 0))
+        offset = (i - len(scales) / 2 + 0.5) * width
+        color = SCALE_COLORS.get(record['scale'], 'gray')
+        bars = ax.bar(x + offset, values, width, label=record['scale'], color=color)
+        for bar, val in zip(bars, values):
+            if val > 0:
+                ax.annotate(f'{val:.0%}', xy=(bar.get_x() + bar.get_width() / 2, bar.get_height()),
+                            xytext=(0, 2), textcoords='offset points',
+                            ha='center', va='bottom', fontsize=6, rotation=90)
+    ax.set_ylabel('Accuracy')
+    ax.set_title(f'{model_type.upper()} - Per-Category Accuracy Across Scales', fontweight='bold')
+    ax.set_xticks(x)
+    ax.set_xticklabels(CATEGORY_ORDER + ['overall'])
+    ax.legend(fontsize=9)
+    ax.set_ylim(0, 1.15)
+    ax.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved accuracy chart: {save_path}")
+
+
+def plot_ablation_summary(ablation_data, model_type, save_path, include_roborefer=False):
+    pairs = [
+        ('above', 'far', 'above-far', '#d62728'),
+        ('under', 'close', 'under-close', '#1f77b4'),
+        ('left', 'right', 'left-right', '#2ca02c'),
+    ]
+    if include_roborefer:
+        scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']
+    else:
+        scale_order = ['vanilla', '80k', '400k', '800k', '2m']
+
+    fig, axes = plt.subplots(1, 2, figsize=(18, 7))
+
+    ax = axes[0]
+    for cat1, cat2, label, color in pairs:
+        x_vals, y_correct, y_all = [], [], []
+        for i, scale in enumerate(scale_order):
+            entry = next((d for d in ablation_data if d['scale'] == scale), None)
+            if entry is None:
+                continue
+            sim_c = entry.get(f'correct_{cat1}_{cat2}')
+            sim_a = entry.get(f'all_{cat1}_{cat2}')
+            if sim_c is not None:
+                x_vals.append(i)
+                y_correct.append(sim_c)
+                y_all.append(sim_a)
+        if x_vals:
+            ax.plot(x_vals, y_correct, '-o', color=color, label=f'{label} (correct)', linewidth=2.5)
+            ax.plot(x_vals, y_all, '--s', color=color, label=f'{label} (all)', linewidth=1.5, alpha=0.6)
+    ax.set_xticks(range(len(scale_order)))
+    ax.set_xticklabels(scale_order)
+    ax.set_xlabel('Scale')
+    ax.set_ylabel('Cosine Similarity')
+    ax.set_title('Correct-Only vs All-Samples Similarity', fontweight='bold')
+    ax.legend(fontsize=8, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    ax2 = axes[1]
+    x_vals, acc_vals = [], []
+    for i, scale in enumerate(scale_order):
+        entry = next((d for d in ablation_data if d['scale'] == scale), None)
+        if entry and 'accuracy' in entry:
+            x_vals.append(i)
+            acc_vals.append(entry['accuracy'])
+    ax2.bar(x_vals, acc_vals, color=[SCALE_COLORS.get(scale_order[x], 'gray') for x in x_vals], alpha=0.8)
+    for x, acc in zip(x_vals, acc_vals):
+        ax2.annotate(f'{acc:.1%}', xy=(x, acc), xytext=(0, 5), textcoords='offset points',
+                     ha='center', fontsize=10, fontweight='bold')
+    ax2.set_xticks(range(len(scale_order)))
+    ax2.set_xticklabels(scale_order)
+    ax2.set_xlabel('Scale')
+    ax2.set_ylabel('Overall Accuracy')
+    ax2.set_title('Model Accuracy by Scale', fontweight='bold')
+    ax2.set_ylim(0, 1.15)
+    ax2.grid(True, alpha=0.3, axis='y')
+
+    fig.suptitle(f'{model_type.upper()} - Ablation: Is Similarity Change Due to Accuracy?',
+                 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 ablation summary: {save_path}")
+
+
+# ============================================================================
+# Process Subset & CSV I/O
+# ============================================================================
+
+def process_subset(
+    subset_name, all_layer_reps, target_layers, scale, model_type, output_dir, n_samples,
+):
+    """Compute similarity matrices and save outputs for one subset."""
+    scale_sims = {}
+    results_list = []
+
+    for layer_idx in sorted(all_layer_reps.keys()):
+        reps = all_layer_reps[layer_idx]
+        if len(reps) < 2:
+            continue
+        sim_df = compute_similarity_matrix(reps)
+        scale_sims[layer_idx] = sim_df
+        results = analyze_hypothesis(sim_df, f"{model_type}_{scale}_{subset_name}")
+        results['layer_idx'] = layer_idx
+        results['subset'] = subset_name
+        results['scale'] = scale
+        results['n_samples_per_cat'] = n_samples
+        results_list.append(results)
+        csv_out = os.path.join(output_dir, 'csv')
+        os.makedirs(csv_out, exist_ok=True)
+        sim_df.to_csv(os.path.join(csv_out, f'similarity_{scale}_L{layer_idx}.csv'))
+
+    if scale_sims:
+        rep_layers = get_representative_layers(sorted(scale_sims.keys()))
+        for layer_idx in rep_layers:
+            plot_similarity_heatmap(
+                scale_sims[layer_idx],
+                f'{model_type.upper()} ({scale}) [{subset_name}, n={n_samples}] - Layer {layer_idx}',
+                os.path.join(output_dir, f'heatmap_{scale}_L{layer_idx}.png')
+            )
+        plot_similarity_trajectories(
+            scale_sims,
+            f'{model_type.upper()} ({scale}) [{subset_name}, n={n_samples}]',
+            os.path.join(output_dir, f'trajectory_{scale}.png')
+        )
+
+    return scale_sims, results_list
+
+
+def _load_scale_sims_from_csvs(subset_dir, scale):
+    import glob as glob_mod
+    pattern = os.path.join(subset_dir, 'csv', f'similarity_{scale}_L*.csv')
+    files = glob_mod.glob(pattern)
+    layer_sims = {}
+    for fpath in files:
+        basename = os.path.basename(fpath)
+        layer_str = basename.replace(f'similarity_{scale}_L', '').replace('.csv', '')
+        try:
+            layer_idx = int(layer_str)
+        except ValueError:
+            continue
+        layer_sims[layer_idx] = pd.read_csv(fpath, index_col=0)
+    return layer_sims
+
+
+# ============================================================================
+# Merge Mode
+# ============================================================================
+
+def run_merge(model_type, scales, output_dir,
+              correct_dir, incorrect_dir, all_dir, accuracy_dir, comparison_dir,
+              write_output_dir=None):
+    """Merge mode. Read from *_dir, write to write_output_dir (or same dirs if None)."""
+    # Write destinations
+    w_comparison = os.path.join(write_output_dir, 'comparison') if write_output_dir else comparison_dir
+    w_accuracy = os.path.join(write_output_dir, 'accuracy') if write_output_dir else accuracy_dir
+    if write_output_dir:
+        os.makedirs(w_comparison, exist_ok=True)
+        os.makedirs(w_accuracy, exist_ok=True)
+
+    scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']
+    available_scales = [s for s in scale_order if s in scales]
+
+    cross_scale_correct, cross_scale_incorrect, cross_scale_all = {}, {}, {}
+    for scale in available_scales:
+        c_sims = _load_scale_sims_from_csvs(correct_dir, scale)
+        if c_sims:
+            cross_scale_correct[scale] = c_sims
+            logger.info(f"  Loaded correct-only CSVs for {scale}: {len(c_sims)} layers")
+        i_sims = _load_scale_sims_from_csvs(incorrect_dir, scale)
+        if i_sims:
+            cross_scale_incorrect[scale] = i_sims
+            logger.info(f"  Loaded incorrect-only CSVs for {scale}: {len(i_sims)} layers")
+        a_sims = _load_scale_sims_from_csvs(all_dir, scale)
+        if a_sims:
+            cross_scale_all[scale] = a_sims
+            logger.info(f"  Loaded all-samples CSVs for {scale}: {len(a_sims)} layers")
+
+    # Cross-scale trajectories + evolution heatmaps
+    for name, data, subdir in [
+        ('correct-only', cross_scale_correct, 'cross_scale_correct_only'),
+        ('incorrect-only', cross_scale_incorrect, 'cross_scale_incorrect_only'),
+        ('all-samples', cross_scale_all, 'cross_scale_all_samples'),
+    ]:
+        if len(data) > 1:
+            logger.info(f"\n--- Cross-scale comparison ({name}) ---")
+            plot_cross_scale_trajectories(
+                data, model_type,
+                os.path.join(w_comparison, f'{subdir}.png')
+            )
+            plot_similarity_evolution_heatmap(
+                data, model_type,
+                os.path.join(w_comparison, f'evolution_heatmap_{subdir.replace("cross_scale_", "")}.png')
+            )
+
+    # Per-scale overlay plots (Fix 3)
+    for scale in available_scales:
+        c = cross_scale_correct.get(scale)
+        i = cross_scale_incorrect.get(scale)
+        a = cross_scale_all.get(scale)
+        generate_overlay_plots(c, i, a, scale, model_type, w_comparison)
+
+    # Accuracy chart
+    accuracy_records = []
+    for scale in available_scales:
+        acc_path = os.path.join(accuracy_dir, 'json', f'accuracy_{scale}.json')
+        if os.path.exists(acc_path):
+            with open(acc_path) as f:
+                accuracy_records.append(json.load(f))
+    if accuracy_records:
+        w_acc_csv = os.path.join(w_accuracy, 'csv')
+        os.makedirs(w_acc_csv, exist_ok=True)
+        pd.DataFrame(accuracy_records).to_csv(os.path.join(w_acc_csv, 'accuracy_summary.csv'), index=False)
+        plot_accuracy_chart(accuracy_records, model_type,
+                            os.path.join(w_accuracy, 'accuracy_chart.png'))
+
+    # Ablation summary
+    ablation_data = []
+    for scale in available_scales:
+        abl_path = os.path.join(comparison_dir, 'json', f'ablation_{scale}.json')
+        if os.path.exists(abl_path):
+            with open(abl_path) as f:
+                ablation_data.append(json.load(f))
+    if ablation_data:
+        w_comp_csv = os.path.join(w_comparison, 'csv')
+        os.makedirs(w_comp_csv, exist_ok=True)
+        pd.DataFrame(ablation_data).to_csv(os.path.join(w_comp_csv, 'ablation_summary.csv'), index=False)
+        plot_ablation_summary(ablation_data, model_type,
+                              os.path.join(w_comparison, 'ablation_summary.png'),
+                              include_roborefer=bool(write_output_dir))
+
+    w_out = write_output_dir or output_dir
+    logger.info(f"\n=== Merge Complete ===\nResults in: {w_out}")
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(description='Correct Filter 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/correct_filter/results')
+    parser.add_argument('--device', type=str, default='cuda')
+    parser.add_argument('--seed', type=int, default=42)
+    parser.add_argument('--merge', action='store_true')
+    parser.add_argument('--merge-output-dir', type=str, default=None, dest='merge_output_dir',
+                        help='Override output dir for merge cross-scale plots (for NVILA dual merge)')
+    parser.add_argument('--no-auto-roborefer', action='store_true', dest='no_auto_roborefer')
+
+    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)
+
+    output_dir = os.path.join(args.output_dir, args.model_type)
+    correct_dir = os.path.join(output_dir, 'correct_only')
+    incorrect_dir = os.path.join(output_dir, 'incorrect_only')
+    all_dir = os.path.join(output_dir, 'all_samples')
+    accuracy_dir = os.path.join(output_dir, 'accuracy')
+    comparison_dir = os.path.join(output_dir, 'comparison')
+    for d in [correct_dir, incorrect_dir, all_dir, accuracy_dir, comparison_dir]:
+        os.makedirs(d, exist_ok=True)
+
+    # Merge mode
+    if args.merge:
+        logger.info("\n=== MERGE MODE ===")
+        run_merge(args.model_type, args.scales, output_dir,
+                  correct_dir, incorrect_dir, all_dir, accuracy_dir, comparison_dir,
+                  write_output_dir=args.merge_output_dir)
+        return
+
+    # Normal mode
+    logger.info("\n=== Loading & Modifying EmbSpatialBench Data (ALL samples) ===")
+    data = load_and_modify_data(args.data_path, args.seed)
+
+    model_configs = MODEL_CONFIGS[args.model_type]
+
+    all_results = []
+    accuracy_records = []
+    cross_scale_correct = {}
+    cross_scale_incorrect = {}
+    cross_scale_all = {}
+    ablation_data = []
+
+    for scale in args.scales:
+        if scale not in model_configs:
+            logger.warning(f"Scale {scale} not available 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
+
+        logger.info(f"\n{'='*60}")
+        logger.info(f"Processing {args.model_type} - {scale}")
+        logger.info(f"Model path: {model_path}")
+        logger.info(f"{'='*60}")
+
+        try:
+            extractor = get_extractor(args.model_type, model_path, scale=scale, device=args.device)
+            target_layers = extractor.target_layers
+
+            # Phase A: Extract all samples with predictions
+            logger.info("\n--- Phase A: Extracting hidden states with predictions ---")
+            sample_records = extract_all_with_predictions(extractor, data)
+
+            acc_csv_dir = os.path.join(accuracy_dir, 'csv')
+            acc_json_dir = os.path.join(accuracy_dir, 'json')
+            os.makedirs(acc_csv_dir, exist_ok=True)
+            os.makedirs(acc_json_dir, exist_ok=True)
+
+            save_per_sample_predictions(
+                sample_records, scale,
+                os.path.join(acc_csv_dir, f'predictions_{scale}.csv')
+            )
+            save_per_sample_norms(
+                sample_records, scale,
+                os.path.join(acc_csv_dir, f'norms_{scale}.csv')
+            )
+
+            acc_stats = compute_accuracy_stats(sample_records, scale, args.model_type)
+            accuracy_records.append(acc_stats)
+            logger.info(f"\n  Accuracy for {scale}: {acc_stats['overall_accuracy']:.1%}")
+            for cat in CATEGORY_ORDER:
+                logger.info(f"    {cat}: {acc_stats[f'{cat}_correct']}/{acc_stats[f'{cat}_total']} "
+                            f"= {acc_stats[f'{cat}_accuracy']:.1%}")
+
+            # Phase B: Compute all-samples similarity for ALL layers
+            logger.info("\n--- Phase B: All-samples similarity (all layers) ---")
+            all_reps = compute_all_samples_reps(sample_records, target_layers)
+            all_sims, all_results_sub = process_subset(
+                'all', all_reps, target_layers, scale,
+                args.model_type, all_dir, sum(len(sample_records.get(c, [])) for c in CATEGORY_ORDER),
+            )
+            all_results.extend(all_results_sub)
+            cross_scale_all[scale] = all_sims
+
+            # Phase C: Balanced sampling
+            logger.info("\n--- Phase C: Balanced sampling ---")
+            n_correct = compute_balanced_size(sample_records, filter_correct=True)
+            n_incorrect = compute_balanced_size(sample_records, filter_correct=False)
+            logger.info(f"  Correct group: {n_correct} samples/category")
+            logger.info(f"  Incorrect group: {n_incorrect} samples/category")
+
+            # Process correct-only subset
+            correct_layer_sims = {}
+            if n_correct > 0:
+                logger.info(f"\n--- Processing correct-only (n={n_correct}) ---")
+                correct_reps = balanced_sample_and_average(
+                    sample_records, filter_correct=True, n_samples=n_correct,
+                    target_layers=target_layers, seed=args.seed,
+                )
+                correct_layer_sims, correct_results = process_subset(
+                    'correct', correct_reps, target_layers, scale,
+                    args.model_type, correct_dir, n_correct,
+                )
+                all_results.extend(correct_results)
+                cross_scale_correct[scale] = correct_layer_sims
+            else:
+                logger.warning(f"  Skipping correct-only: no correct samples in some category")
+
+            # Process incorrect-only subset
+            incorrect_layer_sims = {}
+            if n_incorrect > 0:
+                logger.info(f"\n--- Processing incorrect-only (n={n_incorrect}) ---")
+                incorrect_reps = balanced_sample_and_average(
+                    sample_records, filter_correct=False, n_samples=n_incorrect,
+                    target_layers=target_layers, seed=args.seed,
+                )
+                incorrect_layer_sims, incorrect_results = process_subset(
+                    'incorrect', incorrect_reps, target_layers, scale,
+                    args.model_type, incorrect_dir, n_incorrect,
+                )
+                all_results.extend(incorrect_results)
+                cross_scale_incorrect[scale] = incorrect_layer_sims
+            else:
+                logger.warning(f"  Skipping incorrect-only: no incorrect samples in some category")
+
+            # Phase D: Overlay plots (Fix 3)
+            generate_overlay_plots(
+                correct_layer_sims or None,
+                incorrect_layer_sims or None,
+                all_sims or None,
+                scale, args.model_type, comparison_dir,
+            )
+
+            # Phase E: Build ablation entry (mean similarity across ALL layers)
+            ablation_entry = {
+                'scale': scale,
+                'accuracy': acc_stats['overall_accuracy'],
+                'n_correct_per_cat': n_correct,
+                'n_incorrect_per_cat': n_incorrect,
+            }
+
+            pairs_list = TRAJECTORY_PAIRS['hypothesis'] + TRAJECTORY_PAIRS['within_axis']
+
+            # All-samples: mean similarity across all layers
+            if all_sims:
+                for cat1, cat2, _, _ in pairs_list:
+                    vals = [float(all_sims[l].loc[cat1, cat2])
+                            for l in all_sims
+                            if cat1 in all_sims[l].index and cat2 in all_sims[l].columns]
+                    if vals:
+                        ablation_entry[f'all_{cat1}_{cat2}'] = float(np.mean(vals))
+
+            # Correct-only: mean similarity across all layers
+            if correct_layer_sims:
+                for cat1, cat2, _, _ in pairs_list:
+                    vals = [float(correct_layer_sims[l].loc[cat1, cat2])
+                            for l in correct_layer_sims
+                            if cat1 in correct_layer_sims[l].index and cat2 in correct_layer_sims[l].columns]
+                    if vals:
+                        ablation_entry[f'correct_{cat1}_{cat2}'] = float(np.mean(vals))
+
+            # Incorrect-only: mean similarity across all layers
+            if incorrect_layer_sims:
+                for cat1, cat2, _, _ in pairs_list:
+                    vals = [float(incorrect_layer_sims[l].loc[cat1, cat2])
+                            for l in incorrect_layer_sims
+                            if cat1 in incorrect_layer_sims[l].index and cat2 in incorrect_layer_sims[l].columns]
+                    if vals:
+                        ablation_entry[f'incorrect_{cat1}_{cat2}'] = float(np.mean(vals))
+
+            ablation_data.append(ablation_entry)
+
+            # Save per-scale JSONs
+            comp_json_dir = os.path.join(comparison_dir, 'json')
+            os.makedirs(comp_json_dir, exist_ok=True)
+            with open(os.path.join(comp_json_dir, f'ablation_{scale}.json'), 'w') as f:
+                json.dump(ablation_entry, f, indent=2, default=str)
+            with open(os.path.join(acc_json_dir, f'accuracy_{scale}.json'), 'w') as f:
+                json.dump(acc_stats, f, indent=2, default=str)
+
+            # Cleanup
+            del sample_records
+            extractor.cleanup()
+
+        except Exception as e:
+            logger.error(f"Failed to process {args.model_type} - {scale}: {e}")
+            import traceback
+            traceback.print_exc()
+            continue
+
+    # Cross-scale comparisons
+    for name, data, subdir in [
+        ('correct-only', cross_scale_correct, 'cross_scale_correct_only'),
+        ('incorrect-only', cross_scale_incorrect, 'cross_scale_incorrect_only'),
+        ('all-samples', cross_scale_all, 'cross_scale_all_samples'),
+    ]:
+        if len(data) > 1:
+            logger.info(f"\n--- Cross-scale comparison ({name}) ---")
+            plot_cross_scale_trajectories(
+                data, args.model_type,
+                os.path.join(comparison_dir, f'{subdir}.png')
+            )
+            plot_similarity_evolution_heatmap(
+                data, args.model_type,
+                os.path.join(comparison_dir, f'evolution_heatmap_{subdir.replace("cross_scale_", "")}.png')
+            )
+
+    if accuracy_records:
+        os.makedirs(os.path.join(accuracy_dir, 'csv'), exist_ok=True)
+        pd.DataFrame(accuracy_records).to_csv(os.path.join(accuracy_dir, 'csv', 'accuracy_summary.csv'), index=False)
+        # accuracy_chart.png is only written in merge mode (where all scales are present).
+        # Writing it here (single-scale run) would overwrite the multi-scale merge chart
+        # with a single-scale version whenever any individual scale is re-run.
+
+    if ablation_data:
+        os.makedirs(os.path.join(comparison_dir, 'csv'), exist_ok=True)
+        pd.DataFrame(ablation_data).to_csv(os.path.join(comparison_dir, 'csv', 'ablation_summary.csv'), index=False)
+        plot_ablation_summary(ablation_data, args.model_type,
+                              os.path.join(comparison_dir, 'ablation_summary.png'))
+
+    if all_results:
+        os.makedirs(os.path.join(output_dir, 'csv'), exist_ok=True)
+        pd.DataFrame(all_results).to_csv(os.path.join(output_dir, 'csv', 'results_summary.csv'), index=False)
+
+    logger.info(f"\n{'='*60}")
+    logger.info("=== Analysis Complete ===")
+    logger.info(f"Results saved to: {output_dir}")
+    logger.info(f"{'='*60}")
+
+
+if __name__ == '__main__':
+    main()

correct_filter/norm_analysis.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python3
+"""
+Norm Analysis: Testing the "Neutral Zone Collapse" Hypothesis
+
+Hypothesis: Incorrect samples have higher inter-category cosine similarity NOT
+because they carry the opposite category's features, but because their spatial
+feature extraction failed — causing hidden states to collapse toward a neutral
+(text-bias) region with smaller norms.
+
+Verification: Compare L2 norms of hidden states between correct and incorrect
+samples per category and layer. If incorrect samples have systematically lower
+norms, it supports the "collapse to neutral zone" explanation.
+
+Reads: results/{model_type}/accuracy/norms_{scale}.csv
+       (produced by correct_filter_analysis.py)
+Writes: results/{model_type}/norm_analysis/
+"""
+
+import os
+import argparse
+import glob
+import logging
+
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import seaborn as sns
+from scipy import stats
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+CATEGORY_ORDER = ['left', 'right', 'above', 'under', 'far', 'close']
+SCALE_ORDER = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']
+SCALE_COLORS = {
+    'vanilla': '#1f77b4', '80k': '#ff7f0e', '400k': '#2ca02c',
+    '800k': '#d62728', '2m': '#9467bd', 'roborefer': '#8c564b',
+}
+
+
+def load_norms(results_dir, model_type):
+    """Load all norms_{scale}.csv files for a model."""
+    csv_dir = os.path.join(results_dir, model_type, 'accuracy', 'csv')
+    all_dfs = []
+    for path in sorted(glob.glob(os.path.join(csv_dir, 'norms_*.csv'))):
+        df = pd.read_csv(path)
+        all_dfs.append(df)
+        logger.info(f"Loaded {path}: {len(df)} samples")
+    if not all_dfs:
+        raise FileNotFoundError(f"No norms_*.csv found in {csv_dir}")
+    return pd.concat(all_dfs, ignore_index=True)
+
+
+def get_layer_columns(df):
+    """Extract sorted layer columns from dataframe."""
+    cols = [c for c in df.columns if c.startswith('norm_L')]
+    return sorted(cols, key=lambda c: int(c.replace('norm_L', '')))
+
+
+def get_layer_index(col):
+    return int(col.replace('norm_L', ''))
+
+
+# ============================================================================
+# Analysis 1: Per-layer norm comparison (correct vs incorrect)
+# ============================================================================
+
+def compute_norm_stats(df):
+    """Compute mean/std/median norm for correct vs incorrect, per category × scale × layer."""
+    layer_cols = get_layer_columns(df)
+    rows = []
+    for scale in df['scale'].unique():
+        for cat in CATEGORY_ORDER:
+            subset = df[(df['scale'] == scale) & (df['category'] == cat)]
+            for is_correct in [True, False]:
+                group = subset[subset['is_correct'] == is_correct]
+                if len(group) == 0:
+                    continue
+                label = 'correct' if is_correct else 'incorrect'
+                for col in layer_cols:
+                    norms = group[col].dropna().values
+                    if len(norms) == 0:
+                        continue
+                    rows.append({
+                        'scale': scale, 'category': cat, 'group': label,
+                        'layer': get_layer_index(col), 'n_samples': len(norms),
+                        'mean_norm': np.mean(norms), 'std_norm': np.std(norms),
+                        'median_norm': np.median(norms),
+                    })
+    return pd.DataFrame(rows)
+
+
+def compute_norm_ratios(norm_stats):
+    """Compute incorrect/correct norm ratio per category × scale × layer."""
+    rows = []
+    for (scale, cat, layer), grp in norm_stats.groupby(['scale', 'category', 'layer']):
+        correct = grp[grp['group'] == 'correct']
+        incorrect = grp[grp['group'] == 'incorrect']
+        if len(correct) == 0 or len(incorrect) == 0:
+            continue
+        c_mean = correct['mean_norm'].values[0]
+        i_mean = incorrect['mean_norm'].values[0]
+        if c_mean > 0:
+            rows.append({
+                'scale': scale, 'category': cat, 'layer': layer,
+                'correct_mean': c_mean, 'incorrect_mean': i_mean,
+                'ratio': i_mean / c_mean,
+                'diff': i_mean - c_mean,
+                'n_correct': int(correct['n_samples'].values[0]),
+                'n_incorrect': int(incorrect['n_samples'].values[0]),
+            })
+    return pd.DataFrame(rows)
+
+
+def stat_test_norms(df, scale, layer_col):
+    """Mann-Whitney U test: are incorrect norms significantly different from correct?"""
+    rows = []
+    subset = df[df['scale'] == scale]
+    for cat in CATEGORY_ORDER:
+        cat_data = subset[subset['category'] == cat]
+        correct = cat_data[cat_data['is_correct'] == True][layer_col].dropna().values
+        incorrect = cat_data[cat_data['is_correct'] == False][layer_col].dropna().values
+        if len(correct) < 5 or len(incorrect) < 5:
+            continue
+        u_stat, p_val = stats.mannwhitneyu(correct, incorrect, alternative='two-sided')
+        # Effect size: rank-biserial correlation
+        n1, n2 = len(correct), len(incorrect)
+        r = 1 - (2 * u_stat) / (n1 * n2)
+        rows.append({
+            'category': cat, 'n_correct': n1, 'n_incorrect': n2,
+            'correct_mean': np.mean(correct), 'incorrect_mean': np.mean(incorrect),
+            'U_stat': u_stat, 'p_value': p_val, 'effect_size_r': r,
+            'significant': p_val < 0.05,
+        })
+    return pd.DataFrame(rows)
+
+
+# ============================================================================
+# Plots
+# ============================================================================
+
+def plot_norm_trajectory(norm_stats, scale, model_type, save_path):
+    """Per-scale: mean norm across layers, correct vs incorrect, per category."""
+    data = norm_stats[norm_stats['scale'] == scale]
+    if data.empty:
+        return
+
+    fig, axes = plt.subplots(2, 3, figsize=(18, 10), sharex=True)
+    fig.suptitle(f'{model_type} — {scale}: Hidden State L2 Norm by Layer\n'
+                 f'(Solid=correct, Dashed=incorrect)', fontsize=14)
+
+    for idx, cat in enumerate(CATEGORY_ORDER):
+        ax = axes[idx // 3][idx % 3]
+        for group, style in [('correct', '-'), ('incorrect', '--')]:
+            subset = data[(data['category'] == cat) & (data['group'] == group)]
+            if subset.empty:
+                continue
+            subset = subset.sort_values('layer')
+            ax.plot(subset['layer'], subset['mean_norm'], style,
+                    label=f'{group} (n={subset["n_samples"].iloc[0]})', linewidth=1.5)
+            ax.fill_between(
+                subset['layer'],
+                subset['mean_norm'] - subset['std_norm'],
+                subset['mean_norm'] + subset['std_norm'],
+                alpha=0.15,
+            )
+        ax.set_title(cat, fontsize=12)
+        ax.set_xlabel('Layer')
+        ax.set_ylabel('L2 Norm')
+        ax.legend(fontsize=8)
+        ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=200, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved: {save_path}")
+
+
+def plot_norm_ratio_trajectory(norm_ratios, scale, model_type, save_path):
+    """Per-scale: incorrect/correct norm ratio across layers, all 6 categories."""
+    data = norm_ratios[norm_ratios['scale'] == scale].sort_values('layer')
+    if data.empty:
+        return
+
+    fig, ax = plt.subplots(figsize=(12, 6))
+    for cat in CATEGORY_ORDER:
+        subset = data[data['category'] == cat]
+        if subset.empty:
+            continue
+        ax.plot(subset['layer'], subset['ratio'], label=cat, linewidth=1.5)
+
+    ax.axhline(y=1.0, color='black', linestyle=':', alpha=0.5, label='ratio=1 (equal)')
+    ax.set_title(f'{model_type} — {scale}: Incorrect/Correct Norm Ratio by Layer', fontsize=13)
+    ax.set_xlabel('Layer')
+    ax.set_ylabel('Norm Ratio (incorrect / correct)')
+    ax.legend(fontsize=9)
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=200, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved: {save_path}")
+
+
+def plot_cross_scale_norm_ratio(norm_ratios, model_type, save_path):
+    """Cross-scale: norm ratio at representative layers, all categories averaged."""
+    if norm_ratios.empty:
+        return
+
+    layers = sorted(norm_ratios['layer'].unique())
+    n_layers = len(layers)
+    # Pick 5 representative layers
+    rep_indices = [0, n_layers // 4, n_layers // 2, 3 * n_layers // 4, n_layers - 1]
+    rep_layers = sorted(set(layers[i] for i in rep_indices))
+
+    available_scales = [s for s in SCALE_ORDER if s in norm_ratios['scale'].unique()]
+
+    fig, axes = plt.subplots(1, len(rep_layers), figsize=(4 * len(rep_layers), 5), sharey=True)
+    if len(rep_layers) == 1:
+        axes = [axes]
+
+    for ax, layer in zip(axes, rep_layers):
+        layer_data = norm_ratios[norm_ratios['layer'] == layer]
+        # Grouped bar: x=category, color=scale
+        x = np.arange(len(CATEGORY_ORDER))
+        width = 0.8 / max(len(available_scales), 1)
+        for si, scale in enumerate(available_scales):
+            vals = []
+            for cat in CATEGORY_ORDER:
+                row = layer_data[(layer_data['scale'] == scale) & (layer_data['category'] == cat)]
+                vals.append(row['ratio'].values[0] if len(row) > 0 else np.nan)
+            ax.bar(x + si * width, vals, width, label=scale,
+                   color=SCALE_COLORS.get(scale, '#999999'), alpha=0.8)
+
+        ax.axhline(y=1.0, color='black', linestyle=':', alpha=0.5)
+        ax.set_title(f'Layer {layer}', fontsize=11)
+        ax.set_xticks(x + width * (len(available_scales) - 1) / 2)
+        ax.set_xticklabels(CATEGORY_ORDER, rotation=45, fontsize=9)
+        ax.set_ylabel('Norm Ratio (incorr / corr)' if ax == axes[0] else '')
+        ax.grid(True, alpha=0.2, axis='y')
+
+    axes[-1].legend(fontsize=8, bbox_to_anchor=(1.02, 1), loc='upper left')
+    fig.suptitle(f'{model_type}: Incorrect/Correct Norm Ratio Across Scales', fontsize=13, y=1.02)
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=200, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved: {save_path}")
+
+
+def plot_overall_norm_comparison(norm_stats, model_type, save_path):
+    """Aggregate across categories: mean norm trajectory for correct vs incorrect, per scale."""
+    available_scales = [s for s in SCALE_ORDER if s in norm_stats['scale'].unique()]
+    if not available_scales:
+        return
+
+    fig, ax = plt.subplots(figsize=(12, 6))
+
+    for scale in available_scales:
+        color = SCALE_COLORS.get(scale, '#999999')
+        for group, style, alpha in [('correct', '-', 1.0), ('incorrect', '--', 0.7)]:
+            subset = norm_stats[(norm_stats['scale'] == scale) & (norm_stats['group'] == group)]
+            if subset.empty:
+                continue
+            agg = subset.groupby('layer')['mean_norm'].mean().reset_index()
+            agg = agg.sort_values('layer')
+            ax.plot(agg['layer'], agg['mean_norm'], style,
+                    color=color, alpha=alpha, linewidth=1.5,
+                    label=f'{scale} ({group})')
+
+    ax.set_title(f'{model_type}: Mean Norm (averaged across categories)\n'
+                 f'Solid=correct, Dashed=incorrect', fontsize=13)
+    ax.set_xlabel('Layer')
+    ax.set_ylabel('Mean L2 Norm')
+    ax.legend(fontsize=8, ncol=2, bbox_to_anchor=(1.02, 1), loc='upper left')
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=200, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved: {save_path}")
+
+
+def plot_stat_test_heatmap(df_raw, model_type, out_dir):
+    """For each scale, run stat tests at representative layers and plot a summary heatmap."""
+    layer_cols = get_layer_columns(df_raw)
+    layers = [get_layer_index(c) for c in layer_cols]
+    n_layers = len(layers)
+    rep_indices = [0, n_layers // 4, n_layers // 2, 3 * n_layers // 4, n_layers - 1]
+    rep_layers = sorted(set(layers[i] for i in rep_indices))
+
+    available_scales = [s for s in SCALE_ORDER if s in df_raw['scale'].unique()]
+
+    for scale in available_scales:
+        all_test_rows = []
+        for layer in rep_layers:
+            col = f'norm_L{layer}'
+            if col not in df_raw.columns:
+                continue
+            test_df = stat_test_norms(df_raw, scale, col)
+            if test_df.empty:
+                continue
+            test_df['layer'] = layer
+            all_test_rows.append(test_df)
+
+        if not all_test_rows:
+            continue
+        test_results = pd.concat(all_test_rows, ignore_index=True)
+        test_results.to_csv(os.path.join(out_dir, f'stat_tests_{scale}.csv'), index=False)
+
+        # Heatmap of effect sizes
+        pivot = test_results.pivot_table(
+            index='category', columns='layer', values='effect_size_r',
+        )
+        pivot = pivot.reindex(index=CATEGORY_ORDER)
+
+        fig, ax = plt.subplots(figsize=(max(6, len(rep_layers) * 1.5), 5))
+        sns.heatmap(pivot, annot=True, fmt='.2f', center=0, cmap='RdBu_r',
+                    vmin=-1, vmax=1, ax=ax, linewidths=0.5)
+
+        # Mark significant cells
+        for i, cat in enumerate(pivot.index):
+            for j, layer in enumerate(pivot.columns):
+                row = test_results[(test_results['category'] == cat) & (test_results['layer'] == layer)]
+                if len(row) > 0 and row.iloc[0]['significant']:
+                    ax.text(j + 0.5, i + 0.85, '*', ha='center', va='center',
+                            fontsize=14, fontweight='bold', color='black')
+
+        ax.set_title(f'{model_type} — {scale}: Norm Effect Size (rank-biserial r)\n'
+                     f'Positive r = correct > incorrect. * = p<0.05', fontsize=11)
+        plt.tight_layout()
+        plt.savefig(os.path.join(out_dir, f'effect_size_heatmap_{scale}.png'),
+                    dpi=200, bbox_inches='tight')
+        plt.close()
+        logger.info(f"Saved effect size heatmap: {scale}")
+
+
+# ============================================================================
+# Summary
+# ============================================================================
+
+def generate_summary(norm_ratios, df_raw, model_type, out_dir):
+    """Generate a text summary of findings."""
+    layer_cols = get_layer_columns(df_raw)
+    layers = [get_layer_index(c) for c in layer_cols]
+    # Use last-quarter layer as representative
+    rep_layer = layers[3 * len(layers) // 4]
+
+    lines = [f"=== Norm Analysis Summary: {model_type} ===", ""]
+    lines.append("Hypothesis: Incorrect samples collapse to a neutral zone (lower norms)")
+    lines.append(f"Representative layer: L{rep_layer}")
+    lines.append("")
+
+    available_scales = [s for s in SCALE_ORDER if s in norm_ratios['scale'].unique()]
+    for scale in available_scales:
+        data = norm_ratios[(norm_ratios['scale'] == scale) & (norm_ratios['layer'] == rep_layer)]
+        if data.empty:
+            continue
+        lines.append(f"--- {scale} (L{rep_layer}) ---")
+        n_lower = 0
+        for _, row in data.iterrows():
+            direction = "LOWER" if row['ratio'] < 1.0 else "higher"
+            if row['ratio'] < 1.0:
+                n_lower += 1
+            lines.append(
+                f"  {row['category']:>6s}: ratio={row['ratio']:.3f} "
+                f"(correct={row['correct_mean']:.1f}, incorrect={row['incorrect_mean']:.1f}) "
+                f"-> incorrect is {direction}"
+            )
+        lines.append(f"  => {n_lower}/{len(data)} categories have lower incorrect norms")
+        lines.append("")
+
+    # Stat test at rep layer
+    col = f'norm_L{rep_layer}'
+    if col in df_raw.columns:
+        lines.append(f"--- Statistical Tests (Mann-Whitney U) at L{rep_layer} ---")
+        for scale in available_scales:
+            test_df = stat_test_norms(df_raw, scale, col)
+            if test_df.empty:
+                continue
+            n_sig = test_df['significant'].sum()
+            lines.append(f"  {scale}: {n_sig}/{len(test_df)} categories significant (p<0.05)")
+            for _, row in test_df.iterrows():
+                sig = "*" if row['significant'] else " "
+                lines.append(
+                    f"    {sig} {row['category']:>6s}: p={row['p_value']:.4f}, "
+                    f"r={row['effect_size_r']:+.3f} "
+                    f"(corr={row['correct_mean']:.1f}, incorr={row['incorrect_mean']:.1f})"
+                )
+        lines.append("")
+
+    summary_text = "\n".join(lines)
+    summary_path = os.path.join(out_dir, 'summary.txt')
+    with open(summary_path, 'w') as f:
+        f.write(summary_text)
+    logger.info(f"Saved summary: {summary_path}")
+    print(summary_text)
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(description='Norm Analysis: Neutral Zone Collapse Hypothesis')
+    parser.add_argument('--model_type', type=str, required=True, choices=['molmo', 'nvila', 'qwen'])
+    parser.add_argument('--results_dir', type=str,
+                        default='/data/shared/Qwen/experiments/correct_filter/results')
+    args = parser.parse_args()
+
+    out_dir = os.path.join(args.results_dir, args.model_type, 'norm_analysis')
+    os.makedirs(out_dir, exist_ok=True)
+
+    # Load data
+    logger.info(f"Loading norms for {args.model_type}...")
+    df = load_norms(args.results_dir, args.model_type)
+    logger.info(f"Total samples: {len(df)}")
+    logger.info(f"Scales: {sorted(df['scale'].unique())}")
+    logger.info(f"Correct: {df['is_correct'].sum()}, Incorrect: {(~df['is_correct']).sum()}")
+
+    # Compute stats
+    logger.info("\nComputing norm statistics...")
+    norm_stats = compute_norm_stats(df)
+    norm_stats.to_csv(os.path.join(out_dir, 'norm_stats.csv'), index=False)
+
+    norm_ratios = compute_norm_ratios(norm_stats)
+    norm_ratios.to_csv(os.path.join(out_dir, 'norm_ratios.csv'), index=False)
+
+    # Per-scale plots
+    available_scales = [s for s in SCALE_ORDER if s in df['scale'].unique()]
+    for scale in available_scales:
+        plot_norm_trajectory(norm_stats, scale, args.model_type,
+                            os.path.join(out_dir, f'norm_trajectory_{scale}.png'))
+        plot_norm_ratio_trajectory(norm_ratios, scale, args.model_type,
+                                  os.path.join(out_dir, f'norm_ratio_{scale}.png'))
+
+    # Cross-scale plots
+    plot_cross_scale_norm_ratio(norm_ratios, args.model_type,
+                                os.path.join(out_dir, 'cross_scale_norm_ratio.png'))
+    plot_overall_norm_comparison(norm_stats, args.model_type,
+                                os.path.join(out_dir, 'overall_norm_comparison.png'))
+
+    # Statistical tests + effect size heatmaps
+    plot_stat_test_heatmap(df, args.model_type, out_dir)
+
+    # Summary
+    generate_summary(norm_ratios, df, args.model_type, out_dir)
+
+    logger.info(f"\n=== Norm Analysis Complete ===\nResults in: {out_dir}")
+
+
+if __name__ == '__main__':
+    main()

correct_filter/run_molmo.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+set -e
+
+SCRIPT="/data/shared/Qwen/experiments/correct_filter/correct_filter_analysis.py"
+PYTHON="conda run --no-capture-output -n molmo python"
+MODEL="molmo"
+LOG_DIR="/data/shared/Qwen/experiments/correct_filter/logs/${MODEL}"
+mkdir -p "$LOG_DIR"
+
+# GPU plan: all 6 scripts run simultaneously
+# Molmo(25GB) shares GPU 0-4 with NVILA(8GB) = ~33GB each
+SCALES=("vanilla" "80k" "400k" "800k" "2m")
+GPUS=(0 1 2 3 4)
+
+echo "========================================="
+echo " Molmo Correct Filter: Launching ${#SCALES[@]} scales in parallel"
+echo "========================================="
+
+PIDS=()
+for i in "${!SCALES[@]}"; do
+    scale="${SCALES[$i]}"
+    gpu="${GPUS[$i]}"
+    log="${LOG_DIR}/${scale}.log"
+
+    echo "[GPU $gpu] $scale -> $log"
+    CUDA_VISIBLE_DEVICES=$gpu $PYTHON $SCRIPT \
+        --model_type $MODEL \
+        --scales $scale \
+        --device cuda \
+        --no-auto-roborefer \
+        > "$log" 2>&1 &
+    PIDS+=($!)
+done
+
+echo ""
+echo "Waiting for all ${#PIDS[@]} processes..."
+FAILED=0
+for i in "${!PIDS[@]}"; do
+    pid="${PIDS[$i]}"
+    scale="${SCALES[$i]}"
+    if wait $pid; then
+        echo "[DONE] $scale (PID $pid) - SUCCESS"
+    else
+        echo "[FAIL] $scale (PID $pid) - EXIT CODE $?"
+        FAILED=$((FAILED + 1))
+    fi
+done
+
+if [ $FAILED -gt 0 ]; then
+    echo "WARNING: $FAILED scale(s) failed. Check logs in $LOG_DIR"
+fi
+
+echo "========================================="
+echo " Molmo Correct Filter: Running merge"
+echo "========================================="
+$PYTHON $SCRIPT --model_type $MODEL --merge --scales vanilla 80k 400k 800k 2m \
+    2>&1 | tee "${LOG_DIR}/merge.log"
+
+echo "ALL DONE: $MODEL"

correct_filter/run_nvila.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+set -e
+
+SCRIPT="/data/shared/Qwen/experiments/correct_filter/correct_filter_analysis.py"
+PYTHON="conda run --no-capture-output -n vila python"
+MODEL="nvila"
+RESULTS_BASE="/data/shared/Qwen/experiments/correct_filter/results"
+LOG_DIR="/data/shared/Qwen/experiments/correct_filter/logs/${MODEL}"
+mkdir -p "$LOG_DIR"
+
+# GPU plan: NVILA(8GB) shares GPU 0-4 with Molmo(25GB), GPU 5 with Qwen vanilla(10GB)
+SCALES=("vanilla" "80k" "400k" "800k" "2m" "roborefer")
+GPUS=(0 1 2 3 4 5)
+
+echo "========================================="
+echo " NVILA Correct Filter: Launching ${#SCALES[@]} scales in parallel"
+echo "========================================="
+
+PIDS=()
+for i in "${!SCALES[@]}"; do
+    scale="${SCALES[$i]}"
+    gpu="${GPUS[$i]}"
+    log="${LOG_DIR}/${scale}.log"
+
+    echo "[GPU $gpu] $scale -> $log"
+    CUDA_VISIBLE_DEVICES=$gpu $PYTHON $SCRIPT \
+        --model_type $MODEL \
+        --scales $scale \
+        --device cuda \
+        --no-auto-roborefer \
+        > "$log" 2>&1 &
+    PIDS+=($!)
+done
+
+echo ""
+echo "Waiting for all ${#PIDS[@]} processes..."
+FAILED=0
+for i in "${!PIDS[@]}"; do
+    pid="${PIDS[$i]}"
+    scale="${SCALES[$i]}"
+    if wait $pid; then
+        echo "[DONE] $scale (PID $pid) - SUCCESS"
+    else
+        echo "[FAIL] $scale (PID $pid) - EXIT CODE $?"
+        FAILED=$((FAILED + 1))
+    fi
+done
+
+if [ $FAILED -gt 0 ]; then
+    echo "WARNING: $FAILED scale(s) failed. Check logs in $LOG_DIR"
+fi
+
+echo "========================================="
+echo " NVILA Correct Filter: Merge 1/2 (without roborefer)"
+echo "========================================="
+$PYTHON $SCRIPT --model_type $MODEL --merge \
+    --scales vanilla 80k 400k 800k 2m \
+    2>&1 | tee "${LOG_DIR}/merge.log"
+
+echo "========================================="
+echo " NVILA Correct Filter: Merge 2/2 (with roborefer)"
+echo "========================================="
+$PYTHON $SCRIPT --model_type $MODEL --merge \
+    --scales vanilla 80k 400k 800k 2m roborefer \
+    --merge-output-dir "${RESULTS_BASE}/nvila_with_roborefer" \
+    2>&1 | tee "${LOG_DIR}/merge_with_roborefer.log"
+
+echo "ALL DONE: $MODEL"
+echo "Results (no roborefer): ${RESULTS_BASE}/nvila/"
+echo "Results (with roborefer): ${RESULTS_BASE}/nvila_with_roborefer/"

correct_filter/run_qwen.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+set -e
+
+SCRIPT="/data/shared/Qwen/experiments/correct_filter/correct_filter_analysis.py"
+PYTHON="/usr/bin/python3"
+MODEL="qwen"
+LOG_DIR="/data/shared/Qwen/experiments/correct_filter/logs/${MODEL}"
+mkdir -p "$LOG_DIR"
+
+# GPU plan: Qwen(10GB) on GPU 5-7, sharing with NVILA roborefer on GPU 5
+# GPU 6,7 each host 2 Qwen scales (20GB each, well within 80GB)
+SCALES=("vanilla" "80k" "400k" "800k" "2m")
+GPUS=(5 6 6 7 7)
+
+echo "========================================="
+echo " Qwen Correct Filter: Launching ${#SCALES[@]} scales in parallel"
+echo "========================================="
+
+PIDS=()
+for i in "${!SCALES[@]}"; do
+    scale="${SCALES[$i]}"
+    gpu="${GPUS[$i]}"
+    log="${LOG_DIR}/${scale}.log"
+
+    echo "[GPU $gpu] $scale -> $log"
+    CUDA_VISIBLE_DEVICES=$gpu $PYTHON $SCRIPT \
+        --model_type $MODEL \
+        --scales $scale \
+        --device cuda \
+        --no-auto-roborefer \
+        > "$log" 2>&1 &
+    PIDS+=($!)
+done
+
+echo ""
+echo "Waiting for all ${#PIDS[@]} processes..."
+FAILED=0
+for i in "${!PIDS[@]}"; do
+    pid="${PIDS[$i]}"
+    scale="${SCALES[$i]}"
+    if wait $pid; then
+        echo "[DONE] $scale (PID $pid) - SUCCESS"
+    else
+        echo "[FAIL] $scale (PID $pid) - EXIT CODE $?"
+        FAILED=$((FAILED + 1))
+    fi
+done
+
+if [ $FAILED -gt 0 ]; then
+    echo "WARNING: $FAILED scale(s) failed. Check logs in $LOG_DIR"
+fi
+
+echo "========================================="
+echo " Qwen Correct Filter: Running merge"
+echo "========================================="
+$PYTHON $SCRIPT --model_type $MODEL --merge --scales vanilla 80k 400k 800k 2m \
+    2>&1 | tee "${LOG_DIR}/merge.log"
+
+echo "ALL DONE: $MODEL"

exp2a_correct_filter/exp2a_correct_filter_analysis.py

@@ -0,0 +1,1825 @@
+"""
+Experiment 2-A (Correct Filter): Correctness-Filtered Representation Analysis
+
+Extends exp2a_modified by:
+- Generating model predictions to determine correctness
+- Filtering samples into correct/incorrect groups with balanced sampling
+- Running similarity analysis on each group separately
+- Recording per-scale, per-category accuracy
+- Comparing correct-only vs incorrect-only vs all to check whether
+  scaling effects on similarity are genuine or just accuracy-driven
+
+Balanced sampling: within each group (correct/incorrect), all 6 categories
+have the same number of samples, rounded down to the nearest multiple of 50.
+"""
+
+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.pyplot as plt
+import seaborn as sns
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Category order for output
+CATEGORY_ORDER = ['left', 'right', 'above', 'under', 'far', 'close']
+
+# Opposite map for answer matching
+OPPOSITE_MAP = {
+    'left': 'right', 'right': 'left',
+    'above': 'under', 'under': 'above',
+    'far': 'close', 'close': 'far',
+}
+
+# Pair definitions for trajectory analysis
+TRAJECTORY_PAIRS = {
+    'hypothesis': [
+        ('above', 'far', 'above-far', '#d62728'),      # red
+        ('under', 'close', 'under-close', '#1f77b4'),   # blue
+    ],
+    'within_axis': [
+        ('left', 'right', 'left-right', '#2ca02c'),     # green
+        ('above', 'under', 'above-under', '#ff7f0e'),   # orange
+        ('far', 'close', 'far-close', '#9467bd'),       # purple
+    ],
+    'counter_hypothesis': [
+        ('above', 'close', 'above-close', '#e377c2'),   # pink
+        ('under', 'far', 'under-far', '#17becf'),       # cyan
+    ],
+}
+
+# Scale colors for cross-scale plots
+SCALE_COLORS = {
+    'vanilla': '#1f77b4',
+    '80k': '#ff7f0e',
+    '400k': '#2ca02c',
+    '800k': '#d62728',
+    '2m': '#9467bd',
+    'roborefer': '#8c564b',
+}
+
+
+# ============================================================================
+# Data Loading & Modification (same as exp2a_modified)
+# ============================================================================
+
+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 modify_pairwise_sample(sample: dict) -> dict:
+    obj1, obj2 = extract_objects(sample['question'])
+    category = sample['category']
+
+    if category in ['left', 'right']:
+        new_question = f"Is the {obj1} to the left or right of the {obj2}?"
+    else:  # above, under
+        new_question = f"Is the {obj1} above or under the {obj2}?"
+
+    return {
+        'index': sample['index'],
+        'image_base64': sample['image_base64'],
+        'question': new_question,
+        'answer': category,
+        'category': category,
+    }
+
+
+def modify_distance_sample(sample: dict, rng: random.Random) -> dict:
+    category = sample['category']
+    answer_key = sample['answer']
+    options = sample['options']
+
+    target_object = options[answer_key]
+    candidates = [v for k, v in options.items() if k != answer_key]
+    reference_object = rng.choice(candidates)
+
+    new_question = f"Compared to {reference_object}, is {target_object} far or close from you?"
+
+    return {
+        'index': sample['index'],
+        'image_base64': sample['image_base64'],
+        'question': new_question,
+        'answer': category,
+        'category': category,
+    }
+
+
+def load_and_modify_data(
+    tsv_path: str,
+    seed: int = 42
+) -> Dict[str, List[dict]]:
+    """Load ALL samples (no per-category limit) to maximize data for correct/incorrect filtering."""
+    rng = random.Random(seed)
+    np.random.seed(seed)
+
+    df = pd.read_csv(tsv_path, sep='\t')
+
+    raw_grouped = defaultdict(list)
+    for _, row in df.iterrows():
+        category = row['category']
+        sample = {
+            'index': row['index'],
+            'image_base64': row['image'],
+            'question': row['question'],
+            'answer': row['answer'],
+            'category': category,
+            'options': {
+                'A': row['A'],
+                'B': row['B'],
+                'C': row['C'],
+                'D': row['D']
+            }
+        }
+        raw_grouped[category].append(sample)
+
+    modified_data = defaultdict(list)
+    stats = {'total': 0, 'success': 0, 'failed': 0}
+
+    for category in CATEGORY_ORDER:
+        samples = raw_grouped[category]
+
+        for sample in samples:
+            stats['total'] += 1
+            try:
+                if category in ['left', 'right', 'above', 'under']:
+                    modified = modify_pairwise_sample(sample)
+                else:
+                    modified = modify_distance_sample(sample, rng)
+
+                assert modified['answer'] == modified['category']
+                modified_data[category].append(modified)
+                stats['success'] += 1
+            except Exception as e:
+                stats['failed'] += 1
+                logger.warning(f"  Failed to modify sample {sample['index']}: {e}")
+
+    logger.info(f"Data modification: {stats['success']}/{stats['total']} success, {stats['failed']} failed")
+    for cat in CATEGORY_ORDER:
+        if cat in modified_data:
+            logger.info(f"  {cat}: {len(modified_data[cat])} samples")
+            ex = modified_data[cat][0]
+            logger.info(f"    Example Q: {ex['question']}")
+            logger.info(f"    Example A: {ex['answer']}")
+
+    return dict(modified_data)
+
+
+def decode_base64_image(base64_str: str) -> Image.Image:
+    image_data = base64.b64decode(base64_str)
+    return Image.open(BytesIO(image_data)).convert('RGB')
+
+
+# ============================================================================
+# Answer Matching
+# ============================================================================
+
+def check_answer(generated_text: str, expected_category: str) -> bool:
+    """Check if model's generated text matches the expected category.
+
+    Finds which of the two options (expected vs opposite) appears first.
+    """
+    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
+
+
+# ============================================================================
+# Base Extractor (modified: prefill-only hooks + extract_and_predict)
+# ============================================================================
+
+class BaseHiddenStateExtractor(ABC):
+    """Base class for extracting hidden states from VLMs."""
+
+    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 layers (0..{num_layers-1})")
+        else:
+            self.target_layers = target_layers
+            logger.info(f"Model has {num_layers} layers. Target layers: {self.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)
+                logger.info(f"  Registered hook on layer {layer_idx}")
+
+    def _make_hook(self, layer_idx: int):
+        """Create a hook that only captures during prefill (seq_len > 1)."""
+        def hook_fn(module, input, output):
+            if isinstance(output, tuple):
+                hidden = output[0]
+            else:
+                hidden = output
+
+            # Only capture during prefill pass (seq_len > 1).
+            # During autoregressive generation, each step has seq_len = 1.
+            if hidden.shape[1] > 1:
+                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]:
+        """Extract hidden states AND generate predicted answer in one pass.
+
+        Returns:
+            (hidden_states, predicted_answer_text)
+        """
+        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
+
+        config_path = os.path.join(self.model_path, "config.yaml")
+        checkpoint_path = os.path.join(self.model_path, "model.pt")
+
+        cfg = ModelConfig.load(config_path, key="model", validate_paths=False)
+        cfg.init_device = "cpu"
+
+        self.model = NativeMolmoModel(cfg)
+        state_dict = torch.load(checkpoint_path, 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 model 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
+        )
+        self.model.eval()
+
+        self.processor = AutoProcessor.from_pretrained(
+            self.model_path,
+            trust_remote_code=True
+        )
+        logger.info(f"Loaded HuggingFace Molmo model from {self.model_path}")
+
+    def _get_num_layers(self) -> int:
+        if self.is_native:
+            return len(self.model.transformer.blocks)
+        else:
+            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]
+        else:
+            return self.model.model.transformer.blocks[layer_idx]
+
+    def extract_and_predict(self, image: Image.Image, question: str) -> Tuple[Dict[int, torch.Tensor], str]:
+        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)
+            image_np = np.array(image)
+            batch = self.preprocessor(image_np, 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_tensor(x):
+                if isinstance(x, np.ndarray):
+                    return torch.from_numpy(x)
+                return x
+
+            input_ids = to_tensor(batch['input_ids']).unsqueeze(0).to(self.device)
+            if input_ids.dtype not in [torch.long, torch.int64]:
+                input_ids = input_ids.long()
+
+            images_tensor = to_tensor(batch['images']).unsqueeze(0).to(self.device).to(dtype=torch.bfloat16)
+            image_masks = to_tensor(batch['image_masks']).unsqueeze(0).to(self.device).to(dtype=torch.bfloat16)
+            image_input_idx = to_tensor(batch['image_input_idx']).unsqueeze(0).to(self.device)
+
+            with torch.inference_mode():
+                with torch.autocast(device_type="cuda", enabled=True, dtype=torch.bfloat16):
+                    gen_output = self.model.generate(
+                        input_ids=input_ids,
+                        images=images_tensor,
+                        image_masks=image_masks,
+                        image_input_idx=image_input_idx,
+                        max_steps=20,
+                        beam_size=1,
+                    )
+
+            # gen_output.token_ids shape: (batch, beam, max_steps)
+            generated_ids = gen_output.token_ids[0, 0]  # first batch, first beam
+            answer = self.tokenizer.decode(generated_ids.tolist()).strip()
+            # Remove EOS tokens
+            for eos in ['<|endoftext|>', '</s>', '<|end|>']:
+                answer = answer.replace(eos, '').strip()
+
+        else:
+            from transformers import GenerationConfig
+
+            inputs = self.processor.process(images=[image], text=question)
+            processed_inputs = {}
+            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_inputs[k] = v
+
+            with torch.no_grad():
+                with torch.autocast(device_type="cuda", enabled=True, dtype=torch.bfloat16):
+                    output = self.model.generate_from_batch(
+                        processed_inputs,
+                        GenerationConfig(max_new_tokens=20, stop_strings="<|endoftext|>"),
+                        tokenizer=self.processor.tokenizer,
+                    )
+
+            input_len = processed_inputs['input_ids'].shape[1]
+            generated_tokens = output[0, input_len:]
+            answer = self.processor.tokenizer.decode(generated_tokens, 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 = [key for key in list(sys.modules.keys()) if 'llava' in key.lower()]
+        removed_modules = {}
+        for mod in modules_to_remove:
+            removed_modules[mod] = sys.modules.pop(mod)
+
+        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 mod, module in removed_modules.items():
+                sys.modules[mod] = module
+            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 model 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(('model.llm.model.layers', self.model.llm.model.layers))
+            if hasattr(self.model.llm, 'layers'):
+                candidates.append(('model.llm.layers', self.model.llm.layers))
+
+        if hasattr(self.model, 'model'):
+            if hasattr(self.model.model, 'model') and hasattr(self.model.model.model, 'layers'):
+                candidates.append(('model.model.model.layers', self.model.model.model.layers))
+            if hasattr(self.model.model, 'layers'):
+                candidates.append(('model.model.layers', 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((name, module))
+
+        if candidates:
+            path, layers = candidates[0]
+            logger.info(f"Found LLM layers at: {path} (num_layers={len(layers)})")
+            self.llm_backbone = layers
+            self.layers_path = path
+        else:
+            logger.error("Could not find transformer layers in model!")
+            for name, _ in list(self.model.named_modules())[:20]:
+                logger.info(f"  {name}")
+            raise ValueError("Could not locate transformer layers in NVILA model")
+
+    def _get_num_layers(self) -> int:
+        if hasattr(self, 'llm_backbone') and hasattr(self.llm_backbone, '__len__'):
+            return len(self.llm_backbone)
+        return 24
+
+    def _get_layer_module(self, layer_idx: int):
+        if hasattr(self, 'llm_backbone') and hasattr(self.llm_backbone, '__getitem__'):
+            module = self.llm_backbone[layer_idx]
+            logger.info(f"  Accessing layer {layer_idx}: {type(module).__name__}")
+            return module
+        logger.error(f"Cannot access layer {layer_idx} - llm_backbone not properly initialized")
+        return None
+
+    def extract_and_predict(self, image: Image.Image, question: str) -> Tuple[Dict[int, torch.Tensor], str]:
+        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
+            gen_config = GenerationConfig(max_new_tokens=20, do_sample=False)
+            response = self.model.generate_content(prompt, generation_config=gen_config)
+        finally:
+            os.unlink(temp_path)
+
+        if isinstance(response, list):
+            response = response[0]
+        answer = str(response).strip()
+
+        return self.hidden_states.copy(), answer
+
+
+# ============================================================================
+# RoboRefer Extractor (NVILA-based)
+# ============================================================================
+
+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 = [key for key in list(sys.modules.keys()) if 'llava' in key.lower()]
+        removed_modules = {}
+        for mod in modules_to_remove:
+            removed_modules[mod] = sys.modules.pop(mod)
+
+        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 mod, module in removed_modules.items():
+                sys.modules[mod] = module
+            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 model 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:
+            logger.info("accelerate not available, loading model without device_map...")
+            self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+                self.model_path,
+                torch_dtype=torch.bfloat16,
+            )
+            self.model = self.model.to(self.device)
+
+        self.model.eval()
+
+        if self.model_path.startswith('/'):
+            logger.info(f"Fine-tuned model detected, loading processor from base model: {self.BASE_MODEL}")
+            self.processor = AutoProcessor.from_pretrained(self.BASE_MODEL)
+        else:
+            self.processor = AutoProcessor.from_pretrained(self.model_path)
+        logger.info(f"Loaded Qwen2.5-VL model 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: Image.Image, question: str) -> Tuple[Dict[int, torch.Tensor], str]:
+        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"
+        )
+        inputs = inputs.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]
+        generated_ids = output_ids[0, input_len:]
+        answer = self.processor.tokenizer.decode(generated_ids, skip_special_tokens=True).strip()
+
+        return self.hidden_states.copy(), answer
+
+
+# ============================================================================
+# Factory Function
+# ============================================================================
+
+def get_extractor(model_type: str, model_path: str, scale: str = None, **kwargs) -> BaseHiddenStateExtractor:
+    if model_type == 'nvila' and scale == 'roborefer':
+        return RoboReferExtractor(model_path, **kwargs)
+
+    extractors = {
+        'molmo': MolmoExtractor,
+        'nvila': NVILAExtractor,
+        'qwen': Qwen25VLExtractor,
+    }
+    if model_type not in extractors:
+        raise ValueError(f"Unknown model type: {model_type}. Available: {list(extractors.keys())}")
+    return extractors[model_type](model_path, **kwargs)
+
+
+# ============================================================================
+# Extraction with Per-Sample Recording
+# ============================================================================
+
+def extract_all_with_predictions(
+    extractor: BaseHiddenStateExtractor,
+    data: Dict[str, List[dict]],
+) -> Dict[str, List[dict]]:
+    """Extract hidden states and predictions for all samples.
+
+    Returns:
+        sample_records: {category -> [{hidden_states: {layer: vec}, is_correct: bool, predicted: str, index: int}]}
+    """
+    sample_records = defaultdict(list)
+
+    for category in CATEGORY_ORDER:
+        if category not in data:
+            continue
+        samples = data[category]
+        logger.info(f"Processing category: {category} ({len(samples)} samples)")
+        success_count = 0
+
+        for sample in tqdm(samples, desc=f"  {category}"):
+            try:
+                image = decode_base64_image(sample['image_base64'])
+                hidden_states, predicted = extractor.extract_and_predict(image, sample['question'])
+
+                is_correct = check_answer(predicted, category)
+                mark = "O" if is_correct else "X"
+                tqdm.write(f"    [{mark}] #{sample['index']:<6} expected={category:<8} | predicted=\"{predicted[:80]}\"")
+
+                record = {
+                    'hidden_states': {},
+                    'is_correct': is_correct,
+                    'predicted': predicted,
+                    'index': sample['index'],
+                }
+
+                for layer_idx in extractor.target_layers:
+                    if layer_idx in hidden_states:
+                        state = hidden_states[layer_idx].numpy().flatten()
+                        if state.size > 0:
+                            record['hidden_states'][layer_idx] = state
+
+                if record['hidden_states']:
+                    sample_records[category].append(record)
+                    success_count += 1
+                else:
+                    logger.warning(f"    No hidden states for sample {sample['index']}")
+            except Exception as e:
+                logger.warning(f"    Error processing sample {sample['index']}: {e}")
+                continue
+
+        correct_n = sum(1 for r in sample_records[category] if r['is_correct'])
+        incorrect_n = sum(1 for r in sample_records[category] if not r['is_correct'])
+        acc = correct_n / (correct_n + incorrect_n) * 100 if (correct_n + incorrect_n) > 0 else 0
+        logger.info(f"  {category}: {success_count}/{len(samples)} extracted | "
+                     f"correct={correct_n}, incorrect={incorrect_n}, accuracy={acc:.1f}%")
+
+    # Log overall accuracy summary
+    total_correct = sum(1 for cat in sample_records for r in sample_records[cat] if r['is_correct'])
+    total_all = sum(len(sample_records[cat]) for cat in sample_records)
+    overall_acc = total_correct / total_all * 100 if total_all > 0 else 0
+    logger.info(f"\n  === Category Accuracy Summary ===")
+    for cat in CATEGORY_ORDER:
+        if cat in sample_records:
+            c = sum(1 for r in sample_records[cat] if r['is_correct'])
+            n = len(sample_records[cat])
+            a = c / n * 100 if n > 0 else 0
+            logger.info(f"    {cat:>6s}: {c:>4d}/{n:<4d} = {a:5.1f}%")
+    logger.info(f"    {'TOTAL':>6s}: {total_correct:>4d}/{total_all:<4d} = {overall_acc:5.1f}%")
+    logger.info(f"  ================================\n")
+
+    return dict(sample_records)
+
+
+# ============================================================================
+# Balanced Sampling
+# ============================================================================
+
+def compute_balanced_size(sample_records: Dict[str, List[dict]], filter_correct: bool) -> int:
+    """Find balanced sample size for all 6 categories.
+
+    Rounds down to nearest multiple of 50 when possible.
+    If min < 50 but > 0, uses the raw min (no rounding) to avoid skipping.
+    """
+    counts = []
+    for cat in CATEGORY_ORDER:
+        if cat not in sample_records:
+            return 0
+        n = sum(1 for s in sample_records[cat] if s['is_correct'] == filter_correct)
+        counts.append(n)
+
+    min_count = min(counts)
+    if min_count == 0:
+        return 0
+
+    balanced = (min_count // 50) * 50
+    if balanced == 0:
+        # Less than 50 available but still > 0 — use raw min
+        balanced = min_count
+
+    return balanced
+
+
+def balanced_sample_and_average(
+    sample_records: Dict[str, List[dict]],
+    filter_correct: bool,
+    n_samples: int,
+    target_layers: List[int],
+    seed: int = 42,
+) -> Dict[int, Dict[str, np.ndarray]]:
+    """Sample n_samples per category from filtered group and compute averages.
+
+    Returns:
+        {layer_idx -> {category -> averaged_vector}}
+    """
+    rng = random.Random(seed)
+
+    result = defaultdict(dict)
+
+    for category in CATEGORY_ORDER:
+        filtered = [s for s in sample_records[category] if s['is_correct'] == filter_correct]
+
+        if len(filtered) < n_samples:
+            logger.warning(f"  {category}: only {len(filtered)} samples, need {n_samples}")
+            continue
+
+        sampled = rng.sample(filtered, n_samples)
+
+        for layer_idx in target_layers:
+            vectors = []
+            for record in sampled:
+                if layer_idx in record['hidden_states']:
+                    vectors.append(record['hidden_states'][layer_idx])
+
+            if vectors:
+                result[layer_idx][category] = np.mean(vectors, axis=0)
+
+    return dict(result)
+
+
+# ============================================================================
+# Accuracy
+# ============================================================================
+
+def compute_accuracy_stats(
+    sample_records: Dict[str, List[dict]],
+    scale: str,
+    model_type: str,
+) -> dict:
+    """Compute per-category and overall accuracy."""
+    stats = {
+        'model': model_type,
+        'scale': scale,
+    }
+
+    total_correct = 0
+    total_count = 0
+
+    for cat in CATEGORY_ORDER:
+        records = sample_records.get(cat, [])
+        n = len(records)
+        correct = sum(1 for r in records if r['is_correct'])
+        acc = correct / n if n > 0 else 0.0
+
+        stats[f'{cat}_total'] = n
+        stats[f'{cat}_correct'] = correct
+        stats[f'{cat}_accuracy'] = acc
+
+        total_correct += correct
+        total_count += n
+
+    stats['overall_total'] = total_count
+    stats['overall_correct'] = total_correct
+    stats['overall_accuracy'] = total_correct / total_count if total_count > 0 else 0.0
+
+    return stats
+
+
+def save_per_sample_predictions(
+    sample_records: Dict[str, List[dict]],
+    scale: str,
+    save_path: str,
+):
+    """Save per-sample prediction details to CSV."""
+    rows = []
+    for cat in CATEGORY_ORDER:
+        for record in sample_records.get(cat, []):
+            rows.append({
+                'index': record['index'],
+                'category': cat,
+                'scale': scale,
+                'predicted': record['predicted'],
+                'expected': cat,
+                'is_correct': record['is_correct'],
+            })
+
+    df = pd.DataFrame(rows)
+    df.to_csv(save_path, index=False)
+    logger.info(f"Saved {len(rows)} per-sample predictions to {save_path}")
+
+
+# ============================================================================
+# Analysis Functions
+# ============================================================================
+
+def compute_similarity_matrix(
+    representations: Dict[str, np.ndarray]
+) -> pd.DataFrame:
+    available = [c for c in CATEGORY_ORDER if c in representations]
+    vectors = np.array([representations[cat] for cat in available])
+    sim_matrix = cosine_similarity(vectors)
+    return pd.DataFrame(sim_matrix, index=available, columns=available)
+
+
+def analyze_hypothesis(sim_df: pd.DataFrame, model_name: str) -> dict:
+    results = {'model': model_name}
+
+    pairs_to_check = {
+        'above_far': ('above', 'far'),
+        'under_close': ('under', 'close'),
+        'left_right': ('left', 'right'),
+    }
+
+    for pair_name, (cat1, cat2) in pairs_to_check.items():
+        if cat1 in sim_df.index and cat2 in sim_df.columns:
+            sim = sim_df.loc[cat1, cat2]
+            results[f'sim_{pair_name}'] = sim
+        else:
+            results[f'sim_{pair_name}'] = None
+
+    if results.get('sim_above_far') and results.get('sim_left_right'):
+        results['diff_above_far_vs_left_right'] = results['sim_above_far'] - results['sim_left_right']
+    if results.get('sim_under_close') and results.get('sim_left_right'):
+        results['diff_under_close_vs_left_right'] = results['sim_under_close'] - results['sim_left_right']
+
+    return results
+
+
+# ============================================================================
+# Visualization
+# ============================================================================
+
+def plot_similarity_heatmap(sim_df: pd.DataFrame, title: str, save_path: str):
+    plt.figure(figsize=(10, 8))
+    available_order = [c for c in CATEGORY_ORDER if c in sim_df.index]
+    sim_df_ordered = sim_df.loc[available_order, available_order]
+
+    sns.heatmap(
+        sim_df_ordered, annot=True, fmt='.4f', cmap='RdYlBu_r',
+        center=0.5, vmin=0, vmax=1, square=True, linewidths=0.5,
+        cbar_kws={'label': 'Cosine Similarity'}
+    )
+    plt.title(title, fontsize=14, fontweight='bold')
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved heatmap: {save_path}")
+
+
+def _extract_pair_trajectory(
+    all_layer_sims: Dict[int, pd.DataFrame],
+    cat1: str, cat2: str,
+) -> Tuple[List[int], List[float]]:
+    layers = sorted(all_layer_sims.keys())
+    valid_layers = []
+    values = []
+    for l in layers:
+        df = all_layer_sims[l]
+        if cat1 in df.index and cat2 in df.columns:
+            valid_layers.append(l)
+            values.append(df.loc[cat1, cat2])
+    return valid_layers, values
+
+
+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_similarity_trajectories(
+    all_layer_sims: Dict[int, pd.DataFrame],
+    title: str,
+    save_path: str,
+):
+    fig, axes = plt.subplots(1, 2, figsize=(20, 7))
+
+    ax = axes[0]
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, '-', color=color, label=label, linewidth=2.5, markersize=0)
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['within_axis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, '--', color=color, label=label, linewidth=1.8, markersize=0)
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['counter_hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, ':', color=color, label=label, linewidth=1.5, alpha=0.8)
+
+    ax.set_xlabel('Layer Index', fontsize=12)
+    ax.set_ylabel('Cosine Similarity', fontsize=12)
+    ax.set_title(f'{title}\nPairwise Similarity Across Layers', fontsize=13)
+    ax.legend(fontsize=9, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    ax = axes[1]
+    lr_layers, lr_vals = _extract_pair_trajectory(all_layer_sims, 'left', 'right')
+    lr_dict = dict(zip(lr_layers, lr_vals))
+
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, '-', color=color, label=f'{label} - left-right',
+                linewidth=2.5, markersize=0)
+
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['counter_hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, ':', color=color, label=f'{label} - left-right',
+                linewidth=1.5, alpha=0.8)
+
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['within_axis']:
+        if label == 'left-right':
+            continue
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, '--', color=color, label=f'{label} - left-right',
+                linewidth=1.5, alpha=0.7)
+
+    ax.axhline(y=0, color='gray', linestyle='-', linewidth=1, alpha=0.5)
+    ax.set_xlabel('Layer Index', fontsize=12)
+    ax.set_ylabel('Similarity Difference (pair - left-right)', fontsize=12)
+    ax.set_title(f'{title}\nRelative to Left-Right Baseline', fontsize=13)
+    ax.legend(fontsize=8, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved trajectory plot: {save_path}")
+
+
+def plot_cross_scale_trajectories(
+    cross_scale_data: Dict[str, Dict[int, pd.DataFrame]],
+    model_type: str,
+    save_path: str,
+):
+    pairs = [
+        ('above', 'far', 'above-far (hypothesis)'),
+        ('under', 'close', 'under-close (hypothesis)'),
+        ('left', 'right', 'left-right (control)'),
+    ]
+
+    fig, axes = plt.subplots(1, len(pairs), figsize=(7 * len(pairs), 6))
+    if len(pairs) == 1:
+        axes = [axes]
+
+    for idx, (cat1, cat2, label) in enumerate(pairs):
+        ax = axes[idx]
+        for scale in ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']:
+            if scale not in cross_scale_data:
+                continue
+            layer_sims = cross_scale_data[scale]
+            layers, vals = _extract_pair_trajectory(layer_sims, cat1, cat2)
+            color = SCALE_COLORS.get(scale, 'gray')
+            ax.plot(layers, vals, '-', color=color, label=scale, linewidth=2, markersize=0)
+
+        ax.set_xlabel('Layer Index', fontsize=12)
+        ax.set_ylabel('Cosine Similarity', fontsize=12)
+        ax.set_title(label, fontsize=13, fontweight='bold')
+        ax.legend(fontsize=10)
+        ax.grid(True, alpha=0.3)
+
+    fig.suptitle(
+        f'{model_type.upper()} - Similarity Trajectory 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 cross-scale trajectory: {save_path}")
+
+
+def plot_similarity_evolution_heatmap(
+    cross_scale_data: Dict[str, Dict[int, pd.DataFrame]],
+    model_type: str,
+    save_path: str,
+):
+    pairs = [
+        ('above', 'far', 'above-far'),
+        ('under', 'close', 'under-close'),
+        ('left', 'right', 'left-right'),
+        ('above', 'under', 'above-under'),
+        ('far', 'close', 'far-close'),
+    ]
+    scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']
+    available_scales = [s for s in scale_order if s in cross_scale_data]
+
+    first_scale = available_scales[0]
+    all_layers = sorted(cross_scale_data[first_scale].keys())
+
+    fig, axes = plt.subplots(len(pairs), 1, figsize=(max(14, len(all_layers) * 0.5), 3 * len(pairs)))
+    if len(pairs) == 1:
+        axes = [axes]
+
+    for idx, (cat1, cat2, label) in enumerate(pairs):
+        ax = axes[idx]
+        matrix = np.full((len(available_scales), len(all_layers)), np.nan)
+        for si, scale in enumerate(available_scales):
+            layer_sims = cross_scale_data[scale]
+            for li, layer in enumerate(all_layers):
+                if layer in layer_sims:
+                    df = layer_sims[layer]
+                    if cat1 in df.index and cat2 in df.columns:
+                        matrix[si, li] = df.loc[cat1, cat2]
+
+        im = ax.imshow(matrix, aspect='auto', cmap='RdYlBu_r', vmin=0.5, vmax=1.0)
+        ax.set_yticks(range(len(available_scales)))
+        ax.set_yticklabels(available_scales, fontsize=10)
+
+        step = max(1, len(all_layers) // 15)
+        ax.set_xticks(range(0, len(all_layers), step))
+        ax.set_xticklabels([str(all_layers[i]) for i in range(0, len(all_layers), step)], fontsize=8)
+
+        ax.set_title(label, fontsize=12, fontweight='bold')
+        ax.set_xlabel('Layer Index', fontsize=10)
+        fig.colorbar(im, ax=ax, label='Cosine Similarity', shrink=0.8)
+
+    fig.suptitle(
+        f'{model_type.upper()} - Similarity Evolution (Layer x Scale)',
+        fontsize=15, fontweight='bold', y=1.01
+    )
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved evolution heatmap: {save_path}")
+
+
+# ============================================================================
+# Comparison Visualizations (new for this experiment)
+# ============================================================================
+
+def plot_accuracy_chart(
+    accuracy_records: List[dict],
+    model_type: str,
+    save_path: str,
+):
+    """Bar chart of per-category accuracy across scales."""
+    fig, ax = plt.subplots(figsize=(14, 6))
+
+    scales = [r['scale'] for r in accuracy_records]
+    x = np.arange(len(CATEGORY_ORDER) + 1)  # +1 for overall
+    width = 0.8 / len(scales)
+
+    for i, record in enumerate(accuracy_records):
+        values = [record.get(f'{cat}_accuracy', 0) for cat in CATEGORY_ORDER]
+        values.append(record.get('overall_accuracy', 0))
+        offset = (i - len(scales) / 2 + 0.5) * width
+        color = SCALE_COLORS.get(record['scale'], 'gray')
+        bars = ax.bar(x + offset, values, width, label=record['scale'], color=color)
+
+        for bar, val in zip(bars, values):
+            if val > 0:
+                ax.annotate(
+                    f'{val:.0%}',
+                    xy=(bar.get_x() + bar.get_width() / 2, bar.get_height()),
+                    xytext=(0, 2), textcoords='offset points',
+                    ha='center', va='bottom', fontsize=6, rotation=90,
+                )
+
+    ax.set_ylabel('Accuracy')
+    ax.set_title(f'{model_type.upper()} - Per-Category Accuracy Across Scales', fontsize=14, fontweight='bold')
+    ax.set_xticks(x)
+    ax.set_xticklabels(CATEGORY_ORDER + ['overall'])
+    ax.legend(fontsize=9)
+    ax.set_ylim(0, 1.15)
+    ax.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5, label='chance')
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved accuracy chart: {save_path}")
+
+
+def plot_correct_vs_incorrect_overlay(
+    correct_sims: Dict[int, pd.DataFrame],
+    incorrect_sims: Optional[Dict[int, pd.DataFrame]],
+    scale: str,
+    model_type: str,
+    save_path: str,
+):
+    """Overlay correct vs incorrect similarity trajectories for key pairs."""
+    pairs = [
+        ('above', 'far', 'above-far'),
+        ('under', 'close', 'under-close'),
+        ('left', 'right', 'left-right'),
+    ]
+
+    fig, axes = plt.subplots(1, len(pairs), figsize=(7 * len(pairs), 6))
+    if len(pairs) == 1:
+        axes = [axes]
+
+    for idx, (cat1, cat2, label) in enumerate(pairs):
+        ax = axes[idx]
+
+        layers_c, vals_c = _extract_pair_trajectory(correct_sims, cat1, cat2)
+        ax.plot(layers_c, vals_c, '-', color='#2ca02c', label='correct', linewidth=2)
+
+        if incorrect_sims:
+            layers_i, vals_i = _extract_pair_trajectory(incorrect_sims, cat1, cat2)
+            ax.plot(layers_i, vals_i, '-', color='#d62728', label='incorrect', linewidth=2)
+
+        ax.set_xlabel('Layer Index', fontsize=12)
+        ax.set_ylabel('Cosine Similarity', fontsize=12)
+        ax.set_title(f'{label}', fontsize=13, fontweight='bold')
+        ax.legend(fontsize=10)
+        ax.grid(True, alpha=0.3)
+
+    fig.suptitle(
+        f'{model_type.upper()} ({scale}) - Correct vs Incorrect',
+        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 correct vs incorrect overlay: {save_path}")
+
+
+def plot_ablation_summary(
+    ablation_data: List[dict],
+    model_type: str,
+    save_path: str,
+):
+    """Key ablation plot: correct-only vs all-samples similarity across scales.
+
+    x-axis = scales, two lines per pair:
+      - solid: correct-only similarity
+      - dashed: all-samples similarity (from the same data, no balanced sampling)
+    """
+    pairs = [
+        ('above', 'far', 'above-far', '#d62728'),
+        ('under', 'close', 'under-close', '#1f77b4'),
+        ('left', 'right', 'left-right', '#2ca02c'),
+    ]
+
+    scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']
+
+    fig, axes = plt.subplots(1, 2, figsize=(18, 7))
+
+    # Left panel: absolute similarities
+    ax = axes[0]
+    for cat1, cat2, label, color in pairs:
+        # correct-only line
+        x_vals, y_correct, y_all = [], [], []
+        for i, scale in enumerate(scale_order):
+            entry = next((d for d in ablation_data if d['scale'] == scale), None)
+            if entry is None:
+                continue
+            sim_c = entry.get(f'correct_{cat1}_{cat2}')
+            sim_a = entry.get(f'all_{cat1}_{cat2}')
+            if sim_c is not None:
+                x_vals.append(i)
+                y_correct.append(sim_c)
+                y_all.append(sim_a)
+
+        if x_vals:
+            ax.plot(x_vals, y_correct, '-o', color=color, label=f'{label} (correct)', linewidth=2.5)
+            ax.plot(x_vals, y_all, '--s', color=color, label=f'{label} (all)', linewidth=1.5, alpha=0.6)
+
+    ax.set_xticks(range(len(scale_order)))
+    ax.set_xticklabels(scale_order, fontsize=10)
+    ax.set_xlabel('Scale', fontsize=12)
+    ax.set_ylabel('Cosine Similarity', fontsize=12)
+    ax.set_title('Correct-Only vs All-Samples Similarity', fontsize=13, fontweight='bold')
+    ax.legend(fontsize=8, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    # Right panel: accuracy overlay
+    ax2 = axes[1]
+    x_vals, acc_vals = [], []
+    for i, scale in enumerate(scale_order):
+        entry = next((d for d in ablation_data if d['scale'] == scale), None)
+        if entry and 'accuracy' in entry:
+            x_vals.append(i)
+            acc_vals.append(entry['accuracy'])
+
+    ax2.bar(x_vals, acc_vals, color=[SCALE_COLORS.get(scale_order[x], 'gray') for x in x_vals], alpha=0.8)
+    for x, acc in zip(x_vals, acc_vals):
+        ax2.annotate(f'{acc:.1%}', xy=(x, acc), xytext=(0, 5), textcoords='offset points',
+                     ha='center', fontsize=10, fontweight='bold')
+
+    ax2.set_xticks(range(len(scale_order)))
+    ax2.set_xticklabels(scale_order, fontsize=10)
+    ax2.set_xlabel('Scale', fontsize=12)
+    ax2.set_ylabel('Overall Accuracy', fontsize=12)
+    ax2.set_title('Model Accuracy by Scale', fontsize=13, fontweight='bold')
+    ax2.set_ylim(0, 1.15)
+    ax2.grid(True, alpha=0.3, axis='y')
+
+    fig.suptitle(
+        f'{model_type.upper()} - Ablation: Is Similarity Change Due to Accuracy?',
+        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 ablation summary: {save_path}")
+
+
+# ============================================================================
+# Model Configurations
+# ============================================================================
+
+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',
+    },
+}
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+def process_subset(
+    subset_name: str,
+    all_layer_reps: Dict[int, Dict[str, np.ndarray]],
+    target_layers: List[int],
+    scale: str,
+    model_type: str,
+    output_dir: str,
+    n_samples: int,
+) -> Tuple[Dict[int, pd.DataFrame], List[dict]]:
+    """Compute similarity matrices and save outputs for one subset (correct/incorrect)."""
+    num_layers = len(target_layers)
+    scale_sims = {}
+    results_list = []
+
+    for layer_idx in sorted(all_layer_reps.keys()):
+        reps = all_layer_reps[layer_idx]
+        if len(reps) < 2:
+            continue
+
+        sim_df = compute_similarity_matrix(reps)
+        scale_sims[layer_idx] = sim_df
+
+        model_name = f"{model_type}_{scale}_{subset_name}"
+        results = analyze_hypothesis(sim_df, model_name)
+        results['layer_idx'] = layer_idx
+        results['subset'] = subset_name
+        results['scale'] = scale
+        results['n_samples_per_cat'] = n_samples
+        results_list.append(results)
+
+        sim_df.to_csv(os.path.join(output_dir, f'similarity_{scale}_L{layer_idx}.csv'))
+
+    if scale_sims:
+        rep_layers = get_representative_layers(sorted(scale_sims.keys()))
+        for layer_idx in rep_layers:
+            sim_df = scale_sims[layer_idx]
+            plot_similarity_heatmap(
+                sim_df,
+                f'{model_type.upper()} ({scale}) [{subset_name}, n={n_samples}] - Layer {layer_idx}/{num_layers-1}',
+                os.path.join(output_dir, f'heatmap_{scale}_L{layer_idx}.png')
+            )
+
+        plot_similarity_trajectories(
+            scale_sims,
+            f'{model_type.upper()} ({scale}) [{subset_name}, n={n_samples}]',
+            os.path.join(output_dir, f'trajectory_{scale}.png')
+        )
+
+    return scale_sims, results_list
+
+
+def _load_scale_sims_from_csvs(subset_dir: str, scale: str) -> Dict[int, pd.DataFrame]:
+    """Reload per-layer similarity CSVs for one scale from disk."""
+    import glob as glob_mod
+    pattern = os.path.join(subset_dir, f'similarity_{scale}_L*.csv')
+    files = glob_mod.glob(pattern)
+    layer_sims = {}
+    for fpath in files:
+        basename = os.path.basename(fpath)
+        # similarity_{scale}_L{idx}.csv
+        layer_str = basename.replace(f'similarity_{scale}_L', '').replace('.csv', '')
+        try:
+            layer_idx = int(layer_str)
+        except ValueError:
+            continue
+        df = pd.read_csv(fpath, index_col=0)
+        layer_sims[layer_idx] = df
+    return layer_sims
+
+
+def run_merge(
+    model_type: str,
+    scales: List[str],
+    output_dir: str,
+    correct_dir: str,
+    incorrect_dir: str,
+    accuracy_dir: str,
+    comparison_dir: str,
+):
+    """Merge mode: read per-scale results and generate cross-scale plots."""
+
+    # Determine which scales have data
+    scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']
+    available_scales = [s for s in scale_order if s in scales]
+
+    # 1. Rebuild cross-scale similarity dicts from CSVs
+    cross_scale_correct = {}
+    cross_scale_incorrect = {}
+    for scale in available_scales:
+        c_sims = _load_scale_sims_from_csvs(correct_dir, scale)
+        if c_sims:
+            cross_scale_correct[scale] = c_sims
+            logger.info(f"  Loaded correct-only CSVs for {scale}: {len(c_sims)} layers")
+
+        i_sims = _load_scale_sims_from_csvs(incorrect_dir, scale)
+        if i_sims:
+            cross_scale_incorrect[scale] = i_sims
+            logger.info(f"  Loaded incorrect-only CSVs for {scale}: {len(i_sims)} layers")
+
+    # 2. Cross-scale trajectory and evolution heatmap
+    if len(cross_scale_correct) > 1:
+        logger.info("\n--- Cross-scale comparison (correct-only) ---")
+        plot_cross_scale_trajectories(
+            cross_scale_correct, model_type,
+            os.path.join(comparison_dir, 'cross_scale_correct_only.png')
+        )
+        plot_similarity_evolution_heatmap(
+            cross_scale_correct, model_type,
+            os.path.join(comparison_dir, 'evolution_heatmap_correct.png')
+        )
+
+    if len(cross_scale_incorrect) > 1:
+        logger.info("\n--- Cross-scale comparison (incorrect-only) ---")
+        plot_cross_scale_trajectories(
+            cross_scale_incorrect, model_type,
+            os.path.join(comparison_dir, 'cross_scale_incorrect_only.png')
+        )
+        plot_similarity_evolution_heatmap(
+            cross_scale_incorrect, model_type,
+            os.path.join(comparison_dir, 'evolution_heatmap_incorrect.png')
+        )
+
+    # 3. Accuracy chart from per-scale JSONs
+    accuracy_records = []
+    for scale in available_scales:
+        acc_path = os.path.join(accuracy_dir, f'accuracy_{scale}.json')
+        if os.path.exists(acc_path):
+            with open(acc_path) as f:
+                accuracy_records.append(json.load(f))
+
+    if accuracy_records:
+        acc_df = pd.DataFrame(accuracy_records)
+        acc_df.to_csv(os.path.join(accuracy_dir, 'accuracy_summary.csv'), index=False)
+        plot_accuracy_chart(accuracy_records, model_type,
+                            os.path.join(accuracy_dir, 'accuracy_chart.png'))
+        logger.info(f"  Saved merged accuracy summary ({len(accuracy_records)} scales)")
+
+    # 4. Ablation summary from per-scale JSONs
+    ablation_data = []
+    for scale in available_scales:
+        abl_path = os.path.join(comparison_dir, f'ablation_{scale}.json')
+        if os.path.exists(abl_path):
+            with open(abl_path) as f:
+                ablation_data.append(json.load(f))
+
+    if ablation_data:
+        ablation_df = pd.DataFrame(ablation_data)
+        ablation_df.to_csv(os.path.join(comparison_dir, 'ablation_summary.csv'), index=False)
+        plot_ablation_summary(ablation_data, model_type,
+                              os.path.join(comparison_dir, 'ablation_summary.png'))
+        logger.info(f"  Saved merged ablation summary ({len(ablation_data)} scales)")
+
+    # 5. Merge per-scale results_summary CSVs
+    import glob as glob_mod
+    all_results_files = []
+    for subset_dir, subset_name in [(correct_dir, 'correct'), (incorrect_dir, 'incorrect')]:
+        for scale in available_scales:
+            # Check if any similarity CSVs exist for this scale
+            pattern = os.path.join(subset_dir, f'similarity_{scale}_L*.csv')
+            if glob_mod.glob(pattern):
+                all_results_files.append((subset_dir, scale, subset_name))
+
+    logger.info(f"\n=== Merge Complete ===")
+    logger.info(f"Results in: {output_dir}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Experiment 2-A (Correct Filter): Correctness-Filtered 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_correct_filter/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: skip extraction, read existing per-scale results '
+                             'and generate cross-scale comparison plots only.')
+    parser.add_argument('--no-auto-roborefer', action='store_true', dest='no_auto_roborefer',
+                        help='Do not auto-add roborefer for nvila (use for parallel mode).')
+
+    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)
+
+    output_dir = os.path.join(args.output_dir, args.model_type)
+    correct_dir = os.path.join(output_dir, 'correct_only')
+    incorrect_dir = os.path.join(output_dir, 'incorrect_only')
+    accuracy_dir = os.path.join(output_dir, 'accuracy')
+    comparison_dir = os.path.join(output_dir, 'comparison')
+    for d in [correct_dir, incorrect_dir, accuracy_dir, comparison_dir]:
+        os.makedirs(d, exist_ok=True)
+
+    # ------------------------------------------------------------------
+    # Merge mode: read existing per-scale outputs and generate plots
+    # ------------------------------------------------------------------
+    if args.merge:
+        logger.info("\n=== MERGE MODE: Reading existing per-scale results ===")
+        run_merge(args.model_type, args.scales, output_dir,
+                  correct_dir, incorrect_dir, accuracy_dir, comparison_dir)
+        return
+
+    # ------------------------------------------------------------------
+    # Normal mode: extract + analyze
+    # ------------------------------------------------------------------
+    logger.info("\n=== Loading & Modifying EmbSpatialBench Data (ALL samples) ===")
+    data = load_and_modify_data(args.data_path, args.seed)
+
+    model_configs = MODEL_CONFIGS[args.model_type]
+
+    all_results = []
+    accuracy_records = []
+    cross_scale_correct = {}
+    cross_scale_incorrect = {}
+    ablation_data = []
+
+    for scale in args.scales:
+        if scale not in model_configs:
+            logger.warning(f"Scale {scale} not available for {args.model_type}, skipping...")
+            continue
+
+        model_path = model_configs[scale]
+        if not os.path.exists(model_path) and not model_path.startswith('Qwen/') and not model_path.startswith('allenai/'):
+            logger.warning(f"Model path not found: {model_path}, skipping...")
+            continue
+
+        logger.info(f"\n{'='*60}")
+        logger.info(f"Processing {args.model_type} - {scale}")
+        logger.info(f"Model path: {model_path}")
+        logger.info(f"{'='*60}")
+
+        try:
+            extractor = get_extractor(
+                args.model_type, model_path, scale=scale, device=args.device,
+            )
+            target_layers = extractor.target_layers
+
+            # Phase A: Extract all samples with predictions
+            logger.info("\n--- Phase A: Extracting hidden states with predictions ---")
+            sample_records = extract_all_with_predictions(extractor, data)
+
+            # Save per-sample predictions
+            save_per_sample_predictions(
+                sample_records, scale,
+                os.path.join(accuracy_dir, f'predictions_{scale}.csv')
+            )
+
+            # Compute and save accuracy
+            acc_stats = compute_accuracy_stats(sample_records, scale, args.model_type)
+            accuracy_records.append(acc_stats)
+            logger.info(f"\n  Accuracy for {scale}: {acc_stats['overall_accuracy']:.1%}")
+            for cat in CATEGORY_ORDER:
+                logger.info(f"    {cat}: {acc_stats[f'{cat}_correct']}/{acc_stats[f'{cat}_total']} "
+                            f"= {acc_stats[f'{cat}_accuracy']:.1%}")
+
+            # Phase B: Balanced sampling
+            logger.info("\n--- Phase B: Balanced sampling ---")
+
+            n_correct = compute_balanced_size(sample_records, filter_correct=True)
+            n_incorrect = compute_balanced_size(sample_records, filter_correct=False)
+            logger.info(f"  Correct group: {n_correct} samples/category")
+            logger.info(f"  Incorrect group: {n_incorrect} samples/category")
+
+            # Also compute "all" (no filter) for ablation comparison using ALL samples
+            logger.info("\n--- Computing all-samples similarity (unfiltered) ---")
+            all_reps = {}
+            for layer_idx in target_layers:
+                cat_avgs = {}
+                for cat in CATEGORY_ORDER:
+                    vectors = [r['hidden_states'][layer_idx]
+                               for r in sample_records.get(cat, [])
+                               if layer_idx in r['hidden_states']]
+                    if vectors:
+                        cat_avgs[cat] = np.mean(vectors, axis=0)
+                if cat_avgs:
+                    all_reps[layer_idx] = cat_avgs
+
+            # Get "all" similarity at a representative deep layer for ablation
+            all_sims_for_ablation = {}
+            if all_reps:
+                rep_layer = get_representative_layers(sorted(all_reps.keys()), n=1)[0]
+                rep_sim_all = compute_similarity_matrix(all_reps[rep_layer])
+                for cat1, cat2, _, _ in (TRAJECTORY_PAIRS['hypothesis'] +
+                                         TRAJECTORY_PAIRS['within_axis']):
+                    if cat1 in rep_sim_all.index and cat2 in rep_sim_all.columns:
+                        all_sims_for_ablation[f'all_{cat1}_{cat2}'] = rep_sim_all.loc[cat1, cat2]
+
+            # Phase C: Process correct-only subset
+            correct_layer_sims = {}
+            if n_correct > 0:
+                logger.info(f"\n--- Phase C: Processing correct-only (n={n_correct}) ---")
+                correct_reps = balanced_sample_and_average(
+                    sample_records, filter_correct=True, n_samples=n_correct,
+                    target_layers=target_layers, seed=args.seed,
+                )
+
+                correct_layer_sims, correct_results = process_subset(
+                    'correct', correct_reps, target_layers, scale,
+                    args.model_type, correct_dir, n_correct,
+                )
+                all_results.extend(correct_results)
+                cross_scale_correct[scale] = correct_layer_sims
+            else:
+                logger.warning(f"  Skipping correct-only: no correct samples in some category")
+
+            # Process incorrect-only subset
+            incorrect_layer_sims = {}
+            if n_incorrect > 0:
+                logger.info(f"\n--- Phase C: Processing incorrect-only (n={n_incorrect}) ---")
+                incorrect_reps = balanced_sample_and_average(
+                    sample_records, filter_correct=False, n_samples=n_incorrect,
+                    target_layers=target_layers, seed=args.seed,
+                )
+
+                incorrect_layer_sims, incorrect_results = process_subset(
+                    'incorrect', incorrect_reps, target_layers, scale,
+                    args.model_type, incorrect_dir, n_incorrect,
+                )
+                all_results.extend(incorrect_results)
+                cross_scale_incorrect[scale] = incorrect_layer_sims
+            else:
+                logger.warning(f"  Skipping incorrect-only: no incorrect samples in some category")
+
+            # Correct vs incorrect overlay
+            if correct_layer_sims:
+                plot_correct_vs_incorrect_overlay(
+                    correct_layer_sims,
+                    incorrect_layer_sims if incorrect_layer_sims else None,
+                    scale, args.model_type,
+                    os.path.join(comparison_dir, f'correct_vs_incorrect_{scale}.png')
+                )
+
+            # Build ablation entry
+            ablation_entry = {
+                'scale': scale,
+                'accuracy': acc_stats['overall_accuracy'],
+                'n_correct_per_cat': n_correct,
+                'n_incorrect_per_cat': n_incorrect,
+            }
+            ablation_entry.update(all_sims_for_ablation)
+
+            # Get correct-only similarity at the same representative layer
+            if correct_layer_sims and rep_layer in correct_layer_sims:
+                rep_sim_c = correct_layer_sims[rep_layer]
+                for cat1, cat2, _, _ in (TRAJECTORY_PAIRS['hypothesis'] +
+                                         TRAJECTORY_PAIRS['within_axis']):
+                    if cat1 in rep_sim_c.index and cat2 in rep_sim_c.columns:
+                        ablation_entry[f'correct_{cat1}_{cat2}'] = rep_sim_c.loc[cat1, cat2]
+
+            # Get incorrect-only similarity
+            if incorrect_layer_sims and rep_layer in incorrect_layer_sims:
+                rep_sim_i = incorrect_layer_sims[rep_layer]
+                for cat1, cat2, _, _ in (TRAJECTORY_PAIRS['hypothesis'] +
+                                         TRAJECTORY_PAIRS['within_axis']):
+                    if cat1 in rep_sim_i.index and cat2 in rep_sim_i.columns:
+                        ablation_entry[f'incorrect_{cat1}_{cat2}'] = rep_sim_i.loc[cat1, cat2]
+
+            ablation_data.append(ablation_entry)
+
+            # Save per-scale ablation JSON (for merge mode)
+            ablation_path = os.path.join(comparison_dir, f'ablation_{scale}.json')
+            with open(ablation_path, 'w') as f:
+                json.dump(ablation_entry, f, indent=2, default=str)
+
+            # Save per-scale accuracy JSON (for merge mode)
+            acc_path = os.path.join(accuracy_dir, f'accuracy_{scale}.json')
+            with open(acc_path, 'w') as f:
+                json.dump(acc_stats, f, indent=2, default=str)
+
+            # Cleanup
+            del sample_records
+            extractor.cleanup()
+
+        except Exception as e:
+            logger.error(f"Failed to process {args.model_type} - {scale}: {e}")
+            import traceback
+            traceback.print_exc()
+            continue
+
+    # ========================
+    # Cross-scale comparisons
+    # ========================
+
+    if len(cross_scale_correct) > 1:
+        logger.info("\n--- Cross-scale comparison (correct-only) ---")
+        plot_cross_scale_trajectories(
+            cross_scale_correct, args.model_type,
+            os.path.join(comparison_dir, 'cross_scale_correct_only.png')
+        )
+        plot_similarity_evolution_heatmap(
+            cross_scale_correct, args.model_type,
+            os.path.join(comparison_dir, 'evolution_heatmap_correct.png')
+        )
+
+    if len(cross_scale_incorrect) > 1:
+        logger.info("\n--- Cross-scale comparison (incorrect-only) ---")
+        plot_cross_scale_trajectories(
+            cross_scale_incorrect, args.model_type,
+            os.path.join(comparison_dir, 'cross_scale_incorrect_only.png')
+        )
+        plot_similarity_evolution_heatmap(
+            cross_scale_incorrect, args.model_type,
+            os.path.join(comparison_dir, 'evolution_heatmap_incorrect.png')
+        )
+
+    # Accuracy chart
+    if accuracy_records:
+        acc_df = pd.DataFrame(accuracy_records)
+        acc_df.to_csv(os.path.join(accuracy_dir, 'accuracy_summary.csv'), index=False)
+        plot_accuracy_chart(accuracy_records, args.model_type,
+                            os.path.join(accuracy_dir, 'accuracy_chart.png'))
+
+    # Ablation summary
+    if ablation_data:
+        ablation_df = pd.DataFrame(ablation_data)
+        ablation_df.to_csv(os.path.join(comparison_dir, 'ablation_summary.csv'), index=False)
+        plot_ablation_summary(ablation_data, args.model_type,
+                              os.path.join(comparison_dir, 'ablation_summary.png'))
+
+    # Save all results
+    if all_results:
+        results_df = pd.DataFrame(all_results)
+        results_df.to_csv(os.path.join(output_dir, 'results_summary.csv'), index=False)
+
+    logger.info(f"\n{'='*60}")
+    logger.info("=== Analysis Complete ===")
+    logger.info(f"Results saved to: {output_dir}")
+    logger.info(f"  Accuracy: {accuracy_dir}")
+    logger.info(f"  Correct-only: {correct_dir}")
+    logger.info(f"  Incorrect-only: {incorrect_dir}")
+    logger.info(f"  Comparison: {comparison_dir}")
+    logger.info(f"{'='*60}")
+
+
+if __name__ == '__main__':
+    main()

exp2a_correct_filter/run_molmo.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+set -e
+
+SCRIPT="/data/shared/Qwen/experiments/exp2a_correct_filter/exp2a_correct_filter_analysis.py"
+PYTHON="conda run --no-capture-output -n molmo python"
+MODEL="molmo"
+LOG_DIR="/data/shared/Qwen/experiments/exp2a_correct_filter/logs/${MODEL}"
+mkdir -p "$LOG_DIR"
+
+SCALES=("vanilla" "80k" "400k" "800k" "2m")
+GPUS=(0 1 2 3 4)
+
+echo "========================================="
+echo " Molmo: Launching ${#SCALES[@]} scales in parallel"
+echo "========================================="
+
+PIDS=()
+for i in "${!SCALES[@]}"; do
+    scale="${SCALES[$i]}"
+    gpu="${GPUS[$i]}"
+    log="${LOG_DIR}/${scale}.log"
+
+    echo "[GPU $gpu] $scale -> $log"
+    CUDA_VISIBLE_DEVICES=$gpu $PYTHON $SCRIPT \
+        --model_type $MODEL \
+        --scales $scale \
+        --device cuda \
+        --no-auto-roborefer \
+        > "$log" 2>&1 &
+    PIDS+=($!)
+done
+
+echo ""
+echo "Waiting for all ${#PIDS[@]} processes..."
+echo "PIDs: ${PIDS[*]}"
+echo ""
+
+FAILED=0
+for i in "${!PIDS[@]}"; do
+    pid="${PIDS[$i]}"
+    scale="${SCALES[$i]}"
+    if wait $pid; then
+        echo "[DONE] $scale (PID $pid) - SUCCESS"
+    else
+        echo "[FAIL] $scale (PID $pid) - EXIT CODE $?"
+        FAILED=$((FAILED + 1))
+    fi
+done
+
+echo ""
+if [ $FAILED -gt 0 ]; then
+    echo "WARNING: $FAILED scale(s) failed. Check logs in $LOG_DIR"
+fi
+
+echo "========================================="
+echo " Molmo: Running merge"
+echo "========================================="
+$PYTHON $SCRIPT --model_type $MODEL --merge 2>&1 | tee "${LOG_DIR}/merge.log"
+
+echo ""
+echo "ALL DONE: $MODEL"
+echo "Results: /data/shared/Qwen/experiments/exp2a_correct_filter/results/${MODEL}/"

exp2a_correct_filter/run_nvila.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+set -e
+
+SCRIPT="/data/shared/Qwen/experiments/exp2a_correct_filter/exp2a_correct_filter_analysis.py"
+PYTHON="conda run --no-capture-output -n vila python"
+MODEL="nvila"
+LOG_DIR="/data/shared/Qwen/experiments/exp2a_correct_filter/logs/${MODEL}"
+mkdir -p "$LOG_DIR"
+
+# NVILA has 6 scales (including roborefer)
+SCALES=("vanilla" "80k" "400k" "800k" "2m" "roborefer")
+GPUS=(0 1 2 3 4 5)
+
+echo "========================================="
+echo " NVILA: Launching ${#SCALES[@]} scales in parallel"
+echo "========================================="
+
+PIDS=()
+for i in "${!SCALES[@]}"; do
+    scale="${SCALES[$i]}"
+    gpu="${GPUS[$i]}"
+    log="${LOG_DIR}/${scale}.log"
+
+    echo "[GPU $gpu] $scale -> $log"
+    CUDA_VISIBLE_DEVICES=$gpu $PYTHON $SCRIPT \
+        --model_type $MODEL \
+        --scales $scale \
+        --device cuda \
+        --no-auto-roborefer \
+        > "$log" 2>&1 &
+    PIDS+=($!)
+done
+
+echo ""
+echo "Waiting for all ${#PIDS[@]} processes..."
+echo "PIDs: ${PIDS[*]}"
+echo ""
+
+FAILED=0
+for i in "${!PIDS[@]}"; do
+    pid="${PIDS[$i]}"
+    scale="${SCALES[$i]}"
+    if wait $pid; then
+        echo "[DONE] $scale (PID $pid) - SUCCESS"
+    else
+        echo "[FAIL] $scale (PID $pid) - EXIT CODE $?"
+        FAILED=$((FAILED + 1))
+    fi
+done
+
+echo ""
+if [ $FAILED -gt 0 ]; then
+    echo "WARNING: $FAILED scale(s) failed. Check logs in $LOG_DIR"
+fi
+
+echo "========================================="
+echo " NVILA: Running merge"
+echo "========================================="
+$PYTHON $SCRIPT --model_type $MODEL --merge 2>&1 | tee "${LOG_DIR}/merge.log"
+
+echo ""
+echo "ALL DONE: $MODEL"
+echo "Results: /data/shared/Qwen/experiments/exp2a_correct_filter/results/${MODEL}/"

exp2a_correct_filter/run_qwen.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+set -e
+
+SCRIPT="/data/shared/Qwen/experiments/exp2a_correct_filter/exp2a_correct_filter_analysis.py"
+PYTHON="/usr/bin/python3"
+MODEL="qwen"
+LOG_DIR="/data/shared/Qwen/experiments/exp2a_correct_filter/logs/${MODEL}"
+mkdir -p "$LOG_DIR"
+
+SCALES=("vanilla" "80k" "400k" "800k" "2m")
+GPUS=(0 1 2 3 4)
+
+echo "========================================="
+echo " Qwen: Launching ${#SCALES[@]} scales in parallel"
+echo "========================================="
+
+PIDS=()
+for i in "${!SCALES[@]}"; do
+    scale="${SCALES[$i]}"
+    gpu="${GPUS[$i]}"
+    log="${LOG_DIR}/${scale}.log"
+
+    echo "[GPU $gpu] $scale -> $log"
+    CUDA_VISIBLE_DEVICES=$gpu $PYTHON $SCRIPT \
+        --model_type $MODEL \
+        --scales $scale \
+        --device cuda \
+        --no-auto-roborefer \
+        > "$log" 2>&1 &
+    PIDS+=($!)
+done
+
+echo ""
+echo "Waiting for all ${#PIDS[@]} processes..."
+echo "PIDs: ${PIDS[*]}"
+echo ""
+
+FAILED=0
+for i in "${!PIDS[@]}"; do
+    pid="${PIDS[$i]}"
+    scale="${SCALES[$i]}"
+    if wait $pid; then
+        echo "[DONE] $scale (PID $pid) - SUCCESS"
+    else
+        echo "[FAIL] $scale (PID $pid) - EXIT CODE $?"
+        FAILED=$((FAILED + 1))
+    fi
+done
+
+echo ""
+if [ $FAILED -gt 0 ]; then
+    echo "WARNING: $FAILED scale(s) failed. Check logs in $LOG_DIR"
+fi
+
+echo "========================================="
+echo " Qwen: Running merge"
+echo "========================================="
+$PYTHON $SCRIPT --model_type $MODEL --merge 2>&1 | tee "${LOG_DIR}/merge.log"
+
+echo ""
+echo "ALL DONE: $MODEL"
+echo "Results: /data/shared/Qwen/experiments/exp2a_correct_filter/results/${MODEL}/"

exp2a_modified/exp2a_modified_embedding_analysis.py

@@ -0,0 +1,1228 @@
+"""
+Experiment 2-A (Modified): Image-conditioned Representation Analysis
+
+Modification from original:
+- Remove task format confound by unifying answer format
+- All answers are pure spatial concepts: left, right, above, under, far, close
+- Pairwise: "Is the {obj1} to the left or right of the {obj2}?" -> "left"
+- Distance: "Compared to {ref}, is {target} far or close from you?" -> "far"
+- 200 samples per category (up from 50)
+
+Goal: Verify Hypothesis 4 - that above/far and under/close are mapped to similar
+positions in embedding space, while left/right are well-separated.
+"""
+
+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.pyplot as plt
+import seaborn as sns
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Category order for output
+CATEGORY_ORDER = ['left', 'right', 'above', 'under', 'far', 'close']
+
+# Pair definitions for trajectory analysis
+TRAJECTORY_PAIRS = {
+    'hypothesis': [
+        ('above', 'far', 'above-far', '#d62728'),      # red
+        ('under', 'close', 'under-close', '#1f77b4'),   # blue
+    ],
+    'within_axis': [
+        ('left', 'right', 'left-right', '#2ca02c'),     # green
+        ('above', 'under', 'above-under', '#ff7f0e'),   # orange
+        ('far', 'close', 'far-close', '#9467bd'),       # purple
+    ],
+    'counter_hypothesis': [
+        ('above', 'close', 'above-close', '#e377c2'),   # pink
+        ('under', 'far', 'under-far', '#17becf'),       # cyan
+    ],
+}
+
+# Scale colors for cross-scale plots
+SCALE_COLORS = {
+    'vanilla': '#1f77b4',
+    '80k': '#ff7f0e',
+    '400k': '#2ca02c',
+    '800k': '#d62728',
+    '2m': '#9467bd',
+    'roborefer': '#8c564b',
+}
+
+
+# ============================================================================
+# Data Loading & Modification
+# ============================================================================
+
+# Regex patterns for extracting objects from pairwise questions
+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]:
+    """Extract two objects from a pairwise relation question."""
+    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 modify_pairwise_sample(sample: dict) -> dict:
+    """Modify a pairwise relation sample (left/right/above/under)."""
+    obj1, obj2 = extract_objects(sample['question'])
+    category = sample['category']
+
+    if category in ['left', 'right']:
+        new_question = f"Is the {obj1} to the left or right of the {obj2}?"
+    else:  # above, under
+        new_question = f"Is the {obj1} above or under the {obj2}?"
+
+    return {
+        'index': sample['index'],
+        'image_base64': sample['image_base64'],
+        'question': new_question,
+        'answer': category,
+        'category': category,
+    }
+
+
+def modify_distance_sample(sample: dict, rng: random.Random) -> dict:
+    """Modify a distance relation sample (far/close)."""
+    category = sample['category']
+    answer_key = sample['answer']  # e.g. "C"
+    options = sample['options']    # {'A': 'table', 'B': 'towel', ...}
+
+    target_object = options[answer_key]
+    candidates = [v for k, v in options.items() if k != answer_key]
+    reference_object = rng.choice(candidates)
+
+    new_question = f"Compared to {reference_object}, is {target_object} far or close from you?"
+
+    return {
+        'index': sample['index'],
+        'image_base64': sample['image_base64'],
+        'question': new_question,
+        'answer': category,
+        'category': category,
+    }
+
+
+def load_and_modify_data(
+    tsv_path: str,
+    samples_per_category: int = 200,
+    seed: int = 42
+) -> Dict[str, List[dict]]:
+    """
+    Load EmbSpatialBench data, modify questions to remove format confound.
+    """
+    rng = random.Random(seed)
+    np.random.seed(seed)
+
+    df = pd.read_csv(tsv_path, sep='\t')
+
+    # Group by category
+    raw_grouped = defaultdict(list)
+    for _, row in df.iterrows():
+        category = row['category']
+        sample = {
+            'index': row['index'],
+            'image_base64': row['image'],
+            'question': row['question'],
+            'answer': row['answer'],
+            'category': category,
+            'options': {
+                'A': row['A'],
+                'B': row['B'],
+                'C': row['C'],
+                'D': row['D']
+            }
+        }
+        raw_grouped[category].append(sample)
+
+    # Sample and modify
+    modified_data = defaultdict(list)
+    stats = {'total': 0, 'success': 0, 'failed': 0}
+
+    for category in CATEGORY_ORDER:
+        samples = raw_grouped[category]
+
+        # Sample up to samples_per_category
+        if len(samples) > samples_per_category:
+            indices = np.random.choice(len(samples), samples_per_category, replace=False)
+            samples = [samples[i] for i in indices]
+
+        for sample in samples:
+            stats['total'] += 1
+            try:
+                if category in ['left', 'right', 'above', 'under']:
+                    modified = modify_pairwise_sample(sample)
+                else:  # far, close
+                    modified = modify_distance_sample(sample, rng)
+
+                # Validate
+                assert modified['answer'] == modified['category']
+                modified_data[category].append(modified)
+                stats['success'] += 1
+            except Exception as e:
+                stats['failed'] += 1
+                logger.warning(f"  Failed to modify sample {sample['index']}: {e}")
+
+    logger.info(f"Data modification: {stats['success']}/{stats['total']} success, {stats['failed']} failed")
+    for cat in CATEGORY_ORDER:
+        if cat in modified_data:
+            logger.info(f"  {cat}: {len(modified_data[cat])} samples")
+            # Show first example
+            ex = modified_data[cat][0]
+            logger.info(f"    Example Q: {ex['question']}")
+            logger.info(f"    Example A: {ex['answer']}")
+
+    return dict(modified_data)
+
+
+def decode_base64_image(base64_str: str) -> Image.Image:
+    """Decode base64 string to PIL Image."""
+    image_data = base64.b64decode(base64_str)
+    return Image.open(BytesIO(image_data)).convert('RGB')
+
+
+# ============================================================================
+# Base Extractor
+# ============================================================================
+
+class BaseHiddenStateExtractor(ABC):
+    """Base class for extracting hidden states from VLMs."""
+
+    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 layers (0..{num_layers-1})")
+        else:
+            self.target_layers = target_layers
+            logger.info(f"Model has {num_layers} layers. Target layers: {self.target_layers}")
+
+        self._register_hooks()
+
+    def _register_hooks(self):
+        """Register forward hooks on target layers."""
+        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)
+                logger.info(f"  Registered hook on layer {layer_idx}")
+
+    def _make_hook(self, layer_idx: int):
+        """Create a hook function for a specific layer."""
+        def hook_fn(module, input, output):
+            if isinstance(output, tuple):
+                hidden = output[0]
+            else:
+                hidden = output
+
+            # Last token pooling
+            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(self, image: Image.Image, question: str) -> Dict[int, torch.Tensor]:
+        pass
+
+    def cleanup(self):
+        """Remove hooks and free memory."""
+        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):
+    """Hidden state extractor for Molmo models (native olmo format)."""
+
+    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
+
+        config_path = os.path.join(self.model_path, "config.yaml")
+        checkpoint_path = os.path.join(self.model_path, "model.pt")
+
+        cfg = ModelConfig.load(config_path, key="model", validate_paths=False)
+        cfg.init_device = "cpu"
+
+        self.model = NativeMolmoModel(cfg)
+        state_dict = torch.load(checkpoint_path, 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 model 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
+        )
+        self.model.eval()
+
+        self.processor = AutoProcessor.from_pretrained(
+            self.model_path,
+            trust_remote_code=True
+        )
+        logger.info(f"Loaded HuggingFace Molmo model from {self.model_path}")
+
+    def _get_num_layers(self) -> int:
+        if self.is_native:
+            return len(self.model.transformer.blocks)
+        else:
+            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]
+        else:
+            return self.model.model.transformer.blocks[layer_idx]
+
+    def extract(self, image: Image.Image, question: str) -> Dict[int, torch.Tensor]:
+        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)
+            image_np = np.array(image)
+            batch = self.preprocessor(image_np, 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_tensor(x):
+                if isinstance(x, np.ndarray):
+                    return torch.from_numpy(x)
+                return x
+
+            input_ids = to_tensor(batch['input_ids']).unsqueeze(0).to(self.device)
+            if input_ids.dtype not in [torch.long, torch.int64]:
+                input_ids = input_ids.long()
+
+            images_tensor = to_tensor(batch['images']).unsqueeze(0).to(self.device).to(dtype=torch.bfloat16)
+            image_masks = to_tensor(batch['image_masks']).unsqueeze(0).to(self.device).to(dtype=torch.bfloat16)
+            image_input_idx = to_tensor(batch['image_input_idx']).unsqueeze(0).to(self.device)
+
+            with torch.inference_mode():
+                with torch.autocast(device_type="cuda", enabled=True, dtype=torch.bfloat16):
+                    _ = self.model(
+                        input_ids=input_ids,
+                        images=images_tensor,
+                        image_masks=image_masks,
+                        image_input_idx=image_input_idx,
+                    )
+        else:
+            inputs = self.processor.process(images=[image], text=question)
+            processed_inputs = {}
+            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_inputs[k] = v
+
+            with torch.no_grad():
+                _ = self.model(**processed_inputs)
+
+        return self.hidden_states.copy()
+
+
+# ============================================================================
+# NVILA Extractor
+# ============================================================================
+
+class NVILAExtractor(BaseHiddenStateExtractor):
+    """Hidden state extractor for NVILA models."""
+
+    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 = [key for key in list(sys.modules.keys()) if 'llava' in key.lower()]
+        removed_modules = {}
+        for mod in modules_to_remove:
+            removed_modules[mod] = sys.modules.pop(mod)
+
+        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 mod, module in removed_modules.items():
+                sys.modules[mod] = module
+            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 model from {self.model_path}")
+
+    def _find_llm_backbone(self):
+        """Find the LLM backbone module for hook registration."""
+        candidates = []
+
+        if hasattr(self.model, 'llm'):
+            if hasattr(self.model.llm, 'model') and hasattr(self.model.llm.model, 'layers'):
+                candidates.append(('model.llm.model.layers', self.model.llm.model.layers))
+            if hasattr(self.model.llm, 'layers'):
+                candidates.append(('model.llm.layers', self.model.llm.layers))
+
+        if hasattr(self.model, 'model'):
+            if hasattr(self.model.model, 'model') and hasattr(self.model.model.model, 'layers'):
+                candidates.append(('model.model.model.layers', self.model.model.model.layers))
+            if hasattr(self.model.model, 'layers'):
+                candidates.append(('model.model.layers', 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((name, module))
+
+        if candidates:
+            path, layers = candidates[0]
+            logger.info(f"Found LLM layers at: {path} (num_layers={len(layers)})")
+            self.llm_backbone = layers
+            self.layers_path = path
+        else:
+            logger.error("Could not find transformer layers in model!")
+            for name, _ in list(self.model.named_modules())[:20]:
+                logger.info(f"  {name}")
+            raise ValueError("Could not locate transformer layers in NVILA model")
+
+    def _get_num_layers(self) -> int:
+        if hasattr(self, 'llm_backbone') and hasattr(self.llm_backbone, '__len__'):
+            return len(self.llm_backbone)
+        return 24
+
+    def _get_layer_module(self, layer_idx: int):
+        if hasattr(self, 'llm_backbone') and hasattr(self.llm_backbone, '__getitem__'):
+            module = self.llm_backbone[layer_idx]
+            logger.info(f"  Accessing layer {layer_idx}: {type(module).__name__}")
+            return module
+        logger.error(f"Cannot access layer {layer_idx} - llm_backbone not properly initialized")
+        return None
+
+    def extract(self, image: Image.Image, question: str) -> Dict[int, torch.Tensor]:
+        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
+            gen_config = GenerationConfig(max_new_tokens=1, do_sample=False)
+            _ = self.model.generate_content(prompt, generation_config=gen_config)
+        finally:
+            os.unlink(temp_path)
+
+        return self.hidden_states.copy()
+
+
+# ============================================================================
+# RoboRefer Extractor (NVILA-based)
+# ============================================================================
+
+class RoboReferExtractor(NVILAExtractor):
+    """Hidden state extractor for RoboRefer models (NVILA-based, different llava path)."""
+
+    ROBOREFER_PATH = '/data/shared/Qwen/RoboRefer'
+
+    def _load_model(self):
+        original_sys_path = sys.path.copy()
+
+        # Add RoboRefer path (opposite of NVILA which removes it)
+        if self.ROBOREFER_PATH not in sys.path:
+            sys.path.insert(0, self.ROBOREFER_PATH)
+
+        # Clear any existing llava modules to avoid conflicts
+        modules_to_remove = [key for key in list(sys.modules.keys()) if 'llava' in key.lower()]
+        removed_modules = {}
+        for mod in modules_to_remove:
+            removed_modules[mod] = sys.modules.pop(mod)
+
+        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 mod, module in removed_modules.items():
+                sys.modules[mod] = module
+            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 model from {self.model_path}")
+
+
+# ============================================================================
+# Qwen2.5-VL Extractor
+# ============================================================================
+
+class Qwen25VLExtractor(BaseHiddenStateExtractor):
+    """Hidden state extractor for Qwen2.5-VL models."""
+
+    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:
+            logger.info("accelerate not available, loading model without device_map...")
+            self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+                self.model_path,
+                torch_dtype=torch.bfloat16,
+            )
+            self.model = self.model.to(self.device)
+
+        self.model.eval()
+
+        if self.model_path.startswith('/'):
+            logger.info(f"Fine-tuned model detected, loading processor from base model: {self.BASE_MODEL}")
+            self.processor = AutoProcessor.from_pretrained(self.BASE_MODEL)
+        else:
+            self.processor = AutoProcessor.from_pretrained(self.model_path)
+        logger.info(f"Loaded Qwen2.5-VL model 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(self, image: Image.Image, question: str) -> Dict[int, torch.Tensor]:
+        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"
+        )
+        inputs = inputs.to(self.device)
+
+        with torch.no_grad():
+            _ = self.model(**inputs)
+
+        return self.hidden_states.copy()
+
+
+# ============================================================================
+# Factory Function
+# ============================================================================
+
+def get_extractor(model_type: str, model_path: str, scale: str = None, **kwargs) -> BaseHiddenStateExtractor:
+    # RoboRefer uses NVILA architecture but needs different llava import path
+    if model_type == 'nvila' and scale == 'roborefer':
+        return RoboReferExtractor(model_path, **kwargs)
+
+    extractors = {
+        'molmo': MolmoExtractor,
+        'nvila': NVILAExtractor,
+        'qwen': Qwen25VLExtractor,
+    }
+    if model_type not in extractors:
+        raise ValueError(f"Unknown model type: {model_type}. Available: {list(extractors.keys())}")
+    return extractors[model_type](model_path, **kwargs)
+
+
+# ============================================================================
+# Analysis Functions
+# ============================================================================
+
+def extract_all_layer_representations(
+    extractor: BaseHiddenStateExtractor,
+    data: Dict[str, List[dict]],
+) -> Dict[int, Dict[str, np.ndarray]]:
+    """Extract average hidden state representations for ALL target layers at once.
+
+    Returns:
+        Dict mapping layer_idx -> {category -> avg_vector}
+    """
+    # category_states[layer_idx][category] = list of vectors
+    category_states = defaultdict(lambda: defaultdict(list))
+
+    for category in CATEGORY_ORDER:
+        if category not in data:
+            continue
+        samples = data[category]
+        logger.info(f"Processing category: {category}")
+        success_count = 0
+        for sample in tqdm(samples, desc=f"  {category}"):
+            try:
+                image = decode_base64_image(sample['image_base64'])
+                hidden_states = extractor.extract(image, sample['question'])
+
+                for layer_idx in extractor.target_layers:
+                    if layer_idx in hidden_states:
+                        state = hidden_states[layer_idx].numpy().flatten()
+                        if state.size > 0:
+                            category_states[layer_idx][category].append(state)
+
+                if any(l in hidden_states for l in extractor.target_layers):
+                    success_count += 1
+                else:
+                    logger.warning(f"    No target layers found. Available: {list(hidden_states.keys())}")
+            except Exception as e:
+                logger.warning(f"    Error processing sample {sample['index']}: {e}")
+                continue
+
+        logger.info(f"  {category}: Successfully extracted {success_count}/{len(samples)} samples")
+
+    # Average per category per layer
+    result = {}
+    for layer_idx in extractor.target_layers:
+        category_avg = {}
+        for category, states in category_states[layer_idx].items():
+            if states:
+                category_avg[category] = np.mean(states, axis=0)
+        if category_avg:
+            result[layer_idx] = category_avg
+            logger.info(f"  Layer {layer_idx}: {len(category_avg)} categories collected")
+        else:
+            logger.error(f"  Layer {layer_idx}: No states collected!")
+
+    if not result:
+        raise ValueError("No representations were extracted!")
+
+    return result
+
+
+def compute_similarity_matrix(
+    representations: Dict[str, np.ndarray]
+) -> pd.DataFrame:
+    """Compute pairwise cosine similarity with fixed category order."""
+    available = [c for c in CATEGORY_ORDER if c in representations]
+    vectors = np.array([representations[cat] for cat in available])
+    sim_matrix = cosine_similarity(vectors)
+    return pd.DataFrame(sim_matrix, index=available, columns=available)
+
+
+def analyze_hypothesis(sim_df: pd.DataFrame, model_name: str) -> dict:
+    """Analyze the similarity matrix to test Hypothesis 4."""
+    results = {'model': model_name}
+
+    pairs_to_check = {
+        'above_far': ('above', 'far'),
+        'under_close': ('under', 'close'),
+        'left_right': ('left', 'right'),
+    }
+
+    for pair_name, (cat1, cat2) in pairs_to_check.items():
+        if cat1 in sim_df.index and cat2 in sim_df.columns:
+            sim = sim_df.loc[cat1, cat2]
+            results[f'sim_{pair_name}'] = sim
+            logger.info(f"  {pair_name}: sim({cat1}, {cat2}) = {sim:.4f}")
+        else:
+            results[f'sim_{pair_name}'] = None
+
+    if results.get('sim_above_far') and results.get('sim_left_right'):
+        results['diff_above_far_vs_left_right'] = results['sim_above_far'] - results['sim_left_right']
+    if results.get('sim_under_close') and results.get('sim_left_right'):
+        results['diff_under_close_vs_left_right'] = results['sim_under_close'] - results['sim_left_right']
+
+    return results
+
+
+# ============================================================================
+# Visualization
+# ============================================================================
+
+def plot_similarity_heatmap(sim_df: pd.DataFrame, title: str, save_path: str):
+    """Plot and save similarity heatmap with fixed category order."""
+    plt.figure(figsize=(10, 8))
+
+    available_order = [c for c in CATEGORY_ORDER if c in sim_df.index]
+    sim_df_ordered = sim_df.loc[available_order, available_order]
+
+    sns.heatmap(
+        sim_df_ordered,
+        annot=True,
+        fmt='.4f',
+        cmap='RdYlBu_r',
+        center=0.5,
+        vmin=0,
+        vmax=1,
+        square=True,
+        linewidths=0.5,
+        cbar_kws={'label': 'Cosine Similarity'}
+    )
+
+    plt.title(title, fontsize=14, fontweight='bold')
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved heatmap: {save_path}")
+
+
+def plot_comparison(results_list: List[dict], save_path: str):
+    """Plot comparison of similarity pairs across models."""
+    pairs = ['sim_above_far', 'sim_under_close', 'sim_left_right']
+    pair_labels = ['above-far', 'under-close', 'left-right']
+
+    fig, ax = plt.subplots(figsize=(12, 6))
+
+    x = np.arange(len(pairs))
+    width = 0.8 / len(results_list)
+
+    for i, result in enumerate(results_list):
+        model = result['model']
+        values = [result.get(p, 0) or 0 for p in pairs]
+        offset = (i - len(results_list) / 2 + 0.5) * width
+        bars = ax.bar(x + offset, values, width, label=model)
+
+        for bar, val in zip(bars, values):
+            if val:
+                ax.annotate(
+                    f'{val:.3f}',
+                    xy=(bar.get_x() + bar.get_width() / 2, bar.get_height()),
+                    xytext=(0, 3),
+                    textcoords='offset points',
+                    ha='center',
+                    va='bottom',
+                    fontsize=8
+                )
+
+    ax.set_ylabel('Cosine Similarity')
+    ax.set_title('Spatial Concept Similarity Comparison (Modified Format)\n(Hypothesis 4: above-far & under-close should be > left-right for vanilla)')
+    ax.set_xticks(x)
+    ax.set_xticklabels(pair_labels)
+    ax.legend(loc='upper right', fontsize=8)
+    ax.set_ylim(0, 1)
+    ax.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved comparison plot: {save_path}")
+
+
+def _extract_pair_trajectory(
+    all_layer_sims: Dict[int, pd.DataFrame],
+    cat1: str, cat2: str,
+) -> Tuple[List[int], List[float]]:
+    """Extract similarity values for a pair across all layers."""
+    layers = sorted(all_layer_sims.keys())
+    valid_layers = []
+    values = []
+    for l in layers:
+        df = all_layer_sims[l]
+        if cat1 in df.index and cat2 in df.columns:
+            valid_layers.append(l)
+            values.append(df.loc[cat1, cat2])
+    return valid_layers, values
+
+
+def get_representative_layers(all_layers: List[int], n: int = 5) -> List[int]:
+    """Pick n representative layers (evenly spaced) for heatmap output."""
+    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_similarity_trajectories(
+    all_layer_sims: Dict[int, pd.DataFrame],
+    title: str,
+    save_path: str,
+):
+    """Plot similarity of key category pairs across all layers.
+
+    Left panel: absolute cosine similarity per pair across layers.
+    Right panel: difference from left-right baseline (positive = more similar than L-R).
+    """
+    fig, axes = plt.subplots(1, 2, figsize=(20, 7))
+
+    # --- Left panel: absolute similarity ---
+    ax = axes[0]
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, '-', color=color, label=label, linewidth=2.5, markersize=0)
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['within_axis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, '--', color=color, label=label, linewidth=1.8, markersize=0)
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['counter_hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        ax.plot(layers, vals, ':', color=color, label=label, linewidth=1.5, alpha=0.8)
+
+    ax.set_xlabel('Layer Index', fontsize=12)
+    ax.set_ylabel('Cosine Similarity', fontsize=12)
+    ax.set_title(f'{title}\nPairwise Similarity Across Layers', fontsize=13)
+    ax.legend(fontsize=9, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    # --- Right panel: difference from left-right ---
+    ax = axes[1]
+    lr_layers, lr_vals = _extract_pair_trajectory(all_layer_sims, 'left', 'right')
+    lr_dict = dict(zip(lr_layers, lr_vals))
+
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, '-', color=color, label=f'{label} - left-right',
+                linewidth=2.5, markersize=0)
+
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['counter_hypothesis']:
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, ':', color=color, label=f'{label} - left-right',
+                linewidth=1.5, alpha=0.8)
+
+    # Also show above-under and far-close as references
+    for cat1, cat2, label, color in TRAJECTORY_PAIRS['within_axis']:
+        if label == 'left-right':
+            continue
+        layers, vals = _extract_pair_trajectory(all_layer_sims, cat1, cat2)
+        diffs = [v - lr_dict.get(l, 0) for l, v in zip(layers, vals)]
+        ax.plot(layers, diffs, '--', color=color, label=f'{label} - left-right',
+                linewidth=1.5, alpha=0.7)
+
+    ax.axhline(y=0, color='gray', linestyle='-', linewidth=1, alpha=0.5)
+    ax.set_xlabel('Layer Index', fontsize=12)
+    ax.set_ylabel('Similarity Difference (pair - left-right)', fontsize=12)
+    ax.set_title(f'{title}\nRelative to Left-Right Baseline', fontsize=13)
+    ax.legend(fontsize=8, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved trajectory plot: {save_path}")
+
+
+def plot_cross_scale_trajectories(
+    cross_scale_data: Dict[str, Dict[int, pd.DataFrame]],
+    model_type: str,
+    save_path: str,
+):
+    """Compare layer-wise trajectories across training scales.
+
+    3 columns: above-far, under-close, left-right (control).
+    Each subplot shows one line per scale.
+    """
+    pairs = [
+        ('above', 'far', 'above-far (hypothesis)'),
+        ('under', 'close', 'under-close (hypothesis)'),
+        ('left', 'right', 'left-right (control)'),
+    ]
+
+    fig, axes = plt.subplots(1, len(pairs), figsize=(7 * len(pairs), 6))
+    if len(pairs) == 1:
+        axes = [axes]
+
+    for idx, (cat1, cat2, label) in enumerate(pairs):
+        ax = axes[idx]
+        for scale in ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']:
+            if scale not in cross_scale_data:
+                continue
+            layer_sims = cross_scale_data[scale]
+            layers, vals = _extract_pair_trajectory(layer_sims, cat1, cat2)
+            color = SCALE_COLORS.get(scale, 'gray')
+            ax.plot(layers, vals, '-', color=color, label=scale, linewidth=2, markersize=0)
+
+        ax.set_xlabel('Layer Index', fontsize=12)
+        ax.set_ylabel('Cosine Similarity', fontsize=12)
+        ax.set_title(label, fontsize=13, fontweight='bold')
+        ax.legend(fontsize=10)
+        ax.grid(True, alpha=0.3)
+
+    fig.suptitle(
+        f'{model_type.upper()} - Similarity Trajectory 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 cross-scale trajectory: {save_path}")
+
+
+def plot_similarity_evolution_heatmap(
+    cross_scale_data: Dict[str, Dict[int, pd.DataFrame]],
+    model_type: str,
+    save_path: str,
+):
+    """2D heatmap: x=layer, y=scale, color=similarity for each hypothesis pair.
+
+    Gives a bird's-eye view of how both network depth and training data scale
+    affect the similarity between hypothesis-relevant category pairs.
+    """
+    pairs = [
+        ('above', 'far', 'above-far'),
+        ('under', 'close', 'under-close'),
+        ('left', 'right', 'left-right'),
+        ('above', 'under', 'above-under'),
+        ('far', 'close', 'far-close'),
+    ]
+    scale_order = ['vanilla', '80k', '400k', '800k', '2m', 'roborefer']
+    available_scales = [s for s in scale_order if s in cross_scale_data]
+
+    # Determine layer range from first available scale
+    first_scale = available_scales[0]
+    all_layers = sorted(cross_scale_data[first_scale].keys())
+
+    fig, axes = plt.subplots(len(pairs), 1, figsize=(max(14, len(all_layers) * 0.5), 3 * len(pairs)))
+    if len(pairs) == 1:
+        axes = [axes]
+
+    for idx, (cat1, cat2, label) in enumerate(pairs):
+        ax = axes[idx]
+        # Build matrix: rows=scales, cols=layers
+        matrix = np.full((len(available_scales), len(all_layers)), np.nan)
+        for si, scale in enumerate(available_scales):
+            layer_sims = cross_scale_data[scale]
+            for li, layer in enumerate(all_layers):
+                if layer in layer_sims:
+                    df = layer_sims[layer]
+                    if cat1 in df.index and cat2 in df.columns:
+                        matrix[si, li] = df.loc[cat1, cat2]
+
+        im = ax.imshow(matrix, aspect='auto', cmap='RdYlBu_r', vmin=0.5, vmax=1.0)
+        ax.set_yticks(range(len(available_scales)))
+        ax.set_yticklabels(available_scales, fontsize=10)
+
+        # X-axis: show every Nth layer label to avoid crowding
+        step = max(1, len(all_layers) // 15)
+        ax.set_xticks(range(0, len(all_layers), step))
+        ax.set_xticklabels([str(all_layers[i]) for i in range(0, len(all_layers), step)], fontsize=8)
+
+        ax.set_title(label, fontsize=12, fontweight='bold')
+        ax.set_xlabel('Layer Index', fontsize=10)
+        fig.colorbar(im, ax=ax, label='Cosine Similarity', shrink=0.8)
+
+    fig.suptitle(
+        f'{model_type.upper()} - Similarity Evolution (Layer x Scale)',
+        fontsize=15, fontweight='bold', y=1.01
+    )
+    plt.tight_layout()
+    plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    logger.info(f"Saved evolution heatmap: {save_path}")
+
+
+# ============================================================================
+# Model Configurations
+# ============================================================================
+
+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',
+    },
+}
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(description='Experiment 2-A (Modified): Embedding Space 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_modified/results_all_layers')
+    parser.add_argument('--samples_per_category', type=int, default=200)
+    parser.add_argument('--device', type=str, default='cuda')
+    parser.add_argument('--seed', type=int, default=42)
+
+    args = parser.parse_args()
+
+    # Auto-include roborefer for nvila if not already specified
+    if args.model_type == 'nvila' and 'roborefer' not in args.scales:
+        args.scales.append('roborefer')
+
+    # Set random seed
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    random.seed(args.seed)
+
+    # Create output directory
+    output_dir = os.path.join(args.output_dir, args.model_type)
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Load and modify data
+    logger.info("\n=== Loading & Modifying EmbSpatialBench Data ===")
+    data = load_and_modify_data(args.data_path, args.samples_per_category, args.seed)
+
+    results_list = []
+    cross_scale_data = {}  # scale -> {layer_idx -> sim_df}
+    model_configs = MODEL_CONFIGS[args.model_type]
+
+    for scale in args.scales:
+        if scale not in model_configs:
+            logger.warning(f"Scale {scale} not available for {args.model_type}, skipping...")
+            continue
+
+        model_path = model_configs[scale]
+
+        if not os.path.exists(model_path) and not model_path.startswith('Qwen/') and not model_path.startswith('allenai/'):
+            logger.warning(f"Model path not found: {model_path}, skipping...")
+            continue
+
+        logger.info(f"\n=== Processing {args.model_type} - {scale} ===")
+        logger.info(f"Model path: {model_path}")
+
+        try:
+            extractor = get_extractor(
+                args.model_type,
+                model_path,
+                scale=scale,
+                device=args.device,
+            )
+
+            num_layers = len(extractor.target_layers)
+
+            # Extract representations for ALL layers in one pass
+            all_layer_reps = extract_all_layer_representations(extractor, data)
+
+            # Compute similarity matrices for all layers
+            scale_sims = {}
+            model_name = f"{args.model_type}_{scale}"
+            for layer_idx in sorted(all_layer_reps.keys()):
+                sim_df = compute_similarity_matrix(all_layer_reps[layer_idx])
+                scale_sims[layer_idx] = sim_df
+
+                results = analyze_hypothesis(sim_df, model_name)
+                results['layer_idx'] = layer_idx
+                results_list.append(results)
+
+                # Save CSV for every layer
+                sim_df.to_csv(os.path.join(output_dir, f'similarity_{scale}_L{layer_idx}.csv'))
+
+            cross_scale_data[scale] = scale_sims
+            logger.info(f"  Computed similarity matrices for {len(scale_sims)} layers")
+
+            # Save heatmaps for representative layers only (to avoid hundreds of files)
+            rep_layers = get_representative_layers(sorted(scale_sims.keys()))
+            logger.info(f"  Saving heatmaps for representative layers: {rep_layers}")
+            for layer_idx in rep_layers:
+                sim_df = scale_sims[layer_idx]
+                plot_similarity_heatmap(
+                    sim_df,
+                    f'{args.model_type.upper()} ({scale}) - Layer {layer_idx}/{num_layers-1}',
+                    os.path.join(output_dir, f'heatmap_{scale}_L{layer_idx}.png')
+                )
+
+            # Per-scale trajectory plot
+            plot_similarity_trajectories(
+                scale_sims,
+                f'{args.model_type.upper()} ({scale})',
+                os.path.join(output_dir, f'trajectory_{scale}.png')
+            )
+
+            extractor.cleanup()
+
+        except Exception as e:
+            logger.error(f"Failed to process {args.model_type} - {scale}: {e}")
+            import traceback
+            traceback.print_exc()
+            continue
+
+    # Cross-scale comparison plots
+    if len(cross_scale_data) > 1:
+        plot_cross_scale_trajectories(
+            cross_scale_data,
+            args.model_type,
+            os.path.join(output_dir, 'trajectory_cross_scale.png')
+        )
+        plot_similarity_evolution_heatmap(
+            cross_scale_data,
+            args.model_type,
+            os.path.join(output_dir, 'evolution_heatmap.png')
+        )
+
+    # Save results summary
+    if results_list:
+        results_df = pd.DataFrame(results_list)
+        results_df.to_csv(os.path.join(output_dir, 'results_summary.csv'), index=False)
+
+    logger.info("\n=== Analysis Complete ===")
+    logger.info(f"Results saved to: {output_dir}")
+    logger.info(f"Total: {len(results_list)} (layer, scale) combinations across {len(cross_scale_data)} scales")
+
+
+if __name__ == '__main__':
+    main()

exp2a_modified/results/molmo/results_summary.csv

@@ -0,0 +1,26 @@
+model,sim_above_far,sim_under_close,sim_left_right,diff_above_far_vs_left_right,diff_under_close_vs_left_right,layer_idx,layer_label
+molmo_vanilla,0.93186307,0.9325508,0.9999072,-0.068044126,-0.06735641,6,early
+molmo_vanilla,0.9252183,0.925783,0.9996471,-0.0744288,-0.0738641,13,early_mid
+molmo_vanilla,0.8514263,0.85130924,0.9945253,-0.14309901,-0.14321607,19,middle
+molmo_vanilla,0.7811126,0.7902819,0.9955554,-0.21444279,-0.20527351,26,late_mid
+molmo_vanilla,0.82378054,0.8320327,0.9968723,-0.17309177,-0.16483963,31,late
+molmo_80k,0.94482744,0.9447468,0.9999342,-0.05510676,-0.055187404,6,early
+molmo_80k,0.9501332,0.9501227,0.99982655,-0.049693346,-0.049703836,13,early_mid
+molmo_80k,0.8622559,0.86525977,0.9953824,-0.13312656,-0.13012266,19,middle
+molmo_80k,0.7678993,0.780402,0.99710876,-0.22920948,-0.21670675,26,late_mid
+molmo_80k,0.8963089,0.9020278,0.99889964,-0.10259074,-0.09687185,31,late
+molmo_400k,0.94099295,0.9413343,0.9999467,-0.058953762,-0.058612406,6,early
+molmo_400k,0.93268144,0.93169504,0.9983739,-0.065692484,-0.06667888,13,early_mid
+molmo_400k,0.8004133,0.7915684,0.9835917,-0.18317837,-0.19202328,19,middle
+molmo_400k,0.73278224,0.7314169,0.98859596,-0.25581372,-0.25717908,26,late_mid
+molmo_400k,0.9089592,0.911077,0.99682474,-0.08786553,-0.08574772,31,late
+molmo_800k,0.9501749,0.95063716,0.9999551,-0.04978019,-0.049317956,6,early
+molmo_800k,0.92944044,0.92717594,0.9990981,-0.06965768,-0.07192218,13,early_mid
+molmo_800k,0.7842552,0.7732489,0.9752356,-0.19098037,-0.20198667,19,middle
+molmo_800k,0.7602978,0.7757774,0.9868044,-0.22650665,-0.21102703,26,late_mid
+molmo_800k,0.9205744,0.9238774,0.99709034,-0.07651591,-0.07321292,31,late
+molmo_2m,0.95355743,0.9536563,0.99995154,-0.04639411,-0.046295226,6,early
+molmo_2m,0.9074487,0.9029928,0.999149,-0.091700315,-0.09615624,13,early_mid
+molmo_2m,0.74899715,0.7498276,0.9528682,-0.20387107,-0.2030406,19,middle
+molmo_2m,0.72931236,0.751271,0.9772682,-0.24795586,-0.22599721,26,late_mid
+molmo_2m,0.9040614,0.9161786,0.99538875,-0.09132737,-0.07921016,31,late

exp2a_modified/results/molmo/similarity_2m_L19_middle.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999994,0.9528682,0.8079404,0.7898549,0.75441873,0.74726176
+right,0.9528682,1.0,0.79594153,0.79201853,0.74864805,0.74139905
+above,0.8079404,0.79594153,1.0,0.86362475,0.74899715,0.72680587
+under,0.7898549,0.79201853,0.86362475,0.9999998,0.73787785,0.7498276
+far,0.75441873,0.74864805,0.74899715,0.73787785,1.0000002,0.99016166
+close,0.74726176,0.74139905,0.72680587,0.7498276,0.99016166,0.99999976

exp2a_modified/results/molmo/similarity_2m_L26_late_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000001,0.9772682,0.82484055,0.81500334,0.7462688,0.73856544
+right,0.9772682,1.0,0.81542575,0.81403667,0.73317695,0.7264032
+above,0.82484055,0.81542575,1.0,0.915252,0.72931236,0.7135039
+under,0.81500334,0.81403667,0.915252,1.0000001,0.74381506,0.751271
+far,0.7462688,0.73317695,0.72931236,0.74381506,0.9999998,0.9895668
+close,0.73856544,0.7264032,0.7135039,0.751271,0.9895668,1.0000005

exp2a_modified/results/molmo/similarity_2m_L31_late.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999976,0.99538875,0.94726926,0.945658,0.9218228,0.9192073
+right,0.99538875,0.9999996,0.94363815,0.9437132,0.9156522,0.91351354
+above,0.94726926,0.94363815,1.0,0.9741205,0.9040614,0.8990477
+under,0.945658,0.9437132,0.9741205,0.9999998,0.91565245,0.9161786
+far,0.9218228,0.9156522,0.9040614,0.91565245,0.999999,0.9976242
+close,0.9192073,0.91351354,0.8990477,0.9161786,0.9976242,1.0000002

exp2a_modified/results/molmo/similarity_2m_L6_early.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000001,0.99995154,0.9897138,0.9891182,0.95365894,0.9537702
+right,0.99995154,1.0000001,0.98972285,0.9891555,0.95393157,0.9540078
+above,0.9897138,0.98972285,0.9999999,0.99978626,0.95355743,0.9535313
+under,0.9891182,0.9891555,0.99978626,1.0000004,0.95373374,0.9536563
+far,0.95365894,0.95393157,0.95355743,0.95373374,0.9999998,0.9998942
+close,0.9537702,0.9540078,0.9535313,0.9536563,0.9998942,0.9999999

exp2a_modified/results/molmo/similarity_400k_L13_early_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000005,0.9983739,0.9708368,0.97001463,0.92518365,0.92525065
+right,0.9983739,1.0000001,0.9714834,0.9709337,0.9258892,0.9259387
+above,0.9708368,0.9714834,1.0000001,0.9966369,0.93268144,0.93088496
+under,0.97001463,0.9709337,0.9966369,1.0000001,0.931912,0.93169504
+far,0.92518365,0.9258892,0.93268144,0.931912,1.0,0.9991321
+close,0.92525065,0.9259387,0.93088496,0.93169504,0.9991321,1.0000002

exp2a_modified/results/molmo/similarity_400k_L19_middle.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000001,0.9835917,0.89433604,0.8799748,0.8249269,0.82165074
+right,0.9835917,1.0,0.89446956,0.8852003,0.82732373,0.82341003
+above,0.89433604,0.89446956,1.0,0.9350607,0.8004133,0.78341514
+under,0.8799748,0.8852003,0.9350607,1.0000004,0.7830846,0.7915684
+far,0.8249269,0.82732373,0.8004133,0.7830846,1.0000001,0.9916222
+close,0.82165074,0.82341003,0.78341514,0.7915684,0.9916222,0.9999999

exp2a_modified/results/molmo/similarity_400k_L26_late_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000002,0.98859596,0.87158585,0.858461,0.78897005,0.7835145
+right,0.98859596,0.99999994,0.8694842,0.8613639,0.78442615,0.779482
+above,0.87158585,0.8694842,1.0000007,0.9409423,0.73278224,0.7150828
+under,0.858461,0.8613639,0.9409423,0.9999998,0.7253824,0.7314169
+far,0.78897005,0.78442615,0.73278224,0.7253824,0.9999997,0.9895003
+close,0.7835145,0.779482,0.7150828,0.7314169,0.9895003,0.9999997

exp2a_modified/results/molmo/similarity_400k_L31_late.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000001,0.99682474,0.95443934,0.95085055,0.92124707,0.9183261
+right,0.99682474,1.0000005,0.9529462,0.95104045,0.91831386,0.91579354
+above,0.95443934,0.9529462,0.99999976,0.9797501,0.9089592,0.90330064
+under,0.95085055,0.95104045,0.9797501,1.0000005,0.910488,0.911077
+far,0.92124707,0.91831386,0.9089592,0.910488,1.0000002,0.99741966
+close,0.9183261,0.91579354,0.90330064,0.911077,0.99741966,1.0000001

exp2a_modified/results/molmo/similarity_400k_L6_early.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999999,0.9999467,0.98677695,0.98590326,0.9344799,0.93451536
+right,0.9999467,0.9999999,0.9866656,0.98579997,0.9344424,0.9344614
+above,0.98677695,0.9866656,1.0000002,0.9997301,0.94099295,0.94090044
+under,0.98590326,0.98579997,0.9997301,1.0,0.94144833,0.9413343
+far,0.9344799,0.9344424,0.94099295,0.94144833,0.9999999,0.9999009
+close,0.93451536,0.9344614,0.94090044,0.9413343,0.9999009,1.0000001

exp2a_modified/results/molmo/similarity_800k_L13_early_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000002,0.9990981,0.970269,0.96832395,0.9112702,0.91077095
+right,0.9990981,1.0000005,0.97084796,0.96887577,0.9112278,0.9107026
+above,0.970269,0.97084796,1.0,0.9983258,0.92944044,0.9281176
+under,0.96832395,0.96887577,0.9983258,1.0000006,0.9282915,0.92717594
+far,0.9112702,0.9112278,0.92944044,0.9282915,0.9999999,0.9996043
+close,0.91077095,0.9107026,0.9281176,0.92717594,0.9996043,0.99999946

exp2a_modified/results/molmo/similarity_800k_L26_late_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999996,0.9868044,0.8516903,0.8428743,0.7809909,0.77917296
+right,0.9868044,0.9999997,0.84324884,0.84005576,0.7758011,0.7743711
+above,0.8516903,0.84324884,1.0000004,0.94099367,0.7602978,0.74670935
+under,0.8428743,0.84005576,0.94099367,0.9999995,0.76920235,0.7757774
+far,0.7809909,0.7758011,0.7602978,0.76920235,0.9999997,0.9897728
+close,0.77917296,0.7743711,0.74670935,0.7757774,0.9897728,0.9999995

exp2a_modified/results/molmo/similarity_800k_L31_late.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999946,0.99709034,0.95449007,0.95249826,0.9339559,0.9329122
+right,0.99709034,0.9999998,0.9512191,0.95042264,0.9298728,0.9291853
+above,0.95449007,0.9512191,1.0000004,0.9820097,0.9205744,0.9159472
+under,0.95249826,0.95042264,0.9820097,1.0,0.9233836,0.9238774
+far,0.9339559,0.9298728,0.9205744,0.9233836,1.0,0.9976558
+close,0.9329122,0.9291853,0.9159472,0.9238774,0.9976558,0.99999976

exp2a_modified/results/molmo/similarity_800k_L6_early.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999995,0.9999551,0.98933417,0.9887577,0.9477357,0.9479904
+right,0.9999551,0.9999999,0.9892925,0.98874366,0.9477358,0.94796
+above,0.98933417,0.9892925,0.9999998,0.999767,0.9501749,0.9503241
+under,0.9887577,0.98874366,0.999767,0.99999964,0.95052344,0.95063716
+far,0.9477357,0.9477358,0.9501749,0.95052344,0.9999996,0.9999156
+close,0.9479904,0.94796,0.9503241,0.95063716,0.9999156,1.0000001

exp2a_modified/results/molmo/similarity_80k_L13_early_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000001,0.99982655,0.98557615,0.98462695,0.94595236,0.9460132
+right,0.99982655,0.99999964,0.9854151,0.984502,0.94524086,0.9452381
+above,0.98557615,0.9854151,0.99999964,0.9995325,0.9501332,0.9496666
+under,0.98462695,0.984502,0.9995325,1.0,0.950608,0.9501227
+far,0.94595236,0.94524086,0.9501332,0.950608,1.0000001,0.99974734
+close,0.9460132,0.9452381,0.9496666,0.9501227,0.99974734,1.0000001

exp2a_modified/results/molmo/similarity_80k_L19_middle.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999999,0.9953824,0.951213,0.9497772,0.87746465,0.8757486
+right,0.9953824,1.0000002,0.9533331,0.95202667,0.8783575,0.87553334
+above,0.951213,0.9533331,0.9999997,0.9892175,0.8622559,0.8543509
+under,0.9497772,0.95202667,0.9892175,1.0000002,0.86614037,0.86525977
+far,0.87746465,0.8783575,0.8622559,0.86614037,1.0000001,0.9966103
+close,0.8757486,0.87553334,0.8543509,0.86525977,0.9966103,1.0000001

exp2a_modified/results/molmo/similarity_80k_L26_late_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0,0.99710876,0.94322985,0.94265085,0.8083289,0.80842566
+right,0.99710876,1.0,0.9450414,0.94532174,0.80541736,0.80532265
+above,0.94322985,0.9450414,1.0000002,0.98973715,0.7678993,0.7628029
+under,0.94265085,0.94532174,0.98973715,1.0000006,0.7791806,0.780402
+far,0.8083289,0.80541736,0.7678993,0.7791806,1.0000001,0.9953803
+close,0.80842566,0.80532265,0.7628029,0.780402,0.9953803,0.9999997

exp2a_modified/results/molmo/similarity_80k_L31_late.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999994,0.99889964,0.9706672,0.97065854,0.91552895,0.9142971
+right,0.99889964,1.0000006,0.97100496,0.97146505,0.9128623,0.91171795
+above,0.9706672,0.97100496,1.0000001,0.99551195,0.8963089,0.89303714
+under,0.97065854,0.97146505,0.99551195,1.0,0.9027907,0.9020278
+far,0.91552895,0.9128623,0.8963089,0.9027907,1.0,0.99814963
+close,0.9142971,0.91171795,0.89303714,0.9020278,0.99814963,1.0

exp2a_modified/results/molmo/similarity_80k_L6_early.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000005,0.9999342,0.9846145,0.9833463,0.9410094,0.9415399
+right,0.9999342,1.0000002,0.9844082,0.9831588,0.9409639,0.9414707
+above,0.9846145,0.9844082,0.9999996,0.99965036,0.94482744,0.9451473
+under,0.9833463,0.9831588,0.99965036,1.0000004,0.94445574,0.9447468
+far,0.9410094,0.9409639,0.94482744,0.94445574,1.0000002,0.9998886
+close,0.9415399,0.9414707,0.9451473,0.9447468,0.9998886,1.0000001

exp2a_modified/results/molmo/similarity_vanilla_L13_early_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999976,0.9996471,0.98403525,0.98292845,0.91606426,0.9160556
+right,0.9996471,0.99999994,0.98429143,0.983286,0.9153532,0.9152582
+above,0.98403525,0.98429143,1.0000002,0.9989633,0.9252183,0.9246333
+under,0.98292845,0.983286,0.9989633,1.0,0.9264116,0.925783
+far,0.91606426,0.9153532,0.9252183,0.9264116,0.9999999,0.99945354
+close,0.9160556,0.9152582,0.9246333,0.925783,0.99945354,0.99999976

exp2a_modified/results/molmo/similarity_vanilla_L19_middle.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999976,0.9945253,0.96206295,0.9596552,0.8591312,0.85741884
+right,0.9945253,0.9999999,0.9645537,0.96271646,0.85745674,0.8543235
+above,0.96206295,0.9645537,1.0,0.9921303,0.8514263,0.8453121
+under,0.9596552,0.96271646,0.9921303,1.0000005,0.8540211,0.85130924
+far,0.8591312,0.85745674,0.8514263,0.8540211,0.99999976,0.9961321
+close,0.85741884,0.8543235,0.8453121,0.85130924,0.9961321,0.99999976

exp2a_modified/results/molmo/similarity_vanilla_L31_late.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000004,0.9968723,0.96832633,0.96827185,0.8455303,0.84230846
+right,0.9968723,0.99999964,0.97106063,0.9713094,0.8435764,0.83977795
+above,0.96832633,0.97106063,0.9999999,0.9944878,0.82378054,0.8183431
+under,0.96827185,0.9713094,0.9944878,1.0000004,0.8355485,0.8320327
+far,0.8455303,0.8435764,0.82378054,0.8355485,1.0000001,0.9970446
+close,0.84230846,0.83977795,0.8183431,0.8320327,0.9970446,0.99999976

exp2a_modified/results/molmo/similarity_vanilla_L6_early.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000005,0.9999072,0.9843363,0.98275346,0.9225271,0.92304546
+right,0.9999072,0.99999976,0.98413754,0.9825534,0.9222437,0.9227377
+above,0.9843363,0.98413754,0.99999976,0.99941427,0.93186307,0.9320967
+under,0.98275346,0.9825534,0.99941427,1.0000001,0.932338,0.9325508
+far,0.9225271,0.9222437,0.93186307,0.932338,1.0000005,0.9998285
+close,0.92304546,0.9227377,0.9320967,0.9325508,0.9998285,1.0000001

exp2a_modified/results/nvila/similarity_2m_L11_early_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000004,0.99997437,0.99205077,0.9921235,0.9665318,0.96630245
+right,0.99997437,1.0000001,0.9920338,0.99214566,0.966442,0.9661902
+above,0.99205077,0.9920338,1.0000002,0.99985087,0.97557366,0.97540605
+under,0.9921235,0.99214566,0.99985087,0.99999964,0.97505516,0.9748245
+far,0.9665318,0.966442,0.97557366,0.97505516,0.9999999,0.99989897
+close,0.96630245,0.9661902,0.97540605,0.9748245,0.99989897,1.0000004

exp2a_modified/results/nvila/similarity_2m_L6_early.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0,0.9999543,0.99784696,0.9978435,0.98729,0.98708475
+right,0.9999543,0.99999934,0.9977713,0.9978466,0.9870302,0.98678756
+above,0.99784696,0.9977713,1.0000005,0.99984324,0.9882744,0.9881075
+under,0.9978435,0.9978466,0.99984324,0.9999999,0.987956,0.9877119
+far,0.98729,0.9870302,0.9882744,0.987956,0.9999998,0.99992377
+close,0.98708475,0.98678756,0.9881075,0.9877119,0.99992377,0.99999994

exp2a_modified/results/nvila/similarity_400k_L22_late_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000001,0.98938745,0.94574475,0.9383662,0.84551483,0.8435887
+right,0.98938745,1.0000005,0.944611,0.942079,0.8478445,0.84517944
+above,0.94574475,0.944611,0.9999996,0.98561645,0.8716479,0.86627376
+under,0.9383662,0.942079,0.98561645,0.99999964,0.8625552,0.8639274
+far,0.84551483,0.8478445,0.8716479,0.8625552,0.9999995,0.9961122
+close,0.8435887,0.84517944,0.86627376,0.8639274,0.9961122,1.0

exp2a_modified/results/nvila/similarity_800k_L27_late.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999998,0.9998052,0.99807984,0.9981629,0.9949574,0.9949126
+right,0.9998052,0.99999976,0.99777746,0.9980407,0.9950078,0.9949836
+above,0.99807984,0.99777746,0.9999996,0.9994222,0.9953831,0.995184
+under,0.9981629,0.9980407,0.9994222,1.0000001,0.99535114,0.9954171
+far,0.9949574,0.9950078,0.9953831,0.99535114,1.0000008,0.9998271
+close,0.9949126,0.9949836,0.995184,0.9954171,0.9998271,0.99999976

exp2a_modified/results/nvila/similarity_80k_L11_early_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999964,0.99997884,0.98755705,0.9873893,0.95973134,0.9595373
+right,0.99997884,1.0,0.9876951,0.9875475,0.959848,0.9596424
+above,0.98755705,0.9876951,1.0,0.99975145,0.971831,0.97180074
+under,0.9873893,0.9875475,0.99975145,1.0,0.972558,0.972438
+far,0.95973134,0.959848,0.971831,0.972558,0.9999996,0.9999212
+close,0.9595373,0.9596424,0.97180074,0.972438,0.9999212,1.0000001

exp2a_modified/results/nvila/similarity_80k_L17_middle.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0,0.9781369,0.9310158,0.9325685,0.8561556,0.8558693
+right,0.9781369,1.0000004,0.9284675,0.94139105,0.86132264,0.86142904
+above,0.9310158,0.9284675,0.9999999,0.98366034,0.8978678,0.8936629
+under,0.9325685,0.94139105,0.98366034,0.9999999,0.8987944,0.8984088
+far,0.8561556,0.86132264,0.8978678,0.8987944,1.0,0.9990812
+close,0.8558693,0.86142904,0.8936629,0.8984088,0.9990812,0.99999976

exp2a_modified/results/nvila/similarity_80k_L22_late_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000002,0.98724145,0.92874,0.9283841,0.850011,0.8500076
+right,0.98724145,0.9999997,0.9257482,0.9328269,0.84493864,0.8449371
+above,0.92874,0.9257482,0.9999999,0.9870798,0.8770188,0.8740602
+under,0.9283841,0.9328269,0.9870798,1.0,0.8692532,0.8702637
+far,0.850011,0.84493864,0.8770188,0.8692532,1.0,0.99855036
+close,0.8500076,0.8449371,0.8740602,0.8702637,0.99855036,1.0000004

exp2a_modified/results/nvila/similarity_80k_L27_late.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000004,0.99955857,0.9954845,0.9956236,0.992975,0.9930063
+right,0.99955857,0.99999994,0.9953584,0.99582684,0.9927686,0.9928009
+above,0.9954845,0.9953584,1.0000001,0.99934226,0.9929427,0.99282837
+under,0.9956236,0.99582684,0.99934226,1.0000004,0.99276465,0.99287665
+far,0.992975,0.9927686,0.9929427,0.99276465,1.0,0.9998536
+close,0.9930063,0.9928009,0.99282837,0.99287665,0.9998536,1.0

exp2a_modified/results/nvila/similarity_vanilla_L22_late_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999994,0.9937971,0.91717666,0.9179457,0.8878075,0.88723373
+right,0.9937971,1.0000001,0.9206685,0.92282534,0.8912285,0.8903196
+above,0.91717666,0.9206685,0.9999998,0.9956542,0.9163888,0.91370475
+under,0.9179457,0.92282534,0.9956542,0.9999995,0.9187532,0.9182395
+far,0.8878075,0.8912285,0.9163888,0.9187532,1.0000004,0.9987387
+close,0.88723373,0.8903196,0.91370475,0.9182395,0.9987387,1.0000002

exp2a_modified/results/nvila/similarity_vanilla_L6_early.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000004,0.9997542,0.98725057,0.9877901,0.96586967,0.9646027
+right,0.9997542,0.99999994,0.98683053,0.9876104,0.96541184,0.9639078
+above,0.98725057,0.98683053,1.0000002,0.9994803,0.9768777,0.9762193
+under,0.9877901,0.9876104,0.9994803,1.0,0.97659093,0.9755331
+far,0.96586967,0.96541184,0.9768777,0.97659093,1.0000004,0.99978113
+close,0.9646027,0.9639078,0.9762193,0.9755331,0.99978113,1.0000002

exp2a_modified/results/qwen/results_summary.csv

@@ -0,0 +1,26 @@
+model,sim_above_far,sim_under_close,sim_left_right,diff_above_far_vs_left_right,diff_under_close_vs_left_right,layer_idx,layer_label
+qwen_vanilla,0.9878544,0.9878074,0.9999392,-0.012084782,-0.01213181,7,early
+qwen_vanilla,0.98418283,0.98290306,0.9998846,-0.01570177,-0.016981542,14,early_mid
+qwen_vanilla,0.9776592,0.9756624,0.99965596,-0.021996737,-0.023993552,22,middle
+qwen_vanilla,0.95032614,0.94788146,0.99512017,-0.044794023,-0.047238708,29,late_mid
+qwen_vanilla,0.9415084,0.93939054,0.99848515,-0.056976736,-0.059094608,35,late
+qwen_80k,0.9885977,0.98850304,0.99993646,-0.01133877,-0.011433423,7,early
+qwen_80k,0.9823469,0.98100173,0.99989814,-0.017551243,-0.0188964,14,early_mid
+qwen_80k,0.96985906,0.96774256,0.99973243,-0.029873371,-0.031989872,22,middle
+qwen_80k,0.94964135,0.94838035,0.99680495,-0.047163606,-0.0484246,29,late_mid
+qwen_80k,0.91188186,0.91212624,0.9987229,-0.08684105,-0.08659667,35,late
+qwen_400k,0.9894593,0.9892013,0.99994236,-0.010483086,-0.010741055,7,early
+qwen_400k,0.9844377,0.98320484,0.99993646,-0.015498757,-0.01673162,14,early_mid
+qwen_400k,0.9699773,0.9682413,0.9997704,-0.029793084,-0.03152913,22,middle
+qwen_400k,0.9580884,0.9558412,0.9983553,-0.04026693,-0.042514145,29,late_mid
+qwen_400k,0.9148766,0.9173591,0.99830496,-0.08342838,-0.08094585,35,late
+qwen_800k,0.9899683,0.9896326,0.99994457,-0.009976268,-0.010311961,7,early
+qwen_800k,0.9868173,0.98572755,0.99994314,-0.013125837,-0.014215589,14,early_mid
+qwen_800k,0.9739447,0.9729233,0.9997934,-0.025848687,-0.026870131,22,middle
+qwen_800k,0.95486164,0.95309997,0.9981552,-0.043293536,-0.04505521,29,late_mid
+qwen_800k,0.9358968,0.93043613,0.99775326,-0.06185645,-0.06731713,35,late
+qwen_2m,0.9908798,0.9905167,0.9999402,-0.009060442,-0.009423494,7,early
+qwen_2m,0.989565,0.98875475,0.9999511,-0.010386109,-0.011196375,14,early_mid
+qwen_2m,0.9692019,0.9686675,0.9997675,-0.03056556,-0.031099975,22,middle
+qwen_2m,0.93922085,0.93831193,0.9968462,-0.057625353,-0.058534265,29,late_mid
+qwen_2m,0.9208069,0.9072825,0.9965475,-0.075740635,-0.08926505,35,late

exp2a_modified/results/qwen/similarity_2m_L14_early_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999998,0.9999511,0.99657696,0.996454,0.98376906,0.9835031
+right,0.9999511,1.0,0.99654865,0.99649066,0.98354805,0.98321724
+above,0.99657696,0.99654865,1.0000001,0.9999223,0.989565,0.9892365
+under,0.996454,0.99649066,0.9999223,1.0000001,0.98912716,0.98875475
+far,0.98376906,0.98354805,0.989565,0.98912716,1.0000005,0.9999435
+close,0.9835031,0.98321724,0.9892365,0.98875475,0.9999435,1.0

exp2a_modified/results/qwen/similarity_2m_L22_middle.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999976,0.9997675,0.98960626,0.9895336,0.9607725,0.9608675
+right,0.9997675,1.0,0.9901829,0.99017763,0.96098214,0.96100146
+above,0.98960626,0.9901829,0.9999995,0.99960077,0.9692019,0.9689368
+under,0.9895336,0.99017763,0.99960077,0.9999995,0.96889305,0.9686675
+far,0.9607725,0.96098214,0.9692019,0.96889305,0.9999999,0.999784
+close,0.9608675,0.96100146,0.9689368,0.9686675,0.999784,1.0

exp2a_modified/results/qwen/similarity_2m_L29_late_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.99999976,0.9968462,0.96972966,0.9656495,0.9295452,0.9282496
+right,0.9968462,1.0000004,0.9678302,0.96753937,0.9298134,0.92841697
+above,0.96972966,0.9678302,0.99999964,0.99251354,0.93922085,0.93715733
+under,0.9656495,0.96753937,0.99251354,0.9999999,0.9394452,0.93831193
+far,0.9295452,0.9298134,0.93922085,0.9394452,0.9999995,0.9991802
+close,0.9282496,0.92841697,0.93715733,0.93831193,0.9991802,0.9999995

exp2a_modified/results/qwen/similarity_2m_L35_late.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,1.0000002,0.9965475,0.9649773,0.96030045,0.8989403,0.89823353
+right,0.9965475,1.0,0.9598953,0.9629967,0.8915997,0.89078486
+above,0.9649773,0.9598953,1.0000002,0.98364305,0.9208069,0.9149355
+under,0.96030045,0.9629967,0.98364305,1.0,0.9093851,0.9072825
+far,0.8989403,0.8915997,0.9208069,0.9093851,0.99999994,0.996667
+close,0.89823353,0.89078486,0.9149355,0.9072825,0.996667,0.99999976

exp2a_modified/results/qwen/similarity_2m_L7_early.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999995,0.9999402,0.9966904,0.9964489,0.98790896,0.9878886
+right,0.9999402,0.9999999,0.996633,0.9964943,0.98773515,0.987622
+above,0.9966904,0.996633,0.99999964,0.99989176,0.9908798,0.9907012
+under,0.9964489,0.9964943,0.99989176,1.0000005,0.9907862,0.9905167
+far,0.98790896,0.98773515,0.9908798,0.9907862,1.0,0.999933
+close,0.9878886,0.987622,0.9907012,0.9905167,0.999933,1.0000002

exp2a_modified/results/qwen/similarity_400k_L14_early_mid.csv

@@ -0,0 +1,7 @@
+,left,right,above,under,far,close
+left,0.9999994,0.99993646,0.9955939,0.99546295,0.97487485,0.9744284
+right,0.99993646,0.9999994,0.9957069,0.9956356,0.97504747,0.9745439
+above,0.9955939,0.9957069,0.9999995,0.99986076,0.9844377,0.98397595
+under,0.99546295,0.9956356,0.99986076,1.0,0.9837175,0.98320484
+far,0.97487485,0.97504747,0.9844377,0.9837175,0.9999999,0.9999202
+close,0.9744284,0.9745439,0.98397595,0.98320484,0.9999202,1.0