CLIP预训练实战指南：从零搭建多模态模型的核心步骤

1次阅读

没有评论

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

第一次接触 CLIP 预训练时，最让我头疼的就是数据对齐问题。图像和文本数据就像两个语言不通的人，要让它们理解对方，需要解决几个关键挑战：

数据规模要求高 ：原始 CLIP 用了 4 亿个图文对，普通人根本拿不到这种量级的数据
模态差异大 ：图像是像素矩阵，文本是离散 token，特征空间完全不同
计算成本爆炸 ：同时训练两个模态的模型，显存和算力都是普通单模态模型的 2 - 3 倍

记得我第一次尝试时，模型死活不收敛，loss 像过山车一样上蹿下跳。后来才发现是数据预处理时漏掉了文本的 token 长度归一化。

CLIP 的实现主要有两种架构选择：

双塔结构（推荐）
优点：
- 可以分别处理图像和文本
- 推理时只需要单模态塔
- 方便扩展新模态
缺点：
- 模态间交互较晚
- 需要设计特殊的损失函数
联合编码结构
优点：
- 早期特征交互
- 理论上有更强的表征能力
缺点：
- 计算复杂度高
- 难以扩展新模态

对于大多数场景，我建议从双塔结构开始。下面是我总结的选择依据：

如果追求推理效率 → 选双塔
如果数据量足够大 → 可以尝试联合训练
如果要支持多语言 → 必须用双塔

CLIP 的核心是对比损失，这里用 PyTorch 实现关键部分：

import torch
import torch.nn.functional as F

def clip_loss(image_embeddings, text_embeddings, temperature=0.07):
    """
    Args:
        image_embeddings: [batch_size, embed_dim]
        text_embeddings: [batch_size, embed_dim]
        temperature: 缩放 logits 的超参数
    """
    # 归一化特征向量
    image_embeddings = F.normalize(image_embeddings, p=2, dim=-1)
    text_embeddings = F.normalize(text_embeddings, p=2, dim=-1)

    # 计算相似度矩阵
    logits = torch.matmul(image_embeddings, text_embeddings.t()) / temperature

    # 构建标签（对角线为匹配对）labels = torch.arange(logits.shape[0], device=logits.device)

    # 对称损失计算
    loss_i = F.cross_entropy(logits, labels)
    loss_t = F.cross_entropy(logits.t(), labels)
    return (loss_i + loss_t) / 2

关键参数说明：
– temperature：控制相似度得分的平滑程度，通常取值 0.01-0.1
– 对称损失：同时计算 image→text 和 text→image 两个方向的损失

处理大规模图文对时，TFRecord 是性价比最高的选择。示例配置：

先创建 TFRecord 写入器：

import tensorflow as tf

def _bytes_feature(value):
    return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))

with tf.io.TFRecordWriter('data.tfrecord') as writer:
    for image_path, caption in dataset:
        image_raw = open(image_path, 'rb').read()
        feature = {'image': _bytes_feature(image_raw),
            'text': _bytes_feature(caption.encode('utf-8'))
        }
        example = tf.train.Example(features=tf.train.Features(feature=feature))
        writer.write(example.SerializeToString())

读取时使用并行解析：

def parse_fn(example):
    feature_desc = {'image': tf.io.FixedLenFeature([], tf.string),
        'text': tf.io.FixedLenFeature([], tf.string)
    }
    example = tf.io.parse_single_example(example, feature_desc)
    image = tf.image.decode_jpeg(example['image'], channels=3)
    text = example['text']
    return image, text

dataset = tf.data.TFRecordDataset('data.tfrecord')
    .map(parse_fn, num_parallel_calls=tf.data.AUTOTUNE)
    .prefetch(buffer_size=tf.data.AUTOTUNE)

在现代 GPU 上，混合精度训练可以提升 2 - 3 倍速度：

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

for images, texts in dataloader:
    optimizer.zero_grad()

    with autocast():
        image_features = image_encoder(images)
        text_features = text_encoder(texts)
        loss = clip_loss(image_features, text_features)

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

注意事项：
– 初始化 scaler 时 enabled=True
– 遇到 NaN 时自动跳过当前 batch
– 验证时不需使用 scaler

当显存不足时，梯度累积是救命稻草：

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

for i, (images, texts) in enumerate(dataloader):
    with autocast():
        loss = model(images, texts) / accum_steps  # 损失归一化

    scaler.scale(loss).backward()

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

当文本数据远多于图像时（常见于中文场景），可以采用：

动态重采样：每轮根据 loss 调整采样概率
课程学习：先易后难，初期使用简单样本

示例重采样策略：

class BalancedSampler:
    def __init__(self, dataset):
        self.image_counts = [d['n_images'] for d in dataset]
        self.weights = 1. / torch.tensor(self.image_counts)

    def get_batch(self):
        idx = torch.multinomial(self.weights, batch_size)
        return dataset[idx]

当 loss 剧烈波动时，可以尝试：

检查数据 shuffle 是否充分
降低学习率并启用 warmup
增加 projection 层的维度
添加少量的 label smoothing

在 COCO 上评测的典型流程：

准备 5000 张验证集图片
为每张图片生成文本模板（如 ”a photo of {}”）
计算图文相似度矩阵
取 top-1/5/10 准确率

实现代码：

def evaluate(model, val_loader):
    model.eval()

    all_image_feats, all_text_feats = [], []

    with torch.no_grad():
        for images, texts in val_loader:
            image_feats = model.encode_image(images)
            text_feats = model.encode_text(texts)

            all_image_feats.append(image_feats)
            all_text_feats.append(text_feats)

    # 计算相似度矩阵
    image_feats = torch.cat(all_image_feats)
    text_feats = torch.cat(all_text_feats)
    sim = image_feats @ text_feats.t()

    # 计算 top- k 准确率
    labels = torch.arange(len(sim)).to(sim.device)
    top1 = (sim.argmax(dim=1) == labels).float().mean()
    top5 = (sim.topk(5, dim=1)[1] == labels.unsqueeze(1)).any(1).float().mean()

    return {'top1': top1.item(), 'top5': top5.item()}

不同 batch size 在 V100 上的实测数据：