跳至主要內容

第2199篇：多模态Embedding——图文统一向量空间的工程实现

老张大约 6 分钟

第2199篇：多模态Embedding——图文统一向量空间的工程实现

适读人群：需要实现图文跨模态检索的Java工程师 | 阅读时长：约15分钟 | 核心价值：CLIP及其继任者的Java工程集成，构建真正的图文统一向量空间

做多模态RAG的时候，我遇到一个很基础的问题：怎么让文字"猫咪"和猫咪的图片在向量空间里离得足够近，而不是各说各话？

这就是多模态Embedding要解决的问题。

传统的文字Embedding模型（BERT、BGE等）只处理文字，图片Embedding模型（如ResNet特征）只处理图片，两者生成的向量在完全不同的语义空间里，没有可比性。CLIP的核心贡献是：用对比学习训练，让"猫的图片"和"一只猫"这对匹配的图文对，在向量空间里距离近；让不匹配的图文对距离远。

一、CLIP的工程本质

CLIP（Contrastive Language-Image Pre-Training）用了一个优雅的训练目标：

给定一批图文对：
- (图1, 文字1)   ← 匹配
- (图2, 文字2)   ← 匹配
- (图1, 文字2)   ← 不匹配
- (图2, 文字1)   ← 不匹配

训练目标：
- 匹配对的向量余弦相似度尽量高（接近1）
- 不匹配对的余弦相似度尽量低（接近0或负值）

这使得CLIP生成的向量天然支持：

  • 文字 → 图片：用文字向量在图片向量库里检索
  • 图片 → 文字：用图片向量在文字向量库里检索
  • 图片 → 图片：相似图片检索

主流多模态Embedding模型对比

模型向量维度中文支持推理速度最大图片尺寸
openai/clip-vit-base-patch32512差快224x224
openai/clip-vit-large-patch14768差中224x224
BAAI/bge-visualized-base768优秀中任意（自动缩放）
jinaai/jina-clip-v21024良好中512x512
nomic-ai/nomic-embed-vision768良好快任意

对于中文场景，强烈推荐BGE-Visualized，它是BGE-M3的多模态扩展版，文字理解能力大幅超过原版CLIP。

二、本地部署多模态Embedding服务

把模型部署成REST服务，Java通过HTTP调用是最实用的方案：

Python服务端（简洁实现）

# multimodal_embedding_service.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from transformers import AutoModel, AutoTokenizer
from PIL import Image
import torch
import base64
import io
import numpy as np
from typing import List, Optional

app = FastAPI()

# 加载BGE-Visualized模型
model = AutoModel.from_pretrained("BAAI/bge-visualized", trust_remote_code=True)
model.eval()

class TextEmbedRequest(BaseModel):
    texts: List[str]

class ImageEmbedRequest(BaseModel):
    images_base64: List[str]  # Base64编码的图片列表

@app.post("/embed/text")
async def embed_text(request: TextEmbedRequest):
    with torch.no_grad():
        embeddings = model.encode(texts=request.texts)
    return {"embeddings": embeddings.tolist()}

@app.post("/embed/image")
async def embed_image(request: ImageEmbedRequest):
    images = []
    for b64 in request.images_base64:
        image_bytes = base64.b64decode(b64)
        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
        images.append(image)
    
    with torch.no_grad():
        embeddings = model.encode(images=images)
    return {"embeddings": embeddings.tolist()}

Java客户端实现

@Component
public class MultimodalEmbeddingClient {
    
    private static final Logger log = LoggerFactory.getLogger(MultimodalEmbeddingClient.class);
    
    private final RestTemplate restTemplate;
    private final ObjectMapper objectMapper;
    
    @Value("${embedding.multimodal.url:http://localhost:8100}")
    private String embeddingServiceUrl;
    
    @Value("${embedding.multimodal.timeout:30000}")
    private int timeoutMs;
    
    public MultimodalEmbeddingClient() {
        // 配置连接超时
        HttpComponentsClientHttpRequestFactory factory = 
            new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(5000);
        factory.setReadTimeout(timeoutMs);
        this.restTemplate = new RestTemplate(factory);
        this.objectMapper = new ObjectMapper();
    }
    
    /**
     * 文字向量化
     */
    public float[] embedText(String text) {
        return embedTexts(List.of(text))[0];
    }
    
    /**
     * 批量文字向量化
     */
    public float[][] embedTexts(List<String> texts) {
        Map<String, Object> request = Map.of("texts", texts);
        
        ResponseEntity<Map> response = restTemplate.postForEntity(
            embeddingServiceUrl + "/embed/text",
            request, Map.class);
        
        return parseEmbeddingResponse(response.getBody());
    }
    
    /**
     * 图片向量化
     */
    public float[] embedImage(byte[] imageBytes) {
        return embedImages(List.of(imageBytes))[0];
    }
    
    /**
     * 批量图片向量化
     */
    public float[][] embedImages(List<byte[]> imagesBytesList) {
        List<String> base64Images = imagesBytesList.stream()
            .map(bytes -> Base64.getEncoder().encodeToString(bytes))
            .collect(Collectors.toList());
        
        Map<String, Object> request = Map.of("images_base64", base64Images);
        
        ResponseEntity<Map> response = restTemplate.postForEntity(
            embeddingServiceUrl + "/embed/image",
            request, Map.class);
        
        return parseEmbeddingResponse(response.getBody());
    }
    
    @SuppressWarnings("unchecked")
    private float[][] parseEmbeddingResponse(Map<String, Object> responseBody) {
        List<List<Number>> embeddings = (List<List<Number>>) responseBody.get("embeddings");
        
        float[][] result = new float[embeddings.size()][];
        for (int i = 0; i < embeddings.size(); i++) {
            List<Number> embedding = embeddings.get(i);
            result[i] = new float[embedding.size()];
            for (int j = 0; j < embedding.size(); j++) {
                result[i][j] = embedding.get(j).floatValue();
            }
        }
        return result;
    }
    
    /**
     * 计算余弦相似度
     */
    public float cosineSimilarity(float[] a, float[] b) {
        if (a.length != b.length) {
            throw new IllegalArgumentException("向量维度不匹配");
        }
        
        float dotProduct = 0;
        float normA = 0;
        float normB = 0;
        
        for (int i = 0; i < a.length; i++) {
            dotProduct += a[i] * b[i];
            normA += a[i] * a[i];
            normB += b[i] * b[i];
        }
        
        return dotProduct / (float) (Math.sqrt(normA) * Math.sqrt(normB));
    }
}

三、向量空间的对齐验证

在正式使用多模态Embedding之前，建议做对齐验证，确认模型在你的场景下工作正常：

@Component
public class EmbeddingAlignmentValidator {
    
    private final MultimodalEmbeddingClient embeddingClient;
    
    /**
     * 验证图文对齐质量
     * 给定一批已知匹配的图文对，计算平均相似度
     */
    public AlignmentReport validateAlignment(List<ImageTextPair> matchedPairs,
                                              List<ImageTextPair> unmatchedPairs) {
        // 匹配对的平均相似度（应该高）
        double matchedAvgSimilarity = matchedPairs.stream()
            .mapToDouble(pair -> {
                float[] textEmb = embeddingClient.embedText(pair.text());
                float[] imageEmb = embeddingClient.embedImage(pair.imageBytes());
                return embeddingClient.cosineSimilarity(textEmb, imageEmb);
            })
            .average()
            .orElse(0);
        
        // 不匹配对的平均相似度（应该低）
        double unmatchedAvgSimilarity = unmatchedPairs.stream()
            .mapToDouble(pair -> {
                float[] textEmb = embeddingClient.embedText(pair.text());
                float[] imageEmb = embeddingClient.embedImage(pair.imageBytes());
                return embeddingClient.cosineSimilarity(textEmb, imageEmb);
            })
            .average()
            .orElse(0);
        
        double separationGap = matchedAvgSimilarity - unmatchedAvgSimilarity;
        boolean alignmentGood = separationGap > 0.2; // 分离度>0.2认为对齐良好
        
        return new AlignmentReport(matchedAvgSimilarity, unmatchedAvgSimilarity, 
            separationGap, alignmentGood);
    }
    
    public record AlignmentReport(
        double matchedSimilarity, 
        double unmatchedSimilarity,
        double separationGap,
        boolean isAlignmentGood
    ) {
        @Override
        public String toString() {
            return String.format(
                "对齐报告: 匹配对相似度=%.3f, 不匹配对相似度=%.3f, 分离度=%.3f, 质量=%s",
                matchedSimilarity, unmatchedSimilarity, separationGap,
                isAlignmentGood ? "良好" : "需要改进");
        }
    }
    
    public record ImageTextPair(byte[] imageBytes, String text) {}
}

四、混合向量检索的工程实现

有了多模态向量，下一步是在Milvus里做高效检索：

@Service
public class MultimodalVectorStore {
    
    private final MilvusServiceClient milvusClient;
    private final MultimodalEmbeddingClient embeddingClient;
    
    private static final String COLLECTION_NAME = "multimodal_items";
    private static final int VECTOR_DIM = 768; // BGE-Visualized的维度
    
    /**
     * 创建多模态向量集合
     */
    public void createCollection() {
        // 字段定义
        List<FieldType> fields = List.of(
            FieldType.newBuilder().withName("id").withDataType(DataType.Int64).withPrimaryKey(true).withAutoID(true).build(),
            FieldType.newBuilder().withName("content_type").withDataType(DataType.VarChar).withMaxLength(20).build(),
            FieldType.newBuilder().withName("text_content").withDataType(DataType.VarChar).withMaxLength(5000).build(),
            FieldType.newBuilder().withName("image_url").withDataType(DataType.VarChar).withMaxLength(500).build(),
            FieldType.newBuilder().withName("embedding").withDataType(DataType.FloatVector).withDimension(VECTOR_DIM).build()
        );
        
        CreateCollectionParam createParam = CreateCollectionParam.newBuilder()
            .withCollectionName(COLLECTION_NAME)
            .withFieldTypes(fields)
            .build();
        
        milvusClient.createCollection(createParam);
        
        // 创建索引（IVF_FLAT适合中等规模，超大规模可用HNSW）
        CreateIndexParam indexParam = CreateIndexParam.newBuilder()
            .withCollectionName(COLLECTION_NAME)
            .withFieldName("embedding")
            .withIndexType(IndexType.IVF_FLAT)
            .withMetricType(MetricType.COSINE)
            .withExtraParam("{\"nlist\": 128}")
            .build();
        
        milvusClient.createIndex(indexParam);
    }
    
    /**
     * 插入文字内容
     */
    public void insertText(String textContent) {
        float[] embedding = embeddingClient.embedText(textContent);
        insertItem("text", textContent, null, embedding);
    }
    
    /**
     * 插入图片内容
     */
    public void insertImage(byte[] imageBytes, String imageUrl) {
        float[] embedding = embeddingClient.embedImage(imageBytes);
        insertItem("image", null, imageUrl, embedding);
    }
    
    /**
     * 跨模态搜索：用文字搜图片
     */
    public List<SearchResult> searchImagesByText(String queryText, int topK) {
        float[] queryEmbedding = embeddingClient.embedText(queryText);
        return search(queryEmbedding, topK, "content_type == \"image\"");
    }
    
    /**
     * 跨模态搜索：用图片搜文字
     */
    public List<SearchResult> searchTextsByImage(byte[] queryImage, int topK) {
        float[] queryEmbedding = embeddingClient.embedImage(queryImage);
        return search(queryEmbedding, topK, "content_type == \"text\"");
    }
    
    /**
     * 同模态搜索：用图片搜相似图片
     */
    public List<SearchResult> searchSimilarImages(byte[] queryImage, int topK) {
        float[] queryEmbedding = embeddingClient.embedImage(queryImage);
        return search(queryEmbedding, topK, "content_type == \"image\"");
    }
    
    private List<SearchResult> search(float[] queryEmbedding, int topK, String filter) {
        SearchParam searchParam = SearchParam.newBuilder()
            .withCollectionName(COLLECTION_NAME)
            .withMetricType(MetricType.COSINE)
            .withFloatVectors(List.of(queryEmbedding))
            .withTopK(topK)
            .withExpr(filter)
            .withOutFields(List.of("content_type", "text_content", "image_url"))
            .withParams("{\"nprobe\": 10}")
            .build();
        
        R<SearchResults> searchResult = milvusClient.search(searchParam);
        
        // 解析结果...
        return parseSearchResults(searchResult.getData());
    }
    
    private void insertItem(String contentType, String textContent, 
                             String imageUrl, float[] embedding) {
        InsertParam insertParam = InsertParam.newBuilder()
            .withCollectionName(COLLECTION_NAME)
            .withFields(List.of(
                InsertParam.Field.newBuilder().withName("content_type")
                    .withDataType(DataType.VarChar).withValues(List.of(contentType)).build(),
                InsertParam.Field.newBuilder().withName("text_content")
                    .withDataType(DataType.VarChar)
                    .withValues(List.of(textContent != null ? textContent : "")).build(),
                InsertParam.Field.newBuilder().withName("image_url")
                    .withDataType(DataType.VarChar)
                    .withValues(List.of(imageUrl != null ? imageUrl : "")).build(),
                InsertParam.Field.newBuilder().withName("embedding")
                    .withDataType(DataType.FloatVector).withValues(List.of(embedding)).build()
            ))
            .build();
        
        milvusClient.insert(insertParam);
    }
    
    private List<SearchResult> parseSearchResults(SearchResults rawResults) {
        // 省略具体解析逻辑
        return List.of();
    }
    
    public record SearchResult(String contentType, String textContent, 
                               String imageUrl, float score) {}
}

五、工程经验：向量维度和精度的权衡

维度选择的实际影响

在我们做过的测试里：

  • 768维模型（BGE-Visualized）：检索准确率最高，但存储成本是512维的1.5倍
  • 512维模型（CLIP-base）：检索准确率略低，但推理速度快30%，适合实时场景
  • 1024维模型（jina-clip-v2）：准确率最高，但推理速度慢，适合对准确率要求极高的离线处理

批量向量化的性能

单条处理 vs 批量处理的性能差异极大：

  • 单条：~100ms/条（包含HTTP通信开销）
  • 批量32条：~800ms（相当于25ms/条）

索引大量图片时，务必用批量接口，单条处理性能差了4倍。