CLIP模型预训练核心技术解析：从对比学习到多模态对齐

1次阅读

没有评论

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

CLIP（Contrastive Language-Image Pretraining）是 OpenAI 提出的多模态预训练模型，它通过对比学习实现了图像和文本的联合表征。这个模型的核心价值在于：

打破传统 CV 和 NLP 的界限，实现跨模态搜索（比如用文字搜图）
为零样本（zero-shot）分类任务提供新范式
为下游任务提供强大的预训练特征

在实际应用中，CLIP 已经展现出惊人效果。比如：

电商平台的图像搜索功能
内容审核中的多模态匹配
辅助创作工具中的图文生成

图像和文本本质上是两种完全不同的数据形式：

图像是密集的像素矩阵
文本是离散的符号序列

要让模型理解 ” 猫的图片 ” 和文本 ” 猫 ” 描述的是同一个概念，需要解决：

表征空间的统一映射
细粒度语义对齐
跨模态注意力机制

CLIP 训练需要海量图文对：

Web 数据集通常包含 4 亿以上样本
原始图像分辨率不一（需统一到 224×224）
文本描述长度差异大（需截断或填充）

负样本采样策略影响收敛
大批量训练时的梯度不稳定
温度系数（temperature）敏感度高

transform = transforms.Compose([transforms.Resize(224),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
        std=[0.26862954, 0.26130258, 0.27577711]
    )
])

使用 BERT 风格的 WordPiece 分词
添加 [CLS] 和[SEP]特殊标记
统一截断到最大长度 77

CLIP 采用双编码器结构：

图像编码器：可选 ResNet 或 ViT
文本编码器：Transformer 结构
投影头：将不同模态映射到统一空间

class ProjectionHead(nn.Module):
    def __init__(self, d_in, d_out):
        super().__init__()
        self.linear1 = nn.Linear(d_in, d_in)
        self.gelu = nn.GELU()
        self.linear2 = nn.Linear(d_in, d_out)

    def forward(self, x):
        return self.linear2(self.gelu(self.linear1(x)))

数学形式：

$$
\mathcal{L}{i} = -\log\frac{\exp(\text{sim}(z_i^{img}, z_i^{txt})/\tau)}{\sum
$$}^N \exp(\text{sim}(z_i^{img}, z_j^{txt})/\tau)

其中：

$\tau$ 是温度系数（通常 0.07）
sim()使用余弦相似度
N 是批次大小

数据并行：将批次拆分到多 GPU
梯度累积：模拟更大批次
Sharded 优化器：减少显存占用

import torch
import torch.nn as nn
import torch.nn.functional as F

class CLIP(nn.Module):
    def __init__(self, vision_model, text_model, d_proj=512):
        super().__init__()
        self.vision_encoder = vision_model
        self.text_encoder = text_model
        self.vision_proj = ProjectionHead(vision_embed_dim, d_proj)
        self.text_proj = ProjectionHead(text_embed_dim, d_proj)

    def forward(self, images, texts):
        # 获取特征
        img_feats = self.vision_proj(self.vision_encoder(images))
        txt_feats = self.text_proj(self.text_encoder(texts))

        # 归一化
        img_feats = F.normalize(img_feats, dim=-1)
        txt_feats = F.normalize(txt_feats, dim=-1)

        # 计算相似度矩阵
        logits = img_feats @ txt_feats.T
        return logits

# 训练循环示例
def train_step(batch, model, optimizer, temp=0.07):
    images, texts = batch

    # 前向传播
    logits = model(images, texts)

    # 对称对比损失
    labels = torch.arange(len(logits)).to(device)
    loss_img = F.cross_entropy(logits/temp, labels)
    loss_txt = F.cross_entropy(logits.T/temp, labels)
    loss = (loss_img + loss_txt)/2

    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    return loss.item()

scaler = torch.cuda.amp.GradScaler()

with torch.cuda.amp.autocast():
    logits = model(images, texts)
    # 计算损失...

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