analysis/decoupling_analysis/ABLATION_VERIFICATION.md

# 解耦蒸馏 vs 集成蒸馏 消融实验验证

> 最后更新: 2026-01-23

本文档验证消融实验的正确性，确认 DeCLIP 和 Integrated 的**唯一变量是 Loss 作用位置和最后一层 Block 的处理方式**。

---

## 1. 脚本参数对比

| 参数 | DeCLIP (解耦) | Integrated (集成) | 是否对齐 |
|------|---------------|-------------------|----------|
| `mode` | `csa_vfm_distill` | `vanilla` | ❌ **关键变量** |
| `version` | `declip` | `integrated_grad_analysis` | ❌ **关键变量** |
| `loss_context_weight` | 0.25 | 0.25 | ✅ |
| `loss_content_weight` | 1.0 | 1.0 | ✅ |
| `loss_region_weight` | 0.05 (3loss) / 无 (2loss) | 无 | ✅ (2loss对齐) |
| `batch-size` | 2 | 2 | ✅ |
| `lr` | 1e-5 | 1e-5 | ✅ |
| `epochs` | 6 | 6 | ✅ |
| `model` | EVA02-CLIP-B-16 | EVA02-CLIP-B-16 | ✅ |
| `det-image-size` | 560 | 560 | ✅ |
| `use_vfm` | dinov2-B | dinov2-B | ✅ |
| `lock-image-unlocked-groups` | 12 | 12 | ✅ |

**结论**: 除了 `mode` 和 `version`，所有训练参数完全相同。

---

## 2. 代码链路追踪

### 2.1 训练入口 (training/main.py)

```python
# DeCLIP
if args.version == "declip":
    method = DeCLIP()

# Integrated
elif args.version == "integrated_grad_analysis":
    method = IntegratedDistillationWithGradientAnalysis(...)
```

### 2.2 训练方法对比

**DeCLIP** (`training/declip.py`):
```python
# 调用 encode_pseudo_boxes，mode="csa_vfm_distill"
student_roi_features, context = student.encode_pseudo_boxes(
    images, rois_list, normalize=True, mode=args.mode
)
```

**Integrated** (`training/integrated_distill.py`):
```python
# 调用 encode_dense，mode="vanilla"
student_features = student.encode_dense(
    images, normalize=False, keep_shape=True, mode="vanilla"
)
```

### 2.3 模型层面 (eva_vit_model.py)

**encode_dense 方法 (第752-759行)**:
```python
if "distill" in mode:
    # DeCLIP: 最后一层使用 forward_without_rcffn
    x, context = self.blocks[-1].forward_without_rcffn(x, mode)
else:
    if mode == "vanilla":
        # Integrated: 最后一层使用完整 forward
        x = self.blocks[-1](x, rel_pos_bias=rel_pos_bias)
```

### 2.4 Block 处理方式对比

**完整 forward (Integrated)**:
```python
def forward(self, x, rel_pos_bias=None, attn_mask=None):
    # 残差连接 + Attention
    x = x + self.drop_path(self.attn(self.norm1(x), ...))
    # 残差连接 + MLP
    x = x + self.drop_path(self.mlp(self.norm2(x)))
    return x
```

**forward_without_rcffn (DeCLIP)**:
```python
def forward_without_rcffn(self, x, mode):
    # 没有残差连接，没有 MLP
    x = self.drop_path(self.attn.ss_attn(self.norm1(x), mode))
    return x  # 返回 (attn_output, context)
```

### 2.5 Attention 输出对比

**ss_attn 方法** (mode="csa_vfm_distill"):
```python
def ss_attn(self, x, mode, attn_mask=None):
    # 计算 Q, K, V
    q, k, v = ...
    
    # CSA: Q 自相似 + K 自相似
    q_attn = torch.bmm(q, q.transpose(1, 2))
    k_attn = torch.bmm(k, k.transpose(1, 2))
    attn_weights = F.softmax(q_attn, dim=-1) + F.softmax(k_attn, dim=-1)
    
    # 返回 attention output 和 context (Q, K)
    return attn_output, (q[:,1:], k[:,1:])
```

---

## 3. Loss 作用位置对比

| Loss 类型 | DeCLIP (解耦) | Integrated (集成) |
|-----------|---------------|-------------------|
| **Context Loss** | Q/K 自相似性矩阵 | 融合特征的自相似性矩阵 |
| **Content Loss** | Q 特征的 ROI Align | 融合特征的 ROI Align |
| **Teacher** | DINOv2 相关性矩阵 | DINOv2 相关性矩阵 |

### DeCLIP Context Loss 计算

```python
# context = (q_feature, k_feature) 来自最后一层的 Q, K
q_feature, k_feature = context
student_context_similarity = (
    torch.einsum("bcm,bcn->bmn", q_feature, q_feature) +
    torch.einsum("bcm,bcn->bmn", k_feature, k_feature)
) / 2.0
```

### Integrated Context Loss 计算

```python
# student_features 是完整 forward 后的融合特征
student_features_norm = F.normalize(student_features.flatten(-2), dim=1)
student_intra_corr = torch.einsum('bci,bcj->bij', student_features_norm, student_features_norm)
```

---

## 4. 架构差异图示

```
┌─────────────────────────────────────────────────────────────────────────┐
│                          DeCLIP (解耦蒸馏)                               │
│                                                                         │
│  Block 0-10: 正常 forward (残差 + Attention + MLP)                       │
│                    ↓                                                    │
│  Block 11:  forward_without_rcffn                                       │
│             ┌──────────────────────────────────────────┐                │
│             │  ❌ 无残差连接                             │                │
│             │  ❌ 无 MLP                                │                │
│             │  只有 ss_attn → 返回 Q, K 特征            │                │
│             └──────────────────────────────────────────┘                │
│                    ↓                    ↓                               │
│            ┌──────────────┐    ┌──────────────┐                         │
│            │ Content Loss │    │ Context Loss │                         │
│            │ (Q 的 ROI)   │    │ (Q/K 自相似) │                         │
│            └──────────────┘    └──────────────┘                         │
│                    ↓                    ↓                               │
│            CLIP Teacher         DINOv2 Teacher                          │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                        Integrated (集成蒸馏)                             │
│                                                                         │
│  Block 0-10: 正常 forward (残差 + Attention + MLP)                       │
│                    ↓                                                    │
│  Block 11:  正常 forward (残差 + Attention + MLP)                        │
│             ┌──────────────────────────────────────────┐                │
│             │  ✅ 有残差连接                             │                │
│             │  ✅ 有 MLP                                │                │
│             │  返回融合后的特征                          │                │
│             └──────────────────────────────────────────┘                │
│                             ↓                                           │
│                    ┌──────────────────┐                                 │
│                    │   融合特征        │                                 │
│                    └────────┬─────────┘                                 │
│                    ↓                    ↓                               │
│            ┌──────────────┐    ┌──────────────┐                         │
│            │ Content Loss │    │ Context Loss │                         │
│            │ (融合 ROI)   │    │ (融合自相似) │  ← 梯度冲突！            │
│            └──────────────┘    └──────────────┘                         │
│                    ↓                    ↓                               │
│            CLIP Teacher         DINOv2 Teacher                          │
└─────────────────────────────────────────────────────────────────────────┘
```

---

## 5. 实验结论验证

### 5.1 实验设置正确性

✅ **唯一的变量是 Loss 作用位置和最后一层 Block 处理方式**

- 所有超参数（lr, batch_size, epochs, loss weights）完全对齐
- 模型结构（EVA02-CLIP-B-16）完全相同
- Teacher 模型（DINOv2-B, CLIP）完全相同
- 数据集和数据增强完全相同

### 5.2 关键发现

| 指标 | DeCLIP | Integrated 2loss | Integrated 3loss |
|------|--------|------------------|------------------|
| 最终 Total Loss | 0.59 | 1.00 | 1.62 (归一化后) |
| 梯度冲突比例 | N/A | **78.0%** | **63.8%** |
| 深层冲突 (L9-11) | N/A | 85-88% | 70%+ |

### 5.3 为什么 Integrated 存在梯度冲突？

因为 Content Loss 和 Context Loss 都作用于**同一个融合特征**：
- Content Loss 希望特征靠近 CLIP Teacher（偏向语义/物体识别）
- Context Loss 希望特征靠近 DINOv2（偏向结构/纹理）
- 两者的优化方向在 78% 的情况下是冲突的

### 5.4 为什么 DeCLIP 避免了冲突？

因为 DeCLIP 将两个 Loss 作用于**不同的特征**：
- Content Loss 作用于 Q 特征
- Context Loss 作用于 Q/K 自相似性
- 去掉残差连接和 MLP，避免特征混合