| # 面试：多模态深度 |
|
|
| > 本仓库 `src/models/vlm/` 和 `src/models/vam/` 的多模态实现，覆盖视觉语言模型和全模态模型 |
|
|
| ## 0. 多模态数据流 |
|
|
| ``` |
| 原始输入(图/音) |
| └─ encoder → 模态特征 |
| └─ projector → 投影到 hidden_size |
| └─ 替换 input_ids 中的占位 token 位置的 embedding |
| └─ 进入共享 LM 主干 |
| ``` |
|
|
| --- |
|
|
| ## Q1. 图像/音频怎么进 LLM？ |
|
|
| ### VLM 注入流程（`src/models/vlm/model.py:56-77`） |
|
|
| ```python |
| def count_vision_proj(self, input_ids, vision_proj_output): |
| # 1. 找到图像占位 token 位置 |
| image_ids = self.config.image_ids # [12] |
| image_positions = (input_ids == image_ids[0]).nonzero() |
| |
| # 2. 将视觉特征注入 hidden_states 对应位置 |
| hidden_states = self.model.embed_tokens(input_ids) |
| for i, pos in enumerate(image_positions): |
| hidden_states[pos] = vision_proj_output[i] |
| |
| return hidden_states |
| ``` |
|
|
| ### 注入范式 |
|
|
| ``` |
| 文本侧：特殊占位 token（<|vision_start|>` / ` Müslü`）预留位置 |
| 视觉侧：encoder → projector → 替换占位处 embedding |
| 音频侧：encoder → projector → 替换占位处 embedding |
| ``` |
|
|
| > 面试点：为什么用占位 token 而不是拼接？→ 占位 token 可以精确定位注入位置，拼接会打乱文本顺序 |
|
|
| --- |
|
|
| ## Q2. 为什么常冻结 encoder 只训 projector？ |
|
|
| ### 原因 |
|
|
| 1. **避免灾难性遗忘**：预训练主干参数量大，微调容易遗忘 |
| 2. **轻量对齐**：投影层参数少，足以完成模态对齐 |
| 3. **计算效率**：冻结 encoder 可以省显存和计算 |
|
|
| ### 本仓库实现（`src/utils/multimodal.py:29-53`） |
|
|
| ```python |
| def init_vlm_model(model, config): |
| # 1. 先冻结全部参数 |
| for param in model.parameters(): |
| param.requires_grad = False |
| |
| # 2. 只开 vision_proj |
| for param in model.vision_proj.parameters(): |
| param.requires_grad = True |
| |
| # 3. 按需解冻 LLM |
| if config.unfreeze_llm: |
| for param in model.model.parameters(): |
| param.requires_grad = True |
| ``` |
|
|
| > 面试点：如果全量微调会怎样？→ 显存不足，且容易过拟合，投影层已经足够完成模态对齐 |
|
|
| --- |
|
|
| ## Q3. VAM 的语音生成怎么做？ |
|
|
| ### Thinker + Talker 双塔结构 |
|
|
| ``` |
| 输入文本 |
| │ |
| ▼ |
| ┌─────────────┐ |
| │ Thinker │ (共享 LM 主干) |
| └──────┬──────┘ |
| │ |
| ├──────────────────────┐ |
| │ │ |
| ▼ ▼ |
| ┌─────────────┐ ┌─────────────┐ |
| │ Text Head │ │ TalkerModule │ |
| └──────┬──────┘ └──────┬──────┘ |
| │ │ |
| ▼ ▼ |
| 文本输出 8 层音频 code |
| ``` |
|
|
| ### TalkerModule（`src/models/vam/model.py:52-79`） |
|
|
| ```python |
| class TalkerModule(nn.Module): |
| def __init__(self, config): |
| # 独立的 Transformer 层 |
| self.layers = nn.ModuleList([ |
| Block(config) for _ in range(config.num_talker_hidden_layers) |
| ]) |
| |
| # bridge 机制：将 thinker 的 hidden_states 投影到 talker 维度 |
| self.embed_proj = nn.Linear(config.hidden_size, config.talker_hidden_size) |
| |
| # 双尺度融合（可学习参数） |
| self.text_scale = nn.Parameter(torch.ones(1) * 3.0) |
| self.audio_scale = nn.Parameter(torch.ones(1) * 1.0) |
| |
| def forward(self, thinker_hidden, audio_embeddings): |
| # 1. 投影 thinker hidden |
| text_features = self.embed_proj(thinker_hidden) |
| |
| # 2. 双尺度融合 |
| fused = self.text_scale * text_features + self.audio_scale * audio_embeddings |
| |
| # 3. 通过独立 Transformer 层 |
| for layer in self.layers: |
| fused = layer(fused) |
| |
| return fused |
| ``` |
|
|
| ### TalkerHead（`src/models/vam/model.py:22-34`） |
|
|
| ```python |
| class TalkerHead(nn.Module): |
| def __init__(self, config): |
| self.base = nn.Linear(config.talker_hidden_size, config.audio_vocab_size) |
| # 8 个 adapter，每个 adapter: Linear -> GELU -> Linear |
| self.adapters = nn.ModuleList([ |
| nn.Sequential( |
| nn.Linear(config.talker_hidden_size, config.talker_hidden_size), |
| nn.GELU(), |
| nn.Linear(config.talker_hidden_size, config.audio_vocab_size) |
| ) for _ in range(8) |
| ]) |
| |
| def forward(self, x): |
| # 8 个并行输出头 |
| return [self.base(x) + adapter(x) for adapter in self.adapters] |
| ``` |
|
|
| > 面试点：为什么用 8 个 adapter？→ 音频 code 有 8 层，每层独立预测，8 个 adapter 并行处理 |
|
|
| --- |
|
|
| ## Q4. VAM 的流式生成（`src/models/vam/model.py:309-388`） |
|
|
| ### 核心思想 |
|
|
| 文本先完成，然后 8 个音频 code 交错流式输出。 |
|
|
| ### 实现细节 |
|
|
| ```python |
| def stream_generate(self, input_ids, ...): |
| # 1. 先生成文本 |
| text_tokens = self.thinker.generate(input_ids, ...) |
| |
| # 2. 找到 think 结束标记 |
| think_end_ids = [26, 234, 234] # 思考结束标记 |
| |
| # 3. 8 个音频 code 交错生成 |
| audio_codes = [[] for _ in range(8)] |
| for step in range(max_audio_length): |
| # 每个 step 生成 8 个 code |
| for i in range(8): |
| logits = self.talker_head(talker_hidden) |
| code = sample(logits[i]) |
| |
| # 音频 code 范围: 0-2047 为正常 code，>=2048 为 stop token |
| if code >= 2048: |
| break |
| |
| audio_codes[i].append(code) |
| |
| # 更新 talker hidden |
| audio_embeddings = self.audio_embedding(torch.tensor(audio_codes)) |
| talker_hidden = self.talker(text_hidden, audio_embeddings) |
| |
| return text_tokens, audio_codes |
| ``` |
|
|
| > 面试点：为什么文本和音频分开生成？→ 文本需要自回归生成，音频 code 可以并行预测，分开生成更高效 |
|
|
| --- |
|
|
| ## Q5. SigLIP 视觉编码器 |
|
|
| ### 本仓库使用（`src/encoders/vision/siglip.py`） |
|
|
| - **输入**：图像 (batch, 3, 224, 224) |
| - **输出**：patch 特征 (batch, num_patches, hidden_size) |
|
|
| ### 特点 |
|
|
| 1. **冻结参数**：预训练权重不参与训练 |
| 2. **Patch 特征**：将图像分割为 patch，每个 patch 作为一个 token |
| 3. **输出维度**：通过 projector 投影到 LLM 的 hidden_size |
| |
| > 面试点：SigLIP 和 CLIP 的区别？→ SigLIP 使用 sigmoid loss 替代 softmax loss，训练更稳定 |
| |
| --- |
| |
| ## Q6. SenseVoice 音频编码器 |
| |
| ### 本仓库使用（`src/encoders/audio/sensevoice.py`） |
| |
| - **输入**：音频 (batch, audio_length) |
| - **输出**：语义/声学特征 (batch, seq_len, hidden_size) |
|
|
| ### 特点 |
|
|
| 1. **双特征输出**：语义特征（理解内容）+ 声学特征（理解语气） |
| 2. **冻结参数**：预训练权重不参与训练 |
| 3. **输出维度**：通过 projector 投影到 LLM 的 hidden_size |
| |
| > 面试点：为什么需要双特征？→ 语义特征用于理解内容，声学特征用于理解语气和情感，两者结合才能完整理解语音 |
| |
| --- |
| |
| ## Q7. VLM 的多图处理（`src/models/vlm/model.py:79-157`） |
| |
| ### 支持的输入格式 |
| |
| ```python |
| # pixel_values 可以是： |
| 1. tensor (batch, channels, height, width) # 单图 |
| 2. dict {'pixel_values': tensor, 'image_ids': list} # 多图 |
| 3. 4D/5D/6D 形状 # 不同分辨率 |
| ``` |
| |
| ### 实现细节 |
| |
| ```python |
| def forward(self, input_ids, pixel_values=None, ...): |
| # 1. 文本 embedding |
| hidden_states = self.model.embed_tokens(input_ids) |
| |
| # 2. 处理视觉输入 |
| if pixel_values is not None: |
| if isinstance(pixel_values, dict): |
| # 多图处理 |
| vision_features = self.vision_encoder(pixel_values['pixel_values']) |
| vision_features = self.vision_proj(vision_features) |
| |
| # 注入到对应位置 |
| for i, pos in enumerate(pixel_values['image_ids']): |
| hidden_states[:, pos:pos+self.config.image_token_len] = vision_features[i] |
| else: |
| # 单图处理 |
| vision_features = self.vision_encoder(pixel_values) |
| vision_features = self.vision_proj(vision_features) |
| hidden_states = self.count_vision_proj(input_ids, vision_features) |
| |
| # 3. 通过 LM 主干 |
| outputs = self.model(hidden_states, ...) |
| return outputs |
| ``` |
| |
| > 面试点：多图处理时如何区分不同图像？→ 通过 image_ids 标记每张图像的位置，分别注入对应的视觉特征 |
| |
| --- |
| |
| ## Q8. aux_loss 中的技巧（`src/models/vlm/model.py:145`） |
|
|
| ### 问题 |
|
|
| 在分布式训练中，如果 vision_proj 的参数没有出现在 loss 计算图中，DDP 梯度同步会出错。 |
| |
| ### 解决方案 |
| |
| ```python |
| def forward(self, input_ids, pixel_values=None, ...): |
| # ... 前向传播 ... |
| |
| # 确保 vision_proj 参数出现在计算图中 |
| aux_loss = aux_loss + sum(p.sum() for p in self.vision_proj.parameters()) * 0 |
| |
| return logits, aux_loss |
| ``` |
| |
| ### 为什么用 `* 0`？ |
|
|
| - 保持计算图连通，让 DDP 可以同步梯度 |
| - 实际值为 0，不影响 loss |
|
|
| > 面试点：为什么不用 `.requires_grad = True`？→ 那只是让参数可训练，但不会出现在计算图中，`* 0` 才能保证计算图连通 |
| |
| --- |
| |
| ## Q9. object.__setattr__ 技巧（`src/models/vam/model.py:88-99`） |
| |
| ### 问题 |
| |
| VAM 模型需要将 thinker 的某些属性直接赋值给 VAM，但 `nn.Module.__setattr__` 会自动注册为子模块。 |
| |
| ### 解决方案 |
| |
| ```python |
| class VAM(PreTrainedModel): |
| def __init__(self, config): |
| super().__init__(config) |
| |
| # 绕过 nn.Module.__setattr__ 直接设置属性 |
| object.__setattr__(self, 'thinker', self.model) |
| object.__setattr__(self, 'model', None) # 避免重复注册 |
| ``` |
| |
| ### 为什么需要这个技巧？ |
| |
| - `nn.Module.__setattr__` 会自动将 `nn.Module` 注册为子模块 |
| - 但 thinker 已经是子模块了，重复注册会导致 DDP 问题 |
| - `object.__setattr__` 绕过这个机制 |
| |
| > 面试点：如果不绕过会怎样？→ thinker 会被重复注册为子模块，导致 DDP 梯度同步出错 |
| |
| --- |
| |
| ## Q10. Talker 层复制初始化（`src/utils/multimodal.py:156-164`） |
| |
| ### 问题 |
| |
| Talker 模块需要从头训练，初始化不当会导致训练不稳定。 |
| |
| ### 解决方案 |
| |
| ```python |
| def init_talker_from_thinker(talker, thinker, num_layers): |
| # 用 thinker 的后 N 层初始化 talker |
| for i in range(num_layers): |
| talker.layers[i].load_state_dict(thinker.layers[-(num_layers - i)].state_dict()) |
| ``` |
| |
| ### 为什么用后 N 层？ |
|
|
| - 后 N 层更接近输出，语义更丰富 |
| - 前 N 层更关注低级特征，对语音生成帮助不大 |
|
|
| > 面试点：为什么不随机初始化？→ 随机初始化会导致训练初期不稳定，用 thinker 的权重可以加速收敛 |
|
|
| --- |
|
|
| ## Q11. 音频 code 范围设计（`src/models/vam/config.py`） |
|
|
| ### 关键常量 |
|
|
| ```python |
| audio_vocab_size = 2112 # 音频词汇表大小 |
| audio_pad_token = 2049 # 填充 token |
| audio_stop_token = 2050 # 停止 token |
| audio_spk_token = 2051 # 说话人 token |
| ``` |
|
|
| ### 设计思路 |
|
|
| - **0-2047**：正常音频 code（2048 个） |
| - **2048-2051**：特殊 token（pad, stop, spk） |
|
|
| ### 为什么这样设计？ |
|
|
| 1. **正常 code 足够**：2048 个 code 足以表示音频特征 |
| 2. **特殊 token 分离**：避免与正常 code 混淆 |
| 3. **stop token 重要**：用于判断音频生成何时结束 |
|
|
| --- |
|
|
| ## Q12. bridge_layer 选择（`src/models/vam/config.py:24`） |
| |
| ### 实现 |
| |
| ```python |
| bridge_layer = num_hidden_layers // 2 - 1 |
| ``` |
| |
| ### 为什么选中间层？ |
| |
| - **前层**：关注低级特征，语义不够丰富 |
| - **后层**：关注高级特征，但可能过拟合 |
| - **中间层**：语义丰富度适中，泛化能力最好 |
| |
| > 面试点：如果选最后一层会怎样？→ 可能过拟合，且梯度消失风险更高 |
| |
| --- |
| |
| ## Q13. VLM 的 aux_loss 设计（`src/models/vlm/model.py:145`） |
| |
| ### 问题 |
| |
| 在分布式训练中，如果 vision_proj 的参数没有出现在 loss 计算图中，DDP 梯度同步会出错。 |
| |
| ### 解决方案 |
| |
| ```python |
| def forward(self, input_ids, pixel_values=None, ...): |
| # ... 前向传播 ... |
| |
| # 确保 vision_proj 参数出现在计算图中 |
| aux_loss = aux_loss + sum(p.sum() for p in self.vision_proj.parameters()) * 0 |
| |
| return logits, aux_loss |
| ``` |
| |
| ### 为什么用 `* 0`？ |
|
|
| - 保持计算图连通，让 DDP 可以同步梯度 |
| - 实际值为 0，不影响 loss |
|
|
| > 面试点：为什么不用 `.requires_grad = True`？→ 那只是让参数可训练，但不会出现在计算图中，`* 0` 才能保证计算图连通 |
| |
| --- |
| |
| ## Q14. 多模态训练的冻结策略 |
| |
| ### VLM 冻结策略（`src/utils/multimodal.py:29-53`） |
| |
| ```python |
| # 阶段 1：只训练 vision_proj |
| for param in model.parameters(): |
| param.requires_grad = False |
| for param in model.vision_proj.parameters(): |
| param.requires_grad = True |
| |
| # 阶段 2：解冻 LLM |
| if config.unfreeze_llm: |
| for param in model.model.parameters(): |
| param.requires_grad = True |
| ``` |
| |
| ### VAM 冻结策略（`src/utils/multimodal.py:139-175`） |
| |
| ```python |
| # freeze_backbone 支持 'all' 和 'last1' 模式 |
| if config.freeze_backbone == 'all': |
| # 冻结所有 thinker 参数 |
| for param in model.thinker.parameters(): |
| param.requires_grad = False |
| elif config.freeze_backbone == 'last1': |
| # 只解冻最后一层 |
| for param in model.thinker.layers[-1].parameters(): |
| param.requires_grad = True |
| ``` |
| |
| > 面试点：为什么要分阶段冻结？→ 先对齐模态，再微调主干，避免灾难性遗忘 |
|
|
| --- |
|
|
| ## Q15. 多模态数据处理 |
|
|
| ### VLM 数据集（`src/dataset/vlm.py`） |
|
|
| ```python |
| class VLMDataset(Dataset): |
| def __getitem__(self, idx): |
| # 1. 加载图像 |
| image = Image.open(self.image_paths[idx]) |
| |
| # 2. 加载文本 |
| text = self.texts[idx] |
| |
| # 3. Tokenize |
| input_ids = self.tokenizer(text, return_tensors='pt') |
| |
| # 4. 图像预处理 |
| pixel_values = self.image_processor(image, return_tensors='pt') |
| |
| return input_ids, pixel_values |
| ``` |
|
|
| ### VAM 数据集（`src/dataset/vam.py`） |
|
|
| ```python |
| class VAMDataset(Dataset): |
| def __getitem__(self, idx): |
| # 1. 加载图像 |
| image = Image.open(self.image_paths[idx]) |
| |
| # 2. 加载音频 |
| audio = torchaudio.load(self.audio_paths[idx]) |
| |
| # 3. 加载文本 |
| text = self.texts[idx] |
| |
| # 4. Tokenize |
| input_ids = self.tokenizer(text, return_tensors='pt') |
| |
| # 5. 音频特征提取 |
| audio_features = self.audio_encoder(audio) |
| |
| return input_ids, pixel_values, audio_features |
| ``` |
|
|
| > 面试点：多模态数据如何 batch？→ 使用 collate_fn 处理不同长度的序列，padding 到统一长度 |
| |
