多模态：CLIP详解

已于 2024-05-30 17:47:26 修改
阅读量3.6k 收藏 49
点赞数 21
分类专栏： 多模态 文章标签： 计算机视觉 人工智能 AIGC 图像处理
于 2024-02-08 13:07:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WiSirius/article/details/135659266
版权

文章目录

前言

首先为今天还在努力学习的人们献上🎆 ｡:.ﾟヽ(｡◕‿◕｡)ﾉﾟ.:｡+ﾟ

CLIP目前无论在CV领域还是NLP领域都是人尽皆知的，该模型的发布直接带动了整个多模态领域的飞速发展。Open AI提出Contrastive Language-Image Pre-training (CLIP), 突破了文本-图像之间的限制。CLIP使用大规模的文本-图像配对预训练，并且可以直接迁移到Imagenet上，完全不需要图像标签微调即可实现zero-shot分类。

github：https://github.com/openai/CLIP
paper：https://proceedings.mlr.press/v139/radford21a

一、CLIP介绍

常规的图像分类模型往往都基于有类别标签的图像数据集进行全监督训练，例如在Imagenet上训练的Resnet，ViT等。这往往对于数据需求非常高，需要大量人工标注；同时限制了模型的适用性和泛化能力，不适于任务迁移。而通过网络可以轻松获取大批量的文本-图像配对数据。Open AI团队通过收集4亿（400 million）个文本-图像对（(image, text) pairs），以用来训练其提出的CLIP模型。
请添加图片描述

二、CLIP模型详解

官方CLIP实例：

import torch
import clip
from PIL import Image

device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device) #首次使用会默认下载clip模型

image = preprocess(Image.open("/data/wangyuxuan/gen_model/CLIP/CLIP.png")).unsqueeze(0).to(device)
text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device)

with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)
    
    logits_per_image, logits_per_text = model(image, text)
    probs = logits_per_image.softmax(dim=-1).cpu().numpy()

print("Label probs:", probs)  # prints: [[0.9927937  0.00421068 0.00299572]]

CLIP模型结构：

CLIP(
  (visual): VisionTransformer(
    (conv1): Conv2d(3, 768, kernel_size=(32, 32), stride=(32, 32), bias=False)
    (ln_pre): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
    (transformer): Transformer(
      (resblocks): Sequential(
        (0): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (1): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (2): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (3): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (4): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (5): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (6): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (7): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (8): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (9): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (10): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
        (11): ResidualAttentionBlock(
          (attn): MultiheadAttention(
            (out_proj): NonDynamicallyQuantizableLinear(in_features=768, out_features=768, bias=True)
          )
          (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
          (mlp): Sequential(
            (c_fc): Linear(in_features=768, out_features=3072, bias=True)
            (gelu): QuickGELU()
            (c_proj): Linear(in_features=3072, out_features=768, bias=True)
          )
          (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
        )
      )
    )
    (ln_post): LayerNorm((768,), eps=1e-05, elementwise_affine=True)
  )
  (transformer): Transformer(
    (resblocks): Sequential(
      (0): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (1): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (2): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (3): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (4): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (5): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (6): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (7): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (8): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (9): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (10): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
      (11): ResidualAttentionBlock(
        (attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (ln_1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (mlp): Sequential(
          (c_fc): Linear(in_features=512, out_features=2048, bias=True)
          (gelu): QuickGELU()
          (c_proj): Linear(in_features=2048, out_features=512, bias=True)
        )
        (ln_2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
      )
    )
  )
  (token_embedding): Embedding(49408, 512)
  (ln_final): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
)

请添加图片描述

模型由两个大部分组成，分别为主管图像vision transformer和主管文本的transformer。两个部分最后都会变成一个长度为512的向量。

Vision transformer： vision transformer的结构很简单，图像首先经过一个patch卷积，然后就是连续的残差注意力结构，模型最后的输出是一个(1, 50, 768) 的张量，最后通过矩阵乘法完成到(1 , 512) 的映射。

Transformer: 这部分NLP选手应该很熟悉，CV选手简单了解下，首先文本经过tokenize得到一个新的张量，比如 [“a diagram”, “a dog”, “a cat”] ，经过tokenize得到的（3，77）的张量，经过一个embeding层得到（3，77，512）的tensor，添加位置编码（nn.Parameter）后送入模型，最后模型输出的到（1，512）的特征。

分别获得特征后，将两个特征进行余弦相似度计算，分别获得图像相对文本的相似度矩阵，和文本相对图像的相似度矩阵。两个矩阵数值上是完全相同的，是转置的关系。

    def forward(self, image, text):
        image_features = self.encode_image(image)  #图像特征获取
        text_features = self.encode_text(text)  #文本特征获取

        # normalized features
        # 进行相似度计算时的尺度保持一致
        image_features = image_features / image_features.norm(dim=1, keepdim=True)
        text_features = text_features / text_features.norm(dim=1, keepdim=True)

        # cosine similarity as logits
        logit_scale = self.logit_scale.exp()
        logits_per_image = logit_scale * image_features @ text_features.t()
        logits_per_text = logits_per_image.t() #转置

        # shape = [global_batch_size, global_batch_size]
        return logits_per_image, logits_per_text

##################
    logits_per_image, logits_per_text = model(image, text)
    probs = logits_per_image.softmax(dim=-1).cpu().numpy()
	
	logits_per_image, logits_per_text = model(image, text)
    probs = logits_per_image.softmax(dim=-1).cpu().numpy()
    probs_x = logits_per_text.softmax(dim=0).cpu().numpy()

#####
Label probs: [[0.9927   0.004253 0.002968]]
probs_v2 [[0.9927  ]
 [0.004253]
 [0.002968]]

三、CLIP训练过程

请添加图片描述

  1. 假设一个batch包含了 N 个 (文本-图像) 对。将这 N个文本先通过Text Encoder进行文本编码, Text Encoder将每条文本编码为一个长度为 d t d_{t} dt​ 的一维向量, 那么这个batch的文本数据经Text Encoder的输出为 T 1 , T 2 , ⋯   , T N T_{1}, T_{2}, \cdots, T_{N} T1​,T2​,⋯,TN​; 同样的, 将N个图像先通过Image Encoder进行图像编码, 假设Image Encoder将每个图像编码为一个长度为 d i d_{i} di​ 的一维向量, 那么这个batch的图像数据经Image Encoder的输出为 I 1 , I 2 , ⋯   , I N I_{1}, I_{2}, \cdots, I_{N} I1​,I2​,⋯,IN​.

  2. 得到两个编码器的特征后, 文本-图像是一一对应的, 例如 T 1 T_{1} T1​ 与 I 1 I_{1} I1​ 对应, 这 N 个对应关系认为正样本; 而原本并不对应的文本-图像我们标记为负样本, 例如 T 1 T_{1} T1​ 与 I 2 I_{2} I2​ 不对应。这么一来, 就有个 N个正样本, N 2 − N N^{2}-N N2−N个负样本。这样正负样本就可以作为正负标签, 用来训练 Text Encoder和Image Encoder了。

  3. 通过计算 I i I_{i} Ii​ 与 T j T_{j} Tj​ 之间的余弦相似度 (cosine similarity) I i ⋅ T j I_{i} \cdot T_{j} Ii​⋅Tj​, 用来度量相应的文本与图像之间的对应关系。余弦相似度越大, 表明对应关系越强。那么训练的任务转为最大化 N 个正样本的余弦相似度, 最小化 N 2 − N N^{2}-N N2−N 个负样本的余弦相似度。按上图所示, 最大化对角线中蓝色的数值, 最小化其它非对角线的数值。请添加图片描述
    可以看一个CLIP演示视频：

    CLIP训练过程

论文中的伪代码如下：

# 分别提取图像特征和文本特征
I_f = image_encoder(I) #[n, d_i]
T_f = text_encoder(T) #[n, d_t]

# 对两个特征进行线性投射，得到相同维度的特征，并进行l2归一化
I_e = l2_normalize(np.dot(I_f, W_i), axis=1)
T_e = l2_normalize(np.dot(T_f, W_t), axis=1)

# 计算缩放的余弦相似度：[n, n]
logits = np.dot(I_e, T_e.T) * np.exp(t)

# 对称的对比学习损失：等价于N个类别的cross_entropy_loss
labels = np.arange(n) # 对角线元素的labels
loss_i = cross_entropy_loss(logits, labels, axis=0)
loss_t = cross_entropy_loss(logits, labels, axis=1)
loss = (loss_i + loss_t)/2

四、Zero-shot图像分类

训练完成CLIP后，可以直接做图像分类了（所谓的Zero-shot图像分类），原理其实也很简单：
请添加图片描述
根据所迁移的数据集将所有类别转换为文本。例如Imagenet有1000类，就获得1000个文本：A photo of {label}。将这1000个文本全部输入Text Encoder中，得到1000个编码后的向量作为文本特征。

将需要分类的单个图像输入Image Encoder中，得到这张图像编码后的向量，将该向量与得到的1000个文本特征分别计算余弦相似度。找出1000个相似度中最大的那一个，即可将其分类为狗。

五、实验结果

请添加图片描述
请添加图片描述

总结

CLIP不仅是一个Zero-shot的图像分类模型，更是打开了图像和文本直接的桥梁，实现了文本-图像的预训练。现在多模态大模型，diffusion生图都有CLIP的身影，其思想实在令人赞叹！！！向OpenAI学习！！！

最后提前祝各位新年快乐啦🎉🎉🎉！！！

WiSirius
关注
专栏目录
Openai CLIP模型论文精读及详解
qq_52053775的博客
10-22 1870
计算机视觉任务难以拓展。为了解决这个问题，
openai多模态大模型：clip详解及实战
热门推荐
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
08-20 4万+
零次学习（Zero-Shot Learning，简称ZSL）假设斑马是未见过的类别，但根据描述外形和马相似、有类似老虎的条纹、具有熊猫相似的颜色，通过这些描述推理出斑马的具体形态，从而能对斑马进行辨认。零次学习就是希望能够模仿人类的这个推理过程，使得计算机具有识别新事物的能力，如下图所示。如今深度学习非常火热，使得纯监督学习在很多任务上都达到了让人惊叹的结果，但其限制是：往往需要足够多的样本才能训练出足够好的模型，并且利用猫狗训练出来的分类器，就只能对猫狗进行分类，其他的物种它都无法识别。
CLIP：万物分类（视觉语言大模型）
aibigtruth的博客
11-13 1497
本文来着公众号“AI大道理”​论文地址：https://arxiv.org/abs/2103.00020传统的分类模型需要先验的定义固定的类别，然后经过CNN提取特征，经过softmax进行分类。然而这种模式有个致命的缺点，那就是想加入新的一类就得重新定义这个类别的标签，并重新训练模型，这样非常不方便。CLIP打破了这个桎梏。CLIP能做到在一定标签内进行训练，标签外的也能进行分类。那么CLIP到底是如何认识未知的事物的呢？1、从人脸识别开始说起最早的打破固定标签的方法和应用就是人脸识别了。
多模态论文一：CLIP模型主要内容讲解【原理+代码】
最新发布
xiaoh_7的博客
07-26 1722
在人工智能的浪潮中，图像识别与自然语言处理一直是两个独立的领域。然而，OpenAI的CLIP模型（Contrastive Language-Image Pre-training）的出现，彻底改变了这一格局。本文将带您深入了解CLIP模型的核心原理、预训练过程以及其在零样本学习、图像分类和文本到图像检索等任务中的卓越表现。通过对比学习的力量，CLIP模型不仅能够理解图像与文本之间的深层关联，还能在未见过的类别上实现惊人的零样本迁移能力。
【深度学习】详解 CLIP
闻韶
12-01 9676
【深度学习】详解 CLIP - Learning Transferable Visual Models From Natural Language Supervision
CLIP的概念学习
pumpkin84514的博客
06-16 1271
CLIP，全称是“Contrastive Language-Image Pre-training”，是由OpenAI开发的一种能够同时理解文本和图像的人工智能模型。它可以看作是一个桥梁，连接了语言（文字）和视觉（图像）两种信息形式。CLIP通过将图像和文本两种不同的模态整合到一个模型中，能够理解和处理多种复杂任务。它的核心在于使用对比学习来学习图像和文本之间的关系。通过适当的预处理和编码，CLIP能够在图像搜索、图像生成和内容审核等多种实际应用中发挥强大的作用。
模型实践｜ CLIP 模型
weixin_66945478的博客
03-28 1万+
CLIP(Contrastive Language-Image Pre-Training，以下简称 CLIP) 模型是 OpenAI 在 2021 年初发布的用于匹配图像和文本的预训练神经网络模型，可以说是近年来在多模态研究领域的经典之作。该模型直接使用大量的互联网数据进行预训练，在很多任务表现上达到了目前最佳表现（SOTA）💯。
【多模态】CLIP模型
qq_34845880的博客
05-22 6455
Title: Learning transferable visual models from natural language supervision 作者：Alec Radford * 1 Jong Wook Kim * 1 Chris Hallacy 1 Aditya Ramesh 1 Gabriel Goh 1 Sandhini Agarwal Girish Sastry 1 Amanda Askell 1 Pamela Mishkin 1 Jack Clark 1 Gretchen Kruege
【多模态】CLIP模型详解
向上生长的程序媛的博客
08-01 4616
CLIP在不使用任意一张 ImageNet 图片训练的情况下，直接 Zero-Shot 推理，就能获得跟有监督训练的ResNet-50同样优秀的结果，这么牛的预训练模型确定不点进来看看嘛
CLIP——多模态
weixin_44828962的博客
01-28 335
多模态
【无标题】多模态模型 CLIP
qq_34845880的博客
11-30 1067
论文和代码链接 https://arxiv.org/pdf/2103.00020.pdfhttps://github.com/openai/CLIP 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 介绍 CLIP是一个双模态的任务，例如输入一句句子，输出一个图像；之前有一些工作是通过图像预测文字描述，而CLIP是通过文字输出图像； 亮点 1、双
极智AI | 多模态领域先行者 详解 CLIP 算法实现
极智视界
05-26 3035
大家好，我是极智视界，本文详细介绍一下 CLIP 算法的设计与实现，包括代码。
多模态视觉大模型(2): 常用模型介绍（CLIP和LLAVA）
@bangbang的博客
04-28 1695
Loss使用的是交叉熵来定义，通过Loss来约束使得相同图像和文本对，他们的距离要足够近；其他不匹配的要尽可能远。我们可以换个视角来解决该问题，将它看做两个任务。第一个任务是针对每张图像我需要分类对，需要将它正确分类为对应的类别id;针对每个文本，我们也希望它也能够正确的分类到对应的类别id。所以可以通过两个交叉熵来实现，一个是文本分类的交叉熵，一个是图像分类的交叉熵，通过转置来实现。然后将两个交叉熵的损失加在一起就可以了，# 主函数# 加载数据集# 获取一个小批量的图像和标签。
《深入浅出多模态》(四)：多模态经典模型CLIP
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
04-07 181
本文为《深入浅出多模态》系列多模态经典模型CLIP，首先从整体介绍多模态模型发展，对其中经典CLIP模型进行详述，从具体论文、数据集、代码、模型结构、结果等角度分析，本专栏适合从事多模态小白及爱好者学习，欢迎大家关注，如有侵权请联系删除！
多模态大模型：技术原理与实战 全球多模态大模型介绍
程序员光剑
06-11 597
关键词：多模态大模型、深度学习、计算机视觉、自然语言处理、跨模态学习、迁移学习、人工智能随着人工智能技术的飞速发展，多模态大模型已经成为了当前AI领域最热门的研究方向之一。多模态大模型能够同时处理和理解多种类型的数据，如文本、图像、音频和视频等，这为AI系统在复杂场景下的应用提供了更加强大和灵活的能力。本文将深入探讨多模态大模型的技术原理，介绍其实战应用，并对全球主要的多模态大模型进行全面的介绍和比较。
多模态之CLIP -《Learning Transferable Visual Models From Natural Language Supervision》论文笔记
weixin_43646592的博客
12-19 523
多模态 CLIP，Contrastive Language–Image Pre-training，用 了4亿对来自网络的图文数据集训练（我尼玛够猛的哈🐮）。文本作为图像的标签，也是自监督的预训练，用的是对比学习的方式。在下游任务时，比较牛逼的一点时，如分类任务，不用多加一些分类头来微调，只需提供和图片上的concepts对应的文本描述，直接zero-shot transfer即可，因为CLIP对这些文本和图像做cos similarity来识别出最相似的即可。
【CLIP】多模态预训练模型CLIP论文详解
h661975的博客
12-20 7475
CLIP（ Contrastive Language–Image Pre-training）基于对比学习的语言-图像预训练）建立在零样本迁移（zero-shot transfer）、自然语言监督学习( natural language supervision,) 和多模态学习方面的大量工作之上。CLIP是一个预训练模型，训练好的模型能实现，输入一段文本（或者一张图像），输出文本（图像）的向量表示。
CLIP论文讲解和代码实操
zyw2002的博客
04-17 3450
研究动机作者的研究动机就是在 NLP 领域利用大规模数据去预训练模型，而且用这种跟下游任务无关的训练方式，NLP 那边取得了非常革命性的成功，比如 GPT-3。作者希望把 NLP 中的这种成功应用到其他领域，如视觉领域。在预训练时 CLIP 使用了对比学习，利用文本的提示去做 zero-shot 迁移学习。在大规模数据集和大模型的双向加持下，CLIP 的性能可以与特定任务的有监督训练出来的模型竞争，同时也有很大的改进空间。CLIP 概述。
CLIP论文详解
weixin_52185313的博客
06-10 1万+
CLIP算是在跨模态训练无监督中的开创性工作，作者在开头梳理了现在vision上的训练方式，从有监督的训练，到弱监督训练，再到最终的无监督训练。这样训练的好处在于可以避免的有监督的 categorical label的限制，具有zero-shot性质，极大的提升了模型的实用性能。这篇文章中作者提到早在2017年之后就陆续有工作提出和本文类似的想法，但是他们的数据大小都太小了，导致没有很好的结果。作者单独收集了一份含有4亿份数据的大数据集，才得以得到很好的效果。这种现象最近好像在机器学习领域越来越突出，力大砖
多模态的情感分析clip
10-12
多模态的情感分析是指利用多种不同的数据源（如文本、图像、音频等）来分析和识别情感。而 OpenAI 公司开发的 CLIP（Contrastive Language-Image Pre-Training）模型就是一种能够同时处理文本和图像的多模态模型，它可以对图像和文本进行联合编码，从而实现图像和文本之间的语义对齐。 CLIP 模型的训练过程中使用了对比学习的方法，即通过将正样本与负样本进行比较来学习模型。在情感分析任务中，CLIP 模型可以通过对输入的文本和图像进行编码，然后将它们的编码向量进行拼接，最后输入到一个分类器中进行情感分类。 相比于传统的基于文本的情感分析方法，多模态的情感分析可以更全面地理解用户的情感状态，从而提高情感分析的准确性和可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值