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](monet_qwen_model/modeling_qwen2_5_vl_monet.py#L1757) |

也就是说 **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 目标格式
单条样本结构：

```json
{
  "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](src/task.py#L28-L31)）。
   - 最后一段 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` 附近新增：

```python
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 行](src/precompute_teacher_reps.py#L143-L157)（`if args.sft_stage2_align_poss == 'obs'` 那段）为：

```python
# 抽 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 行](src/precompute_teacher_reps.py#L304-L325)）为：

```python
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 行](src/main.py#L94) `model = Qwen2_5_VLForConditionalGeneration.from_pretrained(...)` 之后、`tokenizer = processor.tokenizer` 之前，插入：

```python
# 必须 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 行](src/precompute_teacher_reps.py#L92-L97)），main.py 之前依赖 Stage 1 间接完成 resize，现在跳过 Stage 1 必须显式补。

#### (b) `collate_fn_sft_stage2`（[第 175-238 行](src/main.py#L175-L238)）

- **新增** latent pad 位置抽取（用于 alignment）：
  ```python
  batch["latent_pad_poss"] = find_ids_poss(
      batch["input_ids"], answer_start_pattern, latent_pad_idx
  )
  ```
- **保留** `observation_poss` 字段，但传空：
  ```python
  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 行](src/main.py#L240-L310)）
基本不动；只把 `observation_poss` 那段（[295-305](src/main.py#L295-L305)）置成空 list 即可。`student_alignment_poss` 本来就是 latent pad 位置，正好用。

### 4.5 `src/trainer.py`

#### (a) `CustomTrainerSFT_STAGE2.compute_loss`（[第 152-224 行](src/trainer.py#L152-L224)）
两处改动：

```python
# 原: 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 行起](src/trainer.py#L268)）
[第 299 行](src/trainer.py#L299)：
```python
# 原: 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`：

```bash
#!/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}} \;=\; \underbrace{\text{CE}\!\big(\text{logits},\ y_{\boxed{\text{ans}}}\big)}_{\text{teacher\_ce\_loss}}
\;+\; \alpha \cdot \underbrace{\big\| h^{\text{stu}}_{P_{\text{latent}}} - \tilde h^{\text{tea}}_{P_{\text{aux}}} \big\|^2_{\text{(per-layer)}}}_{\text{alignment\_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}\!\big(\text{logits},\ y_{\boxed{\text{ans}}}\big)
\;+\; \alpha \cdot \big\| h^{\text{stu, no-aux}}_{P_{\text{latent}}} - \hat z^{\text{stage2}}_{P_{\text{latent}}} \big\|^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](README.md#Inference) 描述）。在此基础上加两条逻辑：

```python
# === 新增：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](src/utils.py#L487) 默认 `not_mask_image=False`：每张 aux image 的 `<|image_pad|>` token **只对它紧跟的那个 `<abs_vis_token>...</abs_vis_token>` 块可见**（[第 570-575 行](src/utils.py#L570-L575)），对后续所有 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}`。整个过程无文本中间产物。