JAVA 构建向量数据库客户端 Query 性能低？Milvus/PGVector 查询优化技巧

JAVA 构建向量数据库客户端 Query 性能低？Milvus/PGVector 查询优化技巧

大家好，今天我们来探讨一个在向量数据库应用开发中经常遇到的问题：使用 Java 构建客户端时，查询性能不佳。我们将聚焦于两个流行的向量数据库：Milvus 和 PGVector，分析可能的原因，并提供一系列优化技巧和代码示例，帮助大家提升查询效率。

1. 问题诊断：为什么 Java 客户端查询性能会下降？

在深入优化之前，我们需要了解可能导致性能瓶颈的常见因素。这些因素可能存在于 Java 客户端本身，也可能与数据库配置或数据结构有关。

• 数据规模和维度： 向量数据库查询的复杂性与数据规模（向量数量）和维度（每个向量的长度）直接相关。数据量越大，维度越高，计算量就越大，查询时间自然会增加。

• 索引选择和配置： 向量数据库依赖索引加速查询。选择合适的索引类型（如 IVF_FLAT, HNSW, ANNOY）并正确配置索引参数（如 nlist, nprobe）至关重要。错误的索引选择或配置可能导致查询效率低下。

• 距离度量方式： 向量数据库使用不同的距离度量方式（如 Euclidean, Inner Product, Cosine Similarity）来计算向量之间的相似度。不同的度量方式计算复杂度不同，对性能的影响也不同。

• 网络延迟： Java 客户端与数据库服务器之间的网络延迟会直接影响查询响应时间。尤其是跨地域部署时，网络延迟问题更加突出。

• 客户端资源限制： Java 客户端的 CPU、内存等资源限制可能成为性能瓶颈。如果客户端资源不足，无法快速处理查询结果，会导致整体查询效率下降。

• 数据类型和序列化： 向量数据的数据类型（如 Float, Binary）和序列化方式会影响数据传输和存储效率。不合理的数据类型或序列化方式可能导致性能下降。

• 分页和批量查询： 处理大量数据时，分页和批量查询策略的选择会影响性能。不合理的分页大小或批量查询方式可能导致频繁的网络请求和资源消耗。

• Java 代码效率： Java 客户端代码本身的效率也会影响查询性能。例如，不合理的循环、内存管理不当、不必要的对象创建等都可能导致性能下降。

2. Milvus 查询优化技巧

Milvus 作为一个高性能的向量数据库，提供了丰富的优化选项。下面我们针对上述问题，逐一介绍 Milvus 的优化技巧。

2.1 索引优化

索引是 Milvus 加速查询的关键。选择合适的索引类型，并根据数据分布和查询场景调整索引参数，可以显著提升查询性能。

索引类型	适用场景	优点	缺点
IVF_FLAT	数据分布均匀，对精度要求高，查询 QPS 要求高的场景	构建速度快，查询速度较快，占用空间小	需要预先划分聚类中心，查询精度受聚类中心数量影响，不适合高维数据。
IVF_SQ8	数据规模较大，对存储空间有要求的场景	压缩数据，节省存储空间，查询速度较快	查询精度略低于 IVF_FLAT，构建速度较慢。
HNSW	数据分布不均匀，对查询精度要求高的场景	查询精度高，查询速度快，适合高维数据	构建速度慢，占用空间大。
ANNOY	对查询精度要求不高，但对查询速度要求非常高的场景	查询速度非常快，适合大规模数据集	查询精度较低。
FLAT	适用于数据规模非常小，或者需要进行精确搜索的场景	无需构建索引，查询精度最高	查询速度慢，不适合大规模数据集。

代码示例：创建 HNSW 索引

import io.milvus.client.MilvusClient;
import io.milvus.client.MilvusServiceClient;
import io.milvus.grpc.DataType;
import io.milvus.grpc.IndexType;
import io.milvus.grpc.MetricType;
import io.milvus.param.IndexParam;
import io.milvus.param.MetricTypeParam;
import io.milvus.param.collection.CreateCollectionParam;
import io.milvus.param.collection.FieldType;
import io.milvus.param.index.CreateIndexParam;
import io.milvus.param.ConnectParam;

import java.util.Arrays;

public class MilvusIndexExample {

    public static void main(String[] args) throws Exception {
        // 1. 连接 Milvus 服务
        ConnectParam connectParam = ConnectParam.newBuilder()
                .withHost("localhost")
                .withPort(19530)
                .build();

        MilvusClient client = new MilvusServiceClient(connectParam);

        // 2. 定义 Collection 名称和字段
        String collectionName = "my_collection";

        FieldType fieldType1 = FieldType.newBuilder()
                .withName("id")
                .withDataType(DataType.INT64)
                .withPrimaryKey(true)
                .withAutoID(false)
                .build();

        FieldType fieldType2 = FieldType.newBuilder()
                .withName("embeddings")
                .withDataType(DataType.FLOAT_VECTOR)
                .withDimension(128)
                .build();

        CreateCollectionParam createCollectionParam = CreateCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .withFields(Arrays.asList(fieldType1, fieldType2))
                .build();

        // 创建 Collection
        client.createCollection(createCollectionParam);

        // 3. 创建 HNSW 索引
        IndexParam indexParam = IndexParam.newBuilder()
                .withIndexType(IndexType.HNSW)
                .withMetricType(MetricType.L2)  // L2 距离，适用于欧氏距离
                .withParams("{"M":16, "efConstruction":200}") // HNSW 参数，M 控制连接数，efConstruction 控制构建速度和精度
                .build();

        CreateIndexParam createIndexParam = CreateIndexParam.newBuilder()
                .withCollectionName(collectionName)
                .withFieldName("embeddings")
                .withIndexParam(indexParam)
                .build();

        // 创建索引
        client.createIndex(createIndexParam);

        // 确保索引已加载
        client.loadCollection(collectionName);

        System.out.println("HNSW index created successfully!");

        client.close();
    }
}

关键参数说明：

• M： 在 HNSW 算法中，每个节点的最大连接数。较大的 M 值可以提高查询精度，但也会增加内存消耗和构建时间。
• efConstruction： 构建索引时的搜索范围。较大的 efConstruction 值可以提高查询精度，但也会增加构建时间。
• nlist (IVF 索引)： 将向量划分为多少个桶。
• nprobe (IVF 索引)： 查询时搜索多少个桶。

优化建议：

• 根据实际数据分布和查询场景，选择合适的索引类型。
• 调整索引参数，平衡查询速度、精度和资源消耗。
• 定期监控查询性能，根据实际情况调整索引配置。

2.2 距离度量方式

不同的距离度量方式对性能的影响不同。一般来说，Inner Product 的计算速度比 Euclidean 快，Cosine Similarity 的计算速度介于两者之间。

代码示例：使用 Inner Product 作为距离度量

import io.milvus.client.MilvusClient;
import io.milvus.client.MilvusServiceClient;
import io.milvus.grpc.DataType;
import io.milvus.grpc.IndexType;
import io.milvus.grpc.MetricType;
import io.milvus.param.IndexParam;
import io.milvus.param.MetricTypeParam;
import io.milvus.param.collection.CreateCollectionParam;
import io.milvus.param.collection.FieldType;
import io.milvus.param.index.CreateIndexParam;
import io.milvus.param.ConnectParam;

import java.util.Arrays;

public class MilvusInnerProductExample {

    public static void main(String[] args) throws Exception {
        // 1. 连接 Milvus 服务
        ConnectParam connectParam = ConnectParam.newBuilder()
                .withHost("localhost")
                .withPort(19530)
                .build();

        MilvusClient client = new MilvusServiceClient(connectParam);

        // 2. 定义 Collection 名称和字段
        String collectionName = "my_collection_ip";

        FieldType fieldType1 = FieldType.newBuilder()
                .withName("id")
                .withDataType(DataType.INT64)
                .withPrimaryKey(true)
                .withAutoID(false)
                .build();

        FieldType fieldType2 = FieldType.newBuilder()
                .withName("embeddings")
                .withDataType(DataType.FLOAT_VECTOR)
                .withDimension(128)
                .build();

        CreateCollectionParam createCollectionParam = CreateCollectionParam.newBuilder()
                .withCollectionName(collectionName)
                .withFields(Arrays.asList(fieldType1, fieldType2))
                .build();

        // 创建 Collection
        client.createCollection(createCollectionParam);

        // 3. 创建 HNSW 索引，使用 Inner Product
        IndexParam indexParam = IndexParam.newBuilder()
                .withIndexType(IndexType.HNSW)
                .withMetricType(MetricType.IP)  // 使用 Inner Product
                .withParams("{"M":16, "efConstruction":200}") // HNSW 参数
                .build();

        CreateIndexParam createIndexParam = CreateIndexParam.newBuilder()
                .withCollectionName(collectionName)
                .withFieldName("embeddings")
                .withIndexParam(indexParam)
                .build();

        // 创建索引
        client.createIndex(createIndexParam);

        // 确保索引已加载
        client.loadCollection(collectionName);

        System.out.println("HNSW index with Inner Product created successfully!");

        client.close();
    }
}

优化建议：

• 根据实际需求选择合适的距离度量方式。如果对精度要求不高，可以考虑使用 Inner Product。

2.3 查询参数优化

Milvus 提供了 nq 和 ef 参数来控制查询行为。nq 表示查询向量的数量，ef 表示查询时的搜索范围。

代码示例：调整 nq 和 ef 参数

import io.milvus.client.MilvusClient;
import io.milvus.client.MilvusServiceClient;
import io.milvus.param.ConnectParam;
import io.milvus.param.SearchParam;
import io.milvus.param.VectorParam;

import java.util.ArrayList;
import java.util.List;

public class MilvusSearchExample {

    public static void main(String[] args) throws Exception {
        // 1. 连接 Milvus 服务
        ConnectParam connectParam = ConnectParam.newBuilder()
                .withHost("localhost")
                .withPort(19530)
                .build();

        MilvusClient client = new MilvusServiceClient(connectParam);

        // 2. 定义 Collection 名称和查询向量
        String collectionName = "my_collection";
        List<Float> queryVector = new ArrayList<>();
        for (int i = 0; i < 128; i++) {
            queryVector.add(0.5f);
        }
        List<List<Float>> queryVectors = new ArrayList<>();
        queryVectors.add(queryVector);

        // 3. 构建 SearchParam
        SearchParam searchParam = SearchParam.newBuilder()
                .withCollectionName(collectionName)
                .withVectors(queryVectors)
                .withTopK(10)
                .withParams("{"ef":128}")  // 调整 ef 参数
                .build();

        VectorParam vectorParam = VectorParam.newBuilder()
                .withFieldName("embeddings")
                .withVectors(queryVectors)
                .build();

        // 执行查询
        client.search(searchParam,vectorParam);

        System.out.println("Search completed!");

        client.close();
    }
}

优化建议：

• 增加 ef 值可以提高查询精度，但也会增加查询时间。
• 合理设置 nq 值，平衡查询速度和资源消耗。

2.4 数据类型和序列化

Milvus 支持 Float 和 Binary 两种向量数据类型。Float 类型适用于一般场景，Binary 类型适用于需要节省存储空间的场景。

优化建议：

• 根据实际需求选择合适的数据类型。如果对存储空间有要求，可以考虑使用 Binary 类型。
• 使用高效的序列化方式，减少数据传输和存储开销。

3. PGVector 查询优化技巧

PGVector 是 PostgreSQL 的一个扩展，用于存储和查询向量数据。与 Milvus 相比，PGVector 更加轻量级，易于集成到现有的 PostgreSQL 应用中。

3.1 索引优化

PGVector 支持多种索引类型，包括 IVF 和 HNSW。与 Milvus 类似，选择合适的索引类型并正确配置索引参数可以显著提升查询性能。

代码示例：创建 HNSW 索引

-- 创建扩展
CREATE EXTENSION vector;

-- 创建表
CREATE TABLE embeddings (
    id bigserial PRIMARY KEY,
    embedding vector(128)  -- 向量维度为 128
);

-- 创建 HNSW 索引
CREATE INDEX ON embeddings
USING hnsw (embedding vector_cosine_ops)  -- 使用 cosine 距离度量
WITH (m = 16, ef_construction = 200);   -- HNSW 参数

关键参数说明：

• m： 在 HNSW 算法中，每个节点的最大连接数。
• ef_construction： 构建索引时的搜索范围。

优化建议：

• 根据实际数据分布和查询场景，选择合适的索引类型。
• 调整索引参数，平衡查询速度、精度和资源消耗。

3.2 距离度量方式

PGVector 支持多种距离度量方式，包括 Euclidean, Inner Product 和 Cosine Similarity。

代码示例：使用 Cosine Similarity 作为距离度量

SELECT id, 1 - (embedding <=> '[0.5, 0.5, ..., 0.5]'::vector(128)) AS similarity  -- 使用 cosine 距离度量
FROM embeddings
ORDER BY embedding <=> '[0.5, 0.5, ..., 0.5]'::vector(128)
LIMIT 10;

优化建议：

• 根据实际需求选择合适的距离度量方式。

3.3 查询优化

PGVector 的查询优化主要集中在 SQL 语句的编写上。合理使用索引、避免全表扫描、优化查询条件可以提升查询性能。

代码示例：使用索引进行查询

-- 使用索引进行查询
SELECT id, 1 - (embedding <=> '[0.5, 0.5, ..., 0.5]'::vector(128)) AS similarity
FROM embeddings
WHERE embedding <=> '[0.5, 0.5, ..., 0.5]'::vector(128) < 0.1  -- 添加查询条件，缩小搜索范围
ORDER BY embedding <=> '[0.5, 0.5, ..., 0.5]'::vector(128)
LIMIT 10;

优化建议：

• 尽量使用索引字段进行查询。
• 添加查询条件，缩小搜索范围。
• 避免在 ORDER BY 子句中使用非索引字段。

4. Java 客户端优化

除了数据库本身的优化，Java 客户端的优化也至关重要。

4.1 连接池

使用连接池可以避免频繁创建和销毁数据库连接，减少资源消耗，提升查询性能。

代码示例：使用 HikariCP 连接池

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class PGVectorConnectionPoolExample {

    private static HikariDataSource dataSource;

    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost:5432/mydatabase");
        config.setUsername("myuser");
        config.setPassword("mypassword");
        config.setMaximumPoolSize(10);  // 设置连接池大小

        dataSource = new HikariDataSource(config);
    }

    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    public static void main(String[] args) {
        try (Connection connection = getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement("SELECT id FROM embeddings LIMIT 10");
             ResultSet resultSet = preparedStatement.executeQuery()) {

            while (resultSet.next()) {
                System.out.println("ID: " + resultSet.getLong("id"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

优化建议：

• 选择合适的连接池实现，如 HikariCP, Apache Commons DBCP 等。
• 根据实际需求调整连接池大小。

4.2 批量查询

对于需要查询多个向量的场景，可以使用批量查询来减少网络请求次数，提升查询效率。

代码示例：使用批量查询

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class PGVectorBatchQueryExample {

    public static void main(String[] args) {
        List<float[]> queryVectors = new ArrayList<>();
        // 假设我们有多个查询向量需要执行
        for (int i = 0; i < 5; i++) {
            float[] vector = new float[128];
            for (int j = 0; j < 128; j++) {
                vector[j] = 0.5f;
            }
            queryVectors.add(vector);
        }

        try (Connection connection = PGVectorConnectionPoolExample.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement("SELECT id, 1 - (embedding <=> ?) AS similarity FROM embeddings ORDER BY embedding <=> ? LIMIT 10")) {

            for (float[] vector : queryVectors) {
                // 将 float 数组转换为字符串形式的向量
                StringBuilder vectorString = new StringBuilder("[");
                for (int i = 0; i < vector.length; i++) {
                    vectorString.append(vector[i]);
                    if (i < vector.length - 1) {
                        vectorString.append(",");
                    }
                }
                vectorString.append("]");

                // 设置 PreparedStatement 的参数
                preparedStatement.setString(1, vectorString.toString());
                preparedStatement.setString(2, vectorString.toString());

                try (ResultSet resultSet = preparedStatement.executeQuery()) {
                    while (resultSet.next()) {
                        System.out.println("ID: " + resultSet.getLong("id") + ", Similarity: " + resultSet.getDouble("similarity"));
                    }
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

优化建议：

• 合理设置批量查询的大小，平衡查询速度和资源消耗。
• 使用 PreparedStatement 避免 SQL 注入风险。

4.3 异步查询

对于耗时较长的查询，可以使用异步查询来避免阻塞主线程，提升用户体验。

代码示例：使用 CompletableFuture 进行异步查询

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PGVectorAsyncQueryExample {

    private static final ExecutorService executor = Executors.newFixedThreadPool(10); // 创建一个线程池

    public static CompletableFuture<Void> executeQueryAsync(float[] queryVector) {
        return CompletableFuture.runAsync(() -> {
            try (Connection connection = PGVectorConnectionPoolExample.getConnection();
                 PreparedStatement preparedStatement = connection.prepareStatement("SELECT id, 1 - (embedding <=> ?) AS similarity FROM embeddings ORDER BY embedding <=> ? LIMIT 10")) {

                // 将 float 数组转换为字符串形式的向量
                StringBuilder vectorString = new StringBuilder("[");
                for (int i = 0; i < queryVector.length; i++) {
                    vectorString.append(queryVector[i]);
                    if (i < queryVector.length - 1) {
                        vectorString.append(",");
                    }
                }
                vectorString.append("]");

                // 设置 PreparedStatement 的参数
                preparedStatement.setString(1, vectorString.toString());
                preparedStatement.setString(2, vectorString.toString());

                try (ResultSet resultSet = preparedStatement.executeQuery()) {
                    while (resultSet.next()) {
                        System.out.println("ID: " + resultSet.getLong("id") + ", Similarity: " + resultSet.getDouble("similarity"));
                    }
                }

            } catch (SQLException e) {
                e.printStackTrace();
            }
        }, executor);
    }

    public static void main(String[] args) {
        float[] queryVector = new float[128];
        for (int i = 0; i < 128; i++) {
            queryVector[i] = 0.5f;
        }

        CompletableFuture<Void> future = executeQueryAsync(queryVector);

        // 在这里可以做其他事情，而不用等待查询完成
        System.out.println("Query submitted, processing in background...");

        // 等待查询完成
        future.join();

        System.out.println("Query completed.");

        // 关闭线程池
        executor.shutdown();
    }
}

优化建议：

• 使用线程池管理异步任务。
• 合理设置线程池大小。

5. 监控和调优

性能优化是一个持续的过程。我们需要定期监控查询性能，并根据实际情况调整配置。

• 监控指标： 查询响应时间、QPS、CPU 使用率、内存使用率等。
• 监控工具： Milvus Insight, PostgreSQL Performance Monitoring Tools, Java Profilers 等。

通过监控这些指标，我们可以及时发现性能瓶颈，并采取相应的优化措施。

性能提升的一些想法

这篇文章涵盖了向量数据库查询优化的各个方面，从数据库配置到 Java 客户端代码，提供了详细的指导和代码示例。希望这些技巧能帮助大家提升向量数据库应用的查询性能。

优化查询，提升效率

本文主要探讨了 Java 客户端构建向量数据库，如果使用Milvus和PGVector时，query性能低下的优化技巧，希望对大家有所帮助。