docs/interview/multimodal.md

# 面试：多模态深度

> 本仓库 `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 到统一长度