CLIP对比学习框架实战指南：从原理到PyTorch实现

1次阅读

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

传统单模态模型（如纯视觉 CNN 或纯文本 BERT）存在明显瓶颈：

模态隔离：视觉和文本特征空间相互独立，难以建立关联
标注依赖：需要大量人工标注的匹配数据（如图像 - 描述对）
泛化差：学到的特征难以迁移到新任务

对比学习的优势在于：

自监督特性：利用数据本身的结构关系（如图文共存关系）作为监督信号
跨模态对齐：通过对比损失拉近匹配样本、推开不匹配样本
零样本能力：预训练好的编码器可直接用于下游任务（如图文检索）

框架	计算效率	数据需求	对齐方式
CLIP	★★★★☆	超大规模	全局特征对比
ConVIRT	★★★☆☆	医疗领域数据	局部区域对比
ALIGN	★★☆☆☆	噪声网页数据	混合粒度对比

CLIP 的独特性在于：

使用 ViT 处理图像、Transformer 处理文本，架构对称
超大规模 4 亿互联网图文对训练
简单的全局特征对比策略

import torch
from transformers import AutoModel, AutoTokenizer

class DualEncoder(torch.nn.Module):
    def __init__(self):
        super().__init__()
        # 视觉编码器（ViT-B/32）self.vision_encoder = torch.hub.load(  # 加载预训练 ViT
            'facebookresearch/dino:main', 
            'dino_vits16', pretrained=True)

        # 文本编码器（BERT-base）self.text_encoder = AutoModel.from_pretrained('bert-base-uncased')
        self.text_tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')

    def forward(self, images, texts):
        # 视觉特征提取
        vis_features = self.vision_encoder(images)  # [batch, dim]

        # 文本特征提取
        text_inputs = self.text_tokenizer(texts, return_tensors='pt', padding=True, truncation=True)
        text_features = self.text_encoder(**text_inputs).last_hidden_state[:, 0]  # 取 [CLS] token

        return vis_features, text_features

损失函数公式：

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

其中 τ 是温度系数，控制分布尖锐程度。代码如下：

def contrastive_loss(logits, tau=0.07):
    """
    logits: 相似度矩阵 [batch, batch]
    tau: 温度系数（默认 0.07）"""
    # 计算对角线 exp（正样本）exp_pos = torch.exp(torch.diag(logits) / tau)

    # 计算每行 sum exp（所有样本）exp_all = torch.sum(torch.exp(logits / tau), dim=1)

    # 计算损失
    loss = -torch.mean(torch.log(exp_pos / exp_all))
    return loss

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

with autocast():
    vis_feat, text_feat = model(images, texts)
    logits = vis_feat @ text_feat.T  # 矩阵乘法
    loss = contrastive_loss(logits)

# 梯度缩放防止下溢出
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

# 计算相似度前必须做 L2 归一化
vis_feat = F.normalize(vis_feat, p=2, dim=1)
text_feat = F.normalize(text_feat, p=2, dim=1)
logits = vis_feat @ text_feat.T * 100  # 缩放因子可调

当 GPU 内存限制 batch size 时：

使用梯度累积：

accum_steps = 4  # 累积 4 个 batch 再更新

for i, (images, texts) in enumerate(dataloader):
    loss = model(images, texts)
    loss = loss / accum_steps
    loss.backward()

    if (i+1) % accum_steps == 0:
        optimizer.step()
        optimizer.zero_grad()

使用内存库（Memory Bank）存储历史特征

经验公式：

学习率：lr = base_lr * sqrt(batch_size / 256)
温度系数 τ：从 0.01 到 0.5 之间网格搜索

# 初始化
model = DualEncoder().cuda()
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)

# 数据加载
train_loader = get_dataloader(batch_size=128)

# 训练循环
for epoch in range(10):
    for images, texts in train_loader:
        images = images.cuda()

        # 前向计算
        vis_feat, text_feat = model(images, texts)
        vis_feat = F.normalize(vis_feat, dim=1)
        text_feat = F.normalize(text_feat, dim=1)
        logits = vis_feat @ text_feat.T

        # 对称损失
        loss = (contrastive_loss(logits) + contrastive_loss(logits.T)) / 2

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()

在实际应用中可尝试：