CLIP多模态模型详解

贝塔西塔

已于 2025-07-07 21:02:04 修改

阅读量1.2k

点赞数 13

CC 4.0 BY-SA版权

分类专栏：对比学习文章标签： CLIP 多模态表征学习 zero shot

于 2025-06-11 21:56:25 首次发布

本文链接：https://blog.csdn.net/sjtu_wyy/article/details/148595102

对比学习专栏收录该内容

2 篇文章

订阅专栏

CLIP多模态模型详解

CLIP（Contrastive Language-Image Pre-training）是OpenAI在2021年提出的突破性多模态模型，它通过对比学习统一了图像和文本的表征空间。

背景与核心贡献

问题背景： 传统计算机视觉模型（如 ResNet、VGG）依赖人工标注的大规模数据集（如 ImageNet），但标注成本高、泛化能力弱 —— 换个任务（如医疗影像分类）就需重新标注和训练。
NLP的启发： NLP 模型（如 GPT）通过无监督预训练（利用互联网文本）获得强泛化能力，启发研究者思考：能否用互联网自然图文对（如 “猫的图片 + 文字描述”）训练视觉模型，让其像 NLP 模型一样 “理解” 世界？
CLIP的诞生 OpenAI 在2021 年提出 CLIP（Contrastive Language-Image Pre-training），首次验证：仅通过4 亿 + 互联网图文对，就能训练出具备零样本迁移能力的多模态模型 —— 无需标注新任务数据，仅用文本描述即可推理。
关键创新：
- 双塔结构统一视觉-语言表征空间
- 零样本迁移能力（无需下游任务微调）
- 规模效应（4亿图像-文本对训练）

模型原理

CLIP 的目标是将图像和文本映射到统一语义空间，让 “匹配的图文对特征相近，不匹配的远离”。

整体架构：双编码器设计

核心组件

图像编码器：
- 可选ViT或ResNet架构
- 输出归一化的特征向量： $I_f \in R^{d_{model}}$
文本编码器：
- Transformer架构（类似GPT）
- 输出归一化的特征向量： $T_f \in R^{d_{model}}$
- 处理方式：[SOS] + text + [EOS] → 取[EOS]位置的特征

对比学习原理

目标：对齐配对图像-文本的向量表示
相似度计算：余弦相似度$
similarity(I, T) = I_f · T_f^T$
训练策略：
- 批次内负采样（Batch内负样本）
- 对称InfoNCE损失，参考对比学习损失函数
  这里CLIP 的损失是对称的双向对比损失，包含 “图像→文本” 和 “文本→图像” 两个方向，确保模型对图文的映射是双向一致的。

总结

CLIP的创新和意义

数据利用革命：
首次证明互联网自然图文对可替代人工标注，将 “无监督预训练” 的成功从 NLP 扩展到多模态领域。
零样本能力：
测试时，仅需用文本描述任务 / 类别（如 “识别 X 光片中的骨折”），就能直接推理 —— 突破了传统监督学习的 “任务绑定” 限制。
多模态生态奠基：
为后续 AIGC 模型（如 DALL-E、Stable Diffusion）提供核心组件（文本 - 图像编码器），推动 “文本→图像生成” 等应用爆发。

应用场景

零样本图像分类：无需训练直接分类
图文检索：跨模态搜索
图像生成引导：如DALL-E的文本条件生成
视频理解：扩展为视频-文本对齐
少样本学习：结合少量样本微调

局限性与改进方向

局限性：
- 计算成本高：预训练需数千 GPU，推理时大模型（如 ViT-L/14）速度慢。
- 细粒度不足：对相似类别（如 “金毛” vs “拉布拉多”）区分能力弱。
- 数据偏差：互联网图文对存在性别、职业等刻板印象。
改进方向：
- 模型压缩：如 MobileCLIP，优化轻量模型适配移动端。
- 损失创新：如 SIGLIP 用 Sigmoid 替代 Softmax，增强对长尾数据的鲁棒性。
- 多模态扩展：融入视频、音频，构建更全面的语义空间（如 CLIP4Video）。

CLIP 的本质是用对比学习在 “图文对” 中挖掘监督信号，其损失函数（InfoNCE）通过批量内的正负样本对比，高效学习跨模态对齐。这种范式不仅打破了传统 CV 的标注依赖，还为多模态智能奠定了基石，是近年来 AI 领域最具变革性的突破之一。

代码

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import resnet50

class TextEncoder(nn.Module):
    """基于Transformer的文本编码器"""
    def __init__(self, vocab_size, embed_dim=512, num_layers=6, num_heads=8):
        super().__init__()
        self.token_embed = nn.Embedding(vocab_size, embed_dim)
        self.position_embed = nn.Parameter(torch.randn(1, 77, embed_dim))
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=embed_dim, nhead=num_heads
        )
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
        self.ln_final = nn.LayerNorm(embed_dim)
        self.text_projection = nn.Parameter(torch.randn(embed_dim, embed_dim))

    def forward(self, text):
        # 文本嵌入 [batch, seq_len] -> [batch, seq_len, dim]
        x = self.token_embed(text) + self.position_embed
        
        # Transformer处理 [seq_len, batch, dim]
        x = x.permute(1, 0, 2)
        x = self.transformer(x)
        x = x.permute(1, 0, 2)
        
        # 取EOS位置特征 [batch, dim]
        eos_token = x[torch.arange(x.shape[0]), text.argmax(dim=-1)]
        
        # 投影和归一化
        x = self.ln_final(eos_token)
        x = x @ self.text_projection
        return F.normalize(x, dim=-1)

class ImageEncoder(nn.Module):
    """基于ResNet的图像编码器"""
    def __init__(self, embed_dim=512):
        super().__init__()
        backbone = resnet50(pretrained=False)
        self.conv1 = backbone.conv1
        self.bn1 = backbone.bn1
        self.relu = backbone.relu
        self.maxpool = backbone.maxpool
        self.layer1 = backbone.layer1
        self.layer2 = backbone.layer2
        self.layer3 = backbone.layer3
        self.layer4 = backbone.layer4
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.image_projection = nn.Parameter(torch.randn(2048, embed_dim))
        self.ln_final = nn.LayerNorm(embed_dim)

    def forward(self, image):
        # 标准ResNet前向传播
        x = self.conv1(image)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        
        # 全局池化和投影
        x = self.avgpool(x).squeeze(-1).squeeze(-1)
        x = self.ln_final(x)
        x = x @ self.image_projection
        return F.normalize(x, dim=-1)

class CLIP(nn.Module):
    """完整的CLIP模型"""
    def __init__(self, vocab_size, embed_dim=512):
        super().__init__()
        self.image_encoder = ImageEncoder(embed_dim)
        self.text_encoder = TextEncoder(vocab_size, embed_dim)
        self.logit_scale = nn.Parameter(torch.ones([]) * torch.tensor(1 / 0.07).log())

    def forward(self, image, text):
        image_features = self.image_encoder(image)
        text_features = self.text_encoder(text)
        
        # 计算相似度矩阵
        logit_scale = self.logit_scale.exp()
        logits_per_image = logit_scale * image_features @ text_features.t()
        logits_per_text = logit_scale * text_features @ image_features.t()
        
        return logits_per_image, logits_per_text

def clip_loss(logits_per_image, logits_per_text):
    """对称对比损失函数"""
    batch_size = logits_per_image.shape[0]
    labels = torch.arange(batch_size, device=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

# 示例用法
if __name__ == "__main__":
    # 初始化模型
    vocab_size = 50000  # 根据实际词汇表设置
    model = CLIP(vocab_size)
    
    # 模拟输入
    images = torch.randn(32, 3, 224, 224)  # 32张224x224 RGB图像
    texts = torch.randint(0, vocab_size, (32, 77))  # 32个文本序列（最大长度77）
    
    # 前向传播
    logits_per_image, logits_per_text = model(images, texts)
    
    # 计算损失
    loss = clip_loss(logits_per_image, logits_per_text)
    print(f"Contrastive Loss: {loss.item():.4f}")
    
    # 零样本分类示例
    class_names = ["cat", "dog", "car", "bird"]
    with torch.no_grad():
        # 图像特征（实际应用中来自真实图像）
        image_feature = model.image_encoder(images[0].unsqueeze(0))
        
        # 构建类别文本特征
        text_descriptions = [f"a photo of a {name}" for name in class_names]
        # 实际应用中需要tokenize文本
        tokenized_texts = ...  # 省略tokenize过程
        text_features = model.text_encoder(tokenized_texts)
        
        # 计算相似度
        logits = (image_feature @ text_features.t()) * model.logit_scale.exp()
        probs = logits.softmax(dim=-1)
        print("Classification probabilities:", probs)

代码解释

logit_scale 是 CLIP 模型中一个关键但常被忽视的参数，它在模型的对比学习机制中扮演着至关重要的角色。
logit_scale 本质上是对比学习中温度参数 $\tau$ 的对数形式：

logit_scale = nn.Parameter(torch.ones([]) * torch.tensor(1 / 0.07).log()
# ...
logits_per_image = logit_scale.exp() * image_features @ text_features.t()

这里 logit_scale.exp() 实际上就是 $1/\tau$ ，即温度参数的倒数。在 CLIP 中， $\tau$ 被设为可学习参数而非固定值，让模型自动找到最优的温度。使用 $logit\_scale = \log(1/\tau)$ 而非直接使用 $\tau$ 或 $1/\tau$ 是为了：

确保缩放因子始终为正： $exp(logit\_scale) > 0$
优化训练稳定性：对数形式在梯度计算中表现更好

方便初始化：用log值初始化更直观

init_value = torch.tensor(1 / 0.07).log() ≈ log(14.28) ≈ 2.66