# Monet 无文本改造方案（aux-image-only latent 训练）
本文档说明：在保留 Monet 三阶段（warmup → latent 训练 → 脱 aux image 蒸馏）结构的前提下，**移除推理过程中所有的文本 CoT / observation**，仅依靠 auxiliary image 作为 teacher 监督源，训练 student 自主生成 latent 并用于推理。
---
## 1. 目标
- **输入**：input image + question
- **推理过程**：模型自回归生成 `…` 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 个 `×L` 块）| 序列长度依 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 块**（离散决策）| `` token CE | 数据预置 → CE 自然学到边界 | `` 下一个 token 概率 |
训练时这两个信号天然对齐：student input 预置 N 个块 → 第 i 个 ``（i`，第 N 个后 = `\boxed{...}` 的起始 token。CE 学的就是这两种过渡的概率分布。
**推理端硬约束 N ∈ [1, 3]**（仅推理需要，训练不动）：
- min=1：第一次决策时强制 sample ``（或靠训练数据 0% N=0 让模型自然不偏）
- max=3：发了 3 块后屏蔽 `` 的 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))`，让新加的 `` 等特殊 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": "",
"sample_id": ""
},
"data": [
{"role": "system", "content": [
{"type": "text", "text": "You are a helpful assistant."}
]},
{"role": "user", "content": [
{"type": "image", "image": "images/input//.png"},
{"type": "text", "text": "... 标记>"}
]},
{"role": "assistant", "content": [
{"type": "text", "text": ""},
{"type": "image", "image": "images/intermediate//.png"},
{"type": "text", "text": ""},
{"type": "image", "image": "images/intermediate//.png"},
...
{"type": "text", "text": "\\boxed{}"}
]}
]
}
```
### 3.3 转换规则
1. **顶层**：包成 `{"metadata": ..., "data": [...]}`。`metadata.dataset_name`/`sample_id` 必须存在（trainer 用作 teacher rep 文件名）。
2. **user**：
- image 用相对于 `--dataset_root` 的路径。
- text 删掉 `[problem_image_1]`、`\nPut your final answer within \\boxed{}.` 等占位。
3. **assistant**（关键）：
- 完全**不含**任何 CoT / observation 文本。
- 每张 aux image 前**紧贴**一段 ``（强校验，[src/task.py:28-31](src/task.py#L28-L31)）。
- 最后一段 text 写 `\\boxed{}`（与原 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 序列中所有 `` 位置（共 $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、`` 进 CE 即可）。**推理侧需要在 vLLM 的 generation 逻辑里加一个 latent-block 计数器和 logit mask**。
### 6.5.1 改动点：`inference/vllm/monet_gpu_model_runner.py`
原 vLLM gpu_model_runner 已被 Monet 改造过，用来检测 `` 触发 latent 模式（[README](README.md#Inference) 描述）。在此基础上加两条逻辑：
```python
# === 新增：per-request 状态 ===
# 在 request 状态里维护 latent_block_count: int = 0
# 每次生成 时 latent_block_count += 1
MAX_LATENT_BLOCKS = 3
MIN_LATENT_BLOCKS = 1
def post_logits_hook(logits, request_state):
# (a) min: 在 assistant 段开头、还没发过 latent 块时，
# 如果模型想发非 的 token，强制 mask 掉所有
# "可能终止" 的 token（如 \boxed、Final、<|im_end|>），只允许
if request_state.latent_block_count < MIN_LATENT_BLOCKS \
and request_state.in_assistant_response \
and not request_state.in_latent_mode:
# 屏蔽所有非 的 logit，强制下一个 token =
forced_id = LATENT_START_ID
logits[:] = -float('inf')
logits[forced_id] = 0.0
# (b) max: 已经发够 MAX_LATENT_BLOCKS，下一次再想发 时
# 把它的 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: <|im_start|>assistant
↓
模型生成 ← min 约束保证（block_count=0 时强制）
↓
触发 latent_mode：vLLM 用最后一层 hidden 替换接下来的 latent_size 个 token
↓
模型生成 ← block_count += 1
↓
模型自己决定：再发 还是 \boxed{...}
├─ 想发 ：检查 block_count
│ < MAX → 通过，回到第二步循环
│ = MAX → mask 掉，被迫走另一支
└─ 想发 \boxed：通过（block_count ≥ MIN）
↓
模型生成 \boxed{}
↓
<|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 **只对它紧跟的那个 `...` 块可见**（[第 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)），否则新加的 `` 等特殊 token 对应的 embedding 行不存在，前向会越界。
---
## 9. 改造前后对照
| 维度 | 原 Monet | 本方案 |
|---|---|---|
| 监督信号来源 | observation 文本 hidden | aux image hidden (pooled) |
| assistant 文本 | CoT + `` + `\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}`。整个过程无文本中间产物。