monet_code/MODIFICATIONS_no_text.md

Monet 无文本改造方案（aux-image-only latent 训练）

本文档说明：在保留 Monet 三阶段（warmup → latent 训练 → 脱 aux image 蒸馏）结构的前提下，移除推理过程中所有的文本 CoT / observation，仅依靠 auxiliary image 作为 teacher 监督源，训练 student 自主生成 latent 并用于推理。

---

1. 目标

• 输入：input image + question
• 推理过程：模型自回归生成 <abs_vis_token>…</abs_vis_token> latent 块（不输出任何中间文本）；latent 块数量由模型自决，范围 N ∈ [1, 3]
• 输出：\boxed{answer}
• 训练目标：让 student 在不看 aux image 的情况下，自己生成的 latent 等同于 teacher 看着 aux image 时压缩出的 latent

aux image 在训练时作为 teacher 的监督源（pool 后的 hidden state 作为 alignment target），在最终推理时不需要存在。

1.1 变长 latent 块的设计

模型自己决定要生成 1、2 还是 3 个 latent 块，由训练数据的 N 分布驱动学习。

关键认识：训练时 N 是 per-sample 不固定的，且全程保持一致。下表展示单条样本 N 在各处的传播：

量	shape	与 N 关系
Student input（含 N 个 <abs_vis_token><pad>×L</abs_vis_token> 块）	序列长度依 N 而变	数据生成阶段确定
Student student_alignment_poss	N × latent_size 个位置	由 student input 计算
Teacher latent（存盘 .pt 文件）	[29, N × latent_size, D]	Stage 2 模型在含 N 块的输入上 dump
Alignment loss 配对	per-sample 校验 teacher.shape[1] == len(align_pos)	自动对齐，modeling…:1757

也就是说 Stage 3 的 ground truth latent 数量本来就是变长的，每条样本带几个 aux image 就有几块 latent 监督，batch 内 N 混杂由 padding 处理，完全不需要额外代码。

两个独立的学习信号：

学到的东西	监督源	训练时变长？	推理时谁决策？
每个 latent 块的内容（向量值）	alignment_loss vs teacher latent	数据预置 N 块	latent_mode 自回归
要不要再发一个 latent 块（离散决策）	<abs_vis_token> token CE	数据预置 → CE 自然学到边界	<abs_vis_token> 下一个 token 概率

训练时这两个信号天然对齐：student input 预置 N 个块 → 第 i 个 </abs_vis_token>（i<N）后下一 token = <abs_vis_token>，第 N 个后 = \boxed{...} 的起始 token。CE 学的就是这两种过渡的概率分布。

**推理端硬约束 N ∈ [1, 3]**（仅推理需要，训练不动）：

• min=1：第一次决策时强制 sample <abs_vis_token>（或靠训练数据 0% N=0 让模型自然不偏）
• max=3：发了 3 块后屏蔽 <abs_vis_token> 的 logit，强制走 \boxed{...}

数据侧要求：训练集 N 分布要覆盖 {1, 2, 3} 且不能极度偏（详见 §8 第 7 条）。可以是 category-clean（每个 category 固定 N），也可以是混合分布；前者学起来更容易。

---

2. 训练 pipeline 总览

完全去除 Stage 1。原版 Stage 1 的作用是用文本 CE（CoT + observation）warmup 模型，在无文本场景下没有可学的监督信号，留着只是浪费算力。代价：需要在 main.py 里补一行 model.resize_token_embeddings(len(tokenizer))，让新加的 <abs_vis_token> 等特殊 token 有对应的 embedding 行（详见 §4.4）。

Step 1. precompute teacher reps  (直接用 base Qwen2.5-VL)
  ─ teacher 前向：input_img + question + aux_imgs + \boxed{ans}
  ─ 抽每张 aux image 的 image_pad token 隐藏态 [T_aux_i, D]
  ─ adaptive_avg_pool1d → [latent_size, D] per aux image
  ─ 跨 aux image concat → [N × latent_size, D] per layer
  ─ 存盘为 rep_all_layers_{dataset}_{sample_id}.pt

Step 2. SFT Stage 2  (训练 latent 本体；从 base 模型直接起训)
  ─ student 输入仍包含 aux image + latent block
  ─ Loss = CE(\boxed{ans}) + α · alignment(latent_pad ↔ pooled aux reps)
  ─ alignment 梯度走 latent-only（compute_latents_only_loss）

Step 3. precompute teacher latents  (Stage 2 模型上跑)
  ─ teacher 前向：含 aux image + latent block, latent_mode=True
  ─ 保存 latent_mode 自回归生成的 latent embeddings
  ─ 存盘为 latent_all_layers_{dataset}_{sample_id}.pt

Step 4. SFT Stage 3  (脱 aux image 蒸馏；从 base 模型起训)
  ─ student 输入：input_img + question + latent block × N + \boxed{ans}
       （aux image 被 remove_auxiliary_images 移除）
  ─ Loss = CE(\boxed{ans}) + α · alignment(student latent ↔ Stage 2 latent)

---

3. 数据修改

3.1 源数据

/raid/yrl/dataset_v1_60k/full_no_tool_paper_strict_v1/merged_66k.jsonl

3.2 目标格式

单条样本结构：

{
  "metadata": {
    "dataset_name": "<category>",
    "sample_id": "<id>"
  },
  "data": [
    {"role": "system", "content": [
      {"type": "text", "text": "You are a helpful assistant."}
    ]},
    {"role": "user", "content": [
      {"type": "image", "image": "images/input/<category>/<id>.png"},
      {"type": "text",  "text": "<question 原文，去掉 <image_start>...<image_end> 标记>"}
    ]},
    {"role": "assistant", "content": [
      {"type": "text",  "text": "<abs_vis_token></abs_vis_token>"},
      {"type": "image", "image": "images/intermediate/<category>/<aux_1>.png"},
      {"type": "text",  "text": "<abs_vis_token></abs_vis_token>"},
      {"type": "image", "image": "images/intermediate/<category>/<aux_2>.png"},
      ...
      {"type": "text",  "text": "\\boxed{<answer>}"}
    ]}
  ]
}

3.3 转换规则

1. 顶层：包成 {"metadata": ..., "data": [...]}。metadata.dataset_name/sample_id 必须存在（trainer 用作 teacher rep 文件名）。
2. user：
   • image 用相对于 --dataset_root 的路径。
   • text 删掉 <image_start>[problem_image_1]<image_end>、\nPut your final answer within \\boxed{}. 等占位。
3. assistant（关键）：
   • 完全不含任何 CoT / observation 文本。
   • 每张 aux image 前紧贴一段 <abs_vis_token></abs_vis_token>（强校验，src/task.py:28-31）。
   • 最后一段 text 写 \\boxed{<answer>}（与原 Monet 保持一致的答案格式）。
4. aux image 数量可变（1~3 张）：按 intermediate_image_paths 顺序放就行，N 不固定不影响 collate。
5. 图像路径：写相对路径，例如 images/intermediate/helper_interleaved/xxx_helper_01.png，训练脚本里 --dataset_root=/raid/yrl/dataset_v1_60k/full_no_tool_paper_strict_v1。
6. 过滤：intermediate_image_paths 为空的样本（如部分 text_cot/visual_representation 无中间图的）直接丢，因为没有 aux image 就没有 latent 可训。
7. 输出：写成 train.jsonl（一行一条）放在某个目录，作为 --data_path 传入。

---

4. 代码修改

所有修改都不删除原 Monet 的逻辑分支，只新增一条"无 text"路径。建议加一个统一开关 --no_text_mode（或直接复用 --allow_no_observation）。

4.1 src/task.py

无需改动，传 --allow_no_observation 即可绕过 observation 必存校验。

4.2 src/utils.py — 新增 aux image 位置抽取工具

在 find_segments_1d 附近新增：

def find_aux_image_token_blocks(input_ids_row, token_ids):
    """
    返回 list of LongTensor，每个 tensor 是一张 aux image 对应的 <|image_pad|> token indices。
    跳过第 0 对 vision_start/end（question image）。
    """
    v_starts = (input_ids_row == token_ids['v_start']).nonzero(as_tuple=False).squeeze(-1)
    v_ends   = (input_ids_row == token_ids['v_end']  ).nonzero(as_tuple=False).squeeze(-1)
    pairs = list(zip(v_starts.tolist(), v_ends.tolist()))
    blocks = []
    for vs, ve in pairs[1:]:  # 跳过 question image
        mask = (input_ids_row[vs+1:ve] == token_ids['img_pad'])
        idx = mask.nonzero(as_tuple=False).squeeze(-1) + vs + 1
        blocks.append(idx)
    return blocks

4.3 src/precompute_teacher_reps.py — 改抽取与 pool 逻辑

替换 第 143-157 行（if args.sft_stage2_align_poss == 'obs' 那段）为：

# 抽 aux image 位置，按样本存 list of LongTensor
batch["teacher_aux_image_blocks"] = [
    find_aux_image_token_blocks(batch["teacher_input_ids"][b], SPECIAL_id)
    for b in range(batch["teacher_input_ids"].size(0))
]

替换主循环里保存隐藏态那段（第 304-325 行）为：

import torch.nn.functional as F

outputs = model(**inputs, return_dict=True)
hidden_states = outputs.hidden_states                  # tuple(L+1, [B, T, D])
hs_stack = torch.stack(hidden_states, dim=0)           # [L+1, B, T, D]

B = hs_stack.size(1)
for b in range(B):
    blocks = batch["teacher_aux_image_blocks"][b]
    if not blocks:
        continue
    pooled_per_aux = []
    for idx in blocks:
        if idx.numel() == 0:
            continue
        hs_aux = hs_stack[:, b, idx, :]                # [L+1, T_aux, D]
        h = hs_aux.permute(0, 2, 1)                    # [L+1, D, T_aux]
        h = F.adaptive_avg_pool1d(h, args.latent_size) # [L+1, D, latent_size]
        pooled_per_aux.append(h.permute(0, 2, 1))      # [L+1, latent_size, D]
    pooled = torch.cat(pooled_per_aux, dim=1)          # [L+1, N*latent_size, D]

    metadata = batch['metadata'][b]
    metadata_info = f"all_layers_{metadata['dataset_name']}_{metadata['sample_id']}"
    save_path = os.path.join(out_dir, f"rep_{metadata_info}.pt")
    torch.save({'metadata_info': metadata_info, 'latent': pooled.cpu()}, save_path)

4.4 src/main.py

(a) 新增 token embedding resize（关键，跳过 Stage 1 必加）

在 第 94 行 model = Qwen2_5_VLForConditionalGeneration.from_pretrained(...) 之后、tokenizer = processor.tokenizer 之前，插入：

# 必须 resize：跳过 Stage 1 时，base 模型的 embedding 矩阵不包含新加的特殊 token
try:
    new_vocab_size = len(processor.tokenizer)
    model.resize_token_embeddings(new_vocab_size)
    model.config.vocab_size = new_vocab_size
except Exception as e:
    logging.warning(f"resize_token_embeddings failed: {e}")

precompute_teacher_reps.py 已经有这一步（第 92-97 行），main.py 之前依赖 Stage 1 间接完成 resize，现在跳过 Stage 1 必须显式补。

(b) collate_fn_sft_stage2（第 175-238 行）

• 新增 latent pad 位置抽取（用于 alignment）：

  batch["latent_pad_poss"] = find_ids_poss(
      batch["input_ids"], answer_start_pattern, latent_pad_idx
  )
  

• 保留 observation_poss 字段，但传空：

  batch["observation_poss"] = [[] for _ in range(batch["input_ids"].size(0))]
  

• labels 用现有的 generate_labels_after_multi_token_start，结果就是只剩 \boxed{ans} 那几个 token 进 CE。

(c) collate_fn_sft_stage3（第 240-310 行）

基本不动；只把 observation_poss 那段（295-305）置成空 list 即可。student_alignment_poss 本来就是 latent pad 位置，正好用。

4.5 src/trainer.py

(a) CustomTrainerSFT_STAGE2.compute_loss（第 152-224 行）

两处改动：

# 原: inputs['ce_emphasize_poss'] = inputs['observation_poss']
inputs['ce_emphasize_poss'] = []                          # 没有 observation 要强调

# 原: inputs['alignment_poss'] = inputs['observation_poss']
inputs['alignment_poss'] = inputs['latent_pad_poss']      # ← 改为 latent pad 位置

inputs['compute_emphasize_acc'] = False                    # 无意义，关掉

emphasize_latent_weight / alignment_weight / ce_emphasize_factor 全部保留原版默认（2.0 / 2.0 / 4.0）。ce_emphasize_factor 在 ce_emphasize_poss=[] 下不会生效，留着不影响行为，但能保证脚本和原版字面一致，便于回溯。compute_latents_only_loss 那条路径不动 —— 这是训练 latent 的关键梯度通路。

(b) CustomTrainerSFT_STAGE3.compute_loss（第 268 行起）

第 299 行：

# 原: inputs['ce_emphasize_poss'] = inputs['observation_poss']
inputs['ce_emphasize_poss'] = []
inputs['compute_emphasize_acc'] = False

其余保留。

4.6 src/precompute_teacher_latents.py

完全不用改。它跑的是 latent_mode=True 自回归生成 latent，与 observation 无关。直接拿改造后的 Stage 2 模型跑就行。

---

5. 训练脚本

新建 script_examples/sft_no_text.sh：

#!/bin/bash
conda activate monet
cd Monet

DATA_ROOT=/raid/yrl/dataset_v1_60k/full_no_tool_paper_strict_v1
TRAIN_JSON=/path/to/converted/train.jsonl
BASE_MODEL=/path/to/Qwen2.5-VL-7B-Instruct
CKPT_ROOT=/path/to/Monet_no_text_ckpts
LATENT_SIZE=8

# ───── Step 1: 预计算 teacher pooled aux image reps（直接用 base 模型）─────
torchrun --nproc-per-node=8 -m src.precompute_teacher_reps \
  --bsz 1 \
  --data_path ${TRAIN_JSON} \
  --load_model_path ${BASE_MODEL} \
  --save_model_path ${CKPT_ROOT}/teacher_reps_pooled \
  --dataset_root ${DATA_ROOT} \
  --latent_size ${LATENT_SIZE} \
  --output_hidden_states \
  --alignment_layer all_layers \
  --allow_no_observation \
  --resume

# ───── Step 2: Stage 2 训 latent（从 base 模型起训；超参与原版一致）─────
CE_EMPHASIZE_FACTOR=4.0          # 原版默认；ce_emphasize_poss=[] 下不生效，留作 parity
ALIGNMENT_WEIGHT=2.0             # 原版默认
EMPHASIZE_LATENT_WEIGHT=2.0      # 原版默认
SAVE=stage2_notext_latent${LATENT_SIZE}_ce${CE_EMPHASIZE_FACTOR}_al${ALIGNMENT_WEIGHT}_emph${EMPHASIZE_LATENT_WEIGHT}
torchrun --nproc-per-node=8 -m src.main \
  --epochs 2 --bsz 1 --grad_accum_steps 16 \
  --stage sft_stage2 \
  --data_path ${TRAIN_JSON} \
  --load_model_path ${BASE_MODEL} \
  --save_model_path ${CKPT_ROOT}/${SAVE} \
  --dataset_root ${DATA_ROOT} \
  --deepspeed ./deepspeed/ds_zero2_gpu.json \
  --latent_size ${LATENT_SIZE} \
  --alignment_weight ${ALIGNMENT_WEIGHT} \
  --emphasize_latent_weight ${EMPHASIZE_LATENT_WEIGHT} \
  --ce_emphasize_factor ${CE_EMPHASIZE_FACTOR} \
  --teacher_reps_dir ${CKPT_ROOT}/teacher_reps_pooled \
  --alignment_layer all_layers \
  --allow_no_observation

# ───── Step 3: 用 Stage 2 模型 dump teacher latents ─────
STAGE2=${CKPT_ROOT}/${SAVE}
torchrun --nproc-per-node=8 -m src.precompute_teacher_latents \
  --bsz 1 \
  --data_path ${TRAIN_JSON} \
  --load_model_path ${STAGE2} \
  --save_model_path ${CKPT_ROOT}/teacher_latents \
  --dataset_root ${DATA_ROOT} \
  --latent_size ${LATENT_SIZE} \
  --output_hidden_states \
  --allow_no_observation \
  --resume

# ───── Step 4: Stage 3 student 脱 aux image（从 base 模型起训；超参与原版一致）─────
CE_EMPHASIZE_FACTOR=4.0          # 原版默认
ALIGNMENT_WEIGHT=2.0             # 原版默认
SAVE=stage3_notext_latent${LATENT_SIZE}_ce${CE_EMPHASIZE_FACTOR}_al${ALIGNMENT_WEIGHT}
torchrun --nproc-per-node=8 -m src.main \
  --epochs 2 --bsz 1 --grad_accum_steps 16 \
  --stage sft_stage3 \
  --data_path ${TRAIN_JSON} \
  --load_model_path ${BASE_MODEL} \
  --save_model_path ${CKPT_ROOT}/${SAVE} \
  --dataset_root ${DATA_ROOT} \
  --deepspeed ./deepspeed/ds_zero2_gpu.json \
  --latent_size ${LATENT_SIZE} \
  --alignment_weight ${ALIGNMENT_WEIGHT} \
  --ce_emphasize_factor ${CE_EMPHASIZE_FACTOR} \
  --teacher_latent_dir ${CKPT_ROOT}/teacher_latents \
  --alignment_layer all_layers \
  --allow_no_observation

Stage 3 是否要从 Stage 2 起训？ 也可以，把 --load_model_path 换成 ${STAGE2} 即可，让 student 继承 Stage 2 学到的 latent-生成能力。从 base 起训则 student 完全独立。推荐先试从 base，对比效果。

---

6. Loss 公式

Stage 2

$${\mathcal{L}}_{\text{stage2}}=\underset{\text{teacher\_ce\_loss}}{\underbrace{\text{CE}\text{\hspace{0.17em}⁣}(\text{logits},y_{\boxed{{\displaystyle \text{ans}}}})}}+\alpha \cdot \underset{\text{alignment\_loss (latent-only grad)}}{\underbrace{\parallel h_{P_{\text{latent}}}^{\text{stu}}-{\tilde{h}}_{P_{\text{aux}}}^{\text{tea}}{\parallel }_{\text{(per-layer)}}^2}}\backslash mathcal\{L\}\_\{\backslash text\{stage2\}\}\; \backslash ;=\backslash ;\; \backslash underbrace\{\backslash text\{CE\}\backslash !\backslash big(\backslash text\{logits\},\backslash \; y\_\{\backslash boxed\{\backslash text\{ans\}\}\}\backslash big)\}\_\{\backslash text\{teacher\backslash \_ce\backslash \_loss\}\}\; \backslash ;+\backslash ;\; \backslash alpha\; \backslash cdot\; \backslash underbrace\{\backslash big\backslash |\; h^\{\backslash text\{stu\}\}\_\{P\_\{\backslash text\{latent\}\}\}\; -\; \backslash tilde\; h^\{\backslash text\{tea\}\}\_\{P\_\{\backslash text\{aux\}\}\}\; \backslash big\backslash |^2\_\{\backslash text\{(per-layer)\}\}\}\_\{\backslash text\{alignment\backslash \_loss\; (latent-only\; grad)\}\}$$

• $P_{\text{latent}}$：student 序列中所有 <abs_vis_token_pad> 位置（共 $N \times L$）
• $\tilde h^{\text{tea}}{P{\text{aux}}}$：teacher 在 aux image 位置的隐藏态，adaptive_avg_pool1d 到 $N \times L$
• $\alpha$ = alignment_weight，沿用原版默认 2.0
• emphasize_latent_weight = 2.0（原版默认）控制 alignment_loss 的梯度只经过 latent embedding 流回参数（compute_latents_only_loss），逼迫 latent 承担信息瓶颈

Stage 3

$${\mathcal{L}}_{\text{stage3}}=\text{CE}\text{\hspace{0.17em}⁣}(\text{logits},y_{\boxed{{\displaystyle \text{ans}}}})+\alpha \cdot \parallel h_{P_{\text{latent}}}^{\text{stu, no-aux}}-{\widehat{z}}_{P_{\text{latent}}}^{\text{stage2}}{\parallel }^2\backslash mathcal\{L\}\_\{\backslash text\{stage3\}\}\; \backslash ;=\backslash ;\; \backslash text\{CE\}\backslash !\backslash big(\backslash text\{logits\},\backslash \; y\_\{\backslash boxed\{\backslash text\{ans\}\}\}\backslash big)\; \backslash ;+\backslash ;\; \backslash alpha\; \backslash cdot\; \backslash big\backslash |\; h^\{\backslash text\{stu,\; no-aux\}\}\_\{P\_\{\backslash text\{latent\}\}\}\; -\; \backslash hat\; z^\{\backslash text\{stage2\}\}\_\{P\_\{\backslash text\{latent\}\}\}\; \backslash big\backslash |^2$$

• $\hat z^{\text{stage2}}$：Stage 2 模型 latent_mode=True 自回归生成的 latent（看着 aux image 时）
• student 这一步看不到 aux image，必须靠 input image + question 自己脑补出 latent

---

6.5 推理端变长 latent 块的实现

训练侧不需要任何代码改动（数据天然带 N=1/2/3、<abs_vis_token> 进 CE 即可）。推理侧需要在 vLLM 的 generation 逻辑里加一个 latent-block 计数器和 logit mask。

6.5.1 改动点：inference/vllm/monet_gpu_model_runner.py

原 vLLM gpu_model_runner 已被 Monet 改造过，用来检测 <abs_vis_token> 触发 latent 模式（README 描述）。在此基础上加两条逻辑：

# === 新增：per-request 状态 ===
# 在 request 状态里维护 latent_block_count: int = 0
# 每次生成 </abs_vis_token> 时 latent_block_count += 1

MAX_LATENT_BLOCKS = 3
MIN_LATENT_BLOCKS = 1

def post_logits_hook(logits, request_state):
    # (a) min: 在 assistant 段开头、还没发过 latent 块时，
    #     如果模型想发非 <abs_vis_token> 的 token，强制 mask 掉所有
    #     "可能终止" 的 token（如 \boxed、Final、<|im_end|>），只允许 <abs_vis_token>
    if request_state.latent_block_count < MIN_LATENT_BLOCKS \
       and request_state.in_assistant_response \
       and not request_state.in_latent_mode:
        # 屏蔽所有非 <abs_vis_token> 的 logit，强制下一个 token = <abs_vis_token>
        forced_id = LATENT_START_ID
        logits[:] = -float('inf')
        logits[forced_id] = 0.0

    # (b) max: 已经发够 MAX_LATENT_BLOCKS，下一次再想发 <abs_vis_token> 时
    #     把它的 logit 屏蔽掉
    if request_state.latent_block_count >= MAX_LATENT_BLOCKS:
        logits[LATENT_START_ID] = -float('inf')

    return logits

这两条约束共同保证 N ∈ [1, 3]，但在 [1, 3] 范围内完全交给模型决策。

6.5.2 推理触发流程（自上而下）

prompt:  <input_img> <question> <|im_start|>assistant
         ↓
模型生成 <abs_vis_token>          ← min 约束保证（block_count=0 时强制）
         ↓
触发 latent_mode：vLLM 用最后一层 hidden 替换接下来的 latent_size 个 token
         ↓
模型生成 </abs_vis_token>          ← block_count += 1
         ↓
模型自己决定：再发 <abs_vis_token> 还是 \boxed{...}
         ├─ 想发 <abs_vis_token>：检查 block_count
         │    < MAX → 通过，回到第二步循环
         │    = MAX → mask 掉，被迫走另一支
         └─ 想发 \boxed：通过（block_count ≥ MIN）
         ↓
模型生成 \boxed{<answer>}
         ↓
<|im_end|>

6.5.3 训练数据准备的对应要求

• 每条样本按其真实需要的 aux image 数构造 latent 块数：N_sample = len(intermediate_image_paths)
• 不要人为统一 N（不要在 N=1 的样本后面 pad 假 latent 块），让模型从数据中学到 N 与 question 表型的关联
• 推荐先做一次 N 分布统计（详见 §8 第 7 条）

---

7. 信息瓶颈机制（为什么 Stage 2 非平凡）

build_4d_attn 默认 not_mask_image=False：每张 aux image 的 <|image_pad|> token 只对它紧跟的那个 <abs_vis_token>...</abs_vis_token> 块可见（第 570-575 行），对后续所有 token 不可见。这意味着：

aux_img_i 的信息  →  只能通过 latent_block_i 传递  →  \boxed{ans}

所以即使 student 在 Stage 2 看得到 aux image，要让 \boxed{ans} 的 CE 降下去，latent 必须真正压缩了 aux image 的信息。再加上 alignment loss 把 latent 拉向"pool 后的 aux image 隐藏态"，latent 就同时承担两个目标：(a) 让 \boxed{ans} 可被预测，(b) 长得像 aux image 的压缩表示。两者共同把 latent 训成有意义的 visual summary。

---

8. 几点工程注意

核心原则：除"无 text"必须的改动外，所有超参一律保持 Monet 原版默认。下表汇总：

参数	原版默认	本方案	是否改
latent_size	8	8	否
alignment_weight	2.0	2.0	否
emphasize_latent_weight	2.0	2.0	否
ce_emphasize_factor	4.0	4.0（实际无效，poss=[]）	否
alignment_layer	all_layers	all_layers	否
epochs	2	2	否
bsz / grad_accum_steps	1 / 16	1 / 16	否
mask_latent / attention flags	默认	默认	否

真正必须的改动只有四处（详见 §4）：

1. src/utils.py 新增 find_aux_image_token_blocks
2. src/precompute_teacher_reps.py 把 observation 抽取换成 aux image pool
3. src/main.py collate 把 observation_poss 置空 + 新增 latent_pad_poss，再加 resize_token_embeddings
4. src/trainer.py Stage 2 把 alignment_poss = observation_poss 改成 = latent_pad_poss

N 分布统计（建议训练前做一次）：N = len(intermediate_image_paths) 在 5 个 category 上的分布决定变长 latent 块决策的难易：

• Category-clean（每个 category 固定 N，如 visual_representation 永远 3、scene_graph 永远 1）：模型几乎只靠 question 表型就能学到 N，最容易。
• 混合分布（同 category 内 N 变化）：模型需要更细粒度的视觉/语义线索决定 N，较难，但训练数据量足（你有 60k）通常可学。
• 一条 bash 速查：jq -r '[.category, (.intermediate_image_paths|length)] | @tsv' merged_66k.jsonl | sort | uniq -c | sort -rn

跳过 Stage 1 必须补的一步：base Qwen2.5-VL 直接进 Stage 2/3，main.py 加 model.resize_token_embeddings(len(tokenizer))（§4.4 (a)），否则新加的 <abs_vis_token> 等特殊 token 对应的 embedding 行不存在，前向会越界。

---

9. 改造前后对照

维度	原 Monet	本方案
监督信号来源	observation 文本 hidden	aux image hidden (pooled)
assistant 文本	CoT + <observation> + \boxed{ans}	仅 \boxed{ans}
Stage 2 alignment 目标	obs token 位置	latent pad 位置 ↔ pooled aux reps
Stage 2 CE 监督	CoT + obs + ans	仅 ans
Stage 3 alignment 目标	latent pad ↔ Stage 2 latent	同
Stage 3 student 输入	input_img + question	同
推理时是否需要 aux image	否	否
推理时是否输出文本 CoT	是（latent 与文本交错）	否（纯 latent + 最终答案）
latent 块数 N	由数据中 aux image 数决定（训练）/ 模型自决（推理）	同；推理端约束 N ∈ [1, 3]

最终模型行为：给定 input image + question，模型自回归发射若干 latent 块（每块 latent_size 个 token），数量 N 由模型根据问题表型自决，硬上下界 [1, 3]；最后输出 \boxed{ans}。整个过程无文本中间产物。