import argparse import inspect import json import math import os import random import re import sys import time from functools import wraps from pathlib import Path from typing import Dict, List, Optional, Tuple import torch from PIL import Image from transformers import AutoTokenizer from transformers.generation.logits_process import LogitsProcessorList REPO_ROOT = Path(__file__).resolve().parents[2] DEFAULT_UPSTREAM_SGL_ROOT = Path(os.environ.get("UPSTREAM_SGL_ROOT", "/home/yf/snap/SGL")) if str(DEFAULT_UPSTREAM_SGL_ROOT) not in sys.path: sys.path.insert(0, str(DEFAULT_UPSTREAM_SGL_ROOT)) eval_vqa_path = DEFAULT_UPSTREAM_SGL_ROOT / "eval" / "vqa" if str(eval_vqa_path) not in sys.path: sys.path.insert(0, str(eval_vqa_path)) from internvl.conversation import get_conv_template from internvl.model.internvl_chat import InternVLChatModel from internvl.model.internvl_chat.configuration_internvl_chat import InternVLChatConfig from internvl.train.dataset import build_transform, dynamic_preprocess from textvqa_eval import TextVQAAccuracyEvaluator BASE_PROMPT = "Answer the question using a single word or phrase." BASE_PROMPT_SUFFIX = " " + BASE_PROMPT HIDDEN_REASONING_INSTRUCTION = ( "Think through the relevant visual evidence and any text in the image step by step internally before answering." ) EXPLICIT_REASONING_INSTRUCTION = ( "Explain your reasoning step by step using the relevant visual evidence and any text in the image." ) DEFAULT_FINAL_ANSWER_INSTRUCTION = "Provide the final answer only." GUIDE_ATTENTION_COT_PROMPT_TEMPLATE = """You are solving a TextVQA task. Read the image carefully, especially visible text. Reason through the answer in at least 5 explicit steps. Do not skip the reasoning. Question: {question} 1. 2. 3. 4. 5. Final answer:""" GUIDE_ATTENTION_REASONING_ONLY_PROMPT_TEMPLATE = """You are solving a TextVQA task. Read the image carefully, especially all visible text. Reason using only evidence from the image and OCR text. You must output exactly 5 numbered reasoning steps. Each step must be a short sentence. Do not provide the final answer. Do not provide a summary. Do not output any text other than the 5 numbered steps. Question: {question} 1. Identify the most relevant visible text or object. 2. Explain how that evidence relates to the question. 3. Check for another supporting clue in the image. 4. Resolve any ambiguity using the strongest evidence. 5. State the final reasoning conclusion without giving the final answer.""" GUIDE_ATTENTION_EXPLICIT_COT_INSTRUCTION = ( "First reason step by step using the relevant visual evidence and OCR text. " "Then end with a new line in the exact format: Answer: ." ) GUIDE_TEXT_HINT_INSTRUCTION = ( "Give a very short guide hint grounded in the image and OCR text. Use a short phrase, not a full sentence." ) GUIDED_DECODE_INSTRUCTION = ( "Use the guide hint only if it matches the image. Answer the question using a single word or phrase." ) REASONING_FILTER_STOPWORDS = { "a", "an", "and", "are", "as", "at", "be", "because", "but", "by", "for", "from", "has", "have", "if", "in", "into", "is", "it", "its", "of", "on", "or", "that", "the", "their", "there", "this", "those", "to", "was", "were", "with", } REASONING_FILTER_TEMPLATE_WORDS = { "answer", "conclusion", "directly", "evidence", "final", "identify", "indicating", "question", "reason", "reasoning", "relates", "relevant", "resolve", "shows", "state", "strongest", "supporting", "supports", "using", "visible", } REASONING_FILTER_POSITION_WORDS = { "left", "right", "top", "bottom", "middle", "center", "centre", "upper", "lower", } REASONING_FILTER_COLOR_WORDS = { "black", "blue", "brown", "gold", "gray", "green", "grey", "orange", "pink", "purple", "red", "silver", "white", "yellow", } REASONING_FILTER_KEEP_POS = {"NOUN", "PROPN", "ADJ"} SPACY_REASONING_NLP = None SPACY_REASONING_LOAD_ATTEMPTED = False SPACY_REASONING_FALLBACK_WARNED = False def resolve_hf_snapshot(path: str) -> str: path = os.path.abspath(path) config_path = os.path.join(path, "config.json") if os.path.isfile(config_path): return path refs_main = os.path.join(path, "refs", "main") if os.path.isfile(refs_main): with open(refs_main) as f: revision = f.read().strip() snapshot_path = os.path.join(path, "snapshots", revision) if os.path.isfile(os.path.join(snapshot_path, "config.json")): return snapshot_path raise FileNotFoundError(f"Could not resolve checkpoint snapshot from: {path}") def configure_model(checkpoint_path: str, use_flash_attn: bool) -> InternVLChatConfig: checkpoint_path = resolve_hf_snapshot(checkpoint_path) config = InternVLChatConfig.from_json_file(os.path.join(checkpoint_path, "config.json")) llm_arch = config.llm_config.architectures[0] if llm_arch == "InternLM2ForCausalLM": config.llm_config.attn_implementation = "eager" else: config.llm_config._attn_implementation = "eager" config.vision_config.use_flash_attn = use_flash_attn return config def patch_internlm2_sample_signature(model: InternVLChatModel) -> None: language_model_cls = model.language_model.__class__ sample_fn = getattr(language_model_cls, "_sample", None) if sample_fn is None or getattr(sample_fn, "_sgl_logits_warper_compat", False): return signature = inspect.signature(sample_fn) logits_warper_param = signature.parameters.get("logits_warper") if logits_warper_param is None or logits_warper_param.default is not inspect._empty: return @wraps(sample_fn) def compat_sample( self, input_ids: torch.LongTensor, logits_processor, stopping_criteria, generation_config, synced_gpus: bool, streamer=None, logits_warper=None, **model_kwargs, ): # transformers>=4.49 folds samplers into logits_processor and no longer # passes logits_warper to custom _sample overrides. if logits_warper is None: logits_warper = LogitsProcessorList() return sample_fn( self, input_ids=input_ids, logits_processor=logits_processor, stopping_criteria=stopping_criteria, generation_config=generation_config, synced_gpus=synced_gpus, streamer=streamer, logits_warper=logits_warper, **model_kwargs, ) compat_sample._sgl_logits_warper_compat = True language_model_cls._sample = compat_sample def load_model( checkpoint_path: str, config: InternVLChatConfig, auto: bool, load_in_8bit: bool, load_in_4bit: bool, ) -> InternVLChatModel: checkpoint_path = resolve_hf_snapshot(checkpoint_path) kwargs = {"device_map": "auto"} if auto else {} model = InternVLChatModel.from_pretrained( checkpoint_path, config=config, low_cpu_mem_usage=True, torch_dtype=torch.bfloat16, load_in_8bit=load_in_8bit, load_in_4bit=load_in_4bit, **kwargs, ).eval() if not auto and not load_in_8bit and not load_in_4bit: model = model.cuda() patch_internlm2_sample_signature(model) return model def build_decode_model( guide_model: InternVLChatModel, large_checkpoint: str, use_flash_attn: bool, auto: bool, load_in_8bit: bool, load_in_4bit: bool, ) -> Tuple[InternVLChatModel, AutoTokenizer]: large_checkpoint = resolve_hf_snapshot(large_checkpoint) large_config = configure_model(large_checkpoint, use_flash_attn=use_flash_attn) large_source = load_model( large_checkpoint, large_config, auto=auto, load_in_8bit=load_in_8bit, load_in_4bit=load_in_4bit, ) decode_model = InternVLChatModel( large_config, vision_model=guide_model.vision_model, language_model=large_source.language_model, ) decode_model.config.vision_config = guide_model.config.vision_config decode_model.vision_model.config = guide_model.config.vision_config decode_model.mlp1 = large_source.mlp1 decode_model.template = large_source.template decode_model.system_message = large_source.system_message decode_model.num_image_token = large_source.num_image_token decode_model.ps_version = guide_model.ps_version decode_model.select_layer = guide_model.select_layer decode_model.downsample_ratio = guide_model.downsample_ratio decode_model.img_context_token_id = large_source.img_context_token_id decode_model.eval() patch_internlm2_sample_signature(decode_model) large_tokenizer = AutoTokenizer.from_pretrained( large_checkpoint, trust_remote_code=True, use_fast=False, ) return decode_model, large_tokenizer def model_text_device(model: InternVLChatModel) -> torch.device: return next(model.language_model.get_input_embeddings().parameters()).device def model_vision_device(model: InternVLChatModel) -> torch.device: return next(model.vision_model.parameters()).device def resolve_image_path(image_path: str, data_root: str, jsonl_dir: str) -> str: candidates = [] if os.path.isabs(image_path): candidates.append(image_path) candidates.append(os.path.join(data_root, image_path)) if image_path.startswith("data/"): candidates.append(os.path.join(data_root, image_path[len("data/"):])) candidates.append(os.path.join(jsonl_dir, image_path)) candidates.append(os.path.join(jsonl_dir, os.path.basename(image_path))) for candidate in candidates: if os.path.exists(candidate): return candidate raise FileNotFoundError(f"Could not resolve image path: {image_path}") class TextVQADataset: def __init__(self, jsonl_path: str, data_root: str, image_size: int, dynamic: bool, use_thumbnail: bool, max_num: int): with open(jsonl_path) as f: self.items = [json.loads(line) for line in f if line.strip()] self.jsonl_dir = os.path.dirname(jsonl_path) self.data_root = data_root self.image_size = image_size self.dynamic = dynamic self.use_thumbnail = use_thumbnail self.max_num = max_num self.transform = build_transform(is_train=False, input_size=image_size) def __len__(self) -> int: return len(self.items) def __getitem__(self, idx: int) -> Dict[str, object]: item = self.items[idx] image_path = resolve_image_path(item["image"], self.data_root, self.jsonl_dir) image = Image.open(image_path).convert("RGB") if self.dynamic: images = dynamic_preprocess( image, image_size=self.image_size, use_thumbnail=self.use_thumbnail, max_num=self.max_num, ) else: images = [image] pixel_values = torch.stack([self.transform(img) for img in images]) return { "question_id": item["question_id"], "question": item["question"], "pixel_values": pixel_values, "annotation": item.get("answer", ""), } def load_annotations(annotation_file: str) -> Dict[int, List[str]]: with open(annotation_file) as f: annotations = json.load(f)["annotations"] return { item["question_id"]: [answer["answer"] for answer in item["answers"]] for item in annotations } def build_query(model: InternVLChatModel, tokenizer, question: str, num_patches: int): img_context_token = "" img_start_token = "" img_end_token = "" if "" not in question: question = "\n" + question model.img_context_token_id = tokenizer.convert_tokens_to_ids(img_context_token) template = get_conv_template(model.template) template.system_message = model.system_message template.append_message(template.roles[0], question) template.append_message(template.roles[1], None) query = template.get_prompt() image_tokens = img_start_token + img_context_token * model.num_image_token * num_patches + img_end_token query = query.replace("", image_tokens, 1) return query, template @torch.inference_mode() def extract_shared_raw_visual_tokens(model: InternVLChatModel, pixel_values: torch.Tensor) -> torch.Tensor: vision_device = model_vision_device(model) pixel_values = pixel_values.to(device=vision_device, dtype=torch.bfloat16) if model.select_layer == -1: vit_embeds = model.vision_model( pixel_values=pixel_values, output_hidden_states=False, return_dict=True, ).last_hidden_state else: vit_embeds = model.vision_model( pixel_values=pixel_values, output_hidden_states=True, return_dict=True, ).hidden_states[model.select_layer] vit_embeds = vit_embeds[:, 1:, :] h = w = int(vit_embeds.shape[1] ** 0.5) vit_embeds = vit_embeds.reshape(vit_embeds.shape[0], h, w, -1) vit_embeds = model.pixel_shuffle(vit_embeds, scale_factor=model.downsample_ratio) return vit_embeds.reshape(vit_embeds.shape[0], -1, vit_embeds.shape[-1]) @torch.inference_mode() def project_visual_tokens(model: InternVLChatModel, raw_visual_tokens: torch.Tensor) -> torch.Tensor: mlp_device = next(model.mlp1.parameters()).device raw_visual_tokens = raw_visual_tokens.to(device=mlp_device, dtype=torch.bfloat16) return model.mlp1(raw_visual_tokens) @torch.inference_mode() def build_input_embeds_from_visual_features( model: InternVLChatModel, input_ids: torch.Tensor, visual_features: torch.Tensor, ) -> Tuple[torch.Tensor, torch.Tensor]: input_embeds = model.language_model.get_input_embeddings()(input_ids) batch_size, seq_len, hidden_size = input_embeds.shape flat_input_embeds = input_embeds.reshape(batch_size * seq_len, hidden_size) flat_input_ids = input_ids.reshape(batch_size * seq_len) selected = flat_input_ids == model.img_context_token_id if selected.sum().item() == 0: raise ValueError("No image context tokens found in input_ids.") flat_input_embeds[selected] = visual_features.reshape(-1, hidden_size).to(flat_input_embeds.device) return flat_input_embeds.reshape(batch_size, seq_len, hidden_size), flat_input_ids @torch.inference_mode() def run_guide_generation( model: InternVLChatModel, tokenizer, projected_visual_tokens: torch.Tensor, question: str, generation_config: dict, ) -> Dict[str, object]: query, template = build_query(model, tokenizer, question, projected_visual_tokens.shape[0]) model_inputs = tokenizer(query, return_tensors="pt") input_device = model_text_device(model) input_ids = model_inputs["input_ids"].to(input_device) attention_mask = model_inputs["attention_mask"].to(input_device) eos_token_id = tokenizer.convert_tokens_to_ids(template.sep) input_embeds, flat_input_ids = build_input_embeds_from_visual_features(model, input_ids, projected_visual_tokens) visual_token_index = (input_ids == model.img_context_token_id).view(-1).nonzero() visual_start_index, visual_end_index = visual_token_index[0], visual_token_index[-1] run_config = dict(generation_config) run_config["eos_token_id"] = eos_token_id outputs = model.language_model.generate( inputs_embeds=input_embeds, attention_mask=attention_mask, generation_config=None, output_hidden_states=None, return_dict=None, use_cache=True, visual_token_index=(visual_start_index, visual_end_index), **run_config, ) response = tokenizer.batch_decode(outputs["sequences"], skip_special_tokens=True)[0] response = response.split(template.sep)[0].strip() return { "response": response, "outputs": outputs, "input_embeds": input_embeds, "flat_input_ids": flat_input_ids, "attention_mask": attention_mask, "visual_token_index": (visual_start_index, visual_end_index), } def aggregate_attention_from_step(attentions, visual_token_index: Tuple[int, int]) -> torch.Tensor: visual_start_index, visual_end_index = visual_token_index visual_token_num = visual_end_index - visual_start_index + 1 visual_token_importance = None for attention in attentions: if attention is None: continue if visual_token_importance is None: visual_token_importance = torch.zeros( visual_token_num, device=attention.device, dtype=torch.float32, ) merged_attention = attention[0].sum(dim=0) if attention.shape[2] != 1: visual_token_importance += merged_attention[ visual_end_index + 1 :, visual_start_index : visual_end_index + 1, ].sum(dim=0) else: visual_token_importance += merged_attention[ 0:1, visual_start_index : visual_end_index + 1, ].sum(dim=0) if visual_token_importance is None: raise RuntimeError("Guide model did not return layer attentions for the current decoding step.") return visual_token_importance def count_attention_query_tokens_from_step(attentions, visual_token_index: Tuple[int, int]) -> int: _, visual_end_index = visual_token_index for attention in attentions: if attention is None: continue query_length = int(attention.shape[2]) if query_length != 1: return max(query_length - int(visual_end_index) - 1, 0) return 1 return 0 def count_generated_tokens(outputs) -> int: sequences = getattr(outputs, "sequences", None) if sequences is None and isinstance(outputs, dict): sequences = outputs.get("sequences") if sequences is None: return 0 if sequences.ndim == 0: return 0 return int(sequences.shape[-1]) def count_attention_query_tokens_from_generation_outputs( outputs, visual_token_index: Tuple[int, int], step_mask: Optional[List[bool]] = None, ) -> int: attentions = getattr(outputs, "attentions", None) if not attentions: return 0 token_count = 0 for step_idx, step_attentions in enumerate(attentions): if step_mask is not None and (step_idx >= len(step_mask) or not step_mask[step_idx]): continue token_count += count_attention_query_tokens_from_step(step_attentions, visual_token_index) if token_count == 0 and step_mask is not None: return count_attention_query_tokens_from_generation_outputs(outputs, visual_token_index, step_mask=None) return token_count def count_question_and_answer_attention_query_tokens( outputs, visual_token_index: Tuple[int, int], ) -> Tuple[int, int]: attentions = getattr(outputs, "attentions", None) if not attentions: return 0, 0 question_token_count = 0 answer_token_count = 0 for step_idx, step_attentions in enumerate(attentions): step_token_count = count_attention_query_tokens_from_step(step_attentions, visual_token_index) if step_idx == 0: question_token_count += step_token_count else: answer_token_count += step_token_count return question_token_count, answer_token_count def get_reasoning_spacy_nlp(): global SPACY_REASONING_NLP, SPACY_REASONING_LOAD_ATTEMPTED if SPACY_REASONING_LOAD_ATTEMPTED: return SPACY_REASONING_NLP SPACY_REASONING_LOAD_ATTEMPTED = True try: import spacy SPACY_REASONING_NLP = spacy.load("en_core_web_sm", disable=["parser", "lemmatizer"]) except Exception: SPACY_REASONING_NLP = None return SPACY_REASONING_NLP def should_keep_reasoning_heuristic_token(token_text: str) -> bool: stripped = token_text.strip() if not stripped: return False lowered = stripped.lower() if re.fullmatch(r"\d+[.)]?", stripped): return False if lowered in REASONING_FILTER_STOPWORDS or lowered in REASONING_FILTER_TEMPLATE_WORDS: return False if lowered in REASONING_FILTER_POSITION_WORDS or lowered in REASONING_FILTER_COLOR_WORDS: return True if any(ch.isdigit() for ch in stripped): return True if any(ch.isupper() for ch in stripped): return True if any(ch in ".:/-@&" for ch in stripped): return True alpha_count = sum(ch.isalpha() for ch in stripped) return alpha_count >= 4 def should_keep_reasoning_doc_token(token) -> bool: stripped = token.text.strip() if not stripped: return False lowered = stripped.lower() if token.is_punct or token.is_space: return False if lowered in REASONING_FILTER_STOPWORDS or lowered in REASONING_FILTER_TEMPLATE_WORDS: return False if token.pos_ in REASONING_FILTER_KEEP_POS: return True return False def build_generated_token_spans(tokenizer, generated_ids: torch.Tensor) -> Tuple[str, List[Tuple[int, int]]]: decoded_text = "" token_spans: List[Tuple[int, int]] = [] for token_id in generated_ids.detach().cpu().tolist(): piece = tokenizer.decode([int(token_id)], skip_special_tokens=True, clean_up_tokenization_spaces=False) start = len(decoded_text) decoded_text += piece token_spans.append((start, len(decoded_text))) return decoded_text, token_spans def analyze_reasoning_filter(text: str, args) -> Tuple[List[Tuple[int, int]], str, List[Dict[str, object]]]: if args.guide_reasoning_filter_mode == "none": return [], "none", [] if args.guide_reasoning_filter_mode == "pos_ner": nlp = get_reasoning_spacy_nlp() if nlp is not None: doc = nlp(text) token_analysis = [] intervals = [ (token.idx, token.idx + len(token)) for token in doc if should_keep_reasoning_doc_token(token) ] for token in doc: token_analysis.append( { "text": token.text, "lemma": token.lemma_, "pos": token.pos_, "tag": token.tag_, "dep": token.dep_, "ent_type": token.ent_type_, "like_num": bool(getattr(token, "like_num", False)), "like_url": bool(getattr(token, "like_url", False)), "is_stop": bool(token.is_stop), "keep": should_keep_reasoning_doc_token(token), } ) return intervals, "spacy_pos_ner", token_analysis token_analysis = [] intervals = [ (match.start(), match.end()) for match in re.finditer(r"\S+", text) if should_keep_reasoning_heuristic_token(match.group(0)) ] for match in re.finditer(r"\S+", text): token_text = match.group(0) token_analysis.append( { "text": token_text, "lemma": token_text.lower(), "pos": "", "tag": "", "dep": "", "ent_type": "", "like_num": any(ch.isdigit() for ch in token_text), "like_url": "http" in token_text.lower() or "www." in token_text.lower(), "is_stop": token_text.lower() in REASONING_FILTER_STOPWORDS, "keep": should_keep_reasoning_heuristic_token(token_text), } ) return intervals, "heuristic_fallback", token_analysis def build_reasoning_attention_step_mask_and_debug(tokenizer, outputs, args) -> Tuple[Optional[List[bool]], Dict[str, object]]: if args.guide_reasoning_filter_mode == "none": return None, {"backend": "none", "kept_tokens": [], "token_analysis": []} sequences = outputs["sequences"][0] decoded_text, token_spans = build_generated_token_spans(tokenizer, sequences) intervals, backend, token_analysis = analyze_reasoning_filter(decoded_text, args) global SPACY_REASONING_FALLBACK_WARNED if backend == "heuristic_fallback" and not SPACY_REASONING_FALLBACK_WARNED: print("Warning: spaCy POS/NER model unavailable; guide reasoning filter is using heuristic fallback.") SPACY_REASONING_FALLBACK_WARNED = True debug_info = { "backend": backend, "token_analysis": token_analysis, "kept_tokens": [token["text"] for token in token_analysis if token.get("keep")], } if not intervals: return None, debug_info step_mask = [] for start, end in token_spans: if start == end: step_mask.append(False) continue keep = any(start < interval_end and end > interval_start for interval_start, interval_end in intervals) step_mask.append(keep) debug_info["step_mask"] = step_mask if not any(step_mask): return None, debug_info return step_mask, debug_info def aggregate_attention_from_generation_outputs( outputs, visual_token_index: Tuple[int, int], step_mask: Optional[List[bool]] = None, ) -> torch.Tensor: aggregated = getattr(outputs, "aggregated_viusal_token_attention", None) if aggregated is not None and step_mask is None: return aggregated.detach().float() attentions = getattr(outputs, "attentions", None) if not attentions: raise RuntimeError("Guide generation did not return attentions; enable output_attentions.") visual_token_importance = None for step_idx, step_attentions in enumerate(attentions): if step_mask is not None and (step_idx >= len(step_mask) or not step_mask[step_idx]): continue step_importance = aggregate_attention_from_step(step_attentions, visual_token_index) if visual_token_importance is None: visual_token_importance = step_importance else: visual_token_importance = visual_token_importance + step_importance if visual_token_importance is None: if step_mask is not None: return aggregate_attention_from_generation_outputs(outputs, visual_token_index, step_mask=None) raise RuntimeError("Guide generation returned no attention steps.") return visual_token_importance def aggregate_question_and_answer_attention_from_generation_outputs( outputs, visual_token_index: Tuple[int, int], ) -> Tuple[torch.Tensor, torch.Tensor]: attentions = getattr(outputs, "attentions", None) if not attentions: raise RuntimeError("Guide generation did not return attentions; enable output_attentions.") question_visual_token_importance = None answer_visual_token_importance = None for step_idx, step_attentions in enumerate(attentions): step_importance = aggregate_attention_from_step(step_attentions, visual_token_index) if step_idx == 0: if question_visual_token_importance is None: question_visual_token_importance = step_importance else: question_visual_token_importance = question_visual_token_importance + step_importance else: if answer_visual_token_importance is None: answer_visual_token_importance = step_importance else: answer_visual_token_importance = answer_visual_token_importance + step_importance if question_visual_token_importance is None and answer_visual_token_importance is None: raise RuntimeError("Guide generation returned no attention steps.") if question_visual_token_importance is None: question_visual_token_importance = torch.zeros_like(answer_visual_token_importance) if answer_visual_token_importance is None: answer_visual_token_importance = torch.zeros_like(question_visual_token_importance) return question_visual_token_importance, answer_visual_token_importance @torch.inference_mode() def compute_consistency_score( model: InternVLChatModel, input_embeds: torch.Tensor, flat_input_ids: torch.Tensor, attention_mask: torch.Tensor, generated_ids: torch.Tensor, visual_token_importance: torch.Tensor, visual_token_index: Tuple[int, int], consistency_token_ratio: float, large_model_prune_selection: str, ) -> torch.Tensor: visual_start_index, visual_end_index = visual_token_index new_input_ids_ = generated_ids new_token_num = new_input_ids_.shape[-1] new_input_embedding = torch.concatenate( (input_embeds, model.language_model.get_input_embeddings()(new_input_ids_).unsqueeze(0)), dim=1, ) new_attention_mask = torch.concatenate( ( attention_mask, torch.ones((1, new_input_ids_.shape[0]), device=attention_mask.device, dtype=attention_mask.dtype), ), dim=-1, ) new_input_ids = torch.concatenate((flat_input_ids, new_input_ids_), dim=-1) consistency_generate_kwargs = { "large_model_prune_layer": 0.0, "large_model_prune_ratio": consistency_token_ratio, "large_model_prune_selection": large_model_prune_selection, "visual_token_index": (visual_start_index, visual_end_index), "visual_token_importance": visual_token_importance, "inputs_embeds": new_input_embedding, "attention_mask": new_attention_mask, "output_scores": False, "output_attentions": False, "return_dict_in_generate": False, "use_cache": True, } consistency_generate_kwargs["inputs_embeds"] = new_input_embedding consistency_generate_kwargs["attention_mask"] = new_attention_mask consistency_generate_kwargs["output_scores"] = False consistency_generate_kwargs["output_attentions"] = False consistency_generate_kwargs = model.language_model._get_initial_cache_position(new_input_ids, consistency_generate_kwargs) model_inputs = model.language_model.prepare_inputs_for_generation(new_input_ids, **consistency_generate_kwargs) consistency_output = model.language_model.forward(**model_inputs, return_dict=True) consistency_score = torch.gather( consistency_output["logits"][:, -new_token_num - 1 : -1, :].softmax(dim=-1), index=new_input_ids_[None, :, None], dim=-1, ) return torch.prod(consistency_score) @torch.inference_mode() def run_guide_branch( model: InternVLChatModel, tokenizer, projected_visual_tokens: torch.Tensor, question: str, generation_config: dict, consistency_token_ratio: float, args, ) -> Tuple[str, List[torch.Tensor], torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, Dict[str, int]]: generation_result = run_guide_generation( model, tokenizer, projected_visual_tokens, question, generation_config, ) outputs = generation_result["outputs"] question_visual_token_importance, answer_visual_token_importance = ( aggregate_question_and_answer_attention_from_generation_outputs( outputs, generation_result["visual_token_index"], ) ) question_attention_token_count, answer_attention_token_count = count_question_and_answer_attention_query_tokens( outputs, generation_result["visual_token_index"], ) visual_token_importance = combine_question_and_answer_attention( question_visual_token_importance, answer_visual_token_importance, args, ) if args.large_model_prune_selection == "similarity_greedy": consistency_score = torch.tensor(1.0, device=visual_token_importance.device) else: consistency_score = compute_consistency_score( model, generation_result["input_embeds"], generation_result["flat_input_ids"], generation_result["attention_mask"], outputs["sequences"][0], visual_token_importance, generation_result["visual_token_index"], consistency_token_ratio, args.large_model_prune_selection, ) return ( generation_result["response"], outputs.scores, consistency_score, visual_token_importance, question_visual_token_importance, answer_visual_token_importance, { "question_attention_token_count": question_attention_token_count, "answer_attention_token_count": answer_attention_token_count, "reasoning_attention_token_count": 0, "guide_answer_generated_token_count": count_generated_tokens(outputs), "guide_reasoning_generated_token_count": 0, }, ) @torch.inference_mode() def run_decode_branch( model: InternVLChatModel, tokenizer, projected_visual_tokens: torch.Tensor, question: str, generation_config: dict, visual_token_importance: torch.Tensor, large_model_prune_layer: float, large_model_prune_ratio: float, large_model_prune_selection: str, ) -> str: query, template = build_query(model, tokenizer, question, projected_visual_tokens.shape[0]) model_inputs = tokenizer(query, return_tensors="pt") input_device = model_text_device(model) input_ids = model_inputs["input_ids"].to(input_device) attention_mask = model_inputs["attention_mask"].to(input_device) eos_token_id = tokenizer.convert_tokens_to_ids(template.sep) input_embeds, _ = build_input_embeds_from_visual_features(model, input_ids, projected_visual_tokens) visual_token_index = (input_ids == model.img_context_token_id).view(-1).nonzero() visual_start_index, visual_end_index = visual_token_index[0], visual_token_index[-1] run_config = dict(generation_config) run_config["eos_token_id"] = eos_token_id run_config["return_dict_in_generate"] = False run_config["output_scores"] = False run_config["output_attentions"] = False run_config["large_model_prune_layer"] = large_model_prune_layer run_config["large_model_prune_ratio"] = large_model_prune_ratio run_config["large_model_prune_selection"] = large_model_prune_selection run_config["visual_token_importance"] = visual_token_importance run_config["visual_token_index"] = (visual_start_index, visual_end_index) output_ids = model.language_model.generate( inputs_embeds=input_embeds, attention_mask=attention_mask, generation_config=None, output_hidden_states=None, return_dict=None, use_cache=True, **run_config, ) response = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0] return response.split(template.sep)[0].strip() def make_generation_config(args) -> dict: generation_config = { "num_beams": args.num_beams, "max_new_tokens": args.max_new_tokens, "min_new_tokens": 1, "do_sample": args.temperature > 0, "return_dict_in_generate": True, "output_scores": True, "output_attentions": True, } if args.temperature > 0: generation_config["temperature"] = args.temperature return generation_config def append_instruction(question: str, instruction: str) -> str: instruction = instruction.strip() if not instruction: return question return f"{question.rstrip()}\n{instruction}" def make_reasoning_generation_config(base_generation_config: dict, args) -> dict: generation_config = dict(base_generation_config) generation_config["max_new_tokens"] = args.reasoning_max_new_tokens generation_config["return_dict_in_generate"] = True generation_config["output_scores"] = True generation_config["output_attentions"] = True temperature = args.reasoning_temperature generation_config["do_sample"] = temperature > 0 if temperature > 0: generation_config["temperature"] = temperature else: generation_config.pop("temperature", None) return generation_config def make_custom_generation_config( base_generation_config: dict, max_new_tokens: int, temperature: float, return_dict_in_generate: bool, output_scores: bool, output_attentions: bool, ) -> dict: generation_config = dict(base_generation_config) generation_config["max_new_tokens"] = max_new_tokens generation_config["return_dict_in_generate"] = return_dict_in_generate generation_config["output_scores"] = output_scores generation_config["output_attentions"] = output_attentions generation_config["do_sample"] = temperature > 0 if temperature > 0: generation_config["temperature"] = temperature else: generation_config.pop("temperature", None) return generation_config def normalize_generated_text(text: str) -> str: return " ".join(text.strip().split()) def strip_base_prompt(question: str) -> str: if question.endswith(BASE_PROMPT_SUFFIX): return question[: -len(BASE_PROMPT_SUFFIX)].rstrip() return question def summarize_visual_token_importance(visual_token_importance: torch.Tensor, topk: int) -> Dict[str, object]: values = visual_token_importance.detach().float().view(-1).cpu() total = values.sum().item() if total > 0: normalized = values / total else: normalized = torch.full_like(values, 1.0 / max(values.numel(), 1)) topk = min(topk, normalized.numel()) top_values, top_indices = torch.topk(normalized, k=topk) entropy = -(normalized * torch.clamp(normalized, min=1e-12).log()).sum().item() return { "raw_sum": total, "entropy": entropy, "max_weight": normalized.max().item(), "top_indices": top_indices.tolist(), "top_weights": top_values.tolist(), "weights": normalized.tolist(), } def normalize_visual_token_importance(visual_token_importance: torch.Tensor) -> torch.Tensor: visual_token_importance = visual_token_importance.detach().float() total = visual_token_importance.sum() if total.item() > 0: return visual_token_importance / total return torch.full_like(visual_token_importance, 1.0 / max(visual_token_importance.numel(), 1)) def prepare_decode_visual_token_importance( visual_token_importance: torch.Tensor, selection_mode: str, ) -> torch.Tensor: raw_importance = visual_token_importance.detach().float() if selection_mode in {"topk", "similarity_greedy"}: return raw_importance if selection_mode == "random": return torch.rand_like(raw_importance) raise ValueError(f"Unsupported large model prune selection mode: {selection_mode}") def maybe_normalize_visual_token_importance(visual_token_importance: torch.Tensor, args) -> torch.Tensor: if args.guide_attention_aggregation_mode == "normalized": return normalize_visual_token_importance(visual_token_importance) return visual_token_importance.detach().float() def combine_question_and_answer_attention( question_visual_token_importance: torch.Tensor, answer_visual_token_importance: torch.Tensor, args, ) -> torch.Tensor: question_weight = args.guide_question_attention_weight answer_weight = args.guide_answer_attention_weight if question_weight == 0 and answer_weight == 0: raise ValueError("At least one guide question/answer attention weight must be > 0.") return ( question_weight * maybe_normalize_visual_token_importance(question_visual_token_importance, args) + answer_weight * maybe_normalize_visual_token_importance(answer_visual_token_importance, args) ) def resolve_guide_attention_source(args) -> str: if args.guide_attention_source != "default": return args.guide_attention_source if args.guide_reasoning_mode == "two_pass_explicit": return "combined" return "answer" def combine_reasoning_and_answer_attention( reasoning_visual_token_importance: torch.Tensor, answer_visual_token_importance: torch.Tensor, args, ) -> torch.Tensor: attention_source = resolve_guide_attention_source(args) if attention_source == "reasoning": return args.guide_reasoning_attention_weight * maybe_normalize_visual_token_importance( reasoning_visual_token_importance, args, ) if attention_source == "answer": return args.guide_answer_attention_weight * maybe_normalize_visual_token_importance( answer_visual_token_importance, args, ) reasoning_weight = args.guide_reasoning_attention_weight answer_weight = args.guide_answer_attention_weight if reasoning_weight == 0 and answer_weight == 0: raise ValueError("At least one guide attention weight must be > 0.") return ( reasoning_weight * maybe_normalize_visual_token_importance(reasoning_visual_token_importance, args) + answer_weight * maybe_normalize_visual_token_importance(answer_visual_token_importance, args) ) def combine_question_reasoning_and_answer_attention( question_visual_token_importance: torch.Tensor, reasoning_visual_token_importance: torch.Tensor, answer_visual_token_importance: torch.Tensor, args, ) -> torch.Tensor: attention_source = resolve_guide_attention_source(args) if attention_source == "reasoning": return args.guide_reasoning_attention_weight * maybe_normalize_visual_token_importance( reasoning_visual_token_importance, args, ) if attention_source == "answer": return combine_question_and_answer_attention( question_visual_token_importance, answer_visual_token_importance, args, ) return combine_question_and_answer_attention( question_visual_token_importance, answer_visual_token_importance, args, ) + args.guide_reasoning_attention_weight * reasoning_visual_token_importance.detach().float() def build_guide_attention_question(question: str, args) -> str: if args.guide_reasoning_mode == "short_cot": return GUIDE_ATTENTION_COT_PROMPT_TEMPLATE.replace("{question}", strip_base_prompt(question)) if args.guide_reasoning_mode == "explicit_cot": return append_instruction(strip_base_prompt(question), GUIDE_ATTENTION_EXPLICIT_COT_INSTRUCTION) return question def build_guide_reasoning_question(question: str) -> str: return GUIDE_ATTENTION_REASONING_ONLY_PROMPT_TEMPLATE.replace( "{question}", strip_base_prompt(question), ) def build_guide_text_question(question: str) -> str: return append_instruction(question, GUIDE_TEXT_HINT_INSTRUCTION) def build_decode_question(question: str, guide_text_hint: Optional[str]) -> str: if not guide_text_hint: return question return append_instruction( question, f"Guide hint: {guide_text_hint}\n{GUIDED_DECODE_INSTRUCTION}", ) def make_guide_attention_generation_config(base_generation_config: dict, args) -> dict: if args.guide_reasoning_mode in {"short_cot", "explicit_cot", "two_pass_explicit"}: return make_custom_generation_config( base_generation_config, max_new_tokens=args.guide_reasoning_max_new_tokens, temperature=args.guide_reasoning_temperature, return_dict_in_generate=True, output_scores=True, output_attentions=True, ) return dict(base_generation_config) def make_guide_text_generation_config(base_generation_config: dict, args) -> dict: return make_custom_generation_config( base_generation_config, max_new_tokens=args.guide_text_max_new_tokens, temperature=args.guide_text_temperature, return_dict_in_generate=False, output_scores=False, output_attentions=False, ) @torch.inference_mode() def run_text_generation_branch( model: InternVLChatModel, tokenizer, projected_visual_tokens: torch.Tensor, question: str, generation_config: dict, ) -> str: query, template = build_query(model, tokenizer, question, projected_visual_tokens.shape[0]) model_inputs = tokenizer(query, return_tensors="pt") input_device = model_text_device(model) input_ids = model_inputs["input_ids"].to(input_device) attention_mask = model_inputs["attention_mask"].to(input_device) eos_token_id = tokenizer.convert_tokens_to_ids(template.sep) input_embeds, _ = build_input_embeds_from_visual_features(model, input_ids, projected_visual_tokens) run_config = dict(generation_config) run_config["eos_token_id"] = eos_token_id output_ids = model.language_model.generate( inputs_embeds=input_embeds, attention_mask=attention_mask, generation_config=None, output_hidden_states=None, return_dict=None, use_cache=True, **run_config, ) response = tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0] return response.split(template.sep)[0].strip() def run_decode_answer( model: InternVLChatModel, tokenizer, projected_visual_tokens: torch.Tensor, question: str, generation_config: dict, visual_token_importance: torch.Tensor, args, ) -> str: return run_decode_branch( model, tokenizer, projected_visual_tokens, question, generation_config, prepare_decode_visual_token_importance( visual_token_importance, args.large_model_prune_selection, ), args.large_model_prune_layer, args.large_model_prune_ratio, args.large_model_prune_selection, ) @torch.inference_mode() def run_guide_two_pass_explicit_branch( model: InternVLChatModel, tokenizer, projected_visual_tokens: torch.Tensor, question: str, reasoning_generation_config: dict, answer_generation_config: dict, consistency_token_ratio: float, args, ) -> Tuple[str, List[torch.Tensor], torch.Tensor, torch.Tensor, str, Dict[str, object], Dict[str, int]]: answer_result = run_guide_generation( model, tokenizer, projected_visual_tokens, question, answer_generation_config, ) reasoning_result = run_guide_generation( model, tokenizer, projected_visual_tokens, build_guide_reasoning_question(question), reasoning_generation_config, ) reasoning = reasoning_result["response"] reasoning_step_mask, reasoning_filter_debug = build_reasoning_attention_step_mask_and_debug( tokenizer, reasoning_result["outputs"], args, ) reasoning_visual_token_importance = aggregate_attention_from_generation_outputs( reasoning_result["outputs"], reasoning_result["visual_token_index"], reasoning_step_mask, ) reasoning_attention_token_count = count_attention_query_tokens_from_generation_outputs( reasoning_result["outputs"], reasoning_result["visual_token_index"], reasoning_step_mask, ) question_visual_token_importance, answer_visual_token_importance = ( aggregate_question_and_answer_attention_from_generation_outputs( answer_result["outputs"], answer_result["visual_token_index"], ) ) question_attention_token_count, answer_attention_token_count = count_question_and_answer_attention_query_tokens( answer_result["outputs"], answer_result["visual_token_index"], ) visual_token_importance = combine_question_reasoning_and_answer_attention( question_visual_token_importance, reasoning_visual_token_importance, answer_visual_token_importance, args, ) if args.large_model_prune_selection == "similarity_greedy": consistency_score = torch.tensor(1.0, device=visual_token_importance.device) else: consistency_score = compute_consistency_score( model, answer_result["input_embeds"], answer_result["flat_input_ids"], answer_result["attention_mask"], answer_result["outputs"]["sequences"][0], visual_token_importance, answer_result["visual_token_index"], consistency_token_ratio, args.large_model_prune_selection, ) return ( answer_result["response"], answer_result["outputs"].scores, consistency_score, visual_token_importance, reasoning, reasoning_filter_debug, { "question_attention_token_count": question_attention_token_count, "answer_attention_token_count": answer_attention_token_count, "reasoning_attention_token_count": reasoning_attention_token_count, "guide_answer_generated_token_count": count_generated_tokens(answer_result["outputs"]), "guide_reasoning_generated_token_count": count_generated_tokens(reasoning_result["outputs"]), }, ) def generate_with_reasoning( guide_model: InternVLChatModel, guide_tokenizer, decode_model: InternVLChatModel, large_tokenizer, projected_visual_tokens: torch.Tensor, question: str, generation_config: dict, reasoning_generation_config: dict, visual_token_importance: torch.Tensor, args, ) -> Tuple[str, str]: reasoning_question = append_instruction(question, EXPLICIT_REASONING_INSTRUCTION) reasoning = run_decode_answer( decode_model, large_tokenizer, projected_visual_tokens, reasoning_question, reasoning_generation_config, visual_token_importance, args, ) final_question = append_instruction( question, f"Reasoning:\n{reasoning}\n{DEFAULT_FINAL_ANSWER_INSTRUCTION}", ) answer = run_decode_answer( decode_model, large_tokenizer, projected_visual_tokens, final_question, generation_config, visual_token_importance, args, ) return answer, reasoning def evaluate(args): guide_checkpoint = resolve_hf_snapshot(args.guide_checkpoint) large_checkpoint = resolve_hf_snapshot(args.large_checkpoint) guide_tokenizer = AutoTokenizer.from_pretrained(guide_checkpoint, trust_remote_code=True, use_fast=False) guide_config = configure_model(guide_checkpoint, use_flash_attn=args.use_flash_attn) guide_model = load_model( guide_checkpoint, guide_config, auto=args.auto, load_in_8bit=args.load_in_8bit, load_in_4bit=args.load_in_4bit, ) decode_model, large_tokenizer = build_decode_model( guide_model, large_checkpoint, use_flash_attn=args.use_flash_attn, auto=args.auto, load_in_8bit=args.load_in_8bit, load_in_4bit=args.load_in_4bit, ) guide_image_size = guide_model.config.force_image_size or guide_model.config.vision_config.image_size large_image_size = decode_model.config.force_image_size or decode_model.config.vision_config.image_size if guide_image_size != large_image_size: raise ValueError(f"Guide and decode image size mismatch: {guide_image_size} vs {large_image_size}") if guide_model.num_image_token != decode_model.num_image_token: raise ValueError( f"Guide and decode image token count mismatch: {guide_model.num_image_token} vs {decode_model.num_image_token}" ) data_root = os.path.abspath(args.data_root) textvqa_root = os.path.abspath(args.textvqa_root) if args.textvqa_root else os.path.join(data_root, "data", "textvqa") dataset = TextVQADataset( jsonl_path=os.path.join(textvqa_root, "textvqa_val.jsonl"), data_root=data_root, image_size=guide_image_size, dynamic=args.dynamic, use_thumbnail=guide_model.config.use_thumbnail, max_num=args.max_num, ) question_id_to_answers = load_annotations(os.path.join(textvqa_root, "textvqa_val_annotations.json")) generation_config = make_generation_config(args) guide_attention_generation_config = make_guide_attention_generation_config(generation_config, args) guide_text_generation_config = None if args.guide_text_mode != "none": guide_text_generation_config = make_guide_text_generation_config(generation_config, args) reasoning_generation_config = None if args.reasoning_mode == "two_pass": reasoning_generation_config = make_reasoning_generation_config(generation_config, args) num_items = len(dataset) if args.limit is None else min(len(dataset), args.limit) results = [] filter_debug_results = [] for idx in range(num_items): sample = dataset[idx] question = sample["question"] + " " + BASE_PROMPT pixel_values = sample["pixel_values"] guide_attention_question = build_guide_attention_question(question, args) torch.cuda.synchronize() start = time.time() raw_visual_tokens = extract_shared_raw_visual_tokens(guide_model, pixel_values) guide_visual_tokens = project_visual_tokens(guide_model, raw_visual_tokens) guide_reasoning = None guide_reasoning_filter_debug = {"backend": "none", "kept_tokens": [], "token_analysis": []} guide_attention_token_counts = { "question_attention_token_count": 0, "answer_attention_token_count": 0, "reasoning_attention_token_count": 0, "guide_answer_generated_token_count": 0, "guide_reasoning_generated_token_count": 0, } question_visual_token_importance = None answer_visual_token_importance = None if args.guide_reasoning_mode == "two_pass_explicit": ( guide_answer, guide_scores, consistency_score, visual_token_importance, guide_reasoning, guide_reasoning_filter_debug, guide_attention_token_counts, ) = ( run_guide_two_pass_explicit_branch( guide_model, guide_tokenizer, guide_visual_tokens, question, guide_attention_generation_config, generation_config, args.consistency_token_ratio, args, ) ) else: ( guide_answer, guide_scores, consistency_score, visual_token_importance, question_visual_token_importance, answer_visual_token_importance, guide_attention_token_counts, ) = run_guide_branch( guide_model, guide_tokenizer, guide_visual_tokens, guide_attention_question, guide_attention_generation_config, args.consistency_token_ratio, args, ) guide_text_hint = None if args.guide_text_mode != "none": if guide_text_generation_config is None: raise ValueError("guide_text_generation_config is required when guide_text_mode is enabled.") guide_text_hint = normalize_generated_text( run_text_generation_branch( guide_model, guide_tokenizer, guide_visual_tokens, build_guide_text_question(question), guide_text_generation_config, ) ) torch.cuda.synchronize() end = time.time() small_model_time = end - start scores = torch.concatenate(guide_scores, dim=0) scores, _ = scores.softmax(dim=-1).max(dim=-1) original_confidence = math.pow(torch.prod(scores).item(), 1 / len(scores)) torch.cuda.synchronize() start = time.time() large_visual_tokens = project_visual_tokens(decode_model, raw_visual_tokens) decode_question = build_decode_question(question, guide_text_hint) reasoning = None if args.reasoning_mode == "none": large_answer = run_decode_answer( decode_model, large_tokenizer, large_visual_tokens, decode_question, generation_config, visual_token_importance, args, ) elif args.reasoning_mode == "prompt": prompted_question = append_instruction(decode_question, HIDDEN_REASONING_INSTRUCTION) large_answer = run_decode_answer( decode_model, large_tokenizer, large_visual_tokens, prompted_question, generation_config, visual_token_importance, args, ) else: if reasoning_generation_config is None: raise ValueError("reasoning_generation_config is required when reasoning_mode='two_pass'.") large_answer, reasoning = generate_with_reasoning( guide_model, guide_tokenizer, decode_model, large_tokenizer, large_visual_tokens, decode_question, generation_config, reasoning_generation_config, visual_token_importance, args, ) torch.cuda.synchronize() end = time.time() large_model_time = end - start visual_token_count = visual_token_importance.shape[0] kept_visual_token_count = max(1, int(visual_token_count * args.large_model_prune_ratio)) result_item = { "question_id": sample["question_id"], "question": sample["question"], "answer": large_answer, "pred_answer": large_answer, "gt_answers": question_id_to_answers[sample["question_id"]], "small_answer": guide_answer, "guide_attention_output": guide_answer, "large_answer": large_answer, "small_model_time": small_model_time, "large_model_time": large_model_time, "original_confidence": original_confidence, "consistency_score": consistency_score.item(), "visual_token_count": visual_token_count, "kept_visual_token_count": kept_visual_token_count, "guide_attention_token_counts": guide_attention_token_counts, } if args.save_visual_token_importance: result_item["visual_token_importance_stats"] = summarize_visual_token_importance( visual_token_importance, topk=args.visual_token_importance_topk, ) if question_visual_token_importance is not None: result_item["question_visual_token_importance_stats"] = summarize_visual_token_importance( question_visual_token_importance, topk=args.visual_token_importance_topk, ) if answer_visual_token_importance is not None: result_item["answer_visual_token_importance_stats"] = summarize_visual_token_importance( answer_visual_token_importance, topk=args.visual_token_importance_topk, ) if guide_text_hint is not None: result_item["guide_text_hint"] = guide_text_hint if args.save_reasoning and guide_reasoning is not None: result_item["guide_reasoning"] = guide_reasoning if args.save_reasoning and reasoning is not None: result_item["large_reasoning"] = reasoning results.append(result_item) filter_debug_results.append( { "question_id": sample["question_id"], "question": sample["question"], "small_answer": guide_answer, "large_answer": large_answer, "guide_reasoning": guide_reasoning, "guide_reasoning_filter_mode": args.guide_reasoning_filter_mode, "guide_reasoning_filter_backend": guide_reasoning_filter_debug.get("backend", "none"), "kept_tokens": guide_reasoning_filter_debug.get("kept_tokens", []), "token_analysis": guide_reasoning_filter_debug.get("token_analysis", []), } ) if (idx + 1) % args.log_every == 0 or idx + 1 == num_items: status = ( f"[{idx + 1}/{num_items}] question_id={sample['question_id']} " f"small={guide_answer} large={large_answer} kept={kept_visual_token_count}/{visual_token_count}" ) if guide_text_hint is not None: status += f" hint={guide_text_hint}" print(status) sys.stdout.flush() evaluator = TextVQAAccuracyEvaluator() accuracy = evaluator.eval_pred_list(results) os.makedirs(args.out_dir, exist_ok=True) run_name = args.run_name or "textvqa_shared_vision_2bguide_8btext" result_path = os.path.join(args.out_dir, f"{run_name}.json") summary_path = os.path.join(args.out_dir, f"{run_name}.summary.json") filter_debug_path = os.path.join(args.out_dir, f"{run_name}.filter_debug.json") with open(result_path, "w") as f: json.dump(results, f, ensure_ascii=False, indent=2) with open(filter_debug_path, "w") as f: json.dump(filter_debug_results, f, ensure_ascii=False, indent=2) token_count_keys = [ "question_attention_token_count", "answer_attention_token_count", "reasoning_attention_token_count", "guide_answer_generated_token_count", "guide_reasoning_generated_token_count", ] avg_guide_attention_token_counts = { key: ( sum(item.get("guide_attention_token_counts", {}).get(key, 0) for item in results) / max(len(results), 1) ) for key in token_count_keys } summary = { "mode": "shared_vision_guided", "guide_checkpoint": guide_checkpoint, "large_checkpoint": large_checkpoint, "count": num_items, "accuracy": accuracy, "large_model_prune_layer": args.large_model_prune_layer, "large_model_prune_ratio": args.large_model_prune_ratio, "large_model_prune_selection": args.large_model_prune_selection, "consistency_token_ratio": args.consistency_token_ratio, "guide_reasoning_mode": args.guide_reasoning_mode, "guide_reasoning_max_new_tokens": args.guide_reasoning_max_new_tokens, "guide_reasoning_filter_mode": args.guide_reasoning_filter_mode, "guide_attention_aggregation_mode": args.guide_attention_aggregation_mode, "guide_attention_source": resolve_guide_attention_source(args), "guide_reasoning_attention_weight": args.guide_reasoning_attention_weight, "guide_answer_attention_weight": args.guide_answer_attention_weight, "guide_question_attention_weight": args.guide_question_attention_weight, "guide_text_mode": args.guide_text_mode, "guide_text_max_new_tokens": args.guide_text_max_new_tokens, "avg_guide_attention_token_counts": avg_guide_attention_token_counts, "avg_small_model_time": sum(item["small_model_time"] for item in results) / max(len(results), 1), "avg_large_model_time": sum(item["large_model_time"] for item in results) / max(len(results), 1), "results_file": result_path, "filter_debug_file": filter_debug_path, } with open(summary_path, "w") as f: json.dump(summary, f, ensure_ascii=False, indent=2) print(f"accuracy: {accuracy:.6f}") print(f"results_file: {result_path}") print(f"summary_file: {summary_path}") def main(): parser = argparse.ArgumentParser() parser.add_argument("--guide-checkpoint", type=str, required=True) parser.add_argument("--large-checkpoint", type=str, required=True) parser.add_argument("--data-root", type=str, default=str(REPO_ROOT)) parser.add_argument("--textvqa-root", type=str, default="") parser.add_argument("--out-dir", type=str, default=str(REPO_ROOT / "outputs" / "shared_vision_guided")) parser.add_argument("--run-name", type=str, default="") parser.add_argument("--limit", type=int, default=None) parser.add_argument("--max-new-tokens", type=int, default=10) parser.add_argument("--num-beams", type=int, default=1) parser.add_argument("--temperature", type=float, default=0.0) parser.add_argument("--reasoning-mode", type=str, choices=["none", "prompt", "two_pass"], default="none") parser.add_argument("--reasoning-max-new-tokens", type=int, default=64) parser.add_argument("--reasoning-temperature", type=float, default=0.0) parser.add_argument("--save-reasoning", action="store_true") parser.add_argument( "--guide-reasoning-mode", type=str, choices=["none", "short_cot", "explicit_cot", "two_pass_explicit"], default="none", ) parser.add_argument("--guide-reasoning-max-new-tokens", type=int, default=1024) parser.add_argument("--guide-reasoning-temperature", type=float, default=0.0) parser.add_argument( "--guide-reasoning-filter-mode", type=str, choices=["none", "pos_ner"], default="none", ) parser.add_argument( "--guide-attention-source", type=str, choices=["default", "reasoning", "answer", "combined"], default="default", ) parser.add_argument( "--guide-attention-aggregation-mode", type=str, choices=["raw", "normalized"], default="raw", ) parser.add_argument("--guide-question-attention-weight", type=float, default=1.0) parser.add_argument("--guide-reasoning-attention-weight", type=float, default=1.0) parser.add_argument("--guide-answer-attention-weight", type=float, default=1.0) parser.add_argument("--guide-text-mode", type=str, choices=["none", "short_rationale"], default="none") parser.add_argument("--guide-text-max-new-tokens", type=int, default=12) parser.add_argument("--guide-text-temperature", type=float, default=0.0) parser.add_argument("--save-visual-token-importance", action="store_true") parser.add_argument("--visual-token-importance-topk", type=int, default=16) parser.add_argument("--dynamic", action="store_true") parser.add_argument("--max-num", type=int, default=6) parser.add_argument("--log-every", type=int, default=20) parser.add_argument("--seed", type=int, default=0) parser.add_argument("--large-model-prune-layer", type=float, default=0.0) parser.add_argument("--large-model-prune-ratio", type=float, default=0.4) parser.add_argument( "--large-model-prune-selection", type=str, choices=["topk", "random", "similarity_greedy"], default="topk", ) parser.add_argument("--consistency-token-ratio", type=float, default=0.05) parser.add_argument("--auto", action="store_true") parser.add_argument("--load-in-8bit", action="store_true") parser.add_argument("--load-in-4bit", action="store_true") parser.add_argument("--use-flash-attn", action="store_true") args = parser.parse_args() if not torch.cuda.is_available(): raise RuntimeError("CUDA is required for shared-vision guided evaluation.") if args.large_model_prune_ratio <= 0 or args.large_model_prune_ratio > 1: raise ValueError("large-model-prune-ratio must be in (0, 1].") if args.consistency_token_ratio <= 0 or args.consistency_token_ratio > 1: raise ValueError("consistency-token-ratio must be in (0, 1].") if args.guide_reasoning_attention_weight < 0 or args.guide_answer_attention_weight < 0: raise ValueError("guide reasoning/answer attention weights must be >= 0.") if args.guide_question_attention_weight < 0: raise ValueError("guide question attention weight must be >= 0.") if args.guide_reasoning_mode == "two_pass_explicit": attention_source = resolve_guide_attention_source(args) if attention_source == "reasoning" and args.guide_reasoning_attention_weight == 0: raise ValueError("guide_reasoning_attention_weight must be > 0 when guide-attention-source=reasoning.") if ( attention_source == "answer" and args.guide_question_attention_weight == 0 and args.guide_answer_attention_weight == 0 ): raise ValueError( "At least one of guide_question_attention_weight or guide_answer_attention_weight " "must be > 0 when guide-attention-source=answer." ) if ( attention_source == "combined" and args.guide_question_attention_weight == 0 and args.guide_reasoning_attention_weight == 0 and args.guide_answer_attention_weight == 0 ): raise ValueError("At least one guide attention weight must be > 0 for two_pass_explicit.") if ( args.guide_reasoning_mode != "two_pass_explicit" and args.guide_question_attention_weight == 0 and args.guide_answer_attention_weight == 0 ): raise ValueError("At least one guide question/answer attention weight must be > 0.") random.seed(args.seed) torch.manual_seed(args.seed) evaluate(args) if __name__ == "__main__": main()