深入解析CLIP的基于对比学习损失的训练机制

1次阅读

共计 2163 个字符，预计需要花费 6 分钟才能阅读完成。

在跨模态学习中，文本和图像之间存在天然的语义鸿沟。图像包含丰富的像素信息，而文本则是离散的符号表示。这种差异导致两个模态的特征空间往往不一致，直接影响了跨模态检索、生成等下游任务的性能。

模态差异 ：图像特征通常是连续的、高维的，而文本特征是离散的、语义化的
对齐困难 ：传统方法难以建立有效的跨模态关联，导致检索时准确率低下
计算成本 ：大规模跨模态对比学习需要处理海量负样本，显存和计算资源消耗巨大

NT-Xent（Normalized Temperature-scaled Cross Entropy）
优点：对负样本敏感，适合大规模对比学习
缺点：温度系数调节敏感
Triplet Loss
优点：概念简单直观
缺点：采样效率低，收敛慢
InfoNCE（Information Noise Contrastive Estimation）
优点：理论保障好，适用于多模态场景
计算复杂度：O(N^2)

CLIP 使用的对称损失函数可表示为：

$$
\mathcal{L}{i} = -\log\frac{\exp(s
$$}/\tau)}{\sum_{j=1}^N \exp(s_{i,j}/\tau)} – \log\frac{\exp(s_{i,i}/\tau)}{\sum_{j=1}^N \exp(s_{j,i}/\tau)

其中 $\tau$ 是可学习的温度系数，$s_{i,j}$ 是图像 i 和文本 j 的相似度。

import torch
import torch.nn.functional as F

class CLIPLoss(torch.nn.Module):
    def __init__(self, temp_init=0.07):
        super().__init__()
        # 可学习的温度系数
        self.logit_scale = torch.nn.Parameter(torch.log(torch.tensor(1/temp_init)))

    def forward(self, image_features, text_features):
        # 归一化特征
        image_features = F.normalize(image_features, dim=-1)
        text_features = F.normalize(text_features, dim=-1)

        # 计算相似度矩阵（使用混合精度加速）with torch.cuda.amp.autocast(enabled=True):
            logit_scale = torch.clamp(self.logit_scale.exp(), max=100)
            logits_per_image = logit_scale * image_features @ text_features.t()
            logits_per_text = logits_per_image.t()

            # 对称交叉熵损失
            labels = torch.arange(len(logits_per_image)).to(logits_per_image.device)
            loss_i = F.cross_entropy(logits_per_image, labels)
            loss_t = F.cross_entropy(logits_per_text, labels)

        return (loss_i + loss_t)/2

梯度检查点（Gradient Checkpointing）
在反向传播时重新计算中间激活值
可减少约 75% 的显存占用
分块计算（Chunked Computation）
将大矩阵运算拆分为多个小块

示例代码：

def chunked_matmul(A, B, chunk_size=1024):
    return torch.cat([A[i:i+chunk_size] @ B for i in range(0, len(A), chunk_size)])

使用 AMP（Automatic Mixed Precision）自动管理精度

关键配置：

scaler = torch.cuda.amp.GradScaler()

with torch.cuda.amp.autocast():
    loss = model(batch)

scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()