Blame for MedEvalKit/grounding_diff_text.py

"""
grounding_diff_text.py — Visual Influence Analysis (Label Mask vs Random Text Mask Divergence)
================================================================================================
For each sample:
  1. MT forward pass  (label tokens masked)               → hs_label [num_layers, D]
  2. RT forward pass  (random equal-count text tokens masked) → hs_rand  [num_layers, D]
  3. Per-layer divergence: D[i] = 1 - cosine(hs_label[i], hs_rand[i])
  4. Save mean divergence across all samples: shape [num_layers]

This directly measures how differently the model processes label-masked vs randomly-masked
text inputs. A large divergence means the label tokens are distinctly important to the model.

Supported models  : qwen2_5vl, qwen3vl, medgemma, llava, llava_med, huatuogpt_vision
Supported datasets: VGMED, COCO

──────────────────────────────────────────────────────────────────────────────────
【中文总览 / 整体说明】
──────────────────────────────────────────────────────────────────────────────────
本脚本是 grounding_mask_text.py 的"随机对照实验"版本。

背景动机（为什么需要这个脚本）：
  grounding_mask_text.py 做的事情是：对比"完整输入(VL)的前向"与"把label token清零之后(MT)
  的前向"之间的隐藏状态差异(divergence)。如果这个divergence很大，研究者会倾向于解读为
  "label token对模型很重要，把它mask掉会显著改变模型的内部表征"。

  但这个解读存在一个混淆因素(confound)：模型的隐藏状态本来就会因为"任意位置的token被
  清零"这种扰动而发生变化——这种变化可能只是因为"输入被改动了"这一事实本身，而不是因为
  被改动的恰好是label token。换句话说，mask_text观测到的divergence，可能只是"扰动任意
  token都会产生的伪效应(artifact)"，而不是label token真的有特殊地位的证据。

  为了排除这个混淆因素，本脚本设计了一个随机对照组：
    - MT前向：依然是把label token清零（与mask_text脚本中的MT完全一致的操作）。
    - RT前向（Random Text，本脚本独有）：不再使用完整未mask的输入做对比，而是随机挑选
      "与label token数量相同、但内容随机、且不包含真实label token"的其他文本token，把
      它们清零，作为对照。
    - 然后计算 MT 和 RT 两次前向之间的逐层余弦距离，作为"divergence"。

  这样一来，MT和RT这两次前向"扰动的token数量"是完全相等的，唯一的区别就是"被扰动的是
  不是label token"。如果两者差异很大，说明label token确实特殊（它被mask掉之后产生的
  隐藏状态，和随便mask掉同样数量的其他token产生的隐藏状态很不一样）；如果两者差异很小，
  说明mask_text.py里观测到的"VL vs MT"的divergence，很可能主要是"扰动操作本身"造成的，
  而不是label token的特殊重要性造成的。

  注意一个关键区别：grounding_mask_text.py对比的是"未mask的VL" vs "label被mask的MT"；
  而本脚本对比的是两个"都被mask了"的前向（MT vs RT），只是mask的token集合不同。这是
  设计上故意为之的，目的就是控制"是否发生了mask扰动"这个变量，只让"mask的是不是label"
  这一个变量发生变化。

  最终产出：每一层(layer)一个divergence数值，跨样本取平均后得到shape=[num_layers]的
  张量并保存为.pt文件。divergence数值的含义是：在该层，"mask掉label token"与"mask掉
  等量随机文本token"两种扰动方式下，模型隐藏状态的不相似程度（1-余弦相似度，并截断到
  非负）。数值越大，说明该层对"被mask的具体是什么token"越敏感，从而越能支持"label token
  具有特殊重要性"这一结论；数值越小，说明该层对"mask哪个token"不敏感，原始mask_text的
  发现在该层可能更多是扰动伪效应。
──────────────────────────────────────────────────────────────────────────────────
"""

import argparse
import os
import random
import warnings

import numpy as np
import torch
import torch.nn.functional as F
from tqdm import tqdm

warnings.filterwarnings("ignore")

# 从同目录下的measure_attention.py导入共享工具函数：
#   - get_dataset_paths / load_questions：读取VGMED或COCO数据集的jsonl标注文件路径与样本列表
#   - get_num_layers：获取当前backend模型的transformer层数
#   - infer_model_type / load_backend：根据model_path自动识别模型类型(qwen/medgemma/llava等)
#     并加载对应的模型、processor/tokenizer，统一封装进backend字典里
#   - process_input_image_and_qs_xxx：针对不同模型，把(图像路径, 问题文本)预处理成模型forward
#     所需的input_ids/inputs，并定位图像token在序列中的起止位置(pos, pos_end)
# 这些函数与grounding_mask_text.py共用同一套实现，保证两个对照实验脚本的输入预处理逻辑一致，
# 这样两者算出来的divergence才具有可比性。
from measure_attention import (
    get_dataset_paths,
    get_num_layers,
    infer_model_type,
    load_backend,
    load_questions,
    process_input_image_and_qs_llava,
    process_input_image_and_qs_llava_med,
    process_input_image_and_qs_medgemma,
    process_input_image_and_qs_qwen,
    render_masked_text_image,
)


# ── hidden-state extraction ───────────────────────────────────────────────────────

# 【函数说明】从某一次forward返回的hidden_states元组中，抽取"最后一个token"在每一层
# 的隐藏向量，并堆叠成形如[num_layers, hidden_dim]的张量。
# 之所以只取最后一个token：在这类自回归VLM的设定下，最后一个token（通常是即将生成答案
# 前的位置）的隐藏状态被视为模型对"整段输入(图像+问题)"信息整合后的汇总表征，最适合用来
# 比较"换了不同mask策略后，模型对同一个问题的理解/表征发生了多大变化"。
# hidden_states[1:]跳过的是第0个元素（embedding层输出，即输入嵌入本身，不算"transformer层"
# 的输出），所以返回的张量第0维大小才等于num_hidden_layers。
# 输入：hidden_states —— 模型forward返回的tuple，每个元素形状大致为[batch, seq_len, hidden_dim]
# 输出：torch.Tensor，shape=[num_layers, hidden_dim]，已detach、转为float32（脱离计算图，方便后续cosine计算与保存）
def _get_last_token_hidden_states(hidden_states):
    return torch.stack(
        [h.view(-1, h.shape[-1])[-1, :].float().detach() for h in hidden_states[1:]]
    )


# 【函数说明】LLaVA-Med专用的"无mask"前向封装（注意：本文件中实际调用的都是带mask的版本，
# 见下方_forward_hidden_masked_llava_med；这个函数在当前主流程里似乎未被直接使用，更像是
# 历史遗留/与mask_text.py保持接口对称而保留的工具函数，仅做forward+取隐藏状态，不做任何mask）。
# 输入：input_ids、imgs(预处理后的图像张量)、model
# 输出：该次forward每层最后一个token的隐藏状态，shape=[num_layers, hidden_dim]
def _forward_hidden_llava_med(input_ids, imgs, model):
    out = model(
        input_ids, images=imgs,
        output_attentions=False, output_hidden_states=True,
        return_dict=True, use_cache=False,
    )
    return _get_last_token_hidden_states(out.hidden_states)


# ── label → token indices ─────────────────────────────────────────────────────────

# 【函数说明】在input_ids序列中定位label字符串对应的token下标集合。
# 实现思路：因为同一个label字符串在不同分词上下文里可能被tokenizer编码成不同的token id
# 序列（例如句首/句中、有无前导空格、大小写不同），所以这里穷举了4种候选写法
# [原样, 前面加空格, 小写, 小写+前导空格]分别编码，然后在input_ids_list中做"子序列匹配"，
# 任何一种候选匹配上的位置都会被加入found这个集合（用set是为了自动去重，避免多个候选
# 写法命中同一段位置时重复计数）。
# 这个函数与grounding_mask_text.py中查找label token的逻辑保持一致，这一点很重要：
# 本脚本的MT前向（mask label）必须mask出与mask_text.py完全相同的token集合，否则两个
# 脚本的对照结果就不可比了。
# 输入：input_ids_list（int列表，完整token序列）、label（字符串）、tokenizer
# 输出：label token在序列中的下标集合（set[int]），如果一个label没有任何候选匹配成功，
#       返回空集合（调用处会因len(label_set)==0导致后续随机采样n=0，相当于不mask任何token，
#       但理论上主流程已经用`label not in question`提前过滤掉了这种样本，正常不会发生）。
def _find_label_token_indices(input_ids_list, label, tokenizer):
    candidates = [label, " " + label, label.lower(), " " + label.lower()]
    found = set()
    for cand in candidates:
        label_ids = tokenizer.encode(cand, add_special_tokens=False)
        if not label_ids:
            continue
        n = len(label_ids)
        for i in range(len(input_ids_list) - n + 1):
            if input_ids_list[i:i + n] == label_ids:
                for j in range(n):
                    found.add(i + j)
    return found


# 【函数说明】仅用于LLaVA-Med/HuatuoGPT这两种模型：它们的input_ids里图像只用单个
# IMAGE_TOKEN_INDEX占位符表示，真正forward时这一个占位符会在模型内部被展开成多个
# (576个)视觉embedding。这导致"在input_ids里数出来的下标"和"展开后真正喂进embedding
# hook的下标"不是一一对应的——展开之后，原本位于img_pos之后的文本token，其在"展开后
# 序列"中的实际位置都要整体左移1位（因为1个占位符变成了576个视觉token，多出来的部分
# 会把后面的文本顶到更后面，所以要先把input_ids里的下标减1，再去推算它在展开后大序列
# 里对应的偏移；这里减1的本质是"补偿占位符本身只占1个位置，而不是576个位置"的差异，
# 配合_make_emb_hook里对输出embedding张量的下标操作）。
# 不适用于LLaVA（HF LlavaProcessor）：它的input_ids本身就已经包含576个真实的图像token
# 条目（没有"1个占位符展开成576个"这一步），所以在input_ids中找到的下标已经是展开后
# 的绝对位置，应该直接用_random_non_label_text_indices（不做调整），和qwen/medgemma
# 的处理方式相同。
def _adjust_text_indices_for_image_placeholder(indices, img_pos):
    """LLaVA-Med/HuatuoGPT only: these use a single IMAGE_TOKEN_INDEX placeholder in
    input_ids that gets expanded into multiple visual embeddings internally, so
    text token positions after img_pos are shifted left by 1 relative to input_ids.
    Does NOT apply to LLaVA (HF LlavaProcessor): there, input_ids already contains
    576 real image-token entries (no placeholder expansion), so indices found in
    input_ids are already correct absolute positions -- use
    _random_non_label_text_indices (no adjustment) instead, same as qwen/medgemma."""
    return [i - 1 if i > img_pos else i for i in indices]


# 【函数说明】在input_ids序列中定位sample["question"]原始文本（即q_type后缀指令
# 追加之前的那段"纯问题"）对应的token下标区间[start, end)。
# 为什么需要这个：随机对照组的候选池不应该是"整条input_ids减去label/图像token"，
# 那样会把chat模板的系统提示词（"You are a helpful assistant"）、特殊token
# （<|im_start|>等）、以及q_type追加的固定指令（"Please output 'yes' or 'no'..."）
# 都当成候选——这些不是"问题内容"的一部分，是每个样本都一样的模板/指令文本，
# 随机抽到它们跟抽到"问题里的实词"在语义上完全不对等，会让"随机文本"这个对照组
# 不够干净。所以候选池要严格限定在sample["question"]这段原始文本本身。
# 输入：ids_list（完整token id序列）、question_raw（sample["question"]原始文本，
#       不含q_type追加的指令后缀）、tokenizer
# 输出：(start, end)元组，问题文本对应的token下标区间；如果question_raw作为
#       子串完全没在解码结果里出现（理论上不应该发生，因为它本来就是prompt的
#       一部分），返回None，调用处按候选不足处理，跳过该样本。
def _find_question_token_span(ids_list, question_raw, tokenizer, img_span=None):
    """
    中文说明（为什么改用"解码后按字符串匹配"，而不是"重新编码后按token序列匹配"）：
    最初的实现是把question_raw单独tokenizer.encode()编码成token id序列，再去
    ids_list里做精确子序列匹配。这个思路有一个致命缺陷：question_raw在真正的
    prompt里紧挨着chat模板的角色标记（比如"<|im_start|>user\n<image>\n
    {question_raw}..."），BPE分词器在这类模板边界处的切分方式，跟"把
    question_raw单独拿出来tokenize"很可能不完全一致——哪怕只是开头第一个
    token切法不同，就会导致整段精确匹配（以及"跳过第一个token"的兜底匹配）
    双双失败，函数返回None，调用方把该样本直接跳过。这在实测中曾导致
    diff_text.py对某些分词器（Qwen、HuatuoGPT-Vision）几乎每一个样本都在这一步
    就return None——而且是在真正调用模型前向之前就失败，所以整个跑起来
    "快得不正常"（比如13962个样本几秒钟就"跑完"，Skipped(other error)=100%），
    根本没有触发任何一次真正的GPU推理。

    现在改成完全不同的思路：不再尝试"重新编码"question_raw去猜测它在原始
    tokenize结果里长什么样，而是反过来——把ids_list里每一个token单独解码
    （tokenizer.decode([tid])），拼接还原出完整文本，再用最朴素的Python字符串
    查找（str.find）去定位question_raw这段文字出现在哪个字符区间，最后把
    这个字符区间映射回对应的token下标范围。字符串层面的子串匹配完全不受
    "BPE在不同上下文里怎么切分"这件事影响——不管某个词的token边界在句子中间
    还是句子开头合并方式变没变，解码出来的文字内容本身是确定的、不会变的。
    这样从根本上避免了"重新编码后tokenize不出same token序列"这一类问题，
    不需要再靠"容忍第一个token对不上"这种脆弱的兜底去碰运气。

    另一个必须注意的坑：LLaVA-Med/HuatuoGPT-Vision/LLaVA这类图像token在
    ids_list里占据实际位置的后端，不能指望"decode图像token会抛异常"来
    识别它们——这个假设并不可靠，因为是否抛异常取决于具体tokenizer实现：
      - HuatuoGPT-Vision的-200：实测会让某些（Rust fast实现的）tokenizer
        抛OverflowError，可以被下面的try/except捕获。
      - LLaVA-Med的-200：其tokenizer走的是老式SentencePiece/慢速Python
        实现（load_pretrained_model加载的LlamaTokenizer），对同样的-200
        不一定抛异常——很可能被内部的取模/环绕逻辑悄悄映射成词表里某个
        真实token并"成功"decode出内容，不会走except分支，却会把无意义的
        文字混进full_text，污染字符串匹配（和下面LLaVA 32000是同一种
        故障模式）。
      - LLaVA的32000：这是LLaVA-1.5词表大小本身的边界值，被挪用做图像
        占位符，是一个合法token id，decode必定"成功"（不抛异常），但
        decode出来的内容对文本重建毫无意义，同样会污染full_text。
    所以不再依赖"try/except能不能兜住"这种因tokenizer实现而异、不可靠的
    检测方式，而是让调用方（本来就知道图像token占据哪些位置）显式传入
    img_span=(start, end)，函数内部对这个区间强制视为空字符串，不管
    decode本身会不会报错、decode出来是什么——统一、确定地把图像token排除在
    "文本重建"之外。try/except依然保留作为通用兜底（应对其他不可预见的
    decode失败情况），但不再是图像token这件事本身的检测手段。

    第三个坑（比图像token这个更根本、影响更大）：一开始"逐token单独调用
    tokenizer.decode([tid])"这个做法，对LLaVA/LLaVA-Med这类基于
    SentencePiece的tokenizer（LLaMA/Vicuna系）是错的，会导致100%的样本
    都在这一步失败（实测：LLaVA跑diff_text.py时，加了上面的img_span
    保护之后，[skip:question_span=None]依然是100%命中，一个样本都过不了，
    证明问题不在图像token，而在别的地方）。

    根本原因：SentencePiece把"一个新词开头前面有空格"编码成词内部自带的
    "▁"标记（比如" the"这个词，实际token是"▁the"），decode的时候
    "▁"->" "。但SentencePiece的decode实现（sp_model.decode_pieces）会把
    传进来的这一批token当作"一整段独立文本的开头"来处理，如果这一整段
    只有1个token（就是这里"逐token单独decode"的做法），那么这个token
    即便本来是"▁the"这种带前导空格标记的token，也会被当成"这段文本的
    第一个词"，其前导空格被自动去掉——这在SentencePiece的设计里是合理的
    （避免一句话开头多出一个空格），但套用到"给每个token单独发起一次
    decode调用"这个场景下，就意味着——不管这个token在原始序列里是不是
    紧跟在某个词后面、本来就该有空格——只要它是"这一次独立decode调用"里
    唯一的token，它的前导空格永远会被丢弃。结果是：整条序列逐token
    decode再拼接后，几乎所有词与词之间的空格全部消失（"Does the image
    contain a truck?"被重建成类似"Doestheimagecontainatruck?"这种连写
    文本），而question_raw本身是带正常空格的，自然永远无法在这样一段
    "全部单词连在一起"的字符串里被find()到，导致100%的样本都在
    char_start==-1这一步失败并return None。

    这个问题不会影响Qwen这类BPE/tiktoken风格的fast tokenizer——它们把
    "前导空格"编码进token本身的字节表示里（比如"Ġthe"，Ġ就是空格的
    字节级表示），解码单个token时直接原样转换，不依赖"是不是整段文本的
    开头"这种上下文判断，所以逐token单独decode不会丢空格。这也是为什么
    HuatuoGPT-Vision/Qwen系列不需要这个修复、只有LLaVA/LLaVA-Med这两个
    SentencePiece系后端会中招的原因。

    修复方式：不再对每个token发起独立的decode调用，而是维护一个
    "从头到当前token为止的累积token列表"（running_ids），每次把新token
    追加进去后，对整个累积列表做一次decode，取本次decode结果相对于
    上一次结果"新增出来的那一段"作为这个token的文本片段。这样
    SentencePiece在decode时始终能看到"这个token前面还有其它token"这个
    上下文，"▁"->" "的转换就不会被误判成"整段文本的开头"而被吞掉，
    单词之间的空格能被正确保留。图像token区间(img_span)内的位置不加入
    running_ids（相当于从"要decode的文本"里完全抠掉，而不是保留占位再
    置空字符串）——这样图像token既不会被误decode出无意义内容，也不会
    因为占用了running_ids里的一个位置而干扰后续文本token的上下文。
    """
    fragments = []
    running_ids = []
    prev_text = ""
    for i, tid in enumerate(ids_list):
        if img_span is not None and img_span[0] <= i < img_span[1]:
            fragments.append("")
            continue
        running_ids.append(tid)
        try:
            cur_text = tokenizer.decode(running_ids)
        except Exception:
            cur_text = prev_text
        fragments.append(cur_text[len(prev_text):])
        prev_text = cur_text
    full_text = "".join(fragments)
    char_start = full_text.find(question_raw)
    if char_start == -1:
        char_start = full_text.find(question_raw.strip())
        if char_start == -1:
            return None
    char_end = char_start + len(question_raw)

    offsets = []
    cursor = 0
    for frag in fragments:
        offsets.append((cursor, cursor + len(frag)))
        cursor += len(frag)

    tok_start = tok_end = None
    for i, (s, e) in enumerate(offsets):
        if tok_start is None and e > char_start:
            tok_start = i
        if s < char_end:
            tok_end = i + 1
    if tok_start is None or tok_end is None:
        return None
    return tok_start, tok_end


# 【函数说明：随机对照组的核心实现，所有后端通用】
# 在"纯问题"文本对应的token区间[q_start, q_end)里，找一段与label token数量完全
# 相同(n个)、且不与label token重叠的"连续"token片段，作为RT（Random Text）前向
# 要mask掉的token集合。
#
# 为什么必须是"连续的一段"，而不是"分散抽取n个不相邻的token"：这跟
# grounding_diff_region.py里_random_multi_rect_indices的设计思路完全对称——label
# 本身在文本里天然是一个连续的短语/词（比如"aorta"就是紧挨着的1个或几个token），
# 如果随机对照组是从问题各处分散抽取的孤立token（彼此之间被其它未mask的词隔开），
# 那么"被mask的是一个连续短语"和"被mask的是几个不相邻的孤立词"这两种情况，对模型
# 的影响机制可能本就不同（前者破坏的是一段连续语义，后者更像是多处零散的局部
# 缺失），这本身就是一个混淆变量。要求随机对照区域和label同样是"连续的一段
# 长度为n的token"，才能让"mask的是不是label本身"成为两组之间唯一的实质性差异——
# 这正是本脚本最初的设计目标（见文件顶部总览），只是早期实现里遗漏了"连续"这个
# 约束，后来在区域版脚本里先修正了，这里同步补上。
#
# 候选池限定在question_span内（而不是整条ids_list减去图像/label token），是为了
# 保证随机对照组抽到的都是"问题内容里的实词"，不会抽到chat模板/系统提示词/q_type
# 追加指令这些每个样本都一样的模板文本——见_find_question_token_span的说明。
#
# 如何保证"数量相等"：调用处永远传入 n = len(label_set)，让MT前向(mask label_set)
# 和RT前向(mask rand_indices)被清零的token数量严格相等。
#
# 坐标系：本函数在"原始input_ids坐标系"（即ids_list本身的下标）里采样，对所有
# 后端一视同仁。对llava_med/huatuogpt_vision这两个用单占位符表示图像的后端，
# 调用方在拿到这里的采样结果后，还需要额外调用
# _adjust_text_indices_for_image_placeholder做"减1"调整，才能得到真正传给
# embedding hook的展开后坐标——这跟label_indices的处理方式完全对称（label_indices
# 同样是先在原始坐标系找到，再按需adjust）。
#
# 输入：ids_list（完整token id列表，本函数未直接使用，保留是为了跟其它同类函数
#       签名一致）、label_set（label token下标集合，原始坐标）、question_span
#       （_find_question_token_span算出的(q_start, q_end)区间）、n（要mask的数量，
#       等于label token数）
# 输出：长度为n、下标连续的list（原始input_ids坐标系）；候选不足时返回None
def _random_non_label_text_indices(ids_list, label_set, question_span, n):
    q_start, q_end = question_span
    if n == 0:
        return []
    candidates = []
    for start in range(q_start, q_end - n + 1):
        run = range(start, start + n)
        if not any(i in label_set for i in run):
            candidates.append(start)
    if not candidates:
        return None
    start = random.choice(candidates)
    return list(range(start, start + n))


# ── masked forward ────────────────────────────────────────────────────────────────

# 【函数说明】构造一个forward hook闭包，挂在embedding层(get_input_embeddings())的输出上，
# 把mask_indices指定的那些token位置的embedding向量整体清零（置为0.0），从而实现"屏蔽某些
# token对后续所有transformer层的影响"的效果——这是本脚本"mask"操作的真正落地方式：不是在
# input_ids层面删除token，而是在embedding输出层面把对应位置的向量清零，保持序列长度不变，
# 只是让模型在该位置"看不到"原始token的语义信息（清零后的embedding不携带该token的语义）。
# output.ndim==2 / 否则(通常是3维[batch, seq_len, hidden_dim])两个分支分别处理"无batch维"
# 和"有batch维"两种embedding输出形状，兼容不同模型实现的embedding层返回值形态。
# 注意.clone()：必须先克隆输出张量再修改，否则会就地修改原始embedding输出，可能引发
# autograd或其他hook的副作用问题。
# 输入：mask_indices —— 要清零的token下标列表（MT前向传label_set，RT前向传rand_indices）
# 输出：一个符合register_forward_hook签名的hook函数(module, args, output) -> output
def _make_emb_hook(mask_indices):
    def _hook(module, args, output):
        output = output.clone()
        if output.ndim == 2:
            for idx in mask_indices:
                if idx < output.shape[0]:
                    output[idx, :] = 0.0
        else:
            for idx in mask_indices:
                if idx < output.shape[1]:
                    output[:, idx, :] = 0.0
        return output
    return _hook


# 【函数说明】qwen2_5vl/qwen3vl/medgemma/llava通用的"带mask的前向"：先把_make_emb_hook
# 注册到embedding层上，做一次完整的forward（开启output_hidden_states以便取每层隐藏状态），
# 最后在finally块里移除hook（避免hook状态泄漏到下一次forward，比如紧接着的另一次mask
# 调用如果忘记移除旧hook，会导致两次mask叠加生效）。
# 本函数在get_sample_hidden_states中被调用两次：一次传label_set得到hs_label(MT前向)，
# 一次传rand_indices得到hs_rand(RT前向)——这就是本脚本的核心对比双胞胎。
# 输入：inputs（processor处理好的模型输入字典）、model、mask_indices（要清零的token下标）
# 输出：该次forward每层最后一个token的隐藏状态，shape=[num_layers, hidden_dim]
def _forward_hidden_masked(inputs, model, mask_indices):
    handles = [model.get_input_embeddings().register_forward_hook(_make_emb_hook(mask_indices))]
    try:
        out = model(**inputs, output_attentions=False, output_hidden_states=True,
                    return_dict=True, use_cache=False)
    finally:
        for h in handles: h.remove()
    return _get_last_token_hidden_states(out.hidden_states)


# 【函数说明】LLaVA-Med专用的"带mask的前向"，逻辑与_forward_hidden_masked完全一样，只是
# LLaVA-Med的模型forward签名是model(input_ids, images=imgs, ...)而不是model(**inputs, ...)，
# 所以单独写一个版本以匹配其调用接口。
def _forward_hidden_masked_llava_med(input_ids, imgs, model, mask_indices):
    handles = [model.get_input_embeddings().register_forward_hook(_make_emb_hook(mask_indices))]
    try:
        out = model(input_ids, images=imgs, output_attentions=False,
                    output_hidden_states=True, return_dict=True, use_cache=False)
    finally:
        for h in handles: h.remove()
    return _get_last_token_hidden_states(out.hidden_states)


# 【函数说明】HuatuoGPT-Vision专用的"带mask的前向"。这里需要重新走一遍HuatuoGPT自己的
# 输入预处理流程（input_moderation -> insert_image_placeholder -> get_conv_without_history
# -> preprocess），因为HuatuoGPT的bot封装没有像qwen/medgemma那样统一暴露processor接口，
# 必须复用bot自身的方法链才能得到正确的input_ids和image_tensors。
# 之所以每次调用都重新跑一遍预处理（而不是像其它分支一样预处理一次复用两次），是因为
# HuatuoGPT分支在get_sample_hidden_states里就是分别为MT、RT各自调用了一次本函数（见下方
# btype == "huatuogpt_vision"分支），传入相同的text/image_path，重复预处理两次，逻辑上
# 等价但效率上略有冗余（每次都要重新moderation+tokenize），这是与其它模型分支实现风格不
# 一致的地方，但不影响结果正确性。
# 输入：text（问题文本）、image_path、backend（含bot对象）、mask_indices（要清零的token下标，
#       已经过_adjust_text_indices_for_image_placeholder调整为展开后的绝对位置）
# 输出：该次forward每层最后一个token的隐藏状态，shape=[num_layers, hidden_dim]
def _forward_hidden_masked_huatuo(text, image_path, backend, mask_indices):
    bot = backend["bot"]
    text = bot.input_moderation(text)
    text = bot.insert_image_placeholder(text, 1)
    conv = bot.get_conv_without_history(text)
    input_ids = bot.preprocess(conv, return_tensors="pt").unsqueeze(0).to(bot.device)
    image_tensors = (torch.stack(bot.get_image_tensors([image_path]))
                     .to(dtype=torch.bfloat16).to(bot.device))
    handles = [bot.model.get_input_embeddings().register_forward_hook(_make_emb_hook(mask_indices))]
    try:
        out = bot.model(input_ids, images=image_tensors, output_attentions=False,
                        output_hidden_states=True, return_dict=True, use_cache=False)
    finally:
        for h in handles: h.remove()
    return _get_last_token_hidden_states(out.hidden_states)


# ── per-sample extraction ─────────────────────────────────────────────────────────

# 【函数说明：单样本处理主流程】
# 对单个样本完整执行一次"MT前向 vs RT前向"的对照实验，返回两组隐藏状态供后续计算divergence。
#
# 整体步骤（六个分支：qwen2_5vl/qwen3vl、medgemma、llava、llava_med、huatuogpt_vision，
# 分支结构基本平行，只是各模型的预处理函数/输入格式不同）：
#   1. 拼接问题文本：根据q_type在原始question后追加任务提示语（localization任务要求输出
#      yes/no，attribute任务要求输出单词或短语）——这与评测时模型实际看到的提示语保持一致，
#      确保这里测的是"模型在真实推理设置下"对label/随机token的敏感度，不是脱离任务上下文
#      单独测的。
#   2. 用对应模型的process_input_image_and_qs_xxx函数，把(图像, 问题)转成模型输入，并得到
#      input_ids列表以及图像token的区间(pos, pos_end)。
#   3. 用_find_label_token_indices在input_ids里定位label对应的token下标集合(label_set)。
#   4. 用_random_non_label_text_indices(_for_image_placeholder)随机采样等量、不重叠、
#      排除图像区间的文本token下标(rand_indices)作为对照组。如果候选不足返回None，则
#      整个样本被跳过（return None）。
#   5. 分别用label_set和rand_indices两套mask下标各做一次带mask的前向，得到hs_label(MT)
#      和hs_rand(RT)两组逐层隐藏状态。
#   6. 任何步骤出错（比如找不到图像token区间、tokenizer解析异常等）都会被外层try/except
#      捕获，打印warning并返回None，保证单个坏样本不会中断整个数据集的遍历。
#
# 返回前用min(hs_label.shape[0], hs_rand.shape[0])对齐两者的层数——理论上MT和RT用的是
# 同一个模型、同一次forward配置，层数应该天然相等，这里取min只是防御性写法，防止某些
# 模型在不同前向间返回的hidden_states层数有细微差异时导致后续stack/cosine计算报错。
#
# 输入：
#   sample      —— 单条jsonl样本字典，需包含image/question/label/bbox(或original_bboxes)等字段
#   data_path   —— 图像文件所在根目录
#   dataset     —— "VGMED"或"COCO"（当前函数体内未直接用到，但保留参数是为了和
#                  get_sample_attention等同名函数签名保持一致，便于代码维护/复用习惯）
#   backend     —— load_backend返回的字典，包含模型、processor/tokenizer等
#   layers      —— 层下标的range对象（当前函数体内同样未直接使用，层数信息实际由
#                  hidden_states自身的长度决定；layers参数更多是签名上的占位，留作以后
#                  若要支持"只计算部分层"时使用，目前是全量计算所有层）
#   q_type      —— "localization"或"attribute"，决定问题末尾追加的提示语
# 输出：
#   成功时返回 (hs_label, hs_rand) 元组，各自shape=[num_layers, hidden_dim]
#   失败/候选不足时返回 None
def get_sample_hidden_states(sample, data_path, dataset, backend, layers, q_type="localization"):
    image_name = sample["image"]
    image_path = os.path.join(data_path, image_name)
    question_raw = sample.get("question", "")
    label = sample.get("label", "")
    if q_type == "attribute":
        question = question_raw + "\nAnswer the question using a single word or phrase."
    else:
        question = question_raw + "\nPlease output 'yes' or 'no'(no extra output)."
    btype = backend["type"]

    try:
        # qwen系列：input_ids中图像token已是展开后的真实位置（无占位符问题），
        # 直接用_random_non_label_text_indices即可，下标不需要额外调整。
        # len(label_set)既是MT要mask的数量，也作为n传给随机采样函数，保证RT和MT
        # 清零的token数量严格一致。随机采样限定在"纯问题"（question_raw，不含
        # q_type追加指令）对应的token区间内——见_find_question_token_span的说明，
        # 避免抽到chat模板/系统提示词/指令后缀这些非"问题内容"的token。
        if btype in {"qwen2_5vl", "qwen3vl"}:
            inputs, _, token_shape, new_size, pos, pos_end = \
                process_input_image_and_qs_qwen(image_path, question, backend)
            tokenizer = backend["processor"].tokenizer
            ids_list = inputs["input_ids"].reshape(-1).tolist()
            label_set = _find_label_token_indices(ids_list, label, tokenizer)
            question_span = _find_question_token_span(ids_list, question_raw, tokenizer)
            if question_span is None:
                return None
            rand_indices = _random_non_label_text_indices(ids_list, label_set, question_span, len(label_set))
            if rand_indices is None:
                return None
            hs_label = _forward_hidden_masked(inputs, backend["model"], list(label_set))
            hs_rand  = _forward_hidden_masked(inputs, backend["model"], rand_indices)
            # 这几个后端image token在ids_list里就是真实展开的，label_set/rand_indices
            # 本身就是ids_list坐标系下的下标，供render_masked_text_image渲染时不需要
            # 额外调整，直接原样复用。
            viz_label_indices, viz_rand_indices, viz_pos, viz_pos_end = label_set, rand_indices, pos, pos_end

        elif btype == "medgemma":
            inputs, _, token_shape, new_size, pos, pos_end = \
                process_input_image_and_qs_medgemma(image_path, question, backend)
            tokenizer = backend["processor"].tokenizer
            ids_list = inputs["input_ids"].reshape(-1).tolist()
            label_set = _find_label_token_indices(ids_list, label, tokenizer)
            question_span = _find_question_token_span(ids_list, question_raw, tokenizer)
            if question_span is None:
                return None
            rand_indices = _random_non_label_text_indices(ids_list, label_set, question_span, len(label_set))
            if rand_indices is None:
                return None
            hs_label = _forward_hidden_masked(inputs, backend["model"], list(label_set))
            hs_rand  = _forward_hidden_masked(inputs, backend["model"], rand_indices)
            viz_label_indices, viz_rand_indices, viz_pos, viz_pos_end = label_set, rand_indices, pos, pos_end

        elif btype == "llava":
            inputs, _, token_shape, new_size, pos, pos_end, _pad_offset, _frame_size = \
                process_input_image_and_qs_llava(image_path, question, backend)
            tokenizer = backend["processor"].tokenizer
            ids_list = inputs["input_ids"].reshape(-1).tolist()
            # HF LlavaProcessor already expands the image into 576 real token
            # entries in input_ids (no single-placeholder expansion), so indices
            # found here are already correct absolute positions -- same handling
            # as qwen/medgemma above, no -1 adjustment.
            label_set = _find_label_token_indices(ids_list, label, tokenizer)
            label_indices = list(label_set)
            question_span = _find_question_token_span(ids_list, question_raw, tokenizer, img_span=(pos, pos_end))
            if question_span is None:
                return None
            rand_indices = _random_non_label_text_indices(ids_list, label_set, question_span, len(label_set))
            if rand_indices is None:
                return None
            hs_label = _forward_hidden_masked(inputs, backend["model"], label_indices)
            hs_rand  = _forward_hidden_masked(inputs, backend["model"], rand_indices)
            viz_label_indices, viz_rand_indices, viz_pos, viz_pos_end = label_set, rand_indices, pos, pos_end

        # llava_med：input_ids用单个IMAGE_TOKEN_INDEX占位符表示图像，所以label_indices
        # 和rand_indices都需要经过"占位符展开"下标调整（_adjust_text_indices_for_
        # image_placeholder）才能正确对应到embedding hook实际操作的展开后序列位置。
        # rand_indices现在和label_indices走完全对称的两步：先在原始坐标系（ids_list
        # 本身）里，限定在question_span范围内采样，再统一做展开坐标调整——这样
        # 调整前的原始下标本来就是采样结果本身，不需要再额外"反推"回原始坐标
        # （对比早期实现：那时候是先在错误的排除区间里采样再调整，可视化时还得把
        # 调整后的结果反推回去，现在两步顺序理清楚后不再需要这一步反推）。
        elif btype == "llava_med":
            input_ids, _, imgs, token_shape, new_size, pos, pos_end = \
                process_input_image_and_qs_llava_med(image_path, question, backend)
            tokenizer = backend["tokenizer"]
            ids_list = input_ids.reshape(-1).tolist()
            label_set = _find_label_token_indices(ids_list, label, tokenizer)
            label_indices = _adjust_text_indices_for_image_placeholder(list(label_set), pos)
            question_span = _find_question_token_span(ids_list, question_raw, tokenizer, img_span=(pos, pos + 1))
            if question_span is None:
                return None
            rand_raw = _random_non_label_text_indices(ids_list, label_set, question_span, len(label_set))
            if rand_raw is None:
                return None
            rand_indices = _adjust_text_indices_for_image_placeholder(rand_raw, pos)
            hs_label = _forward_hidden_masked_llava_med(input_ids, imgs, backend["model"], label_indices)
            hs_rand  = _forward_hidden_masked_llava_med(input_ids, imgs, backend["model"], rand_indices)
            # label_set/rand_raw都已经是"调整前"的原始ids_list坐标，直接用于渲染。
            # ids_list里图像只占pos这一个位置（不是pos_end-pos那么多个，pos_end是
            # "假设展开后"的虚拟终点），所以折叠"<IMG>"的区间是[pos, pos+1)。
            viz_label_indices = label_set
            viz_rand_indices = rand_raw
            viz_pos, viz_pos_end = pos, pos + 1

        # huatuogpt_vision：同样是单占位符模型（占位符token id固定为-200，这是HuatuoGPT
        # 自身预处理约定的特殊id，下面用`next(... if t == -200)`从input_ids里查找它的位置），
        # 图像区间长度固定为HUATUO_NUM_IMG_TOKENS(=576个patch token)。这个分支没有复用
        # process_input_image_and_qs_xxx系列函数，而是直接调用bot自身的预处理方法链，
        # 与_forward_hidden_masked_huatuo内部的预处理步骤完全一致（即这里又重复跑了一次
        # 相同的预处理，只是为了取得ids_list用来定位label/随机token下标；真正forward时
        # _forward_hidden_masked_huatuo还会再重新跑一次预处理）。
        elif btype == "huatuogpt_vision":
            from measure_attention import HUATUO_NUM_IMG_TOKENS, HUATUO_PATCHES
            bot = backend["bot"]
            text_mod = bot.input_moderation(question)
            text_mod = bot.insert_image_placeholder(text_mod, 1)
            conv = bot.get_conv_without_history(text_mod)
            input_ids_raw = bot.preprocess(conv, return_tensors="pt")
            ids_list = input_ids_raw.reshape(-1).tolist()
            img_pos = next(i for i, t in enumerate(ids_list) if t == -200)
            pos_end = img_pos + HUATUO_NUM_IMG_TOKENS
            label_set = _find_label_token_indices(ids_list, label, bot.tokenizer)
            label_indices = _adjust_text_indices_for_image_placeholder(list(label_set), img_pos)
            question_span = _find_question_token_span(ids_list, question_raw, bot.tokenizer, img_span=(img_pos, img_pos + 1))
            if question_span is None:
                return None
            rand_raw = _random_non_label_text_indices(ids_list, label_set, question_span, len(label_set))
            if rand_raw is None:
                return None
            rand_indices = _adjust_text_indices_for_image_placeholder(rand_raw, img_pos)
            hs_label = _forward_hidden_masked_huatuo(question, image_path, backend, label_indices)
            hs_rand  = _forward_hidden_masked_huatuo(question, image_path, backend, rand_indices)
            tokenizer = bot.tokenizer
            viz_label_indices = label_set
            viz_rand_indices = rand_raw
            viz_pos, viz_pos_end = img_pos, img_pos + 1

        else:
            raise ValueError(f"Unknown backend type: {btype}")

    # 任何分支内部出现异常（比如某个样本的图片缺失、tokenizer解析失败、找不到图像token
    # 区间等），都在这里统一兜底捕获：打印警告但不让单个坏样本中断整个数据集的批量处理。
    # traceback.print_exc()把完整堆栈打到stderr（跟grounding_mask_region.py/
    # grounding_diff_region.py的做法保持一致），方便定位到底是哪一行、哪个函数
    # 触发的异常，而不是只看到异常信息本身这一行文字。
    # 内层再包一层try/except：防止异常信息本身（比如包含终端编码打印不出来的字符）
    # 导致这两行打印自己也抛异常——那样"本该被优雅跳过"的错误反而会变成让整个
    # 脚本崩溃的未捕获异常，彻底违背这里try/except想要的效果。
    except Exception as e:
        try:
            import traceback
            traceback.print_exc()
            print(f"[Warning] Skipping {image_name}: {e}")
        except Exception:
            print(f"[Warning] Skipping {image_name}: <error message could not be printed>")
        return None

    # 防御性对齐：理论上MT前向和RT前向用的是同一个模型、同样的forward配置，层数应该相等；
    # 这里取min只是为了避免极端情况下两次前向返回的hidden_states长度不一致导致后续
    # torch堆叠/余弦计算报错。
    num_layers = min(hs_label.shape[0], hs_rand.shape[0])
    viz_info = {
        "ids_list": ids_list,
        "tokenizer": tokenizer,
        "label_indices": viz_label_indices,
        "rand_indices": viz_rand_indices,
        "pos": viz_pos,
        "pos_end": viz_pos_end,
    }
    return hs_label[:num_layers], hs_rand[:num_layers], viz_info


# ── divergence ────────────────────────────────────────────────────────────────────

# 【函数说明：本脚本的核心度量指标】
# 逐层计算hs_label(MT前向，label token被mask)与hs_rand(RT前向，等量随机文本token被mask)
# 之间的余弦距离 D[i] = 1 - cosine_similarity(hs_label[i], hs_rand[i])。
# dim=-1表示在hidden_dim维度上计算余弦相似度，对hs_label/hs_rand这种shape=[num_layers,
# hidden_dim]的张量，结果是shape=[num_layers]的逐层divergence。
# .clamp(min=0.0)把可能出现的负值（余弦相似度>1时由浮点误差导致1-cos<0，或者理论上
# 不应发生但数值上可能出现的情况）截断为0，保证divergence始终非负，语义上更符合
# "距离"的定义。
# 输入：hs_label、hs_rand —— 形状相同的[num_layers, hidden_dim]张量
# 输出：shape=[num_layers]的逐层divergence张量。数值越大表示该层"mask label"与
#       "mask随机等量文本"产生的隐藏状态差异越大，即label token在该层的处理上越"特殊"。
def compute_divergence_per_layer(hs_label: torch.Tensor, hs_rand: torch.Tensor) -> torch.Tensor:
    return (1.0 - F.cosine_similarity(hs_label, hs_rand, dim=-1)).clamp(min=0.0)


# ── save ──────────────────────────────────────────────────────────────────────────

# 【函数说明】把跨样本平均后的逐层divergence张量(mean_div, shape=[num_layers])保存到
# {output_root}/{model_name}/diff_text/{dataset}_{q_type}_mean_divergence_per_layer.pt。
# 目录里专门用"diff_text"子目录区分本脚本（随机文本对照组）与grounding_mask_text.py
# 等其它实验的输出，避免文件名/路径冲突，方便后续脚本分别加载两组结果做对比分析。
def save_divergences(output_root, model_name, dataset, q_type, mean_div):
    save_path = os.path.join(output_root, model_name, "diff_text")
    os.makedirs(save_path, exist_ok=True)
    torch.save(mean_div, f"{save_path}/{dataset}_{q_type}_mean_divergence_per_layer.pt")


# ── CLI ───────────────────────────────────────────────────────────────────────────

# 【函数说明】定义并解析命令行参数。整体与grounding_mask_text.py的参数集合基本一致，
# 唯一本脚本特有的是--seed（随机种子，默认42），用于控制随机对照组采样的可复现性
# （在main()里通过random.seed(args.seed)生效，作用于_random_non_label_text_indices
# 系列函数内部调用的random.sample）。
# 其余参数：--dataset/--q_type决定加载哪个数据集与任务类型的问题模板；--model_path/
# --model_type/--model_base_path决定加载哪个模型；--vgmed_root/--coco_root/
# --coco_annotation_root是各数据集所需的路径（按数据集做了必填校验）；--output_root
# 是结果保存根目录。
def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--dataset", type=str, choices=["VGMED", "COCO"], required=True)
    parser.add_argument("--q_type", type=str, choices=["localization", "attribute"], required=True)
    parser.add_argument("--model_path", type=str, required=True)
    parser.add_argument("--model_base_path", type=str, default=None)
    parser.add_argument("--model_type", type=str, default="auto",
                        choices=["auto", "qwen2_5vl", "qwen3vl", "medgemma",
                                 "llava", "llava_med", "huatuogpt_vision"])
    parser.add_argument("--device", type=str, default="cuda:0")
    parser.add_argument("--huatuo_repo", type=str, default="./HuatuoGPT-Vision")
    parser.add_argument("--qwen_vl_utils_path", type=str, default=None)
    parser.add_argument("--vgmed_root", type=str, default=None)
    parser.add_argument("--coco_root", type=str, default=None)
    parser.add_argument("--coco_annotation_root", type=str, default=None)
    parser.add_argument("--output_root", type=str, required=True)
    parser.add_argument("--hf_home", type=str, default=None)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument(
        "--no_visualize", action="store_false", dest="visualize",
        help="Disable saving label/random-token-highlight sanity-check images "
             "(on by default)",
    )
    parser.set_defaults(visualize=True)
    parser.add_argument(
        "--visualize_limit", type=int, default=50,
        help="Max number of samples to save highlight images for (default: 50).",
    )
    args = parser.parse_args()

    if args.dataset == "VGMED" and not args.vgmed_root:
        parser.error("--vgmed_root is required when --dataset VGMED.")
    if args.dataset == "COCO":
        if not args.coco_root:
            parser.error("--coco_root is required when --dataset COCO.")
        if not args.coco_annotation_root:
            parser.error("--coco_annotation_root is required when --dataset COCO.")
    return args


# ── main ─────────────────────────────────────────────────────────────────────────

# 【函数说明：脚本主入口】
# 整体流程：
#   1. 解析参数，设置随机种子(random.seed(args.seed))——这一步决定了后续所有样本的
#      随机对照token采样是否可复现。注意这是在加载模型/遍历样本之前就调用的，所以
#      只要数据集遍历顺序和样本数量不变，固定seed就能复现完全相同的随机对照组结果。
#   2. 根据model_path推断/指定模型类型，加载backend（need_attn=False，因为本脚本只需要
#      hidden_states，不需要attention矩阵，可以用更快的sdpa attention实现而不强制eager）。
#   3. 加载数据集问题列表，并确定模型层数(layers)。
#   4. 遍历每个样本，先做几道前置过滤（必须有bbox标注、必须有question文本、label必须
#      真实出现在question里——这一条尤其关键，因为如果label根本没出现在问题文本中，
#      _find_label_token_indices会返回空集合，导致label_set为空、随机采样n=0，使得
#      MT和RT两次前向都变成"不mask任何token"的无意义对照，所以这里提前过滤掉这类样本），
#      再调用get_sample_hidden_states拿到(hs_label, hs_rand)，计算逐层divergence并
#      累积到all_divergences列表中。
#   5. 所有样本处理完后，把all_divergences堆叠成[num_samples, num_layers]的数组，
#      在样本维度(axis=0)上取均值，得到最终shape=[num_layers]的mean_div，即"该模型在
#      该数据集/任务类型下，每一层的平均divergence"——这就是本脚本最终要回答的问题的
#      数值答案：每一层"mask label"与"mask等量随机文本"的差异有多大。
#   6. 打印统计信息（跳过了多少样本、各类跳过原因），并保存mean_div到.pt文件。
def main():
    args = parse_args()
    if args.hf_home:
        os.environ["HF_HOME"] = args.hf_home
    random.seed(args.seed)

    model_name = os.path.basename(os.path.normpath(args.model_path))
    model_type = infer_model_type(args.model_path, args.model_type)
    backend = load_backend(
        args.model_path, args.model_base_path,
        model_type=model_type, device=args.device,
        huatuo_repo=args.huatuo_repo,
        qwen_vl_utils_path=args.qwen_vl_utils_path,
        need_attn=False,
    )

    input_path, data_path = get_dataset_paths(args)
    questions = load_questions(input_path)
    layers = range(get_num_layers(backend))

    all_divergences = []
    skip_no_bbox = 0
    skip_no_question = 0
    skip_label_not_in_question = 0
    skip_other = 0
    visualized_count = 0

    with torch.no_grad():
        for sample in tqdm(questions):
            # 前置过滤1：样本必须有bbox标注（bbox或original_bboxes二者之一），因为本脚本
            # 的样本筛选逻辑与mask_text/attention系列脚本保持一致（即便本脚本本身并不
            # 直接使用bbox信息计算divergence，过滤条件统一是为了让不同实验脚本处理的是
            # 同一批样本子集，便于横向对比结果）。
            if not (sample.get("bbox") or sample.get("original_bboxes")):
                skip_no_bbox += 1
                continue
            # 前置过滤2：样本必须有问题文本，否则无法构造模型输入。
            if not sample.get("question", ""):
                skip_no_question += 1
                continue
            # 前置过滤3（关键）：label必须真实地以子串形式出现在question文本里。如果label
            # 不在question中，_find_label_token_indices几乎肯定找不到任何匹配，label_set
            # 会是空集合，导致后续随机采样n=0，MT/RT两次前向都变成"什么都不mask"，使本次
            # 对照实验失去意义——这里提前过滤掉这类样本，保证后面统计的divergence都来自
            # "确实mask了至少1个真实label token"的有效对照。
            label = sample.get("label", "")
            if not label or label not in sample.get("question", ""):
                skip_label_not_in_question += 1
                continue
            result = get_sample_hidden_states(sample, data_path, args.dataset, backend, layers, args.q_type)
            if result is None:
                skip_other += 1
                continue
            hs_label, hs_rand, viz_info = result
            div = compute_divergence_per_layer(hs_label, hs_rand)
            all_divergences.append(div.cpu().numpy())

            # 抽样保存"label词(红)+随机对照词(蓝)"标记图片，供人工确认label token
            # 是否真的对应了sample["label"]这个词、随机词是否落在了不同的位置上——
            # 光看divergence数值完全看不出mask对不对（历史上正是因为没有这类检查，
            # llava_med/huatuogpt_vision的随机采样bug才一直没被发现）。
            if args.visualize and visualized_count < args.visualize_limit:
                visualized_count += 1
                image_name = sample["image"]
                stem = os.path.splitext(os.path.basename(image_name))[0]
                save_path = os.path.join(
                    args.output_root, model_name, "diff_text", "masks",
                    args.dataset, args.q_type, f"{stem}.png",
                )
                render_masked_text_image(
                    viz_info["ids_list"], viz_info["tokenizer"],
                    viz_info["label_indices"], viz_info["rand_indices"],
                    viz_info["pos"], viz_info["pos_end"],
                    save_path=save_path,
                )

    # 跳过统计无论后面有没有成功样本都要打印——之前的写法是"all_divergences为空
    # 就直接return"，导致全部样本失败时，终端只能看到一行"No samples processed."，
    # 看不出到底是skip_no_bbox/skip_no_question/skip_label_not_in_question/
    # skip_other里哪一类占了大头，排查问题时完全没有线索。现在提前到判断之前打印，
    # 保证不管成功与否都能看到完整的分类统计。
    total_skipped = skip_no_bbox + skip_no_question + skip_label_not_in_question + skip_other
    print(f"\nTotal in dataset               : {len(questions)}")
    print(f"Skipped (no bbox)              : {skip_no_bbox}")
    print(f"Skipped (no question)          : {skip_no_question}")
    print(f"Skipped (label not in question): {skip_label_not_in_question}")
    print(f"Skipped (other error)          : {skip_other}")
    print(f"Total skipped                  : {total_skipped}")
    print(f"Samples processed              : {len(all_divergences)}")

    if not all_divergences:
        print("[Error] No samples processed.")
        return

    # 把所有样本的逐层divergence堆叠成[num_samples, num_layers]的二维数组，
    # 在样本维度(axis=0)上取平均，得到最终的"每层平均divergence"，即本脚本的最终产出。
    div_array = np.stack(all_divergences)
    mean_div  = torch.tensor(div_array.mean(axis=0))
    print(f"Num layers                     : {mean_div.shape[0]}")
    print(f"Mean divergence                : {mean_div.numpy()}")

    save_divergences(args.output_root, model_name, args.dataset, args.q_type, mean_div)
    print(f"\n[Saved] {args.output_root}/{model_name}/diff_text/{args.dataset}_{args.q_type}_mean_divergence_per_layer.pt")


if __name__ == "__main__":
    main()