高级多模态AI实践笔记

多模态AI CLIP GPT-4V 计算机视觉 深度学习
作者: 醉月思 发布日期: 2024-07-04 分类: 技术实践

2021年OpenAI发布CLIP的时候，我正在折腾一个产品图片分类的项目。

但数据收集到一半就发现一个问题：产品类别太多太细，而且新SKU上得很快，根本没法保证训练集永远够用。

从CLIP开始：图文匹配的第一次尝试

2021年OpenAI发布CLIP的时候，我正在折腾一个产品图片分类的项目。原本想着按传统思路走：准备数据集、训练分类器、调参、上线。但数据收集到一半就发现一个问题：产品类别太多太细，而且新SKU上得很快，根本没法保证训练集永远够用。

CLIP给出的思路是：既然已经有大量的图文对，为什么不直接学这个对比关系，而不是每个类别都从头训一个分类器？这个想法在当时挺新鲜的，而且从结果看效果也不差。

基础用法：零样本分类

最基础的用法就是零样本分类。比如你有一张图片，想知道它是什么类别，就给CLIP一堆文本描述，让它算出哪个描述最匹配图片。

import torch
from PIL import Image
import clip

device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)

# 准备图片
image = preprocess(Image.open("product.jpg")).unsqueeze(0).to(device)

# 定义候选文本描述
text_inputs = torch.cat([
    clip.tokenize(f"a photo of a {c}") for c in
    ["智能手机", "笔记本电脑", "耳机", "智能手表", "平板电脑"]
]).to(device)

# 计算相似度
with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text_inputs)

    logits_per_image, logits_per_text = model(image, text_inputs)
    probs = logits_per_image.softmax(dim=-1).cpu().numpy()

print("Label probs:", probs)

第一次跑通这段代码的时候有点惊讶：虽然我并没有训练这个模型，但它居然能认出来图片里的产品是什么，而且准确率比想象中高。这说明在预训练阶段，CLIP已经见过足够多的图文对，学到了不少关于物体和场景的知识。

这里有个需要注意的地方：文本描述的写法对结果影响挺大。比如"a photo of 智能手机"和"智能手机"的效果就可能差不少，因为CLIP的训练数据里，描述通常是完整句子，不是孤立的词。我后来试过不同写法，发现加上"a photo of"或者"a picture showing"这样的前缀，平均能提升几个点的准确率。

踩坑：领域适应性

虽然CLIP在通用数据上表现不错，但放到特定领域就开始出问题了。

第一个坑是专业术语。比如医疗影像、工业缺陷检测这些领域，CLIP见过的图文对肯定不够，很多专业名词它根本不理解。我试过用CLIP来做PCB板缺陷检测，结果它在"短路"、“虚焊”、“漏焊"这些概念上完全混乱，因为这些术语在通用训练数据里很少出现。

另一个坑是细节差异。CLIP学的是整体视觉特征，对细微差别不太敏感。比如同系列不同型号的智能手机，或者外观几乎一样的工业零件，它经常分不清。这其实不奇怪，因为对比学习的目标就是让相似的东西靠近，太细的差别反而可能被当作噪声忽略掉了。

解决方法有几个：

  1. 数据增强：在领域数据上做对比学习的微调，保留预训练知识的同时适应特定分布
  2. 提示工程：精心设计文本描述，把关键特征显式说出来，比如"带有Type-C接口的智能手机"而不是笼统的"智能手机”
  3. 结合传统方法：把CLIP作为特征提取器，后面接一个轻量分类器做二次判断

后来在产品分类项目里，我采用的是"提示工程 + 后处理"的方案。前端分类用CLIP把可能性降到一个很小的集合，然后在这个集合上训练一个小分类器做最终判断。这样既利用了CLIP的泛化能力，又保证了领域内的准确率。

向GPT-4V过渡：从识别到理解

CLIP虽然好用，但本质上还是在做"图文匹配"这件事。你给它一对，它告诉你相似度分数，但不会告诉你为什么这么判断，也不会做推理或者生成。

GPT-4V的出现把这个局面彻底改变了。它不仅能识别图里的东西，还能解释、分析、推理，甚至根据图片内容帮你做事。

第一次调用：简单的物体识别

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "这张图片里有什么？请详细描述一下。"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.jpg",
                    }
                }
            ]
        }
    ],
    max_tokens=500
)

print(response.choices[0].message.content)

第一次跑通这段代码的时候，感觉确实不一样。CLIP只会告诉你"这张图最可能属于类别A"，但GPT-4V会告诉你：“这张图显示了一个办公场景，桌上有笔记本电脑、咖啡杯、几本书，窗户开着，阳光从左侧射入…“这种描述虽然未必百分百准确，但明显更接近人类的观察方式。

进阶用法：复杂的多模态任务

GPT-4V真正有意思的是它能处理更复杂的任务，而不仅仅是描述。比如：

场景理解与推理：

response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "分析这张图片里的安全风险，并给出改进建议。"
                },
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/workplace.jpg"}
                }
            ]
        }
    ],
    max_tokens=800
)

技术问题诊断：

response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": """这是一个报错界面截图。请分析可能的错误原因，
                    并给出排查步骤。如果能看到代码或配置，也请指出问题。"""
                },
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/error-screenshot.png"}
                }
            ]
        }
    ],
    max_tokens=1000
)

这些任务放在三年前是想都不敢想的。现在一个API调用就能拿到相当不错的初步分析，虽然不能完全替代专业诊断，但作为起点已经很有价值了。

踩坑：成本与性能

GPT-4V虽然强大，但不是没有代价的。

第一个明显的问题是成本。Vision模型的价格比纯文本模型高不少，而且图像越大、细节越多，计算量就越大。我做过一个对比：同样做产品分类，CLIP在本地GPU上跑一次只要几十毫秒，成本基本是电费；而GPT-4V每次调用要花几美分，而且还有延迟。

另一个问题是稳定性。GPT-4V有时候会"幻觉”，比如描述图里没有的东西，或者对模糊区域过度解读。这种问题在关键场景下挺麻烦的，你不能确定它什么时候在认真分析，什么时候在"编故事”。

还有一些技术细节需要注意：

  • 图片分辨率：太低的图片可能丢失关键信息，太高的图片又增加成本和延迟。实践中我通常会把长边控制在1024左右，必要时裁剪到关键区域
  • 多图交互：一次对话可以包含多张图片，但模型在多图之间的推理能力有限，复杂场景最好分步骤处理
  • 结构化输出：如果需要机器解析，最好让模型输出JSON，然后在后端做验证和回退
response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": """分析这张图片中的UI元素，返回JSON格式：
                    {
                        "elements": [
                            {"type": "button", "label": "按钮文字", "position": "top-left"},
                            ...
                        ],
                        "layout": "vertical/horizontal/grid",
                        "complaints": ["问题1", "问题2"]
                    }"""
                },
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/ui.jpg"}
                }
            ]
        }
    ],
    response_format={"type": "json_object"},
    max_tokens=1000
)

混合架构：把模型组合起来用

实际项目里，很少只用一个模型。不同的模型有不同的强项，合理组合能兼顾效果、成本和延迟。

典型流程

我现在常用的一个混合架构是这样的：

flowchart TD A[输入图片] --> B{是否需要精细分析?} B -->|否| C[CLIP零样本分类] B -->|是| D[GPT-4V视觉理解] C --> E[输出分类结果] D --> F{是否需要二次验证?} F -->|否| G[输出分析结果] F -->|是| H[传统CV方法验证] H --> I[综合输出]

具体到代码实现，大概是这样：

def classify_image(image_path, use_gpt4v=False):
    # 先用CLIP做个快速判断
    clip_result = clip_classify(image_path)

    if not use_gpt4v:
        return clip_result

    # 如果置信度不够高，或者用户明确要求详细分析
    if clip_result['confidence'] < 0.8:
        gpt4v_result = gpt4v_analyze(image_path)
        return {
            'clip': clip_result,
            'gpt4v': gpt4v_result,
            'final': combine_results(clip_result, gpt4v_result)
        }

    return clip_result

def clip_classify(image_path):
    # CLIP分类逻辑
    image = preprocess(Image.open(image_path)).unsqueeze(0).to(device)
    text_inputs = torch.cat([clip.tokenize(f"a photo of a {c}")
                            for c in CATEGORIES]).to(device)

    with torch.no_grad():
        logits_per_image, _ = model(image, text_inputs)
        probs = logits_per_image.softmax(dim=-1).cpu().numpy()[0]

    top_idx = probs.argmax()
    return {
        'category': CATEGORIES[top_idx],
        'confidence': float(probs[top_idx]),
        'all_probs': {c: float(p) for c, p in zip(CATEGORIES, probs)}
    }

def gpt4v_analyze(image_path):
    # GPT-4V分析逻辑
    with open(image_path, "rb") as f:
        base64_image = base64.b64encode(f.read()).decode()

    response = client.chat.completions.create(
        model="gpt-4-vision-preview",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": f"""分析这张图片，判断它属于以下哪个类别：
                        {', '.join(CATEGORIES)}。
                        返回JSON格式：{{"category": "类别名", "reasoning": "判断依据"}}"""
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}"
                        }
                    }
                ]
            }
        ],
        response_format={"type": "json_object"},
        max_tokens=500
    )

    return json.loads(response.choices[0].message.content)

实际场景：产品质检

去年我在一个产品质检项目里用了这套混合架构，效果比单独用任何一个模型都好。

场景是这样的：工厂需要检查产品外观，包括划痕、裂纹、色差等问题。传统做法是训练专门的缺陷检测模型，但缺陷类型多、样本少，训练效果不理想。纯用GPT-4V又太慢，而且偶尔会漏掉细微缺陷。

最终采用的方案是：

  1. 快速筛选：用CLIP把明显正常的产品筛出去，这部分占70-80%
  2. 精细分析：对筛选出的可疑产品，用GPT-4V做详细分析
  3. 二次验证：对GPT-4V标记的缺陷，用传统边缘检测和颜色分析做交叉验证

这个方案的优点是：

  • 成本可控：大部分产品只用CLIP，只有少部分用GPT-4V
  • 准确率提升：GPT-4V能发现一些传统方法漏掉的语义级缺陷（比如"整体色偏"）
  • 可解释性：GPT-4V的分析结果能直接给质检人员参考，而不是黑盒输出

缺点也有：

  • 延迟：可疑产品需要两轮分析，总延迟可能超过1秒
  • 一致性：CLIP和GPT-4V有时候会给出不同判断，需要额外的合并逻辑
def quality_check(image_path):
    # 第一轮：CLIP筛选
    clip_result = clip_classify(image_path, categories=["正常产品", "有缺陷"])

    if clip_result['category'] == '正常产品' and clip_result['confidence'] > 0.9:
        return {'status': 'passed', 'method': 'clip_only'}

    # 第二轮：GPT-4V详细分析
    gpt4v_result = gpt4v_analyze_defect(image_path)

    # 第三轮：传统方法验证
    traditional_result = traditional_defect_detection(image_path)

    # 综合判断
    if gpt4v_result['has_defect'] and traditional_result['has_defect']:
        return {
            'status': 'failed',
            'defect_type': gpt4v_result['defect_type'],
            'confidence': 'high',
            'reasoning': gpt4v_result['reasoning'],
            'method': 'hybrid_confirmed'
        }
    elif gpt4v_result['has_defect']:
        return {
            'status': 'review_needed',
            'defect_type': gpt4v_result['defect_type'],
            'confidence': 'medium',
            'reasoning': gpt4v_result['reasoning'],
            'method': 'gpt4v_only'
        }
    else:
        return {'status': 'passed', 'method': 'hybrid_no_defect'}

工程实践中的几个关键点

经过这几年的折腾，有几点体会挺深刻的。

数据质量比模型选择更重要

很多人一上来就纠结"用CLIP还是用BLIP"、“GPT-4V还是Gemini”，但实际上数据质量往往比模型本身影响更大。

一个真实的例子：我帮朋友做农产品分级，一开始用CLIP，效果一般。后来才发现问题不在模型，而在数据——他们收集的训练图片光线不统一、背景杂乱、标注重叠严重。花了一个月时间整理数据，换了个小模型，效果反而提升了20%。

所以我的建议是：先把数据搞清楚，再选模型。数据问题解决了，中等的模型也能做出不错的效果；数据问题不解决，最先进的模型也救不了你。

评估指标要贴实际

学术上常用的指标（准确率、F1、mAP）有时候和实际需求脱节。

比如在产品分类场景里，“分错但相邻"和"分错且离谱"的代价是不一样的——把"iPhone 13"分到"iPhone 14"可能影响不大，但分到"AirPods"就完全错了。但标准准确率指标不区分这些。

我后来自己设计了一个"阶梯式损失”：

def hierarchical_loss(pred, target, category_hierarchy):
    """
    pred: 预测的类别
    target: 真实的类别
    category_hierarchy: 类别层级关系，{"智能手机": ["iPhone", "Samsung"], "笔记本": ["MacBook", "ThinkPad"]}
    """
    if pred == target:
        return 0.0  # 完全正确
    elif is_sibling(pred, target, category_hierarchy):
        return 0.3  # 同级错误
    elif is_same_parent(pred, target, category_hierarchy):
        return 0.6  # 同父不同子
    else:
        return 1.0  # 完全错误

这样评估出来的结果更贴近业务需求，也更容易和产品经理解释。

边缘情况的处理

多模态模型在边缘情况上的表现经常出问题，比如：

  • 极低分辨率图片：GPT-4V会胡编乱造
  • 过亮或过暗的图片：颜色判断完全错误
  • 遮挡严重的场景：看不到的关键区域会被"脑补"
  • 多语言混合：中文文本在英文图片上可能被误识别

这些情况不能指望模型自动处理好，需要在工程层面做防御：

def validate_image_quality(image_path):
    """检查图片质量，不满足要求的拒绝处理"""
    img = Image.open(image_path)
    width, height = img.size

    # 检查分辨率
    if width < 200 or height < 200:
        return False, "分辨率过低"

    # 检查亮度
    gray = np.array(img.convert('L'))
    avg_brightness = gray.mean()
    if avg_brightness < 30 or avg_brightness > 225:
        return False, f"亮度异常: {avg_brightness}"

    # 检查文件大小（可能是模糊的）
    file_size = os.path.getsize(image_path)
    if file_size < 5000:  # 小于5KB
        return False, "文件过小，可能模糊"

    return True, "ok"

def safe_analyze(image_path):
    is_valid, reason = validate_image_quality(image_path)
    if not is_valid:
        return {
            'status': 'rejected',
            'reason': reason,
            'suggestion': '请提供清晰、光线适中的图片'
        }

    # 只有通过质量检查才调用模型
    return gpt4v_analyze(image_path)

一些未解的问题

多模态AI这几年进步很快，但还有一些问题没完全解决。

成本与准确率的平衡：GPT-4V确实强大，但成本不低。对于高频场景，还是需要找到更便宜的替代方案。现在有一些开源的多模态模型（如LLaVA、Qwen-VL）在追赶，但整体体验还是有差距。

一致性与可靠性：同一个问题问两遍，GPT-4V有时候会给出不同的答案。这种不一致在生产环境中挺麻烦的，特别是需要可复现结果的场景。

隐私与安全：把图片发送到第三方API，对于医疗、金融这些敏感领域是个问题。本地部署的开源模型是一个方向，但硬件成本和模型规模又是个坎。

评估标准：多模态任务的评估比纯文本更复杂。怎么定义"理解"？怎么衡量"推理质量"？现在还没有特别好的标准，很多时候还是靠人工抽查。

写在最后

从CLIP到GPT-4V，这三年多模态AI的发展确实快得有点跟不上节奏。但真正落到工程实践中，还是得一步步来：先把基础打牢，再考虑高级功能；先解决80%的常见问题，再优化那20%的边缘情况。

技术是好东西，但它本身不解决问题，解决问题的是人。多模态AI给了我们新的工具和可能，但怎么用好它、怎么把它真正嵌入到业务流程里，这些还是需要扎扎实实的工程实践和业务理解。

如果有人问我"现在要不要做多模态"，我会说：看场景、看数据、看成本，别看 hype。有些问题确实适合用多模态模型解决，有些问题传统方法可能更高效。技术选型永远是权衡，而不是追新。

版权声明: 本文首发于 指尖魔法屋-高级多模态AI实践笔记（https://blog.thinkmoon.cn/post/185-multimodal-ai-clip-gpt4v-practice/） 转载或引用必须申明原指尖魔法屋来源及源地址！

相关阅读

根据标签、分类和主题为你挑选的相近文章