| # 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}`。整个过程无文本中间产物。 |
|
|
