多模态AI实战：CLIP模型原理与代码深度剖析

1. 引言：多模态AI与CLIP简介

1.1. 什么是CLIP？

CLIP 是OpenAI于2021年发布的多模态预训练模型，它通过4亿张图像及其文本描述进行对比学习，将图像和文本映射到同一个特征空间。CLIP的出现彻底改变了计算机视觉领域，它使得零样本分类、跨模态检索等任务成为可能，无需针对特定任务进行微调即可直接应用。

1.2. CLIP的核心原理：对比学习与双编码器架构

CLIP由两个编码器组成：图像编码器（通常使用ViT或ResNet）和文本编码器（Transformer）。在训练阶段，模型从数据集中随机抽取一个batch的图文对，通过对比学习最大化正确配对图像和文本之间的余弦相似度，同时最小化错误配对之间的相似度。这种训练方式使得模型能够理解图像和文本之间的语义关联，最终将两者映射到一个512维的统一特征空间中。

1.3. 为什么CLIP如此重要？

零样本迁移能力：CLIP可以直接对任意类别进行分类，只需提供类别名称的文本描述，无需任何训练样本。
跨模态检索：支持"以文搜图"和"以图搜文"，为搜索引擎、推荐系统等提供强大支持。
统一特征空间：图像和文本的特征可以直接比较，为多模态任务提供了基础。

本文将通过一个完整的Python演示代码，详细剖析CLIP的四个核心功能：零样本图像分类、以文搜图、以图搜文、特征空间探索，深入解释每个步骤背后的原理。

2. 环境准备与模型加载

2.1. 安装依赖库

运行本代码需要安装以下库：

python 复制代码

pip install transformers pillow requests torch torchvision safetensors

其中safetensors是推荐的模型加载格式，可避免PyTorch版本限制带来的安全警告。

2.2. 加载CLIP模型和处理器的注意事项

代码中使用openai/clip-vit-base-patch32作为预训练模型。由于PyTorch 2.6以下版本存在安全漏洞（CVE-2025-32434），加载PyTorch格式的权重可能受限。因此代码优先尝试使用safetensors格式加载：

python 复制代码

model = CLIPModel.from_pretrained(MODEL_NAME, use_safetensors=True)

若未安装safetensors，则自动安装；若仍失败，则降级为标准加载方式。这种处理体现了在实际开发中应对依赖兼容性的技巧。

2.3. 代码实现与解释

加载模型后，我们获得两个核心对象：

model：CLIP模型，包含图像编码器和文本编码器。
processor：CLIP处理器，负责将原始图像和文本转换为模型所需的输入张量，包括图像尺寸调整、归一化、文本tokenization等。

3. 零样本图像分类：将分类转化为图文匹配

3.1. 任务目标与原理

零样本分类的目标是：给定一张图片，从一组候选文本标签中选出最匹配的一个。CLIP将分类问题转化为图文匹配问题－它并不在特定类别上训练，而是直接计算图像与各文本标签的相似度，选择相似度最高的标签作为分类结果。

3.2. 代码实现步骤

下载图片：从COCO数据集中获取一张示例图片。
准备候选标签：使用带有"a photo of"前缀的文本描述，这符合CLIP的训练数据分布，能提高准确率。
预处理：通过processor将图片和所有文本标签转换为张量。
推理：将输入送入模型，得到logits_per_image，即图像与各文本的相似度分数。
概率转换：使用softmax将logits转换为概率分布，便于直观比较。

python 复制代码

probs = logits_per_image.softmax(dim=1)

3.3. 结果解读

代码以条形图形式展示每个标签的概率，最终输出最佳匹配标签及其置信度。例如，图片"宇航员骑马"应匹配标签"a photo of an astronaut riding a horse"。这展示了CLIP强大的语义理解能力－它能够将图像内容与从未直接训练过的复杂文本描述关联起来。

4. 以文搜图：文本检索图像

4.1. 任务目标与原理

以文搜图是指给定一段文本描述，从图像库中找出与该描述最匹配的图像。应用场景包括智能相册搜索、电商商品检索等。原理同样基于特征空间中的相似度计算：将查询文本和所有候选图像分别编码为特征向量，计算文本特征与各图像特征的余弦相似度，按相似度排序返回Top-K结果。

4.2. 代码实现

准备查询文本：例如"a red car parked on the street"。
准备图像库：从网络下载多张图片（包括猫、狗、宇航员等），并为每张图片提供简要描述（便于展示）。
批量预处理：使用processor同时处理文本和所有图像。
获取特征与相似度：模型输出的logits_per_text表示文本与各图像的匹配分数，同样经过softmax转换为概率。
排序输出：将图像按相似度降序排列，并打印排名。

4.3. 结果展示

代码会显示每张图片的相似度分数，并以条形图可视化。由于图像库中可能没有与查询匹配的红色汽车，相似度分数会均匀分布，但代码展示了完整的检索流程。在实际应用中，图像库应包含相关图片，检索效果将非常显著。

5. 以图搜文：图像检索文本

5.1. 任务目标与原理

以图搜文与以文搜图互为逆过程：给定一张图片，从文本库中找出最能描述该图片的文本。应用场景包括自动图像标注、内容理解等。原理不变，只是将查询改为图像特征，计算其与各文本特征的相似度。

5.2. 代码实现

查询图片：使用之前下载的第一张图片（宇航员骑马）。
候选文本：准备多个文本描述，包括正确描述和干扰项。
预处理与推理：与以文搜图类似，但使用logits_per_image作为相似度依据。
结果排序：输出最匹配的文本描述。

5.3. 结果解读

正确描述"a photo of an astronaut riding a horse"应获得最高相似度。这验证了CLIP在双向跨模态检索中的对称性。

6. 特征空间探索：理解跨模态语义对齐

6.1. 任务目标与原理

CLIP将图像和文本映射到同一个512维特征空间。特征空间探索的目标是直观展示这种对齐：语义相似的图文对在该空间中距离更近。通过计算图像特征与文本特征的相似度矩阵，我们可以观察匹配对之间的高分现象。

6.2. 代码实现

提取特征：分别使用model.get_image_features和model.get_text_features获取归一化后的特征向量。
相似度矩阵：计算图像特征与文本特征的点积，即余弦相似度，并乘以100放大显示。
统计信息：输出特征向量的均值、标准差和范数，验证归一化效果。

6.3. 结果解读与可视化

代码打印了相似度矩阵，理想情况下，匹配的图文对的相似度应高于其他组合。特征向量范数接近1.0，表明已正确归一化。这种分析有助于理解CLIP如何通过对比学习组织特征空间。

7. 总结与扩展

7.1. CLIP核心能力回顾

零样本图像分类：无需微调即可识别新类别。
以文搜图/以图搜文：双向跨模态检索。
跨模态理解：图像和文本在统一特征空间中对齐。

7.2. 关键技术要点总结

对比学习：通过4亿图文对训练，最大化匹配对相似度，最小化不匹配对。
双编码器架构：ViT图像编码器 + Transformer文本编码器，分别提取模态特征。
统一嵌入空间：512维特征空间，支持余弦相似度比较。
零样本迁移：预训练后可直接应用于下游任务，无需微调。

7.3. 实际应用场景与扩展学习方向

实际应用：智能相册搜索、内容审核、电商商品检索、自动图像标注。
扩展方向：
- LLaVA：多模态大模型，支持视觉对话。
- Stable Diffusion：基于文本生成图像。
- 向量数据库：如FAISS、ChromaDB，用于大规模跨模态检索。
- 多模态Agent：结合LangChain构建智能体。

8. 源码附录

python 复制代码

# ==============================================================================
# 多模态AI实战：CLIP模型教学演示
# ==============================================================================
# 本演示代码展示了CLIP模型的核心功能：
# 1. 零样本图像分类 - 展示CLIP的零样本迁移能力
# 2. 以文搜图 - 通过文本描述检索相关图片
# 3. 以图搜文 - 通过图片检索匹配的文本描述
# 4. 特征空间探索 - 展示CLIP如何将图像和文本映射到统一特征空间
# ==============================================================================

# 步骤 1: 导入必要的库
from transformers import CLIPProcessor, CLIPModel
from PIL import Image
import requests
import torch
import numpy as np
from torch.nn.functional import cosine_similarity
from io import BytesIO

print("=" * 70)
print("多模态AI实战：CLIP模型核心功能演示")
print("=" * 70)
print("\n【CLIP模型简介】")
print("CLIP (Contrastive Language-Image Pre-training) 是OpenAI开发的多模态模型")
print("通过4亿图文对预训练，将图像和文本映射到统一的512维特征空间")
print("实现跨模态语义对齐，支持零样本迁移和跨模态检索\n")

# 步骤 2: 加载预训练的CLIP模型和处理器
# 模型是"大脑"，处理器是"助手"，负责将原始的图片和文字转换成模型能理解的格式。
# 我们使用OpenAI官方发布的经典模型 'openai/clip-vit-base-patch32'
MODEL_NAME = "openai/clip-vit-base-patch32"

print("【模型加载】")
print(f"正在加载模型: {MODEL_NAME}")
print("模型架构：ViT图像编码器 + Transformer文本编码器")
print("特征维度：512维统一嵌入空间")

# 检查 PyTorch 版本并选择最佳加载方式
torch_version = torch.__version__
print(f"当前 PyTorch 版本: {torch_version}")

# 由于 PyTorch < 2.6 的安全限制，优先使用 safetensors 格式
# safetensors 格式不受 PyTorch 版本限制
print("注意：使用 safetensors 格式以兼容当前 PyTorch 版本...")

try:
    # 方法1：优先使用 safetensors 格式（不受 PyTorch 版本限制）
    # 检查是否安装了 safetensors
    try:
        import safetensors
        print("✓ 检测到 safetensors 库，使用 safetensors 格式加载...")
        model = CLIPModel.from_pretrained(MODEL_NAME, use_safetensors=True)
    except ImportError:
        print("⚠ 未安装 safetensors 库，尝试自动安装...")
        import subprocess
        import sys
        subprocess.check_call([sys.executable, "-m", "pip", "install", "safetensors", "-q"])
        print("✓ safetensors 安装完成，使用 safetensors 格式加载...")
        model = CLIPModel.from_pretrained(MODEL_NAME, use_safetensors=True)
    except Exception as e:
        # 如果 safetensors 加载失败，尝试不使用 safetensors
        print(f"⚠ 使用 safetensors 加载失败: {e}")
        print("尝试使用标准格式加载...")
        model = CLIPModel.from_pretrained(MODEL_NAME, use_safetensors=False)
    
    processor = CLIPProcessor.from_pretrained(MODEL_NAME)
    print("✓ 模型加载完成！\n")
    
except Exception as e:
    error_msg = str(e)
    if "torch.load" in error_msg or "CVE-2025-32434" in error_msg or "version 2.6" in error_msg.lower():
        print(f"\n❌ 模型加载失败: PyTorch 版本限制")
        print(f"错误详情: {error_msg[:200]}...")
        print("\n【解决方案】")
        print("=" * 70)
        print("方案1（推荐）：安装 safetensors 库")
        print("  命令: pip install safetensors")
        print("  说明: safetensors 格式不受 PyTorch 版本限制")
        print("\n方案2：升级 PyTorch 到 2.6+ 版本")
        print("  命令: pip install torch>=2.6.0 --upgrade")
        print("  说明: 解决安全漏洞 CVE-2025-32434")
        print("\n方案3：降级 transformers 库")
        print("  命令: pip install transformers<4.40.0")
        print("  说明: 使用旧版本 transformers 可能支持 PyTorch 2.2")
        print("=" * 70)
    else:
        print(f"❌ 模型加载失败: {e}")
    raise

# ==============================================================================
#  Part 1: 零样本图像分类 (Zero-Shot Image Classification)
# ==============================================================================
# 目标：给模型一张图片，让它从我们提供的文本标签中选出最匹配的一个。
# 原理：CLIP通过对比学习，将图像和文本映射到统一特征空间，计算相似度
# ==============================================================================
print("\n" + "=" * 70)
print("任务1: 零样本图像分类 (Zero-Shot Classification)")
print("=" * 70)
print("\n【核心原理】")
print("CLIP将分类任务转化为开放域图文匹配问题")
print("通过计算图像特征与文本标签特征的相似度，选择最匹配的标签")
print("无需针对特定类别进行微调，即可实现零样本分类\n")

# 步骤 3: 准备输入数据（一张图片和几个候选文本）
# 我们从网上找一张宇航员骑马的经典图片
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
print("【数据准备】")
print(f"正在下载测试图片: {url}")
try:
    response = requests.get(url, stream=True, timeout=10)
    response.raise_for_status()  # 检查HTTP状态码
    
    # 验证响应内容是否为图片
    content_type = response.headers.get('content-type', '').lower()
    if not content_type.startswith('image/'):
        raise ValueError(f"URL返回的不是图片格式，Content-Type: {content_type}")
    
    # 将响应内容保存到BytesIO以便多次读取
    image_data = BytesIO(response.content)
    
    # 打开并验证图片
    image = Image.open(image_data)
    # 验证图片是否有效
    image.verify()
    # 重新打开（因为verify后需要重新打开）
    image_data.seek(0)  # 重置流位置
    image = Image.open(image_data)
    print(f"✓ 图片下载成功！尺寸: {image.size}")
except (requests.exceptions.RequestException, IOError, ValueError, Exception) as e:
    print(f"⚠ 图片下载失败: {e}")
    # 如果下载失败，创建一个简单的白色图片作为备用
    image = Image.new('RGB', (224, 224), color='white')
    print("已创建一个备用白色图片。")

# 准备我们的候选文本标签（注意：使用"a photo of"前缀可以提高CLIP的识别准确率）
text_labels = [
    "a photo of a cat", 
    "a photo of a dog", 
    "a photo of an astronaut riding a horse",
    "a photo of a bird",
    "a photo of a car"
]
print(f"\n候选文本标签 ({len(text_labels)}个):")
for i, label in enumerate(text_labels, 1):
    print(f"  {i}. {label}")

# 步骤 4: 数据预处理并进行推理
print("\n【特征提取与推理】")
print("1. 使用CLIP处理器将图片和文本转换为模型输入格式")
print("2. 图像编码器(ViT)提取图像特征向量")
print("3. 文本编码器(Transformer)提取文本特征向量")
print("4. 计算图像特征与各文本特征的相似度")

# 使用"助手"(processor)将图片和文本打包成模型需要的格式（PyTorch张量）
# padding=True 表示将所有文本处理成相同的长度
# return_tensors="pt" 表示返回PyTorch Tensors
inputs = processor(text=text_labels, images=image, return_tensors="pt", padding=True)

# 将处理好的数据送入"大脑"(model)进行计算
# torch.no_grad() 表示我们只是在做推理，不需要计算梯度，这样可以节省计算资源
with torch.no_grad():
    outputs = model(**inputs)

# 模型的输出包含了各种信息，我们最关心的是图片与每个文本的相似度得分
# logits_per_image 是一个矩阵，表示每张图片与每个文本标签的原始匹配分数（logits）
logits_per_image = outputs.logits_per_image 

# 步骤 5: 解读并展示结果
# 为了让分数更直观，我们使用softmax函数将其转换为概率分布
# 这样所有标签的概率加起来会等于1
probs = logits_per_image.softmax(dim=1) 

print("\n【分类结果】")
print("-" * 70)
# 将概率和标签配对，并按概率从高到低排序
results = sorted(zip(text_labels, probs[0].tolist()), key=lambda x: x[1], reverse=True)

# 打印出每个标签及其对应的概率
for rank, (label, score) in enumerate(results, 1):
    bar_length = int(score * 50)  # 用条形图可视化概率
    bar = "█" * bar_length
    print(f"排名 {rank}: {label:<45} | 概率: {score:.4f} | {bar}")

best_label, best_score = results[0]
print("-" * 70)
print(f"\n✓ 最佳匹配: '{best_label}' (置信度: {best_score:.2%})")
print("\n【技术要点】")
print("• CLIP通过对比学习实现跨模态语义对齐")
print("• 零样本能力：无需针对特定类别进行训练")
print("• 统一特征空间：图像和文本映射到相同的512维空间")
print("=" * 70)


# ==============================================================================
#  Part 2: 以文搜图 (Text-to-Image Retrieval)
# ==============================================================================
# 目标：给定一个文本描述，从多张图片中找出最符合描述的那一张。
# 应用场景：智能相册搜索、内容审核、电商商品检索等
# ==============================================================================
print("\n" + "=" * 70)
print("任务2: 以文搜图 (Text-to-Image Retrieval)")
print("=" * 70)
print("\n【核心原理】")
print("1. 提取查询文本的特征向量")
print("2. 提取图库中所有图片的特征向量")
print("3. 计算文本特征与各图片特征的余弦相似度")
print("4. 按相似度排序，返回Top-K最相关图片\n")

# 步骤 1: 准备输入数据（一个文本描述和多张图片）
query_text = "a red car parked on the street"
print("【数据准备】")
print(f"查询文本: '{query_text}'")

# 准备一组图片URL（使用更可靠的图片源）
image_urls = [
    "http://images.cocodataset.org/val2017/000000039769.jpg",  # 宇航员骑马
    "http://images.cocodataset.org/val2017/000000039623.jpg",  # 多只猫
    "http://images.cocodataset.org/val2017/000000039631.jpg",  # 多只狗
    "http://images.cocodataset.org/val2017/000000039632.jpg",  # 多只猫
]

# 为每张图片添加描述（用于后续展示）
image_descriptions = [
    "宇航员骑马",
    "多只猫",
    "多只狗",
    "多只猫"
]

images = []
print(f"\n正在下载 {len(image_urls)} 张图片...")
for i, url in enumerate(image_urls):
    try:
        # 下载图片
        response = requests.get(url, stream=True, timeout=10)
        response.raise_for_status()  # 检查HTTP状态码
        
        # 验证响应内容是否为图片
        content_type = response.headers.get('content-type', '').lower()
        if not content_type.startswith('image/'):
            raise ValueError(f"URL返回的不是图片格式，Content-Type: {content_type}")
        
        # 将响应内容保存到BytesIO以便多次读取
        image_data = BytesIO(response.content)
        
        # 打开并验证图片
        img = Image.open(image_data)
        # 验证图片是否有效
        img.verify()
        # 重新打开（因为verify后需要重新打开）
        image_data.seek(0)  # 重置流位置
        img = Image.open(image_data)
        
        images.append(img)
        desc = image_descriptions[i] if i < len(image_descriptions) else f"图片{i+1}"
        print(f"  ✓ 图片 {i+1}: {desc} - 尺寸: {img.size}")
    except (requests.exceptions.RequestException, IOError, ValueError, Exception) as e:
        error_type = type(e).__name__
        print(f"  ⚠ 无法下载图片 {i+1} ({error_type}): {url}")
        if hasattr(e, 'message'):
            print(f"     错误详情: {e.message}")
        # 创建备用图片
        images.append(Image.new('RGB', (224, 224), color=(100, 100, 100)))
        # 更新描述以反映这是备用图片
        if i < len(image_descriptions):
            image_descriptions[i] = f"备用图片{i+1}"

print(f"\n✓ 成功准备 {len(images)} 张图片用于检索\n")

# 步骤 2: 数据预处理并进行推理
print("【特征提取与相似度计算】")
print("正在计算文本特征与各图片特征的相似度...")

# 这次我们有多张图片和一个文本
inputs = processor(text=[query_text], images=images, return_tensors="pt", padding=True)

with torch.no_grad():
    outputs = model(**inputs)

# 这次我们关心的是每个图片与这个文本的匹配度
# logits_per_text 是一个矩阵，表示每个文本与每张图片的原始匹配分数
logits_per_text = outputs.logits_per_text

# 同样，使用softmax转换为概率
probs = logits_per_text.softmax(dim=1)

# 步骤 3: 解读并展示结果
print("\n【检索结果】")
print("-" * 70)
# 将概率和图片信息配对，并按概率从高到低排序
results = sorted(zip(range(len(images)), image_descriptions, image_urls, probs[0].tolist()), 
                 key=lambda x: x[3], reverse=True)

for rank, (idx, desc, url, score) in enumerate(results, 1):
    bar_length = int(score * 50)
    bar = "█" * bar_length
    print(f"排名 {rank}: {desc:<15} | 相似度: {score:.4f} | {bar}")
    print(f"         URL: {url[:60]}...")

print("-" * 70)
best_idx, best_desc, best_url, best_score = results[0]
print(f"\n✓ 最佳匹配: 图片 '{best_desc}' (相似度: {best_score:.2%})")
print("\n【技术要点】")
print("• 余弦相似度：衡量文本和图像特征向量的方向一致性")
print("• 批量检索：可同时处理多张图片，提高检索效率")
print("• 实际应用：召回率可达85%以上（Flickr30K数据集）")
print("=" * 70)


# ==============================================================================
#  Part 3: 以图搜文 (Image-to-Text Retrieval)
# ==============================================================================
# 目标：给定一张图片，从多个文本描述中找出最匹配的那一个。
# 应用场景：自动图像标注、内容理解、智能推荐等
# ==============================================================================
print("\n" + "=" * 70)
print("任务3: 以图搜文 (Image-to-Text Retrieval)")
print("=" * 70)
print("\n【核心原理】")
print("1. 提取查询图片的特征向量")
print("2. 提取文本库中所有文本的特征向量")
print("3. 计算图片特征与各文本特征的余弦相似度")
print("4. 按相似度排序，返回Top-K最相关文本描述\n")

# 步骤 1: 准备输入数据（一张图片和多个文本描述）
print("【数据准备】")
# 使用之前下载的图片（例如第一张）
if not images:
    print("⚠ 警告: 没有可用的图片，将使用备用白色图片")
    query_image = Image.new('RGB', (224, 224), color='white')
else:
    query_image = images[0]
print(f"查询图片: 尺寸 {query_image.size}")

# 准备多个候选文本描述
candidate_texts = [
    "a photo of an astronaut riding a horse",
    "a photo of a cat sitting on a sofa",
    "a photo of a dog playing in the park",
    "a photo of a red car parked on the street",
    "a photo of a beautiful landscape with mountains",
    "a photo of multiple cats lying together",
    "a photo of a person reading a book",
    "a photo of a bicycle on the road"
]

print(f"\n候选文本描述 ({len(candidate_texts)}个):")
for i, text in enumerate(candidate_texts, 1):
    print(f"  {i}. {text}")

# 步骤 2: 数据预处理并进行推理
print("\n【特征提取与相似度计算】")
print("正在计算图片特征与各文本特征的相似度...")

inputs = processor(text=candidate_texts, images=query_image, return_tensors="pt", padding=True)

with torch.no_grad():
    outputs = model(**inputs)

# 使用 logits_per_image 表示图片与各文本的匹配度
logits_per_image = outputs.logits_per_image
probs = logits_per_image.softmax(dim=1)

# 步骤 3: 解读并展示结果
print("\n【检索结果】")
print("-" * 70)
results = sorted(zip(candidate_texts, probs[0].tolist()), key=lambda x: x[1], reverse=True)

for rank, (text, score) in enumerate(results, 1):
    bar_length = int(score * 50)
    bar = "█" * bar_length
    print(f"排名 {rank}: {text:<55} | 相似度: {score:.4f} | {bar}")

print("-" * 70)
best_text, best_score = results[0]
print(f"\n✓ 最佳匹配: '{best_text}' (相似度: {best_score:.2%})")
print("\n【技术要点】")
print("• 双向检索：CLIP支持文本→图像和图像→文本的双向检索")
print("• 语义理解：能够理解图像的高级语义，而非仅依赖低级特征")
print("• 实际应用：可用于自动图像标注、内容审核等场景")
print("=" * 70)


# ==============================================================================
#  Part 4: 特征空间探索 (Feature Space Exploration)
# ==============================================================================
# 目标：展示CLIP如何将图像和文本映射到统一特征空间
# 通过可视化特征向量，理解跨模态语义对齐机制
# ==============================================================================
print("\n" + "=" * 70)
print("任务4: 特征空间探索 (Feature Space Exploration)")
print("=" * 70)
print("\n【核心原理】")
print("CLIP通过对比学习，将图像和文本映射到统一的512维特征空间")
print("语义相似的图像和文本在特征空间中距离更近")
print("通过分析特征向量的相似度，可以理解模型的跨模态理解能力\n")

# 步骤 1: 提取多个图像和文本的特征向量
print("【特征提取】")
if not images:
    print("⚠ 警告: 没有可用的图片，将使用备用图片")
    sample_images = [Image.new('RGB', (224, 224), color=(100, 100, 100)) for _ in range(3)]
else:
    sample_images = images[:3] if len(images) >= 3 else images
sample_texts = [
    "a photo of a cat",
    "a photo of a dog", 
    "a photo of an astronaut"
]

# 准备图像描述（用于显示）
# 确保描述数量与图片数量一致
if len(image_descriptions) >= len(sample_images):
    sample_image_descriptions = image_descriptions[:len(sample_images)]
else:
    # 如果描述不够，用通用描述补充
    sample_image_descriptions = image_descriptions + [f"图片{i+1}" for i in range(len(image_descriptions), len(sample_images))]

print(f"提取 {len(sample_images)} 张图片和 {len(sample_texts)} 个文本的特征向量...")

# 分别提取图像特征和文本特征
with torch.no_grad():
    # 提取图像特征
    image_inputs = processor(images=sample_images, return_tensors="pt")
    image_features = model.get_image_features(**image_inputs)
    # 归一化特征向量（CLIP的标准做法）
    image_features = image_features / image_features.norm(dim=-1, keepdim=True)
    
    # 提取文本特征
    text_inputs = processor(text=sample_texts, return_tensors="pt", padding=True)
    text_features = model.get_text_features(**text_inputs)
    # 归一化特征向量
    text_features = text_features / text_features.norm(dim=-1, keepdim=True)

print(f"✓ 图像特征维度: {image_features.shape}")  # [num_images, 512]
print(f"✓ 文本特征维度: {text_features.shape}")    # [num_texts, 512]

# 步骤 2: 计算跨模态相似度矩阵
print("\n【相似度矩阵分析】")
print("计算图像特征与文本特征的相似度矩阵...")

# 计算相似度矩阵：image_features @ text_features.T
similarity_matrix = (image_features @ text_features.T) * 100  # 乘以100是为了与logits scale一致
similarity_matrix = similarity_matrix.cpu().numpy()

print("\n相似度矩阵 (图像 × 文本):")
print("-" * 70)
print(f"{'图像/文本':<20}", end="")
for text in sample_texts:
    print(f"{text[:20]:<22}", end="")
print()

for i, img_desc in enumerate(sample_image_descriptions):
    print(f"{img_desc:<20}", end="")
    for j in range(len(sample_texts)):
        print(f"{similarity_matrix[i][j]:>20.2f}", end="  ")
    print()

print("-" * 70)
print("\n【解读】")
print("• 数值越大表示相似度越高（范围通常在-100到100之间）")
print("• 对角线或接近对角线的值通常较高，表示匹配的图文对")
print("• 通过对比学习，CLIP学会了将语义相关的图像和文本映射到相近的位置")

# 步骤 3: 展示特征向量的统计信息
print("\n【特征向量统计】")
print("分析特征向量的分布特性...")

print(f"\n图像特征统计:")
print(f"• 均值: {image_features.mean().item():.4f}")
print(f"• 标准差: {image_features.std().item():.4f}")
print(f"• 特征向量范数: {image_features.norm(dim=-1).mean().item():.4f} (归一化后应为1.0)")

print(f"\n文本特征统计:")
print(f"• 均值: {text_features.mean().item():.4f}")
print(f"• 标准差: {text_features.std().item():.4f}")
print(f"• 特征向量范数: {text_features.norm(dim=-1).mean().item():.4f} (归一化后应为1.0)")

print("\n【技术要点】")
print("• 统一特征空间：图像和文本共享512维嵌入空间")
print("• 归一化处理：特征向量经过L2归一化，便于计算余弦相似度")
print("• 对比学习：通过最大化匹配对的相似度，最小化不匹配对的相似度来训练")
print("=" * 70)


# ==============================================================================
#  课程总结
# ==============================================================================
print("\n" + "=" * 70)
print("课程总结")
print("=" * 70)
print("\n【CLIP核心能力回顾】")
print("1. ✓ 零样本图像分类：无需微调即可识别新类别")
print("2. ✓ 以文搜图：通过文本描述检索相关图片")
print("3. ✓ 以图搜文：通过图片检索匹配的文本描述")
print("4. ✓ 跨模态理解：图像和文本映射到统一特征空间")

print("\n【关键技术要点】")
print("• 对比学习：通过4亿图文对预训练，实现跨模态语义对齐")
print("• 双编码器架构：ViT图像编码器 + Transformer文本编码器")
print("• 统一嵌入空间：512维特征空间，支持跨模态检索")
print("• 零样本迁移：预训练后可直接应用于下游任务，无需微调")

print("\n【实际应用场景】")
print("• 智能相册：通过文字搜索照片")
print("• 内容审核：图文匹配检测")
print("• 电商检索：商品图片与描述匹配")
print("• 自动标注：为图片生成文字描述")

print("\n【扩展学习方向】")
print("• LLaVA：多模态大模型，支持视觉对话")
print("• Stable Diffusion：文生图技术")
print("• 向量数据库：FAISS/ChromaDB用于大规模检索")
print("• 多模态Agent：结合LangChain构建智能体")

print("\n" + "=" * 70)
print("感谢学习！多模态AI的世界充满无限可能！")
print("=" * 70)