tools/run_shared_vision_cases.py

import argparse
import json
import math
import os
import time
from pathlib import Path

import torch
from PIL import Image
from transformers import AutoTokenizer

from eval.vqa.run_shared_vision_guided_textvqa import (
    build_decode_model,
    build_guide_attention_question,
    configure_model,
    extract_shared_raw_visual_tokens,
    load_model,
    make_generation_config,
    make_guide_attention_generation_config,
    project_visual_tokens,
    resolve_hf_snapshot,
    run_decode_answer,
    run_guide_branch,
    run_guide_two_pass_explicit_branch,
)
from internvl.train.dataset import build_transform, dynamic_preprocess


def load_case_records(case_json_path: str, source_jsonl_path: str):
    with open(case_json_path) as f:
        case_items = json.load(f)
    cases_by_qid = {item["question_id"]: item for item in case_items}

    source_by_qid = {}
    with open(source_jsonl_path) as f:
        for line in f:
            item = json.loads(line)
            if item["question_id"] in cases_by_qid:
                source_by_qid[item["question_id"]] = item

    missing = sorted(set(cases_by_qid) - set(source_by_qid))
    if missing:
        raise RuntimeError(f"Missing {len(missing)} source records, e.g. {missing[:5]}")

    return [source_by_qid[qid] | {"gt_answers": cases_by_qid[qid]["gt_answers"], "gt_answer_counts": cases_by_qid[qid]["gt_answer_counts"]} for qid in sorted(cases_by_qid)]


def load_pixels(image_path: str, image_size: int, dynamic: bool, use_thumbnail: bool, max_num: int):
    transform = build_transform(is_train=False, input_size=image_size)
    image = Image.open(image_path).convert("RGB")
    if dynamic:
        images = dynamic_preprocess(image, image_size=image_size, use_thumbnail=use_thumbnail, max_num=max_num)
    else:
        images = [image]
    return torch.stack([transform(img) for img in images])


def vqa_score(prediction: str, gt_answers):
    normalized_prediction = prediction.strip().lower()
    matches = sum(1 for answer in gt_answers if answer.strip().lower() == normalized_prediction)
    return min(1.0, matches / 3.0)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--case-json", required=True)
    parser.add_argument("--source-jsonl", required=True)
    parser.add_argument("--guide-checkpoint", required=True)
    parser.add_argument("--large-checkpoint", required=True)
    parser.add_argument("--out-dir", required=True)
    parser.add_argument("--run-name", required=True)
    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("--dynamic", action="store_true")
    parser.add_argument("--max-num", type=int, default=6)
    parser.add_argument("--log-every", type=int, default=10)
    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(
        "--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-attention-source",
        type=str,
        choices=["default", "reasoning", "answer", "combined"],
        default="default",
    )
    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("--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.")

    torch.manual_seed(args.seed)
    records = load_case_records(args.case_json, args.source_jsonl)
    if args.limit is not None:
        records = records[: args.limit]

    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,
    )

    image_size = guide_model.config.force_image_size or guide_model.config.vision_config.image_size
    generation_config = make_generation_config(args)
    guide_attention_generation_config = make_guide_attention_generation_config(generation_config, args)

    os.makedirs(args.out_dir, exist_ok=True)
    results = []

    for idx, record in enumerate(records):
        question = record["question"] + " Answer the question using a single word or phrase."
        pixel_values = load_pixels(
            image_path=record["image"],
            image_size=image_size,
            dynamic=args.dynamic,
            use_thumbnail=guide_model.config.use_thumbnail,
            max_num=args.max_num,
        )
        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_attention_token_counts = {}
        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,
            )
        torch.cuda.synchronize()
        small_model_time = time.time() - 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)
        large_answer = run_decode_answer(
            decode_model,
            large_tokenizer,
            large_visual_tokens,
            question,
            generation_config,
            visual_token_importance,
            args,
        )
        torch.cuda.synchronize()
        large_model_time = time.time() - start

        score = vqa_score(large_answer, record["gt_answers"])
        results.append(
            {
                "question_id": record["question_id"],
                "question": record["question"],
                "image": record["image"],
                "gt_answers": record["gt_answers"],
                "gt_answer_counts": record["gt_answer_counts"],
                "small_answer": guide_answer,
                "large_answer": large_answer,
                "vqa_score": score,
                "small_model_time": small_model_time,
                "large_model_time": large_model_time,
                "original_confidence": original_confidence,
                "consistency_score": consistency_score.item(),
                "visual_token_count": int(visual_token_importance.shape[0]),
                "kept_visual_token_count": max(1, int(visual_token_importance.shape[0] * args.large_model_prune_ratio)),
                "guide_attention_token_counts": guide_attention_token_counts,
            }
        )
        if (idx + 1) % args.log_every == 0 or idx + 1 == len(records):
            print(
                f"[{idx + 1}/{len(records)}] qid={record['question_id']} "
                f"score={score:.3f} small={guide_answer[:80]!r} large={large_answer!r}"
            )

    accuracy = sum(item["vqa_score"] for item in results) / max(len(results), 1)
    result_path = Path(args.out_dir) / f"{args.run_name}.json"
    summary_path = Path(args.out_dir) / f"{args.run_name}.summary.json"
    with open(result_path, "w") as f:
        json.dump(results, f, ensure_ascii=False, indent=2)
    summary = {
        "count": len(results),
        "accuracy": accuracy,
        "guide_checkpoint": guide_checkpoint,
        "large_checkpoint": large_checkpoint,
        "case_json": args.case_json,
        "source_jsonl": args.source_jsonl,
        "guide_reasoning_mode": args.guide_reasoning_mode,
        "guide_attention_source": args.guide_attention_source,
        "guide_question_attention_weight": args.guide_question_attention_weight,
        "guide_reasoning_attention_weight": args.guide_reasoning_attention_weight,
        "guide_answer_attention_weight": args.guide_answer_attention_weight,
        "large_model_prune_ratio": args.large_model_prune_ratio,
        "results_file": str(result_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}")


if __name__ == "__main__":
    main()