feat: add diskann index (#369)

This commit is contained in:
rayx
2026-06-04 20:52:43 +08:00
committed by GitHub
parent c46efe1241
commit e720c1fd20
104 changed files with 13913 additions and 232 deletions
+10 -2
View File
@@ -8,6 +8,14 @@ cc_directories(ivf)
cc_directories(hnsw)
cc_directories(hnsw_sparse)
cc_directories(vamana)
if(RABITQ_SUPPORTED)
cc_directories(hnsw_rabitq)
if(DISKANN_SUPPORTED)
message(STATUS "build diskann tests")
cc_directory(diskann)
else()
message(STATUS "skip diskann tests (unsupported platform)")
endif()
if(RABITQ_SUPPORTED)
cc_directories(hnsw_rabitq)
endif()
@@ -52,8 +52,8 @@ TEST(KmeansCluster, General) {
ASSERT_TRUE(!!cluster);
zvec::ailego::Params params;
params.set("proxima.general.cluster.count", 1);
params.set("proxima.kmeans.cluster.count", 56);
params.set("zvec.general.cluster.count", 1);
params.set("zvec.kmeans.cluster.count", 56);
ASSERT_EQ(0, cluster->init(index_meta, params));
ASSERT_EQ(0, cluster->mount(features));
@@ -0,0 +1,221 @@
// Copyright 2025-present the zvec project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "cluster/multi_chunk_cluster.h"
#include <cmath>
#include <random>
#include <ailego/algorithm/kmeans.h>
#include <gtest/gtest.h>
#include <zvec/ailego/container/params.h>
#include "zvec/core/framework/index_framework.h"
using namespace zvec::core;
using namespace zvec::ailego;
using namespace zvec::ailego;
TEST(MultiChunkCluster, General) {
const uint32_t count = 10000u;
const uint32_t dimension = 960u;
const uint32_t chunk_count = 480u;
const uint32_t cluster_count = 256u;
// const uint32_t thread_count = 4;
const uint32_t thread_count = 16;
IndexMeta index_meta;
index_meta.set_meta(IndexMeta::DataType::DT_FP32, dimension);
index_meta.set_metric("SquaredEuclidean", 0, Params());
std::shared_ptr<CompactIndexFeatures> features(
new CompactIndexFeatures(index_meta));
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<float> dist(0.0, 5.0);
for (uint32_t i = 0; i < count; ++i) {
std::vector<float> vec(dimension);
for (size_t j = 0; j < dimension; ++j) {
vec[j] = dist(gen);
}
features->emplace(vec.data());
}
// Create a Kmeans cluster
MultiChunkCluster cluster = MultiChunkCluster();
Params params;
params.set("zvec.cluster.multi_chunk_cluster.count", cluster_count);
params.set("zvec.cluster.multi_chunk_cluster.chunk_count", chunk_count);
params.set("zvec.cluster.multi_chunk_cluster.thread_count", thread_count);
ASSERT_EQ(0, cluster.init(index_meta, params));
ASSERT_EQ(0, cluster.mount(features));
IndexCluster::CentroidList centroids;
std::vector<uint32_t> labels;
ASSERT_EQ(0, cluster.cluster(nullptr, centroids));
for (size_t chunk = 0; chunk < chunk_count; ++chunk) {
for (size_t cluster = 0; cluster < cluster_count; ++cluster) {
size_t idx = chunk * cluster_count + cluster;
const auto &cent = centroids[idx];
const auto &vec = cent.vector<float>();
std::cout << "chunk: " << chunk << ", cluster: " << cluster
<< ", dim: " << vec.size() << ", count: " << cent.follows()
<< " (" << cent.score() << ") { " << vec[0] << "," << vec[1]
<< " }" << std::endl;
ASSERT_EQ(0u, cent.similars().size());
}
}
ASSERT_EQ(0, cluster.label(nullptr, centroids, &labels));
}
TEST(MultiChunkCluster, TestChunk) {
const uint32_t count = 10000u;
const uint32_t dimension = 95;
const uint32_t chunk_count = 20u;
const uint32_t cluster_count = 256u;
// const uint32_t thread_count = 4;
const uint32_t thread_count = 16;
IndexMeta index_meta;
index_meta.set_meta(IndexMeta::DataType::DT_FP32, dimension);
index_meta.set_metric("SquaredEuclidean", 0, Params());
std::shared_ptr<CompactIndexFeatures> features(
new CompactIndexFeatures(index_meta));
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<float> dist(0.0, 5.0);
for (uint32_t i = 0; i < count; ++i) {
std::vector<float> vec(dimension);
for (size_t j = 0; j < dimension; ++j) {
vec[j] = dist(gen);
}
features->emplace(vec.data());
}
// Create a Kmeans cluster
MultiChunkCluster cluster = MultiChunkCluster();
Params params;
params.set("zvec.cluster.multi_chunk_cluster.count", cluster_count);
params.set("zvec.cluster.multi_chunk_cluster.chunk_count", chunk_count);
params.set("zvec.cluster.multi_chunk_cluster.thread_count", thread_count);
ASSERT_EQ(0, cluster.init(index_meta, params));
ASSERT_EQ(0, cluster.mount(features));
IndexCluster::CentroidList centroids;
std::vector<uint32_t> labels;
ASSERT_EQ(0, cluster.cluster(nullptr, centroids));
for (size_t chunk = 0; chunk < chunk_count; ++chunk) {
for (size_t cluster = 0; cluster < cluster_count; ++cluster) {
size_t idx = chunk * cluster_count + cluster;
const auto &cent = centroids[idx];
const auto &vec = cent.vector<float>();
std::cout << "chunk: " << chunk << ", cluster: " << cluster
<< ", dim: " << vec.size() << ", count: " << cent.follows()
<< " (" << cent.score() << ") { " << vec[0] << "," << vec[1]
<< " }" << std::endl;
ASSERT_EQ(0u, cent.similars().size());
}
}
ASSERT_EQ(0, cluster.label(nullptr, centroids, &labels));
}
TEST(MultiChunkCluster, General_InnerProduct) {
const uint32_t count = 50000u;
const uint32_t dimension = 96u;
const uint32_t chunk_count = 12u;
const uint32_t cluster_count = 16u;
const uint32_t chain_length = 0;
const uint32_t thread_count = 16;
IndexMeta index_meta;
index_meta.set_meta(IndexMeta::DataType::DT_FP32, dimension);
index_meta.set_metric("InnerProduct", 0, Params());
std::shared_ptr<CompactIndexFeatures> features(
new CompactIndexFeatures(index_meta));
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<float> dist(-1.0, 1.0);
// do normalize
for (uint32_t i = 0; i < count; ++i) {
std::vector<float> vec(dimension);
float norm = 0;
for (size_t j = 0; j < dimension; ++j) {
vec[j] = dist(gen);
norm += vec[j] * vec[j];
}
norm = sqrt(norm);
for (size_t j = 0; j < dimension; ++j) {
vec[j] /= norm;
}
features->emplace(vec.data());
}
// Create a Kmeans cluster
MultiChunkCluster cluster = MultiChunkCluster();
Params params;
params.set("zvec.cluster.multi_chunk_cluster.count", cluster_count);
params.set("zvec.cluster.multi_chunk_cluster.chunk_count", chunk_count);
params.set("zvec.cluster.multi_chunk_cluster.thread_count", thread_count);
params.set("zvec.cluster.multi_chunk_cluster.markov_chain_length",
chain_length);
ASSERT_EQ(0, cluster.init(index_meta, params));
ASSERT_EQ(0, cluster.mount(features));
IndexCluster::CentroidList centroids;
std::vector<uint32_t> labels;
ASSERT_EQ(0, cluster.cluster(nullptr, centroids));
for (size_t chunk = 0; chunk < chunk_count; ++chunk) {
for (size_t cluster = 0; cluster < cluster_count; ++cluster) {
size_t idx = chunk * cluster_count + cluster;
const auto &cent = centroids[idx];
const auto &vec = cent.vector<float>();
std::cout << "chunk: " << chunk << ", cluster: " << cluster
<< ", dim: " << vec.size() << ", count: " << cent.follows()
<< " (" << cent.score() << ") { " << vec[0] << ", " << vec[1]
<< ", " << vec[2] << ", ... , " << vec[vec.size() - 2] << ", "
<< vec[vec.size() - 1] << " }" << std::endl;
ASSERT_EQ(0u, cent.similars().size());
}
}
ASSERT_EQ(0, cluster.label(nullptr, centroids, &labels));
}
@@ -52,8 +52,8 @@ TEST(OptKmeansCluster, General) {
ASSERT_TRUE(!!cluster);
Params params;
params.set("proxima.general.cluster.count", 1);
params.set("proxima.optkmeans.cluster.count", 56);
params.set("zvec.general.cluster.count", 1);
params.set("zvec.optkmeans.cluster.count", 56);
ASSERT_EQ(0, cluster->init(index_meta, params));
ASSERT_EQ(0, cluster->mount(features));
@@ -191,7 +191,7 @@ TEST(OptKmeansCluster, General) {
// << ", " << vec[vec.size() - 1] << " }" << std::endl;
// }
// params.set("proxima.optkmeans.cluster.purge_empty", true);
// params.set("zvec.optkmeans.cluster.purge_empty", true);
// cluster->update(params);
// ASSERT_EQ(12u, centroids.size());
@@ -254,8 +254,8 @@ TEST(OptKmeansCluster, IN4General) {
ASSERT_EQ(0, cluster->init(index_meta_wrong, params));
ASSERT_NE(0, cluster->mount(features_wrong));
params.set("proxima.general.cluster.count", 1);
params.set("proxima.optkmeans.cluster.count", 56);
params.set("zvec.general.cluster.count", 1);
params.set("zvec.optkmeans.cluster.count", 56);
ASSERT_EQ(0, cluster->init(index_meta, params));
ASSERT_EQ(0, cluster->mount(features));
@@ -351,11 +351,11 @@ TEST(OptKmeansCluster, IN4Correctness) {
ASSERT_TRUE(!!cluster_once);
Params params_once;
params_once.set("proxima.general.cluster.count", 65);
params_once.set("proxima.optkmeans.cluster.count", 63);
params_once.set("proxima.optkmeans.cluster.max_iterations", 1);
params_once.set("zvec.general.cluster.count", 65);
params_once.set("zvec.optkmeans.cluster.count", 63);
params_once.set("zvec.optkmeans.cluster.max_iterations", 1);
// Use KMC2 to init centroids
params_once.set("proxima.optkmeans.cluster.markov_chain_length", 20);
params_once.set("zvec.optkmeans.cluster.markov_chain_length", 20);
ASSERT_EQ(0, cluster_once->init(index_meta1, params_once));
ASSERT_EQ(0, cluster_once->mount(features1));
@@ -374,8 +374,8 @@ TEST(OptKmeansCluster, IN4Correctness) {
ASSERT_TRUE(!!cluster_int8);
Params params_int8;
params_int8.set("proxima.general.cluster.count", 65);
params_int8.set("proxima.optkmeans.cluster.count", 63);
params_int8.set("zvec.general.cluster.count", 65);
params_int8.set("zvec.optkmeans.cluster.count", 63);
ASSERT_EQ(0, cluster_int8->init(index_meta1, params_int8));
ASSERT_EQ(0, cluster_int8->mount(features1));
@@ -387,8 +387,8 @@ TEST(OptKmeansCluster, IN4Correctness) {
ASSERT_TRUE(!!cluster_int4);
Params params_int4;
params_int4.set("proxima.general.cluster.count", 65);
params_int4.set("proxima.optkmeans.cluster.count", 63);
params_int4.set("zvec.general.cluster.count", 65);
params_int4.set("zvec.optkmeans.cluster.count", 63);
ASSERT_EQ(0, cluster_int4->init(index_meta2, params_int4));
ASSERT_EQ(0, cluster_int4->mount(features2));
@@ -448,8 +448,8 @@ TEST(OptKmeansCluster, InnerProduct) {
ASSERT_TRUE(!!cluster);
Params params;
params.set("proxima.general.cluster.count", 1);
params.set("proxima.optkmeans.cluster.count", 56);
params.set("zvec.general.cluster.count", 1);
params.set("zvec.optkmeans.cluster.count", 56);
ASSERT_EQ(0, cluster->init(index_meta, params));
ASSERT_EQ(0, cluster->mount(features));
@@ -0,0 +1,14 @@
include(${CMAKE_SOURCE_DIR}/cmake/bazel.cmake)
file(GLOB_RECURSE ALL_TEST_SRCS *_test.cc)
foreach(CC_SRCS ${ALL_TEST_SRCS})
get_filename_component(CC_TARGET ${CC_SRCS} NAME_WE)
cc_gtest(
NAME ${CC_TARGET}
STRICT
LIBS zvec_ailego core_framework core_utility core_metric core_quantizer core_knn_cluster core_plugin core_knn_diskann
SRCS ${CC_SRCS}
INCS . ${CMAKE_SOURCE_DIR}/src/core ${CMAKE_SOURCE_DIR}/src/core/algorithm/diskann
)
endforeach()
@@ -0,0 +1,125 @@
// Copyright 2025-present the zvec project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "diskann_builder.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <future>
#include <gtest/gtest.h>
#include <zvec/ailego/container/vector.h>
#include <zvec/core/framework/index_framework.h>
#include "diskann_holder.h"
using namespace zvec::core;
using namespace zvec::ailego;
using namespace std;
constexpr size_t static dim = 64;
class DiskAnnBuilderTest : public testing::Test {
protected:
void SetUp(void) override;
void TearDown(void) override;
static std::string _dir;
static shared_ptr<IndexMeta> _index_meta_ptr;
};
std::string DiskAnnBuilderTest::_dir("DiskAnnBuilderTest");
shared_ptr<IndexMeta> DiskAnnBuilderTest::_index_meta_ptr;
void DiskAnnBuilderTest::SetUp(void) {
LoggerBroker::SetLevel(Logger::LEVEL_INFO);
_index_meta_ptr.reset(new (nothrow)
IndexMeta(IndexMeta::DataType::DT_FP32, dim));
_index_meta_ptr->set_metric("SquaredEuclidean", 0, Params());
}
void DiskAnnBuilderTest::TearDown(void) {
char cmdBuf[100];
snprintf(cmdBuf, 100, "rm -rf %s", _dir.c_str());
system(cmdBuf);
}
TEST_F(DiskAnnBuilderTest, TestGeneral) {
IndexBuilder::Pointer builder = IndexFactory::CreateBuilder("DiskAnnBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 10000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = i;
}
ASSERT_TRUE(holder->emplace(i, vec));
}
Params params;
params.set("zvec.diskann.builder.max_degree", 32);
params.set("zvec.diskann.builder.list_size", 50);
params.set("zvec.diskann.builder.max_pq_chunk_num", 32);
params.set("zvec.diskann.builder.threads", 4);
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder));
ASSERT_EQ(0, builder->build(holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestGeneral";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(doc_cnt, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_GT(stats.trained_costtime(), 0UL);
ASSERT_GT(stats.built_costtime(), 0UL);
}
// DiskAnn is now exposed implicitly: no caller ever invokes a
// ``LoadDiskAnnPlugin`` / ``IsLibAioAvailable`` API (those were removed from
// the public surface together with ``zvec.load_diskann_plugin()`` in Python).
// The only contract this test validates is the UX guarantee: once the DiskAnn
// module has been linked into the hosting binary (here, directly into the
// test via the ``core_knn_diskann`` target), its factory entries are
// registered automatically and the global ``IndexFactory`` can hand out a
// ``DiskAnnBuilder`` without any explicit setup step. On hosts missing
// libaio, DiskAnn would fail at the index-creation layer with a clear error
// while other index types (HNSW/IVF/Flat/Vamana) remain unaffected; that
// runtime branch lives in ``DiskAnnIndex::CreateAndInitStreamer`` and is
// covered by the higher-level interface tests.
TEST_F(DiskAnnBuilderTest, TestImplicitFactoryRegistration) {
IndexBuilder::Pointer builder = IndexFactory::CreateBuilder("DiskAnnBuilder");
ASSERT_NE(builder, nullptr)
<< "DiskAnnBuilder factory entry missing: DiskAnn must be available "
"without any manual plugin load step.";
IndexStreamer::Pointer streamer =
IndexFactory::CreateStreamer("DiskAnnStreamer");
ASSERT_NE(streamer, nullptr)
<< "DiskAnnStreamer factory entry missing: DiskAnn must be available "
"without any manual plugin load step.";
}
@@ -0,0 +1,816 @@
// Copyright 2025-present the zvec project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "diskann_searcher.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <ailego/math/distance.h>
#include <gtest/gtest.h>
#include <zvec/ailego/container/vector.h>
#include <zvec/core/framework/index_framework.h>
#include "diskann_holder.h"
#include "diskann_params.h"
using namespace zvec::core;
using namespace zvec::ailego;
using namespace std;
constexpr size_t static dim = 64;
class DiskAnnSearcherTest : public testing::Test {
protected:
void SetUp(void) override;
void TearDown(void) override;
static std::string _dir;
static shared_ptr<IndexMeta> _index_meta_ptr;
};
std::string DiskAnnSearcherTest::_dir("DiskAnnSearcherTest/");
shared_ptr<IndexMeta> DiskAnnSearcherTest::_index_meta_ptr;
void DiskAnnSearcherTest::SetUp(void) {
LoggerBroker::SetLevel(Logger::LEVEL_INFO);
_index_meta_ptr.reset(new (nothrow)
IndexMeta(IndexMeta::DataType::DT_FP32, dim));
_index_meta_ptr->set_metric("SquaredEuclidean", 0, Params());
}
void DiskAnnSearcherTest::TearDown(void) {
char cmdBuf[100];
snprintf(cmdBuf, 100, "rm -rf %s", _dir.c_str());
system(cmdBuf);
}
TEST_F(DiskAnnSearcherTest, TestGeneral) {
IndexBuilder::Pointer builder = IndexFactory::CreateBuilder("DiskAnnBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 10000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = i;
}
ASSERT_TRUE(holder->emplace(i, vec));
}
Params params;
params.set("zvec.diskann.builder.max_degree", 32);
params.set("zvec.diskann.builder.list_size", 300);
params.set("zvec.diskann.builder.max_pq_chunk_num", 32);
params.set("zvec.diskann.builder.threads", 4);
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder));
ASSERT_EQ(0, builder->build(holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestGeneral";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(doc_cnt, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_GT(stats.trained_costtime(), 0UL);
ASSERT_GT(stats.built_costtime(), 0UL);
// test searcher
IndexSearcher::Pointer searcher =
IndexFactory::CreateSearcher("DiskAnnSearcher");
ASSERT_TRUE(searcher != nullptr);
Params search_params;
search_params.set("zvec.diskann.searcher.list_size", 500);
ASSERT_EQ(0, searcher->init(search_params));
auto storage = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_EQ(0, storage->open(path, false));
ASSERT_EQ(0, searcher->load(storage, IndexMetric::Pointer()));
auto ctx = searcher->create_context();
ASSERT_TRUE(!!ctx);
auto linearCtx = searcher->create_context();
auto linearByPKeysCtx = searcher->create_context();
auto knnCtx = searcher->create_context();
ASSERT_TRUE(!!linearCtx);
ASSERT_TRUE(!!linearByPKeysCtx);
ASSERT_TRUE(!!knnCtx);
NumericalVector<float> vec(dim);
IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
size_t topk = 200;
uint64_t knnTotalTime = 0;
uint64_t linearTotalTime = 0;
int totalHits = 0;
int totalCnts = 0;
int topk1Hits = 0;
linearCtx->set_topk(topk);
linearByPKeysCtx->set_topk(topk);
knnCtx->set_topk(topk);
// do linear search test
{
float query[dim];
for (size_t i = 0; i < dim; ++i) {
query[i] = 3.1f;
}
ASSERT_EQ(0, searcher->search_bf_impl(query, qmeta, linearCtx));
auto &linearResult = linearCtx->result();
ASSERT_EQ(3UL, linearResult[0].key());
ASSERT_EQ(4UL, linearResult[1].key());
ASSERT_EQ(2UL, linearResult[2].key());
ASSERT_EQ(5UL, linearResult[3].key());
ASSERT_EQ(1UL, linearResult[4].key());
ASSERT_EQ(6UL, linearResult[5].key());
ASSERT_EQ(0UL, linearResult[6].key());
ASSERT_EQ(7UL, linearResult[7].key());
for (size_t i = 8; i < topk; ++i) {
ASSERT_EQ(i, linearResult[i].key());
}
}
// do linear search by p_keys test
std::vector<std::vector<uint64_t>> p_keys;
p_keys.resize(1);
p_keys[0] = {8, 9, 10, 11, 3, 2, 1, 0};
{
float query[dim];
for (size_t i = 0; i < dim; ++i) {
query[i] = 3.1f;
}
ASSERT_EQ(0, searcher->search_bf_by_p_keys_impl(query, p_keys, qmeta,
linearByPKeysCtx));
auto &linearByPKeysResult = linearByPKeysCtx->result();
ASSERT_EQ(8, linearByPKeysResult.size());
ASSERT_EQ(3UL, linearByPKeysResult[0].key());
ASSERT_EQ(2UL, linearByPKeysResult[1].key());
ASSERT_EQ(1UL, linearByPKeysResult[2].key());
ASSERT_EQ(0UL, linearByPKeysResult[3].key());
ASSERT_EQ(8UL, linearByPKeysResult[4].key());
ASSERT_EQ(9UL, linearByPKeysResult[5].key());
ASSERT_EQ(10UL, linearByPKeysResult[6].key());
ASSERT_EQ(11UL, linearByPKeysResult[7].key());
}
size_t step = 500;
for (size_t i = 0; i < doc_cnt; i += step) {
for (size_t j = 0; j < dim; ++j) {
vec[j] = i + 0.1f;
}
auto t1 = Realtime::MicroSeconds();
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
auto t2 = Realtime::MicroSeconds();
ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
auto t3 = Realtime::MicroSeconds();
knnTotalTime += t2 - t1;
linearTotalTime += t3 - t2;
auto &knnResult = knnCtx->result();
// TODO: check
topk1Hits += i == knnResult[0].key();
auto &linearResult = linearCtx->result();
ASSERT_EQ(topk, linearResult.size());
ASSERT_EQ(i, linearResult[0].key());
for (size_t k = 0; k < topk; ++k) {
totalCnts++;
for (size_t j = 0; j < topk; ++j) {
if (linearResult[j].key() == knnResult[k].key()) {
totalHits++;
break;
}
}
}
}
float recall = totalHits * step * step * 1.0f / totalCnts;
float topk1Recall = topk1Hits * step * 1.0f / doc_cnt;
float cost = linearTotalTime * 1.0f / knnTotalTime;
EXPECT_GT(recall, 0.90f);
EXPECT_GT(topk1Recall, 0.80f);
EXPECT_GT(cost, 2.0f);
}
TEST_F(DiskAnnSearcherTest, TestNodeCache) {
IndexBuilder::Pointer builder = IndexFactory::CreateBuilder("DiskAnnBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 10000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = i;
}
ASSERT_TRUE(holder->emplace(i, vec));
}
Params params;
params.set("zvec.diskann.builder.max_degree", 32);
params.set("zvec.diskann.builder.list_size", 300);
params.set("zvec.diskann.builder.max_pq_chunk_num", 32);
params.set("zvec.diskann.builder.threads", 4);
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder));
ASSERT_EQ(0, builder->build(holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestNodeCache";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(doc_cnt, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_GT(stats.trained_costtime(), 0UL);
ASSERT_GT(stats.built_costtime(), 0UL);
// test searcher
IndexSearcher::Pointer searcher =
IndexFactory::CreateSearcher("DiskAnnSearcher");
ASSERT_TRUE(searcher != nullptr);
Params search_params;
search_params.set("zvec.diskann.searcher.cache_node_num", 32);
search_params.set("zvec.diskann.searcher.list_size", 500);
ASSERT_EQ(0, searcher->init(search_params));
auto storage = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_EQ(0, storage->open(path, false));
ASSERT_EQ(0, searcher->load(storage, IndexMetric::Pointer()));
auto ctx = searcher->create_context();
ASSERT_TRUE(!!ctx);
auto linearCtx = searcher->create_context();
auto linearByPKeysCtx = searcher->create_context();
auto knnCtx = searcher->create_context();
ASSERT_TRUE(!!linearCtx);
ASSERT_TRUE(!!linearByPKeysCtx);
ASSERT_TRUE(!!knnCtx);
NumericalVector<float> vec(dim);
IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
size_t topk = 200;
uint64_t knnTotalTime = 0;
uint64_t linearTotalTime = 0;
int totalHits = 0;
int totalCnts = 0;
int topk1Hits = 0;
linearCtx->set_topk(topk);
linearByPKeysCtx->set_topk(topk);
knnCtx->set_topk(topk);
size_t step = 500;
for (size_t i = 0; i < doc_cnt; i += step) {
for (size_t j = 0; j < dim; ++j) {
vec[j] = i + 0.1f;
}
auto t1 = Realtime::MicroSeconds();
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
auto t2 = Realtime::MicroSeconds();
ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
auto t3 = Realtime::MicroSeconds();
knnTotalTime += t2 - t1;
linearTotalTime += t3 - t2;
auto &knnResult = knnCtx->result();
// TODO: check
topk1Hits += i == knnResult[0].key();
auto &linearResult = linearCtx->result();
ASSERT_EQ(topk, linearResult.size());
ASSERT_EQ(i, linearResult[0].key());
for (size_t k = 0; k < topk; ++k) {
totalCnts++;
for (size_t j = 0; j < topk; ++j) {
if (linearResult[j].key() == knnResult[k].key()) {
totalHits++;
break;
}
}
}
}
float recall = totalHits * step * step * 1.0f / totalCnts;
float topk1Recall = topk1Hits * step * 1.0f / doc_cnt;
float cost = linearTotalTime * 1.0f / knnTotalTime;
EXPECT_GT(recall, 0.90f);
EXPECT_GT(topk1Recall, 0.80f);
EXPECT_GT(cost, 2.0f);
}
TEST_F(DiskAnnSearcherTest, TestFilter) {
IndexBuilder::Pointer builder = IndexFactory::CreateBuilder("DiskAnnBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 10000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = i;
}
ASSERT_TRUE(holder->emplace(i, vec));
}
Params params;
params.set("zvec.diskann.builder.max_degree", 32);
params.set("zvec.diskann.builder.list_size", 300);
params.set("zvec.diskann.builder.max_pq_chunk_num", 32);
params.set("zvec.diskann.builder.threads", 4);
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder));
ASSERT_EQ(0, builder->build(holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestFilter";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(doc_cnt, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_GT(stats.trained_costtime(), 0UL);
ASSERT_GT(stats.built_costtime(), 0UL);
// test searcher
IndexSearcher::Pointer searcher =
IndexFactory::CreateSearcher("DiskAnnSearcher");
ASSERT_TRUE(searcher != nullptr);
Params search_params;
search_params.set("zvec.diskann.searcher.cache_node_num", 32);
search_params.set("zvec.diskann.searcher.list_size", 500);
ASSERT_EQ(0, searcher->init(search_params));
auto storage = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_EQ(0, storage->open(path, false));
ASSERT_EQ(0, searcher->load(storage, IndexMetric::Pointer()));
auto ctx = searcher->create_context();
ASSERT_TRUE(!!ctx);
auto linearCtx = searcher->create_context();
auto linearByPKeysCtx = searcher->create_context();
auto knnCtx = searcher->create_context();
ASSERT_TRUE(!!linearCtx);
ASSERT_TRUE(!!linearByPKeysCtx);
ASSERT_TRUE(!!knnCtx);
NumericalVector<float> vec(dim);
IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
size_t topk = 200;
linearCtx->set_topk(topk);
linearByPKeysCtx->set_topk(topk);
knnCtx->set_topk(topk);
size_t key = 50;
for (size_t j = 0; j < dim; ++j) {
vec[j] = key + 0.1f;
}
// no filter
{
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
auto &knnResult = knnCtx->result();
ASSERT_EQ(topk, knnResult.size());
ASSERT_EQ(50UL, knnResult[0].key());
ASSERT_EQ(51UL, knnResult[1].key());
ASSERT_EQ(49UL, knnResult[2].key());
ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
auto &linearResult = linearCtx->result();
ASSERT_EQ(topk, linearResult.size());
ASSERT_EQ(50UL, linearResult[0].key());
ASSERT_EQ(51UL, linearResult[1].key());
ASSERT_EQ(49UL, linearResult[2].key());
}
// with filter
{
auto filterFunc = [](uint64_t key) {
if (key == 50UL || key == 51UL || key == 49UL) {
return true;
}
return false;
};
knnCtx->set_filter(filterFunc);
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
auto &knnResult = knnCtx->result();
ASSERT_EQ(topk, knnResult.size());
ASSERT_EQ(52UL, knnResult[0].key());
ASSERT_EQ(48UL, knnResult[1].key());
ASSERT_EQ(53UL, knnResult[2].key());
linearCtx->set_filter(filterFunc);
ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
auto &linearResult = linearCtx->result();
ASSERT_EQ(topk, linearResult.size());
ASSERT_EQ(52UL, linearResult[0].key());
ASSERT_EQ(48UL, linearResult[1].key());
ASSERT_EQ(53UL, linearResult[2].key());
}
}
TEST_F(DiskAnnSearcherTest, TestGroup) {
IndexBuilder::Pointer builder = IndexFactory::CreateBuilder("DiskAnnBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 10000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = i / 10.0;
}
ASSERT_TRUE(holder->emplace(i, vec));
}
Params params;
params.set("zvec.diskann.builder.max_degree", 32);
params.set("zvec.diskann.builder.list_size", 300);
params.set("zvec.diskann.builder.max_pq_chunk_num", 32);
params.set("zvec.diskann.builder.threads", 4);
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder));
ASSERT_EQ(0, builder->build(holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestGroup";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(doc_cnt, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_GT(stats.trained_costtime(), 0UL);
ASSERT_GT(stats.built_costtime(), 0UL);
// test searcher
IndexSearcher::Pointer searcher =
IndexFactory::CreateSearcher("DiskAnnSearcher");
ASSERT_TRUE(searcher != nullptr);
Params search_params;
search_params.set("zvec.diskann.searcher.list_size", 500);
ASSERT_EQ(0, searcher->init(search_params));
auto storage = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_EQ(0, storage->open(path, false));
ASSERT_EQ(0, searcher->load(storage, IndexMetric::Pointer()));
auto ctx = searcher->create_context();
ASSERT_TRUE(!!ctx);
NumericalVector<float> vec(dim);
IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
size_t group_topk = 20;
uint64_t total_time = 0;
auto groupbyFunc = [](uint64_t key) {
uint32_t group_id = key / 10 % 10;
// std::cout << "key: " << key << ", group id: " << group_id << std::endl;
return std::string("g_") + std::to_string(group_id);
};
size_t group_num = 5;
ctx->set_group_params(group_num, group_topk);
ctx->set_group_by(groupbyFunc);
size_t query_value = doc_cnt / 2;
for (size_t j = 0; j < dim; ++j) {
vec[j] = query_value / 10 + 0.1f;
}
auto t1 = Realtime::MicroSeconds();
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, ctx));
auto t2 = Realtime::MicroSeconds();
total_time += t2 - t1;
auto &group_result = ctx->group_result();
for (uint32_t i = 0; i < group_result.size(); ++i) {
const std::string &group_id = group_result[i].group_id();
auto &result = group_result[i].docs();
ASSERT_GT(result.size(), 0);
std::cout << "Group ID: " << group_id << std::endl;
for (uint32_t j = 0; j < result.size(); ++j) {
std::cout << "\tKey: " << result[j].key() << std::fixed
<< std::setprecision(3) << ", Score: " << result[j].score()
<< std::endl;
}
}
#if 0
// do linear search by p_keys test
auto groupbyFuncLinear = [](uint64_t key) {
uint32_t group_id = key % 10;
return std::string("g_") + std::to_string(group_id);
};
auto linear_pk_ctx = searcher->create_context();
linear_pk_ctx->set_group_params(group_num, group_topk);
linear_pk_ctx->set_group_by(groupbyFuncLinear);
std::vector<std::vector<uint64_t>> p_keys;
p_keys.resize(1);
p_keys[0] = {4, 3, 2, 1, 5, 6, 7, 8, 9, 10};
ASSERT_EQ(0, searcher->search_bf_by_p_keys_impl(vec.data(), p_keys, qmeta,
linear_pk_ctx));
auto &linear_by_pkeys_group_result = linear_pk_ctx->group_result();
ASSERT_EQ(linear_by_pkeys_group_result.size(), group_num);
for (uint32_t i = 0; i < linear_by_pkeys_group_result.size(); ++i) {
const std::string &group_id = linear_by_pkeys_group_result[i].group_id();
auto &result = linear_by_pkeys_group_result[i].docs();
ASSERT_GT(result.size(), 0);
std::cout << "Group ID: " << group_id << std::endl;
for (uint32_t j = 0; j < result.size(); ++j) {
std::cout << "\tKey: " << result[j].key() << std::fixed
<< std::setprecision(3) << ", Score: " << result[j].score()
<< std::endl;
}
ASSERT_EQ(10 - i, result[0].key());
}
#endif
}
TEST_F(DiskAnnSearcherTest, TestFetchVector) {
IndexBuilder::Pointer builder = IndexFactory::CreateBuilder("DiskAnnBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 10000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = i;
}
ASSERT_TRUE(holder->emplace(i, vec));
}
Params params;
params.set("zvec.diskann.builder.max_degree", 32);
params.set("zvec.diskann.builder.list_size", 300);
params.set("zvec.diskann.builder.max_pq_chunk_num", 32);
params.set("zvec.diskann.builder.threads", 4);
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder));
ASSERT_EQ(0, builder->build(holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestFetchVector";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(doc_cnt, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_GT(stats.trained_costtime(), 0UL);
ASSERT_GT(stats.built_costtime(), 0UL);
// test searcher
IndexSearcher::Pointer searcher =
IndexFactory::CreateSearcher("DiskAnnSearcher");
ASSERT_TRUE(searcher != nullptr);
Params search_params;
search_params.set("zvec.diskann.searcher.list_size", 500);
ASSERT_EQ(0, searcher->init(search_params));
auto storage = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_EQ(0, storage->open(path, false));
ASSERT_EQ(0, searcher->load(storage, IndexMetric::Pointer()));
size_t query_cnt = 20U;
auto linearCtx = searcher->create_context();
auto knnCtx = searcher->create_context();
auto linearByPKeysCtx = searcher->create_context();
knnCtx->set_fetch_vector(true);
for (size_t i = 0; i < doc_cnt; i += doc_cnt / 10) {
std::string vec_value;
ASSERT_EQ(0, searcher->get_vector(i, linearCtx, vec_value));
float vector_value = *(const float *)(vec_value.data());
ASSERT_EQ(vector_value, i);
}
size_t topk = 200;
linearCtx->set_topk(topk);
knnCtx->set_topk(topk);
uint64_t knnTotalTime = 0;
uint64_t linearTotalTime = 0;
IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
NumericalVector<float> vec(dim);
for (size_t i = 0; i < query_cnt; i++) {
for (size_t j = 0; j < dim; ++j) {
vec[j] = i;
}
auto t1 = Realtime::MicroSeconds();
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, knnCtx));
auto t2 = Realtime::MicroSeconds();
ASSERT_EQ(0, searcher->search_bf_impl(vec.data(), qmeta, linearCtx));
auto t3 = Realtime::MicroSeconds();
knnTotalTime += t2 - t1;
linearTotalTime += t3 - t2;
auto &knnResult = knnCtx->result();
ASSERT_EQ(topk, knnResult.size());
auto &linearResult = linearCtx->result();
ASSERT_EQ(topk, linearResult.size());
ASSERT_EQ(i, linearResult[0].key());
ASSERT_NE(knnResult[0].vector_string(), "");
float vector_value = *((float *)(knnResult[0].vector_string().data()));
ASSERT_EQ(vector_value, i);
}
}
TEST_F(DiskAnnSearcherTest, TestRnnSearch) {
IndexBuilder::Pointer builder = IndexFactory::CreateBuilder("DiskAnnBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 10000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = i;
}
ASSERT_TRUE(holder->emplace(i, vec));
}
Params params;
params.set("zvec.diskann.builder.max_degree", 32);
params.set("zvec.diskann.builder.list_size", 300);
params.set("zvec.diskann.builder.max_pq_chunk_num", 32);
params.set("zvec.diskann.builder.threads", 4);
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder));
ASSERT_EQ(0, builder->build(holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestRnnSearch";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(doc_cnt, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_GT(stats.trained_costtime(), 0UL);
ASSERT_GT(stats.built_costtime(), 0UL);
// test searcher
IndexSearcher::Pointer searcher =
IndexFactory::CreateSearcher("DiskAnnSearcher");
ASSERT_TRUE(searcher != nullptr);
Params search_params;
search_params.set("zvec.diskann.searcher.list_size", 500);
ASSERT_EQ(0, searcher->init(search_params));
auto storage = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_EQ(0, storage->open(path, false));
ASSERT_EQ(0, searcher->load(storage, IndexMetric::Pointer()));
auto ctx = searcher->create_context();
ASSERT_TRUE(!!ctx);
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = 0.0;
}
IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
size_t topk = 50;
ctx->set_topk(topk);
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, ctx));
auto &results = ctx->result();
ASSERT_EQ(topk, results.size());
float radius = results[topk / 2].score();
ctx->set_threshold(radius);
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, ctx));
ASSERT_GT(topk, results.size());
for (size_t k = 0; k < results.size(); ++k) {
ASSERT_GE(radius, results[k].score());
}
// Test Reset Threshold
ctx->reset_threshold();
ASSERT_EQ(0, searcher->search_impl(vec.data(), qmeta, ctx));
ASSERT_EQ(topk, results.size());
ASSERT_LT(radius, results[topk - 1].score());
}
+2 -2
View File
@@ -132,7 +132,7 @@ TEST_F(IVFBuilderTest, TestTrainWithTrainer2Level) {
prepare_index_holder(0, 1000);
Params params;
params.set("proxima.stratified.trainer.cluster_count", "4*2");
params.set("zvec.stratified.trainer.cluster_count", "4*2");
ASSERT_EQ(0, trainer->init(index_meta_, params));
ASSERT_EQ(0, trainer->train(threads_, holder_));
@@ -165,7 +165,7 @@ TEST_F(IVFBuilderTest, TestTrainWithTrainer1Level) {
prepare_index_holder(0, 1000);
Params params1;
params1.set("proxima.stratified.trainer.cluster_count", "4");
params1.set("zvec.stratified.trainer.cluster_count", "4");
ASSERT_EQ(0, trainer->init(index_meta_, params1));
ASSERT_EQ(0, trainer->train(threads_, holder_));