feat: add hnsw-rabitq support (#69)

* feat: add hnsw-rabitq

* undefine transform

* support config rotator type

* support sample_count

* fix ut

* refactor: update interface

* refactor: update interface

* update rabitq index params

* fix interface update

* fix searcher test

* fix streamer test

* streamer support bf and add more ut

* rm env check

* add collection ut

* add schema check

* add rabitq query param binding

* add integration test

* fix local_builder

* cleanup dist calculator

* add RaBitQ-Library submodule

* cleanup rabitq converter/reformer

* add files

* disable build on mac

* disable Feature_Optimize_HNSW_RABITQ

* disable python/tests/test_collection_hnsw_rabitq.py:13

* check avx2/avx512

* fix refine

* fix mac ci

* add dimension check

* fix mac ci

* fix ci

* add missing lib

* fix centroids selection for Cosine/InnerProduct

* rename hnsw-rabitq to hnsw_rabitq

* address comments

* fix compile

* fix rabitqlib name

* fix mac compile

* check avx2/avx512 support

* runtime check again compile-time

* check AUTO_DETECT_ARCH

* rm debug log

* fix

* rabitq use avx2 by default

* add missing file

* fix search_bf/group_by dist

* address comments

* fix typo

* address comments

* rabitq support disable id_map

* address comments
This commit is contained in:
egolearner
2026-03-19 17:21:42 +08:00
committed by GitHub
parent 432de52c5f
commit e5ba11b6fe
96 changed files with 14500 additions and 92 deletions
+3
View File
@@ -7,3 +7,6 @@ cc_directories(flat_sparse)
cc_directories(ivf)
cc_directories(hnsw)
cc_directories(hnsw_sparse)
if(RABITQ_SUPPORTED)
cc_directories(hnsw_rabitq)
endif()
@@ -0,0 +1,34 @@
include(${CMAKE_SOURCE_DIR}/cmake/bazel.cmake)
include(${CMAKE_SOURCE_DIR}/cmake/option.cmake)
if(APPLE)
set(APPLE_FRAMEWORK_LIBS
-framework CoreFoundation
-framework CoreGraphics
-framework CoreData
-framework CoreText
-framework Security
-framework Foundation
-Wl,-U,_MallocExtension_ReleaseFreeMemory
-Wl,-U,_ProfilerStart
-Wl,-U,_ProfilerStop
-Wl,-U,_RegisterThriftProtocol
)
endif()
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_hnsw_rabitq core_knn_flat core_knn_cluster
${CMAKE_THREAD_LIBS_INIT}
${CMAKE_DL_LIBS}
SRCS ${CC_SRCS}
INCS . ${CMAKE_SOURCE_DIR}/src/core ${CMAKE_SOURCE_DIR}/src/core/algorithm/hnsw_rabitq
LDFLAGS ${APPLE_FRAMEWORK_LIBS}
)
cc_test_suite(hnsw_rabitq ${CC_TARGET})
endforeach()
@@ -0,0 +1,428 @@
// 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 "hnsw_rabitq_builder.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <future>
#include <gtest/gtest.h>
#include <zvec/ailego/container/params.h>
#include <zvec/ailego/container/vector.h>
#include "zvec/core/framework/index_framework.h"
#include "zvec/core/framework/index_logger.h"
#include "zvec/core/framework/index_provider.h"
#if defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
#endif
using namespace std;
using namespace zvec::ailego;
namespace zvec {
namespace core {
constexpr size_t static dim = 128;
class HnswRabitqBuilderTest : public testing::Test {
protected:
void SetUp(void);
void TearDown(void);
static std::string _dir;
static shared_ptr<IndexMeta> _index_meta_ptr;
};
std::string HnswRabitqBuilderTest::_dir("hnswRabitqBuilderTest");
shared_ptr<IndexMeta> HnswRabitqBuilderTest::_index_meta_ptr;
void HnswRabitqBuilderTest::SetUp(void) {
IndexLoggerBroker::SetLevel(0);
_index_meta_ptr.reset(new (nothrow)
IndexMeta(IndexMeta::DataType::DT_FP32, dim));
_index_meta_ptr->set_metric("SquaredEuclidean", 0, ailego::Params());
}
void HnswRabitqBuilderTest::TearDown(void) {
char cmdBuf[100];
snprintf(cmdBuf, 100, "rm -rf %s", _dir.c_str());
// system(cmdBuf);
}
TEST_F(HnswRabitqBuilderTest, TestGeneral) {
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 1000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
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(0UL, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_EQ(0UL, stats.trained_costtime());
ASSERT_GT(stats.built_costtime(), 0UL);
}
TEST_F(HnswRabitqBuilderTest, TestLoad) {
// Load index with searcher and verify search
auto searcher = IndexFactory::CreateSearcher("HnswRabitqSearcher");
ASSERT_NE(searcher, nullptr);
ailego::Params search_params;
search_params.set("proxima.hnsw_rabitq.searcher.ef", 100UL);
ASSERT_EQ(0, searcher->init(search_params));
auto loader = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_NE(loader, nullptr);
ASSERT_EQ(0, loader->init(ailego::Params()));
string path = _dir + "/TestGeneral";
ASSERT_EQ(0, loader->open(path, false));
ASSERT_EQ(0, searcher->load(loader, nullptr));
// Perform search verification
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(j) / 1000.0f;
}
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
auto context = searcher->create_context();
ASSERT_NE(context, nullptr);
context->set_topk(10);
ASSERT_EQ(0, searcher->search_impl(query_vec.data(), query_meta, 1, context));
const auto &result = context->result(0);
ASSERT_GT(result.size(), 0UL);
ASSERT_LE(result.size(), 10UL);
}
TEST_F(HnswRabitqBuilderTest, TestDimensions) {
std::vector<size_t> dimensions = {1, 2, 4, 8, 16, 32, 33,
63, 64, 128, 256, 512, 1024, 2047,
2048, 2049, 4095, 4096, 4097, 8192, 16384};
size_t doc_cnt = 100;
for (size_t test_dim : dimensions) {
std::cout << "Testing dimension: " << test_dim << std::endl;
IndexMeta index_meta(IndexMeta::DataType::DT_FP32, test_dim);
index_meta.set_metric("SquaredEuclidean", 0, ailego::Params());
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr) << "dim=" << test_dim;
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", test_dim);
int ret = builder->init(index_meta, params);
// dimension <= 63 or >= 4096: init() should return -31
if (test_dim <= 63 || test_dim >= 4096) {
ASSERT_EQ(-31, ret) << "expected init to fail with -31, dim=" << test_dim;
std::cout << "Dimension " << test_dim
<< " correctly rejected with ret=" << ret << std::endl;
continue;
}
// Valid dimensions: verify full build succeeds
ASSERT_EQ(0, ret) << "init failed, dim=" << test_dim;
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(
test_dim);
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(test_dim);
for (size_t j = 0; j < test_dim; ++j) {
vec[j] = static_cast<float>(i * test_dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec))) << "dim=" << test_dim;
}
ret = builder->train(holder);
ASSERT_EQ(0, ret) << "train failed, dim=" << test_dim;
ret = builder->build(holder);
ASSERT_EQ(0, ret) << "build failed, dim=" << test_dim;
auto &stats = builder->stats();
ASSERT_EQ(doc_cnt, stats.built_count()) << "dim=" << test_dim;
std::cout << "Dimension " << test_dim << " passed, built "
<< stats.built_count() << " docs" << std::endl;
}
}
TEST_F(HnswRabitqBuilderTest, TestMemquota) {
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 1000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
params.set("proxima.hnsw_rabitq.builder.memory_quota", 100000UL);
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder));
ASSERT_EQ(IndexError_NoMemory, builder->build(holder));
}
TEST_F(HnswRabitqBuilderTest, TestIndexThreads) {
IndexBuilder::Pointer builder1 =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder1, nullptr);
IndexBuilder::Pointer builder2 =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder2, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 1000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
std::srand(ailego::Realtime::MilliSeconds());
auto threads =
std::make_shared<SingleQueueIndexThreads>(std::rand() % 4, false);
ASSERT_EQ(0, builder1->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder2->init(*_index_meta_ptr, params));
auto build_index1 = [&]() {
ASSERT_EQ(0, builder1->train(threads, holder));
ASSERT_EQ(0, builder1->build(threads, holder));
};
auto build_index2 = [&]() {
ASSERT_EQ(0, builder2->train(threads, holder));
ASSERT_EQ(0, builder2->build(threads, holder));
};
auto t1 = std::async(std::launch::async, build_index1);
auto t2 = std::async(std::launch::async, build_index2);
t1.wait();
t2.wait();
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestIndexThreads";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder1->dump(dumper));
ASSERT_EQ(0, dumper->close());
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder2->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats1 = builder1->stats();
ASSERT_EQ(doc_cnt, stats1.built_count());
auto &stats2 = builder2->stats();
ASSERT_EQ(doc_cnt, stats2.built_count());
}
TEST_F(HnswRabitqBuilderTest, TestCosine) {
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 1000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
IndexMeta index_meta_raw(IndexMeta::DataType::DT_FP32, dim);
index_meta_raw.set_metric("Cosine", 0, ailego::Params());
ailego::Params converter_params;
auto converter = IndexFactory::CreateConverter("CosineFp32Converter");
converter->init(index_meta_raw, converter_params);
IndexMeta index_meta = converter->meta();
converter->transform(holder);
auto converted_holder = converter->result();
converted_holder = convert_holder_to_provider(converted_holder);
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
ASSERT_EQ(0, builder->init(index_meta, params));
ASSERT_EQ(0, builder->train(converted_holder));
ASSERT_EQ(0, builder->build(converted_holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestCosine";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(0UL, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_EQ(0UL, stats.trained_costtime());
ASSERT_GT(stats.built_costtime(), 0UL);
}
TEST_F(HnswRabitqBuilderTest, TestCleanupAndRebuild) {
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 1000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
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 + "/TestCleanupAndRebuild";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
auto &stats = builder->stats();
ASSERT_EQ(0UL, stats.trained_count());
ASSERT_EQ(doc_cnt, stats.built_count());
ASSERT_EQ(doc_cnt, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_EQ(0UL, stats.trained_costtime());
ASSERT_GT(stats.built_costtime(), 0UL);
// Cleanup and rebuild with more documents
ASSERT_EQ(0, builder->cleanup());
auto holder2 =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt2 = 2000UL;
for (size_t i = 0; i < doc_cnt2; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder2->emplace(i, std::move(vec)));
}
ASSERT_EQ(0, builder->init(*_index_meta_ptr, params));
ASSERT_EQ(0, builder->train(holder2));
ASSERT_EQ(0, builder->build(holder2));
auto dumper2 = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper2, nullptr);
ASSERT_EQ(0, dumper2->create(path));
ASSERT_EQ(0, builder->dump(dumper2));
ASSERT_EQ(0, dumper2->close());
ASSERT_EQ(0UL, stats.trained_count());
ASSERT_EQ(doc_cnt2, stats.built_count());
ASSERT_EQ(doc_cnt2, stats.dumped_count());
ASSERT_EQ(0UL, stats.discarded_count());
ASSERT_EQ(0UL, stats.trained_costtime());
ASSERT_GT(stats.built_costtime(), 0UL);
}
} // namespace core
} // namespace zvec
#if defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic pop
#endif
@@ -0,0 +1,573 @@
// 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 "hnsw_rabitq_searcher.h"
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <cstdio>
#include <random>
#include <gtest/gtest.h>
#include <zvec/ailego/container/params.h>
#include <zvec/ailego/container/vector.h>
#include "zvec/core/framework/index_framework.h"
#include "zvec/core/framework/index_logger.h"
#include "hnsw_rabitq_builder.h"
#if defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
#endif
using namespace std;
using namespace zvec::ailego;
namespace zvec {
namespace core {
constexpr size_t static dim = 128;
class HnswRabitqSearcherTest : public testing::Test {
protected:
void SetUp(void);
void TearDown(void);
static std::string _dir;
static shared_ptr<IndexMeta> _index_meta_ptr;
};
std::string HnswRabitqSearcherTest::_dir("HnswRabitqSearcherTest");
shared_ptr<IndexMeta> HnswRabitqSearcherTest::_index_meta_ptr;
void HnswRabitqSearcherTest::SetUp(void) {
IndexLoggerBroker::SetLevel(0);
_index_meta_ptr.reset(new (nothrow)
IndexMeta(IndexMeta::DataType::DT_FP32, dim));
_index_meta_ptr->set_metric("SquaredEuclidean", 0, ailego::Params());
}
void HnswRabitqSearcherTest::TearDown(void) {
char cmdBuf[100];
snprintf(cmdBuf, 100, "rm -rf %s", _dir.c_str());
// system(cmdBuf);
}
TEST_F(HnswRabitqSearcherTest, TestBasicSearch) {
// Build index first
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<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] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
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 + "/TestBasicSearch";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
// Test searcher
auto searcher = IndexFactory::CreateSearcher("HnswRabitqSearcher");
ASSERT_NE(searcher, nullptr);
ailego::Params search_params;
search_params.set("proxima.hnsw_rabitq.searcher.ef", 100UL);
ASSERT_EQ(0, searcher->init(search_params));
auto loader = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_NE(loader, nullptr);
ASSERT_EQ(0, loader->init(ailego::Params()));
ASSERT_EQ(0, loader->open(path, false));
ASSERT_EQ(0, searcher->load(loader, nullptr));
// Perform search
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(j) / 1000.0f;
}
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
auto context = searcher->create_context();
ASSERT_TRUE(!!context);
context->set_topk(10);
ASSERT_EQ(0, searcher->search_impl(query_vec.data(), query_meta, 1, context));
const auto &result = context->result(0);
ASSERT_GT(result.size(), 0UL);
ASSERT_LE(result.size(), 10UL);
// Verify results are sorted by distance
for (size_t i = 1; i < result.size(); ++i) {
ASSERT_LE(result[i - 1].score(), result[i].score());
}
}
TEST_F(HnswRabitqSearcherTest, DISABLED_TestRnnSearch) {
// Build index first
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<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] = static_cast<float>(i);
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
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());
// Test searcher with radius search
auto searcher = IndexFactory::CreateSearcher("HnswRabitqSearcher");
ASSERT_NE(searcher, nullptr);
ailego::Params search_params;
search_params.set("proxima.hnsw_rabitq.searcher.ef", 100UL);
ASSERT_EQ(0, searcher->init(search_params));
auto loader = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_NE(loader, nullptr);
ASSERT_EQ(0, loader->init(ailego::Params()));
ASSERT_EQ(0, loader->open(path, false));
ASSERT_EQ(0, searcher->load(loader, nullptr));
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = 0.0f;
}
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
auto context = searcher->create_context();
ASSERT_NE(context, nullptr);
size_t topk = 50;
context->set_topk(topk);
ASSERT_EQ(0, searcher->search_impl(query_vec.data(), query_meta, 1, context));
const auto &results = context->result(0);
ASSERT_EQ(topk, results.size());
// Test with radius threshold
float radius = results[topk / 2].score();
context->set_threshold(radius);
ASSERT_EQ(0, searcher->search_impl(query_vec.data(), query_meta, 1, context));
ASSERT_GT(topk, results.size());
for (size_t k = 0; k < results.size(); ++k) {
ASSERT_GE(radius, results[k].score());
}
// Test reset threshold
context->reset_threshold();
ASSERT_EQ(0, searcher->search_impl(query_vec.data(), query_meta, 1, context));
ASSERT_EQ(topk, results.size());
ASSERT_LT(radius, results[topk - 1].score());
}
TEST_F(HnswRabitqSearcherTest, DISABLED_TestSearchInnerProduct) {
// Build index with InnerProduct metric
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<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] = static_cast<float>(i);
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
IndexMeta index_meta(IndexMeta::DataType::DT_FP32, dim);
index_meta.set_metric("InnerProduct", 0, ailego::Params());
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
ASSERT_EQ(0, builder->init(index_meta, 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 + "/TestSearchInnerProduct";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
// Test searcher
auto searcher = IndexFactory::CreateSearcher("HnswRabitqSearcher");
ASSERT_NE(searcher, nullptr);
ailego::Params search_params;
search_params.set("proxima.hnsw_rabitq.searcher.ef", 100UL);
ASSERT_EQ(0, searcher->init(search_params));
auto loader = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_NE(loader, nullptr);
ASSERT_EQ(0, loader->init(ailego::Params()));
ASSERT_EQ(0, loader->open(path, false));
ASSERT_EQ(0, searcher->load(loader, nullptr));
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = 1.0f;
}
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
auto context = searcher->create_context();
ASSERT_TRUE(!!context);
size_t topk = 50;
context->set_topk(topk);
ASSERT_EQ(0, searcher->search_impl(query_vec.data(), query_meta, 1, context));
const auto &results = context->result(0);
ASSERT_EQ(topk, results.size());
// Test with radius threshold (note: InnerProduct uses negative scores)
float radius = -results[topk / 2].score();
context->set_threshold(radius);
ASSERT_EQ(0, searcher->search_impl(query_vec.data(), query_meta, 1, context));
ASSERT_GT(topk, results.size());
for (size_t k = 0; k < results.size(); ++k) {
LOG_ERROR("radius: %f, score: %f", radius, results[k].score());
EXPECT_GE(radius, results[k].score());
}
// Test reset threshold
context->reset_threshold();
ASSERT_EQ(0, searcher->search_impl(query_vec.data(), query_meta, 1, context));
ASSERT_EQ(topk, results.size());
ASSERT_LT(-radius, results[topk - 1].score());
}
TEST_F(HnswRabitqSearcherTest, TestSearchCosine) {
// Build index with Cosine metric
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 10000UL;
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<float> dist(-1.0, 1.0);
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = dist(gen);
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
IndexMeta index_meta_raw(IndexMeta::DataType::DT_FP32, dim);
index_meta_raw.set_metric("Cosine", 0, ailego::Params());
ailego::Params converter_params;
auto converter = IndexFactory::CreateConverter("CosineFp32Converter");
converter->init(index_meta_raw, converter_params);
IndexMeta index_meta = converter->meta();
converter->transform(holder);
auto converted_holder = converter->result();
converted_holder = convert_holder_to_provider(converted_holder);
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
ASSERT_EQ(0, builder->init(index_meta, params));
ASSERT_EQ(0, builder->train(converted_holder));
ASSERT_EQ(0, builder->build(converted_holder));
auto dumper = IndexFactory::CreateDumper("FileDumper");
ASSERT_NE(dumper, nullptr);
string path = _dir + "/TestSearchCosine";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
// Test searcher
auto searcher = IndexFactory::CreateSearcher("HnswRabitqSearcher");
ASSERT_NE(searcher, nullptr);
ailego::Params search_params;
search_params.set("proxima.hnsw_rabitq.searcher.ef", 100UL);
ASSERT_EQ(0, searcher->init(search_params));
auto loader = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_NE(loader, nullptr);
ASSERT_EQ(0, loader->init(ailego::Params()));
ASSERT_EQ(0, loader->open(path, false));
ASSERT_EQ(0, searcher->load(loader, nullptr));
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = 1.0f;
}
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
auto reformer = IndexFactory::CreateReformer(index_meta.reformer_name());
ASSERT_TRUE(reformer != nullptr);
ASSERT_EQ(0, reformer->init(index_meta.reformer_params()));
std::string new_query;
IndexQueryMeta new_meta;
ASSERT_EQ(0, reformer->transform(query_vec.data(), query_meta, &new_query,
&new_meta));
auto context = searcher->create_context();
ASSERT_TRUE(!!context);
size_t topk = 50;
context->set_topk(topk);
ASSERT_EQ(0, searcher->search_impl(new_query.data(), new_meta, 1, context));
const auto &results = context->result(0);
ASSERT_EQ(topk, results.size());
// Test with radius threshold
float radius = 0.5f;
context->set_threshold(radius);
ASSERT_EQ(0, searcher->search_impl(new_query.data(), new_meta, 1, context));
ASSERT_GT(topk, results.size());
for (size_t k = 0; k < results.size(); ++k) {
ASSERT_GE(radius, results[k].score());
}
// Test reset threshold
context->reset_threshold();
ASSERT_EQ(0, searcher->search_impl(new_query.data(), new_meta, 1, context));
ASSERT_EQ(topk, results.size());
ASSERT_LT(radius, results[topk - 1].score());
}
TEST_F(HnswRabitqSearcherTest, TestMultipleQueries) {
// Build index first
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<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] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
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 + "/TestMultipleQueries";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
// Test searcher with multiple queries
auto searcher = IndexFactory::CreateSearcher("HnswRabitqSearcher");
ASSERT_NE(searcher, nullptr);
ailego::Params search_params;
search_params.set("proxima.hnsw_rabitq.searcher.ef", 100UL);
ASSERT_EQ(0, searcher->init(search_params));
auto loader = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_NE(loader, nullptr);
ASSERT_EQ(0, loader->init(ailego::Params()));
ASSERT_EQ(0, loader->open(path, false));
ASSERT_EQ(0, searcher->load(loader, nullptr));
// Test with different query vectors
for (size_t query_id = 0; query_id < 5; ++query_id) {
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(query_id * dim + j) / 1000.0f;
}
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
auto context = searcher->create_context();
ASSERT_TRUE(!!context);
context->set_topk(20);
ASSERT_EQ(0,
searcher->search_impl(query_vec.data(), query_meta, 1, context));
const auto &result = context->result(0);
ASSERT_GT(result.size(), 0UL);
ASSERT_LE(result.size(), 20UL);
// Verify results are sorted
for (size_t i = 1; i < result.size(); ++i) {
ASSERT_LE(result[i - 1].score(), result[i].score());
}
}
}
TEST_F(HnswRabitqSearcherTest, TestDifferentTopK) {
// Build index first
IndexBuilder::Pointer builder =
IndexFactory::CreateBuilder("HnswRabitqBuilder");
ASSERT_NE(builder, nullptr);
auto holder =
make_shared<MultiPassIndexProvider<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] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec)));
}
ailego::Params params;
params.set("proxima.rabitq.num_clusters", 16UL);
params.set("proxima.rabitq.total_bits", 2UL);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
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 + "/TestDifferentTopK";
ASSERT_EQ(0, dumper->create(path));
ASSERT_EQ(0, builder->dump(dumper));
ASSERT_EQ(0, dumper->close());
// Test searcher with different topk values
auto searcher = IndexFactory::CreateSearcher("HnswRabitqSearcher");
ASSERT_NE(searcher, nullptr);
ailego::Params search_params;
search_params.set("proxima.hnsw_rabitq.searcher.ef", 100UL);
ASSERT_EQ(0, searcher->init(search_params));
auto loader = IndexFactory::CreateStorage("FileReadStorage");
ASSERT_NE(loader, nullptr);
ASSERT_EQ(0, loader->init(ailego::Params()));
ASSERT_EQ(0, loader->open(path, false));
ASSERT_EQ(0, searcher->load(loader, nullptr));
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(j) / 1000.0f;
}
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
// Test with different topk values
std::vector<size_t> topk_values = {1, 5, 10, 20, 50, 100};
for (size_t topk : topk_values) {
auto context = searcher->create_context();
ASSERT_TRUE(!!context);
context->set_topk(topk);
ASSERT_EQ(0,
searcher->search_impl(query_vec.data(), query_meta, 1, context));
const auto &result = context->result(0);
ASSERT_GT(result.size(), 0UL);
ASSERT_LE(result.size(), topk);
// Verify results are sorted
for (size_t i = 1; i < result.size(); ++i) {
ASSERT_LE(result[i - 1].score(), result[i].score());
}
}
}
} // namespace core
} // namespace zvec
#if defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic pop
#endif
@@ -0,0 +1,618 @@
// 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 "hnsw_rabitq_streamer.h"
#include <memory>
#include <gtest/gtest.h>
#include "zvec/ailego/container/params.h"
#include "zvec/core/framework/index_holder.h"
#include "zvec/core/framework/index_streamer.h"
#include "hnsw_rabitq_streamer.h"
#include "rabitq_converter.h"
#include "rabitq_reformer.h"
using namespace std;
using namespace zvec::ailego;
namespace zvec {
namespace core {
constexpr size_t static dim = 128;
class HnswRabitqStreamerTest : public testing::Test {
protected:
void SetUp(void);
void TearDown(void);
static std::string dir_;
static shared_ptr<IndexMeta> index_meta_ptr_;
};
std::string HnswRabitqStreamerTest::dir_("hnswRabitqStreamerTest");
shared_ptr<IndexMeta> HnswRabitqStreamerTest::index_meta_ptr_;
void HnswRabitqStreamerTest::SetUp(void) {
index_meta_ptr_.reset(new (nothrow)
IndexMeta(IndexMeta::DataType::DT_FP32, dim));
index_meta_ptr_->set_metric("SquaredEuclidean", 0, ailego::Params());
}
void HnswRabitqStreamerTest::TearDown(void) {
char cmdBuf[100];
snprintf(cmdBuf, 100, "rm -rf %s", dir_.c_str());
system(cmdBuf);
}
TEST_F(HnswRabitqStreamerTest, TestBuildAndSearch) {
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 1000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i * dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, vec));
}
RabitqConverter converter;
converter.init(*index_meta_ptr_, ailego::Params());
ASSERT_EQ(converter.train(holder), 0);
std::shared_ptr<IndexReformer> index_reformer;
ASSERT_EQ(converter.to_reformer(&index_reformer), 0);
auto reformer = std::dynamic_pointer_cast<RabitqReformer>(index_reformer);
IndexStreamer::Pointer streamer =
std::make_shared<HnswRabitqStreamer>(holder, reformer);
ailego::Params params;
params.set("proxima.hnsw_rabitq.streamer.max_neighbor_count", 16U);
params.set("proxima.hnsw_rabitq.streamer.upper_neighbor_count", 8U);
params.set("proxima.hnsw_rabitq.streamer.scaling_factor", 5U);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
auto storage = IndexFactory::CreateStorage("MMapFileStorage");
ASSERT_NE(nullptr, storage);
ailego::Params stg_params;
ASSERT_EQ(0, storage->init(stg_params));
ASSERT_EQ(0, storage->open(dir_ + "/Test/AddVector", true));
ASSERT_EQ(0, streamer->open(storage));
auto context = streamer->create_context();
for (auto it = holder->create_iterator(); it->is_valid(); it->next()) {
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
ASSERT_EQ(0,
streamer->add_impl(it->key(), it->data(), query_meta, context));
}
streamer->flush(0UL);
// Perform search verification
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(j) / 1000.0f;
}
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
context->set_topk(10);
ASSERT_EQ(0, streamer->search_impl(query_vec.data(), query_meta, 1, context));
const auto &result = context->result(0);
ASSERT_GT(result.size(), 0UL);
ASSERT_LE(result.size(), 10UL);
// reopen and load reformer from storage
ASSERT_EQ(0, streamer->close());
IndexStreamer::Pointer new_streamer =
std::make_shared<HnswRabitqStreamer>(holder);
ASSERT_EQ(0, new_streamer->init(*index_meta_ptr_, params));
ASSERT_EQ(0, new_streamer->open(storage));
}
TEST_F(HnswRabitqStreamerTest, TestLinearSearch) {
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 1000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i);
}
ASSERT_TRUE(holder->emplace(i, vec));
}
RabitqConverter converter;
converter.init(*index_meta_ptr_, ailego::Params());
ASSERT_EQ(converter.train(holder), 0);
std::shared_ptr<IndexReformer> index_reformer;
ASSERT_EQ(converter.to_reformer(&index_reformer), 0);
auto reformer = std::dynamic_pointer_cast<RabitqReformer>(index_reformer);
IndexStreamer::Pointer streamer =
std::make_shared<HnswRabitqStreamer>(holder, reformer);
ailego::Params params;
params.set("proxima.hnsw_rabitq.streamer.max_neighbor_count", 16U);
params.set("proxima.hnsw_rabitq.streamer.upper_neighbor_count", 8U);
params.set("proxima.hnsw_rabitq.streamer.scaling_factor", 5U);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
auto storage = IndexFactory::CreateStorage("MMapFileStorage");
ASSERT_NE(nullptr, storage);
ailego::Params stg_params;
ASSERT_EQ(0, storage->init(stg_params));
ASSERT_EQ(0, storage->open(dir_ + "/TestLinearSearch", true));
ASSERT_EQ(0, streamer->open(storage));
auto context = streamer->create_context();
for (auto it = holder->create_iterator(); it->is_valid(); it->next()) {
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
ASSERT_EQ(0,
streamer->add_impl(it->key(), it->data(), query_meta, context));
}
// Test linear search with exact match
size_t topk = 3;
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
NumericalVector<float> query_vec(dim);
for (size_t i = 0; i < doc_cnt; i += 100) {
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(i);
}
context->set_topk(1U);
ASSERT_EQ(0,
streamer->search_bf_impl(query_vec.data(), query_meta, context));
auto &result1 = context->result();
ASSERT_EQ(1UL, result1.size());
ASSERT_EQ(i, result1[0].key());
// Test with slight offset
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(i) + 0.1f;
}
context->set_topk(topk);
ASSERT_EQ(0,
streamer->search_bf_impl(query_vec.data(), query_meta, context));
auto &result2 = context->result();
ASSERT_EQ(topk, result2.size());
ASSERT_EQ(i, result2[0].key());
}
}
TEST_F(HnswRabitqStreamerTest, TestKnnSearch) {
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 2000UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i);
}
ASSERT_TRUE(holder->emplace(i, vec));
}
RabitqConverter converter;
converter.init(*index_meta_ptr_, ailego::Params());
ASSERT_EQ(converter.train(holder), 0);
std::shared_ptr<IndexReformer> index_reformer;
ASSERT_EQ(converter.to_reformer(&index_reformer), 0);
auto reformer = std::dynamic_pointer_cast<RabitqReformer>(index_reformer);
IndexStreamer::Pointer streamer =
std::make_shared<HnswRabitqStreamer>(holder, reformer);
ailego::Params params;
params.set("proxima.hnsw_rabitq.streamer.max_neighbor_count", 16U);
params.set("proxima.hnsw_rabitq.streamer.upper_neighbor_count", 8U);
params.set("proxima.hnsw_rabitq.streamer.scaling_factor", 10U);
params.set("proxima.hnsw_rabitq.streamer.efconstruction", 100U);
params.set("proxima.hnsw_rabitq.streamer.ef", 50U);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
auto storage = IndexFactory::CreateStorage("MMapFileStorage");
ASSERT_NE(nullptr, storage);
ailego::Params stg_params;
ASSERT_EQ(0, storage->init(stg_params));
ASSERT_EQ(0, storage->open(dir_ + "/TestKnnSearch", true));
ASSERT_EQ(0, streamer->open(storage));
auto context = streamer->create_context();
for (auto it = holder->create_iterator(); it->is_valid(); it->next()) {
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
ASSERT_EQ(0,
streamer->add_impl(it->key(), it->data(), query_meta, context));
}
// Compare KNN search with brute force search
auto linear_ctx = streamer->create_context();
auto knn_ctx = streamer->create_context();
size_t topk = 50;
linear_ctx->set_topk(topk);
knn_ctx->set_topk(topk);
int total_hits = 0;
int total_cnts = 0;
int topk1_hits = 0;
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
NumericalVector<float> query_vec(dim);
for (size_t i = 0; i < doc_cnt; i += 100) {
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(i) + 0.1f;
}
ASSERT_EQ(0,
streamer->search_impl(query_vec.data(), query_meta, 1, knn_ctx));
ASSERT_EQ(
0, streamer->search_bf_impl(query_vec.data(), query_meta, linear_ctx));
auto &knn_result = knn_ctx->result(0);
ASSERT_EQ(topk, knn_result.size());
topk1_hits += (i == knn_result[0].key());
auto &linear_result = linear_ctx->result();
ASSERT_EQ(topk, linear_result.size());
ASSERT_EQ(i, linear_result[0].key());
for (size_t k = 0; k < topk; ++k) {
total_cnts++;
for (size_t j = 0; j < topk; ++j) {
if (linear_result[j].key() == knn_result[k].key()) {
total_hits++;
break;
}
}
}
}
float recall = total_hits * 1.0f / total_cnts;
float topk1_recall = topk1_hits * 100.0f / static_cast<float>(doc_cnt);
EXPECT_GT(recall, 0.60f);
// actual: no guarantee
// TODO(jiliang.ljl): check if ok?
EXPECT_GT(topk1_recall, 0.00f);
}
TEST_F(HnswRabitqStreamerTest, TestRandomData) {
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 1500UL;
// Add random vectors
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
}
ASSERT_TRUE(holder->emplace(i, vec));
}
RabitqConverter converter;
converter.init(*index_meta_ptr_, ailego::Params());
ASSERT_EQ(converter.train(holder), 0);
std::shared_ptr<IndexReformer> index_reformer;
ASSERT_EQ(converter.to_reformer(&index_reformer), 0);
auto reformer = std::dynamic_pointer_cast<RabitqReformer>(index_reformer);
IndexStreamer::Pointer streamer =
std::make_shared<HnswRabitqStreamer>(holder, reformer);
ailego::Params params;
params.set("proxima.hnsw_rabitq.streamer.max_neighbor_count", 32U);
params.set("proxima.hnsw_rabitq.streamer.upper_neighbor_count", 16U);
params.set("proxima.hnsw_rabitq.streamer.scaling_factor", 20U);
params.set("proxima.hnsw_rabitq.streamer.efconstruction", 200U);
params.set("proxima.hnsw_rabitq.streamer.ef", 100U);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
auto storage = IndexFactory::CreateStorage("MMapFileStorage");
ASSERT_NE(nullptr, storage);
ailego::Params stg_params;
ASSERT_EQ(0, storage->init(stg_params));
ASSERT_EQ(0, storage->open(dir_ + "/TestRandomData", true));
ASSERT_EQ(0, streamer->open(storage));
auto context = streamer->create_context();
for (auto it = holder->create_iterator(); it->is_valid(); it->next()) {
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
ASSERT_EQ(0,
streamer->add_impl(it->key(), it->data(), query_meta, context));
}
// Test with random queries
auto linear_ctx = streamer->create_context();
auto knn_ctx = streamer->create_context();
size_t topk = 50;
linear_ctx->set_topk(topk);
knn_ctx->set_topk(topk);
int total_hits = 0;
int total_cnts = 0;
int topk1_hits = 0;
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
NumericalVector<float> query_vec(dim);
size_t query_cnt = 200;
for (size_t i = 0; i < query_cnt; i++) {
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
}
ASSERT_EQ(
0, streamer->search_bf_impl(query_vec.data(), query_meta, linear_ctx));
ASSERT_EQ(0,
streamer->search_impl(query_vec.data(), query_meta, 1, knn_ctx));
auto &knn_result = knn_ctx->result(0);
ASSERT_EQ(topk, knn_result.size());
auto &linear_result = linear_ctx->result();
ASSERT_EQ(topk, linear_result.size());
topk1_hits += (linear_result[0].key() == knn_result[0].key());
for (size_t k = 0; k < topk; ++k) {
total_cnts++;
for (size_t j = 0; j < topk; ++j) {
if (linear_result[j].key() == knn_result[k].key()) {
total_hits++;
break;
}
}
}
}
float recall = total_hits * 1.0f / total_cnts;
float topk1_recall = topk1_hits * 1.0f / query_cnt;
EXPECT_GT(recall, 0.50f);
EXPECT_GT(topk1_recall, 0.70f);
}
TEST_F(HnswRabitqStreamerTest, TestOpenClose) {
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 500UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i);
}
ASSERT_TRUE(holder->emplace(i, vec));
}
RabitqConverter converter;
converter.init(*index_meta_ptr_, ailego::Params());
ASSERT_EQ(converter.train(holder), 0);
std::shared_ptr<IndexReformer> index_reformer;
ASSERT_EQ(converter.to_reformer(&index_reformer), 0);
auto reformer = std::dynamic_pointer_cast<RabitqReformer>(index_reformer);
ailego::Params params;
params.set("proxima.hnsw_rabitq.streamer.max_neighbor_count", 16U);
params.set("proxima.hnsw_rabitq.streamer.upper_neighbor_count", 8U);
params.set("proxima.hnsw_rabitq.streamer.scaling_factor", 5U);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
auto storage = IndexFactory::CreateStorage("MMapFileStorage");
ASSERT_NE(nullptr, storage);
ailego::Params stg_params;
ASSERT_EQ(0, storage->init(stg_params));
ASSERT_EQ(0, storage->open(dir_ + "/TestOpenClose", true));
IndexStreamer::Pointer streamer =
std::make_shared<HnswRabitqStreamer>(holder, reformer);
ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
ASSERT_EQ(0, streamer->open(storage));
auto context = streamer->create_context();
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
// Add first half of vectors
for (size_t i = 0; i < doc_cnt / 2; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i);
}
ASSERT_EQ(0, streamer->add_impl(i, vec.data(), query_meta, context));
}
ASSERT_EQ(0, streamer->flush(0UL));
ASSERT_EQ(0, streamer->close());
// Reopen and add second half
IndexStreamer::Pointer streamer2 =
std::make_shared<HnswRabitqStreamer>(holder);
ASSERT_EQ(0, streamer2->init(*index_meta_ptr_, params));
ASSERT_EQ(0, streamer2->open(storage));
auto context2 = streamer2->create_context();
for (size_t i = doc_cnt / 2; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i);
}
ASSERT_EQ(0, streamer2->add_impl(i, vec.data(), query_meta, context2));
}
ASSERT_EQ(0, streamer2->flush(0UL));
// Verify search works after reopen
NumericalVector<float> query_vec(dim);
for (size_t j = 0; j < dim; ++j) {
query_vec[j] = 10.0f;
}
context2->set_topk(5);
ASSERT_EQ(0,
streamer2->search_impl(query_vec.data(), query_meta, 1, context2));
const auto &result = context2->result(0);
ASSERT_EQ(5UL, result.size());
ASSERT_EQ(10UL, result[0].key());
}
TEST_F(HnswRabitqStreamerTest, TestCreateIterator) {
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(dim);
size_t doc_cnt = 300UL;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i);
}
ASSERT_TRUE(holder->emplace(i, vec));
}
RabitqConverter converter;
converter.init(*index_meta_ptr_, ailego::Params());
ASSERT_EQ(converter.train(holder), 0);
std::shared_ptr<IndexReformer> index_reformer;
ASSERT_EQ(converter.to_reformer(&index_reformer), 0);
auto reformer = std::dynamic_pointer_cast<RabitqReformer>(index_reformer);
IndexStreamer::Pointer streamer =
std::make_shared<HnswRabitqStreamer>(holder, reformer);
ailego::Params params;
params.set("proxima.hnsw_rabitq.streamer.max_neighbor_count", 16U);
params.set("proxima.hnsw_rabitq.streamer.upper_neighbor_count", 8U);
params.set("proxima.hnsw_rabitq.streamer.scaling_factor", 5U);
params.set("proxima.hnsw_rabitq.general.dimension", dim);
ASSERT_EQ(0, streamer->init(*index_meta_ptr_, params));
auto storage = IndexFactory::CreateStorage("MMapFileStorage");
ASSERT_NE(nullptr, storage);
ailego::Params stg_params;
ASSERT_EQ(0, storage->init(stg_params));
ASSERT_EQ(0, storage->open(dir_ + "/TestCreateIterator", true));
ASSERT_EQ(0, streamer->open(storage));
auto context = streamer->create_context();
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, dim);
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(dim);
for (size_t j = 0; j < dim; ++j) {
vec[j] = static_cast<float>(i);
}
ASSERT_EQ(0, streamer->add_impl(i, vec.data(), query_meta, context));
}
streamer->flush(0UL);
// Test iterator
auto provider = streamer->create_provider();
auto iter = provider->create_iterator();
ASSERT_TRUE(!!iter);
size_t count = 0;
while (iter->is_valid()) {
ASSERT_EQ(count, iter->key());
// const float *data = (const float *)iter->data();
// for (size_t j = 0; j < dim; ++j) {
// ASSERT_EQ(static_cast<float>(count), data[j]);
// }
iter->next();
count++;
}
ASSERT_EQ(doc_cnt, count);
// Test get_vector
// for (size_t i = 0; i < doc_cnt; i++) {
// const float *data = (const float *)provider->get_vector(i);
// ASSERT_NE(data, nullptr);
// for (size_t j = 0; j < dim; ++j) {
// ASSERT_EQ(static_cast<float>(i), data[j]);
// }
// }
}
TEST_F(HnswRabitqStreamerTest, TestDimensions) {
std::vector<size_t> dimensions = {1, 2, 4, 8, 16, 32, 33,
63, 64, 128, 256, 512, 1024, 2047,
2048, 2049, 4095, 4096, 4097, 8192, 16384};
size_t doc_cnt = 100;
for (size_t test_dim : dimensions) {
std::cout << "Testing dimension: " << test_dim << std::endl;
IndexMeta index_meta(IndexMeta::DataType::DT_FP32, test_dim);
index_meta.set_metric("SquaredEuclidean", 0, ailego::Params());
auto holder =
make_shared<MultiPassIndexProvider<IndexMeta::DataType::DT_FP32>>(
test_dim);
IndexStreamer::Pointer streamer =
std::make_shared<HnswRabitqStreamer>(holder);
ailego::Params params;
params.set("proxima.hnsw_rabitq.streamer.max_neighbor_count", 16U);
params.set("proxima.hnsw_rabitq.streamer.upper_neighbor_count", 8U);
params.set("proxima.hnsw_rabitq.streamer.scaling_factor", 5U);
params.set("proxima.hnsw_rabitq.general.dimension", test_dim);
int ret = streamer->init(index_meta, params);
// dimension <= 63 or >= 4096: init() should return -31
if (test_dim <= 63 || test_dim >= 4096) {
ASSERT_EQ(-31, ret) << "expected init to fail with -31, dim=" << test_dim;
std::cout << "Dimension " << test_dim
<< " correctly rejected with ret=" << ret << std::endl;
continue;
}
// Valid dimensions: verify full streaming build succeeds
ASSERT_EQ(0, ret) << "init failed, dim=" << test_dim;
for (size_t i = 0; i < doc_cnt; i++) {
NumericalVector<float> vec(test_dim);
for (size_t j = 0; j < test_dim; ++j) {
vec[j] = static_cast<float>(i * test_dim + j) / 1000.0f;
}
ASSERT_TRUE(holder->emplace(i, std::move(vec))) << "dim=" << test_dim;
}
RabitqConverter converter;
converter.init(index_meta, ailego::Params());
ASSERT_EQ(0, converter.train(holder))
<< "converter train failed, dim=" << test_dim;
std::shared_ptr<IndexReformer> index_reformer;
ASSERT_EQ(0, converter.to_reformer(&index_reformer)) << "dim=" << test_dim;
auto reformer = std::dynamic_pointer_cast<RabitqReformer>(index_reformer);
// Recreate streamer with reformer
streamer = std::make_shared<HnswRabitqStreamer>(holder, reformer);
ASSERT_EQ(0, streamer->init(index_meta, params))
<< "init with reformer failed, dim=" << test_dim;
auto storage = IndexFactory::CreateStorage("MMapFileStorage");
ASSERT_NE(nullptr, storage);
ailego::Params stg_params;
ASSERT_EQ(0, storage->init(stg_params));
std::string storage_path =
dir_ + "/TestDimensions_" + std::to_string(test_dim);
ASSERT_EQ(0, storage->open(storage_path, true))
<< "storage open failed, dim=" << test_dim;
ASSERT_EQ(0, streamer->open(storage))
<< "streamer open failed, dim=" << test_dim;
auto context = streamer->create_context();
IndexQueryMeta query_meta(IndexMeta::DataType::DT_FP32, test_dim);
for (auto it = holder->create_iterator(); it->is_valid(); it->next()) {
ASSERT_EQ(0,
streamer->add_impl(it->key(), it->data(), query_meta, context))
<< "add failed, dim=" << test_dim << ", key=" << it->key();
}
ASSERT_EQ(0, streamer->flush(0UL)) << "flush failed, dim=" << test_dim;
std::cout << "Dimension " << test_dim << " passed" << std::endl;
}
}
} // namespace core
} // namespace zvec