AMD GPU上对比语言图像预训练（CLIP）模型的交互

AMD GPU上对比语言图像预训练（CLIP）模型的交互

3.1.1 介绍

对比语言图像预训练（CLIP）是一种连接视觉和自然语言的多模态深度学习模型。它是在OpenAI的论文从自然语言监督中学习可转移的视觉模型（2021）中介绍的，并在大量（4亿）图像字幕对的网络抓取数据上进行了对比训练（这是最早做到这一点的模型之一）。

在预训练阶段，CLIP被训练来预测批处理中图像和文本之间的语义关联。这涉及确定哪些图像文本对彼此关系最密切或最相关。该过程涉及图像编码器和文本编码器的同时训练。目标是最大化批处理中图像和文本对嵌入之间的余弦相似性，同时最小化不正确对嵌入的相似性。该模型通过学习多模态嵌入空间来实现这一点。对称交叉熵损失在这些相似性得分上得到了优化。标准图像模型联合训练图像特征，提取器和线性分类器预测标签，如图3-1所示。

 

图3-1 标准图像模型联合训练图像特征，提取器和线性分类器预测标签

标准图像模型联合训练图像特征提取器和线性分类器来预测一些标签，而CLIP联合训练图像编码器和文本编码器来预测一批（图像、文本）训练示例的正确配对。在测试时，学习的文本编码器通过嵌入目标数据集的类的名称或描述来合成零样本线性分类器。

图片来源：从自然语言监督中学习可转移的视觉模型。

在的后续部分，将利用PyTorch框架和ROCm来运行CLIP模型，以计算任意图像和文本输入之间的相似性。

3.1.2 安装程序

此演示是使用以下设置创建的。

1）硬件和操作系统：

①AMD Instinct GPU

②Ubuntu 22.04.3 LTS

2）软件：

①ROCm 5.7.0+

②Pytorch 2.0+

3.1.3 任意图像和文本输入之间的相似性计算

1. 第一步：开始

首先，确认GPU的可用性。

!rocm-smi –显示产品名称

ROCm系统管理界面

产品信息

    GPU[0]：板卡系列：AMD INSTINCT MI250（MCM）OAM AC MBA

GPU[0]：卡型号：0x0b0c

GPU[0]：卡供应商：Advanced Micro Devices，股份有限公司[AMD/ATI]

GPU[0]：卡SKU：D65209

ROCm SMI日志结束

接下来，安装CLIP和所需的库。

! pip install git+https://github.com/openai/CLIP.git ftfy regex tqdm matplotlib

2. 步骤2：加载模型

import torch

import clip

import numpy as np

 

# 将加载ViT-L/14@336px剪辑模型

model, preprocess = clip.load("ViT-L/14@336px")

model.cuda().eval()

# 检查模型架构

print(model)

# 检查预处理器

print(preprocess)

输出：

    CLIP(

  (visual): VisionTransformer(

    (conv1): Conv2d(3, 1024, kernel_size=(14, 14), stride=(14, 14), bias=False)

    (ln_pre): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)

    (transformer): Transformer(

      (resblocks): Sequential(

        (0): ResidualAttentionBlock(

          (attn): MultiheadAttention(

            (out_proj): NonDynamicallyQuantizableLinear(in_features=1024, out_features=1024, bias=True)

          )

          (ln_1): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)

          (mlp): Sequential(

            (c_fc): Linear(in_features=1024, out_features=4096, bias=True)

            (gelu): QuickGELU()

            (c_proj): Linear(in_features=4096, out_features=1024, bias=True)

          )

          (ln_2): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)

        )

        (1): ResidualAttentionBlock(

          (attn): MultiheadAttention(

            (out_proj): NonDynamicallyQuantizableLinear(in_features=1024, out_features=1024, bias=True)

          )

          (ln_1): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)

          (mlp): Sequential(

            (c_fc): Linear(in_features=1024, out_features=4096, bias=True)

            (gelu): QuickGELU()

            (c_proj): Linear(in_features=4096, out_features=1024, bias=True)

          )

          (ln_2): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)

        )

       ...

        (23): ResidualAttentionBlock(

          (attn): MultiheadAttention(

            (out_proj): NonDynamicallyQuantizableLinear(in_features=1024, out_features=1024, bias=True)

          )

          (ln_1): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)

          (mlp): Sequential(

            (c_fc): Linear(in_features=1024, out_features=4096, bias=True)

            (gelu): QuickGELU()

            (c_proj): Linear(in_features=4096, out_features=1024, bias=True)

          )

          (ln_2): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)

        )

      )

    )

    (ln_post): LayerNorm((1024,), 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)

      )

     ...

      (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)

      )

    )

  )

  (token_embedding): Embedding(49408, 768)

  (ln_final): LayerNorm((768,), eps=1e-05, elementwise_affine=True)

)

 

Compose(

    Resize(size=336, interpolation=bicubic, max_size=None, antialias=warn)

    CenterCrop(size=(336, 336))

    <function _convert_image_to_rgb at 0x7f8616295630>

    ToTensor()

    Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))

)

3. 步骤3：检查图像和文本

将COCO数据集中的8幅样本图像及其文本描述输入模型，并比较相应特征之间的相似性。

import os

import matplotlib.pyplot as plt

from PIL import Image

 

# 使用COCO数据集中的图像及其文本描述

image_urls  = [

    "http://farm1.staticflickr.com/6/8378612_34ab6787ae_z.jpg",

    "http://farm9.staticflickr.com/8456/8033451486_aa38ee006c_z.jpg",

    "http://farm9.staticflickr.com/8344/8221561363_a6042ba9e0_z.jpg",

    "http://farm5.staticflickr.com/4147/5210232105_b22d909ab7_z.jpg",

    "http://farm4.staticflickr.com/3098/2852057907_29f1f35ff7_z.jpg",

    "http://farm4.staticflickr.com/3324/3289158186_155a301760_z.jpg",

    "http://farm4.staticflickr.com/3718/9148767840_a30c2c7dcb_z.jpg",

    "http://farm9.staticflickr.com/8030/7989105762_4ef9e7a03c_z.jpg"[1] 

]

 

text_descriptions = [

    “一只猫站在木地板上”，

“跑道上的飞机”，

“一辆停在树旁的白色卡车”，

“一头大象站在动物园里”，

“窗边桌子上的笔记本电脑”，

“一只长颈鹿站在泥地里”，

“一辆公共汽车停在公共汽车站”，

“市场上有两束香蕉”

]

将八幅图像与其各自的文本描述一起显示。

import requests

from io import BytesIO

---

链接需要删除

images_for_display=[]

images=[]

# 创建新图形

plt.figure(figsize=(12, 6))

size = (400, 320)

# 循环浏览每个URL，并在子图中绘制图像

for i, url1 in enumerate(image_urls):

    # # 从URL获取图像

    response = requests.get(url1)

    image = Image.open(BytesIO(response.content))

    image = image.resize(size)

    # 添加子地块subplot（2行，4列，索引i+1）

    plt.subplot(2, 4, i + 1)

    # 绘图

    plt.imshow(image)

    plt.axis('off')  # 关闭轴标签

    # 添加标题（可选）

    plt.title(f'{text_descriptions[i]}')

    images_for_display.append(image)

    images.append(preprocess(image))

# 调整布局以防止重叠

plt.tight_layout()

# 显示图

plt.show()

    将COCO数据集中的8幅样本图像及其文本，特征显示，如图3-2所示。

图3-2 将COCO数据集中的8幅样本图像及其文本，特征显示

4. 步骤4：生成特征

接下来，准备图像和文本输入，并继续执行模型的前向传递。此步骤的结果是提取相应的图像和文本特征。

image_inputs = torch.tensor(np.stack(images)).cuda()

text_tokens = clip.tokenize(["It is " + text_descriptions中的文本]).cuda()

with torch.no_grad():

    image_features = model.encode_image(image_inputs).float()

text_features = model.encode_text(text_tokens).float()

5. 步骤5：计算文本和图像之间的相似性得分

对特征进行归一化，并计算每对的点积。

image_features /= image_features.norm(dim=-1, keepdim=True)

text_features /= text_features.norm(dim=-1, keepdim=True)

similarity_score = text_features.cpu().numpy() @ image_features.cpu().numpy().T

6. 步骤6：可视化文本和图像之间的相似性

def plot_similarity(text_descriptions, similarity_score, images_for_display):

    count = len(text_descriptions)

    fig, ax = plt.subplots(figsize=(18, 15))

    im = ax.imshow(similarity_score, cmap=plt.cm.YlOrRd)

    plt.colorbar(im, ax=ax)

    # y轴刻度：文本描述

    ax.set_yticks(np.arange(count))

    ax.set_yticklabels(text_descriptions, fontsize=12)

    ax.set_xticklabels([])

    ax.xaxis.set_visible(False)

    for i, image in enumerate(images_for_display):

        ax.imshow(image, extent=(i - 0.5, i + 0.5, -1.6, -0.6), origin="lower")

    for x in range(similarity_score.shape[1]):

        for y in range(similarity_score.shape[0]):

            ax.text(x, y, f"{similarity_score[y, x]:.2f}", ha="center", va="center", size=10)

    ax.spines[["left", "top", "right", "bottom"]].set_visible(False)

    # 设置x和y轴的限制

    ax.set_xlim([-0.5, count - 0.5])

    ax.set_ylim([count + 0.5, -2])

    # 为布局添加标题

    ax.set_title("用CLIP计算文本和图像相似性得分", size=14)

  plt.show()

plot_similarity(text_descriptions, similarity_score, images_for_display)

    使用CLIP计算文本和图像相似性得分，如图3-3所示。

图3-3 使用CLIP计算文本和图像相似性得分

正如所述，CLIP旨在最大化一批图像和文本对嵌入之间的相似性，同时最小化不正确对嵌入的相似性。在结果中，观察到对角线上的单元格在各自的列和行中

---

 [n1]此类需要矢量图。而且，若单色印刷，需要考虑颜色如何处理显示出最高值。