JAVA 构建向量检索服务如何做分页？基于 Score 的游标分页方案

基于 Score 的游标分页构建 Java 向量检索服务

大家好，今天我们来探讨一下如何构建一个具备分页功能的 Java 向量检索服务，并且重点介绍一种基于 Score 的游标分页方案。

一、向量检索服务的基本架构

在深入分页之前，我们先快速回顾一个典型的向量检索服务架构。 一个简单的向量检索服务通常包含以下几个关键组件：

• 向量索引: 用于存储和高效检索向量数据。常用的向量索引技术包括 HNSW、Faiss 等。
• 向量数据库: 持久化存储向量数据，例如 Milvus、Pinecone，或者关系型数据库/NoSQL 数据库（需要进行向量数据格式转换）。
• API 接口: 提供向量检索的入口，接收查询向量，返回检索结果。
• 相似度计算: 定义向量之间的相似度度量方法，例如余弦相似度、欧氏距离等。

二、传统分页方案的局限性

传统的分页方式通常是基于 OFFSET 和 LIMIT。例如，查询第 2 页，每页 10 条数据，SQL 可能是：

SELECT * FROM vectors ORDER BY score DESC LIMIT 10 OFFSET 10;

这种方式在向量检索场景下存在一些问题：

• 性能问题: 当 OFFSET 值很大时，数据库需要扫描大量数据才能跳到目标位置，导致性能急剧下降。
• 数据一致性问题: 在高并发场景下，如果数据在分页过程中发生变化，可能会导致分页结果出现重复或遗漏。

三、基于 Score 的游标分页方案

基于 Score 的游标分页是一种更适合向量检索场景的分页方案。其核心思想是利用上一页的最后一个结果的 score 作为游标，作为下一页查询的条件。

1. 游标的定义: 游标实际上就是上一次检索结果集中最后一个向量的相似度得分 (score)。

2. 查询逻辑: 查询下一页时，使用 score 作为条件，只检索 score 小于等于上一次游标值的向量。

3. 优点:

• 性能更佳: 避免了 OFFSET 带来的全表扫描问题，查询效率更高。
• 数据一致性更好: 减少了由于数据变化导致的分页数据重复或遗漏的可能性。

4. 缺点:

• 不适合随机访问: 只能按顺序一页一页地翻页，不支持直接跳转到指定页数。
• 需要保证 Score 的唯一性: 如果多个向量具有相同的 score，可能会导致分页结果出现重复。 解决方法是 score 相同时按照其他唯一字段排序，例如 ID。

四、Java 代码实现

下面我们用 Java 代码演示如何实现基于 Score 的游标分页。

1. 数据模型:

import lombok.Data;

@Data
public class VectorResult {
    private String id; // 向量的唯一标识
    private float[] vector; // 向量数据
    private double score; // 相似度得分
    private String metadata; // 其他元数据
}

2. 向量检索接口:

import java.util.List;

public interface VectorSearchService {
    /**
     * 向量检索
     *
     * @param queryVector 查询向量
     * @param pageSize    每页大小
     * @param lastScore   上一页最后一个结果的 score，首次查询传 null
     * @return 分页结果
     */
    PageResult<VectorResult> search(float[] queryVector, int pageSize, Double lastScore);
}

3. 分页结果类:

import lombok.Data;
import java.util.List;

@Data
public class PageResult<T> {
    private List<T> data; // 当前页的数据
    private Double nextCursor; // 下一页的游标，如果没有下一页则为 null
}

4. 向量检索服务实现 (伪代码):

这里我们使用伪代码模拟向量检索的逻辑。实际实现需要根据你选择的向量数据库或索引库进行调整。

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class VectorSearchServiceImpl implements VectorSearchService {

    // 假设这里有一个向量数据库 client
    // private VectorDatabaseClient client;

    @Override
    public PageResult<VectorResult> search(float[] queryVector, int pageSize, Double lastScore) {

        // 1. 构建查询条件
        // 假设向量数据存储在 List<VectorResult> allVectors 中
        List<VectorResult> allVectors = loadAllVectors(); // 从数据库加载所有向量数据
        List<VectorResult> filteredVectors;

        // 模拟过滤掉 score 大于等于 lastScore 的向量
        if (lastScore != null) {
            filteredVectors = allVectors.stream()
                    .filter(v -> v.getScore() <= lastScore)
                    .collect(Collectors.toList());
        } else {
            filteredVectors = new ArrayList<>(allVectors);
        }

        // 2. 计算相似度 (这里使用伪代码)
        for (VectorResult vectorResult : filteredVectors) {
            double score = calculateSimilarity(queryVector, vectorResult.getVector());
            vectorResult.setScore(score);
        }

        // 3. 排序 (降序)
        filteredVectors.sort(Comparator.comparing(VectorResult::getScore).reversed().thenComparing(VectorResult::getId)); // score 降序， id 升序

        // 4. 分页
        int startIndex = 0;
        int endIndex = Math.min(pageSize, filteredVectors.size());
        List<VectorResult> pageData = filteredVectors.subList(startIndex, endIndex);

        // 5. 构建分页结果
        PageResult<VectorResult> pageResult = new PageResult<>();
        pageResult.setData(pageData);

        // 6. 设置下一页的游标
        if (filteredVectors.size() > pageSize) {
            // 还有下一页
            pageResult.setNextCursor(pageData.get(pageData.size() - 1).getScore());
        } else {
            pageResult.setNextCursor(null); // 没有下一页
        }

        return pageResult;
    }

    private double calculateSimilarity(float[] vector1, float[] vector2) {
        // 伪代码：计算向量相似度，例如余弦相似度
        double dotProduct = 0.0;
        double magnitude1 = 0.0;
        double magnitude2 = 0.0;
        for (int i = 0; i < vector1.length; i++) {
            dotProduct += vector1[i] * vector2[i];
            magnitude1 += Math.pow(vector1[i], 2);
            magnitude2 += Math.pow(vector2[i], 2);
        }
        magnitude1 = Math.sqrt(magnitude1);
        magnitude2 = Math.sqrt(magnitude2);
        if (magnitude1 == 0 || magnitude2 == 0) {
            return 0.0;
        }
        return dotProduct / (magnitude1 * magnitude2);
    }

    private List<VectorResult> loadAllVectors() {
        // 伪代码：从数据库加载所有向量数据
        List<VectorResult> vectors = new ArrayList<>();

        // 模拟数据
        for (int i = 0; i < 25; i++) {
            VectorResult vectorResult = new VectorResult();
            vectorResult.setId("vector_" + i);
            float[] vector = new float[128]; // 假设向量维度是 128
            for (int j = 0; j < 128; j++) {
                vector[j] = (float) Math.random();
            }
            vectorResult.setVector(vector);
            vectorResult.setScore(Math.random()); // 初始score随机生成，用于后续检索
            vectors.add(vectorResult);
        }

        return vectors;
    }
}

5. API 接口示例:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class VectorSearchController {

    @Autowired
    private VectorSearchService vectorSearchService;

    @GetMapping("/search")
    public PageResult<VectorResult> search(
            @RequestParam("queryVector") float[] queryVector,
            @RequestParam("pageSize") int pageSize,
            @RequestParam(value = "lastScore", required = false) Double lastScore) {
        return vectorSearchService.search(queryVector, pageSize, lastScore);
    }
}

6. 使用示例:

首次查询：

GET /search?queryVector=[...]&pageSize=10

获取下一页：

GET /search?queryVector=[...]&pageSize=10&lastScore=0.85

五、选择合适的向量数据库或索引库

选择合适的向量数据库或索引库对向量检索服务的性能至关重要。以下是一些常见的选择和它们的特点：

技术栈	优点	缺点
Milvus	开源、高性能、支持多种相似度度量、易于扩展、云原生	部署和维护相对复杂
Pinecone	托管服务、易于使用、自动扩容、高性能	成本较高、 vendor lock-in
Faiss	Facebook 开源、高性能、支持多种索引类型、适用于大规模数据集	需要自己管理和维护、需要编写大量代码
Elasticsearch	适用于混合搜索 (文本 + 向量)、成熟的生态系统、易于使用	向量检索性能不如专业的向量数据库、不适合纯向量检索场景
Qdrant	开源、云原生、支持结构化和非结构化数据、支持多种距离度量	相对较新，社区规模较小

选择时需要综合考虑性能、成本、易用性、可扩展性等因素。

六、优化策略

为了进一步提升向量检索服务的性能，可以考虑以下优化策略：

• 选择合适的索引类型: 不同的索引类型适用于不同的数据集和查询场景。例如，HNSW 适合高维向量，IVF 适合大规模数据集。
• 参数调优: 调整索引和查询参数，例如 efConstruction 和 efSearch，可以提高检索精度和速度。
• 量化: 使用量化技术，例如 PQ (Product Quantization) 和 Scalar Quantization，可以减少向量的存储空间和计算量。
• 缓存: 缓存热门查询结果，可以减少数据库的压力。
• 异步处理: 对于非实时性要求高的查询，可以使用异步方式处理。
• 负载均衡: 使用负载均衡器将请求分发到多个服务器，提高服务的可用性和吞吐量。
• 监控和告警: 建立完善的监控和告警机制，及时发现和解决问题。

七、保证 Score 的唯一性

如果向量的 score 值存在重复，那么基于 score 的游标分页可能会出现问题，即同一页的数据可能重复出现。为了避免这个问题，我们需要保证 score 的唯一性。常见的解决方案是在 score 相同时，按照其他字段进行排序，例如 ID。

在上面的 VectorSearchServiceImpl 代码中，我们已经使用了 thenComparing(VectorResult::getId) 来保证 score 相同时，按照 ID 进行排序。这样可以确保分页结果的正确性。

八、总结，让检索更有效率

我们讨论了如何构建一个具备分页功能的 Java 向量检索服务，并重点介绍了基于 Score 的游标分页方案。这种方案可以有效地解决传统分页方案的性能问题和数据一致性问题。同时，我们也探讨了如何选择合适的向量数据库或索引库，以及如何优化向量检索服务的性能。选择合适的索引类型、参数调优、量化、缓存等技术都可以显著提高检索效率。