vectordb-bench 0.0.25__py3-none-any.whl → 0.0.26__py3-none-any.whl

vectordb_bench/backend/clients/api.py

@@ -16,10 +16,15 @@ class MetricType(str, Enum):
 
 class IndexType(str, Enum):
     HNSW = "HNSW"
+    HNSW_SQ = "HNSW_SQ"
+    HNSW_PQ = "HNSW_PQ"
+    HNSW_PRQ = "HNSW_PRQ"
     DISKANN = "DISKANN"
     STREAMING_DISKANN = "DISKANN"
     IVFFlat = "IVF_FLAT"
+    IVFPQ = "IVF_PQ"
     IVFSQ8 = "IVF_SQ8"
+    IVF_RABITQ = "IVF_RABITQ"
     Flat = "FLAT"
     AUTOINDEX = "AUTOINDEX"
     ES_HNSW = "hnsw"
@@ -31,6 +36,14 @@ class IndexType(str, Enum):
     SCANN = "scann"
 
 
+class SQType(str, Enum):
+    SQ6 = "SQ6"
+    SQ8 = "SQ8"
+    BF16 = "BF16"
+    FP16 = "FP16"
+    FP32 = "FP32"
+
+
 class DBConfig(ABC, BaseModel):
     """DBConfig contains the connection info of vector database
 

vectordb_bench/backend/clients/clickhouse/clickhouse.py

@@ -5,8 +5,11 @@ from contextlib import contextmanager
 from typing import Any
 
 import clickhouse_connect
+from clickhouse_connect.driver import Client
 
-from ..api import DBCaseConfig, VectorDB
+from .. import IndexType
+from ..api import VectorDB
+from .config import ClickhouseConfigDict, ClickhouseIndexConfig
 
 log = logging.getLogger(__name__)
 
@@ -17,8 +20,8 @@ class Clickhouse(VectorDB):
     def __init__(
         self,
         dim: int,
-        db_config: dict,
-        db_case_config: DBCaseConfig,
+        db_config: ClickhouseConfigDict,
+        db_case_config: ClickhouseIndexConfig,
         collection_name: str = "CHVectorCollection",
         drop_old: bool = False,
         **kwargs,
@@ -28,29 +31,29 @@ class Clickhouse(VectorDB):
         self.table_name = collection_name
         self.dim = dim
 
+        self.index_param = self.case_config.index_param()
+        self.search_param = self.case_config.search_param()
+        self.session_param = self.case_config.session_param()
+
         self._index_name = "clickhouse_index"
         self._primary_field = "id"
         self._vector_field = "embedding"
 
         # construct basic units
-        self.conn = clickhouse_connect.get_client(
-            host=self.db_config["host"],
-            port=self.db_config["port"],
-            username=self.db_config["user"],
-            password=self.db_config["password"],
-            database=self.db_config["dbname"],
-        )
+        self.conn = self._create_connection(**self.db_config, settings=self.session_param)
 
         if drop_old:
             log.info(f"Clickhouse client drop table : {self.table_name}")
             self._drop_table()
             self._create_table(dim)
+            if self.case_config.create_index_before_load:
+                self._create_index()
 
         self.conn.close()
         self.conn = None
 
     @contextmanager
-    def init(self):
+    def init(self) -> None:
         """
         Examples:
             >>> with self.init():
@@ -58,13 +61,7 @@ class Clickhouse(VectorDB):
             >>>     self.search_embedding()
         """
 
-        self.conn = clickhouse_connect.get_client(
-            host=self.db_config["host"],
-            port=self.db_config["port"],
-            username=self.db_config["user"],
-            password=self.db_config["password"],
-            database=self.db_config["dbname"],
-        )
+        self.conn = self._create_connection(**self.db_config, settings=self.session_param)
 
         try:
             yield
@@ -72,10 +69,61 @@ class Clickhouse(VectorDB):
             self.conn.close()
             self.conn = None
 
+    def _create_connection(self, settings: dict | None, **kwargs) -> Client:
+        return clickhouse_connect.get_client(**self.db_config, settings=settings)
+
+    def _drop_index(self):
+        assert self.conn is not None, "Connection is not initialized"
+        try:
+            self.conn.command(
+                f'ALTER TABLE {self.db_config["database"]}.{self.table_name} DROP INDEX {self._index_name}'
+            )
+        except Exception as e:
+            log.warning(f"Failed to drop index on table {self.db_config['database']}.{self.table_name}: {e}")
+            raise e from None
+
     def _drop_table(self):
         assert self.conn is not None, "Connection is not initialized"
 
-        self.conn.command(f'DROP TABLE IF EXISTS {self.db_config["dbname"]}.{self.table_name}')
+        try:
+            self.conn.command(f'DROP TABLE IF EXISTS {self.db_config["database"]}.{self.table_name}')
+        except Exception as e:
+            log.warning(f"Failed to drop table {self.db_config['database']}.{self.table_name}: {e}")
+            raise e from None
+
+    def _perfomance_tuning(self):
+        self.conn.command("SET materialize_skip_indexes_on_insert = 1")
+
+    def _create_index(self):
+        assert self.conn is not None, "Connection is not initialized"
+        try:
+            if self.index_param["index_type"] == IndexType.HNSW.value:
+                if (
+                    self.index_param["quantization"]
+                    and self.index_param["params"]["M"]
+                    and self.index_param["params"]["efConstruction"]
+                ):
+                    query = f"""
+                        ALTER TABLE {self.db_config["database"]}.{self.table_name}
+                        ADD INDEX {self._index_name} {self._vector_field}
+                        TYPE vector_similarity('hnsw', '{self.index_param["metric_type"]}',
+                        '{self.index_param["quantization"]}',
+                        {self.index_param["params"]["M"]}, {self.index_param["params"]["efConstruction"]})
+                        GRANULARITY {self.index_param["granularity"]}
+                        """
+                else:
+                    query = f"""
+                        ALTER TABLE {self.db_config["database"]}.{self.table_name}
+                        ADD INDEX {self._index_name} {self._vector_field}
+                        TYPE vector_similarity('hnsw', '{self.index_param["metric_type"]}')
+                        GRANULARITY {self.index_param["granularity"]}
+                        """
+                self.conn.command(cmd=query)
+            else:
+                log.warning("HNSW is only avaliable method in clickhouse now")
+        except Exception as e:
+            log.warning(f"Failed to create Clickhouse vector index on table: {self.table_name} error: {e}")
+            raise e from None
 
     def _create_table(self, dim: int):
         assert self.conn is not None, "Connection is not initialized"
@@ -83,21 +131,22 @@ class Clickhouse(VectorDB):
         try:
             # create table
             self.conn.command(
-                f'CREATE TABLE IF NOT EXISTS {self.db_config["dbname"]}.{self.table_name} \
-                    (id UInt32, embedding Array(Float64)) ENGINE = MergeTree() ORDER BY id;'
+                f'CREATE TABLE IF NOT EXISTS {self.db_config["database"]}.{self.table_name} '
+                f"({self._primary_field} UInt32, "
+                f'{self._vector_field} Array({self.index_param["vector_data_type"]}) CODEC(NONE), '
+                f"CONSTRAINT same_length CHECK length(embedding) = {dim}) "
+                f"ENGINE = MergeTree() "
+                f"ORDER BY {self._primary_field}"
             )
 
         except Exception as e:
             log.warning(f"Failed to create Clickhouse table: {self.table_name} error: {e}")
             raise e from None
 
-    def ready_to_load(self):
-        pass
-
     def optimize(self, data_size: int | None = None):
         pass
 
-    def ready_to_search(self):
+    def _post_insert(self):
         pass
 
     def insert_embeddings(
@@ -105,7 +154,7 @@ class Clickhouse(VectorDB):
         embeddings: list[list[float]],
         metadata: list[int],
         **kwargs: Any,
-    ) -> tuple[int, Exception]:
+    ) -> (int, Exception):
         assert self.conn is not None, "Connection is not initialized"
 
         try:
@@ -116,7 +165,7 @@ class Clickhouse(VectorDB):
                 table=self.table_name,
                 data=items,
                 column_names=["id", "embedding"],
-                column_type_names=["UInt32", "Array(Float64)"],
+                column_type_names=["UInt32", f'Array({self.index_param["vector_data_type"]})'],
                 column_oriented=True,
             )
             return len(metadata), None
@@ -132,25 +181,52 @@ class Clickhouse(VectorDB):
         timeout: int | None = None,
     ) -> list[int]:
         assert self.conn is not None, "Connection is not initialized"
-
-        index_param = self.case_config.index_param()  # noqa: F841
-        search_param = self.case_config.search_param()
-
-        if filters:
-            gt = filters.get("id")
-            filter_sql = (
-                f'SELECT id, {search_param["metric_type"]}(embedding,{query}) AS score '  # noqa: S608
-                f'FROM {self.db_config["dbname"]}.{self.table_name}  '
-                f"WHERE id > {gt} "
-                f"ORDER BY score LIMIT {k};"
-            )
-            result = self.conn.query(filter_sql).result_rows
+        parameters = {
+            "primary_field": self._primary_field,
+            "vector_field": self._vector_field,
+            "schema": self.db_config["database"],
+            "table": self.table_name,
+            "gt": filters.get("id"),
+            "k": k,
+            "metric_type": self.search_param["metric_type"],
+            "query": query,
+        }
+        if self.case_config.metric_type == "COSINE":
+            if filters:
+                result = self.conn.query(
+                    "SELECT {primary_field:Identifier}, {vector_field:Identifier} "
+                    "FROM {schema:Identifier}.{table:Identifier} "
+                    "WHERE {primary_field:Identifier} > {gt:UInt32} "
+                    "ORDER BY cosineDistance(embedding,{query:Array(Float64)}) "
+                    "LIMIT {k:UInt32}",
+                    parameters=parameters,
+                ).result_rows
+                return [int(row[0]) for row in result]
+
+            result = self.conn.query(
+                "SELECT {primary_field:Identifier}, {vector_field:Identifier} "
+                "FROM {schema:Identifier}.{table:Identifier} "
+                "ORDER BY cosineDistance(embedding,{query:Array(Float64)}) "
+                "LIMIT {k:UInt32}",
+                parameters=parameters,
+            ).result_rows
             return [int(row[0]) for row in result]
-        else:  # noqa: RET505
-            select_sql = (
-                f'SELECT id, {search_param["metric_type"]}(embedding,{query}) AS score '  # noqa: S608
-                f'FROM {self.db_config["dbname"]}.{self.table_name}  '
-                f"ORDER BY score LIMIT {k};"
-            )
-            result = self.conn.query(select_sql).result_rows
+        if filters:
+            result = self.conn.query(
+                "SELECT {primary_field:Identifier}, {vector_field:Identifier} "
+                "FROM {schema:Identifier}.{table:Identifier} "
+                "WHERE {primary_field:Identifier} > {gt:UInt32} "
+                "ORDER BY L2Distance(embedding,{query:Array(Float64)}) "
+                "LIMIT {k:UInt32}",
+                parameters=parameters,
+            ).result_rows
             return [int(row[0]) for row in result]
+
+        result = self.conn.query(
+            "SELECT {primary_field:Identifier}, {vector_field:Identifier} "
+            "FROM {schema:Identifier}.{table:Identifier} "
+            "ORDER BY L2Distance(embedding,{query:Array(Float64)}) "
+            "LIMIT {k:UInt32}",
+            parameters=parameters,
+        ).result_rows
+        return [int(row[0]) for row in result]

vectordb_bench/backend/clients/clickhouse/config.py

@@ -1,29 +1,46 @@
+from abc import abstractmethod
+from typing import TypedDict
+
 from pydantic import BaseModel, SecretStr
 
 from ..api import DBCaseConfig, DBConfig, IndexType, MetricType
 
 
+class ClickhouseConfigDict(TypedDict):
+    user: str
+    password: str
+    host: str
+    port: int
+    database: str
+    secure: bool
+
+
 class ClickhouseConfig(DBConfig):
     user_name: str = "clickhouse"
     password: SecretStr
     host: str = "localhost"
     port: int = 8123
     db_name: str = "default"
+    secure: bool = False
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> ClickhouseConfigDict:
         pwd_str = self.password.get_secret_value()
         return {
             "host": self.host,
             "port": self.port,
-            "dbname": self.db_name,
+            "database": self.db_name,
             "user": self.user_name,
             "password": pwd_str,
+            "secure": self.secure,
         }
 
 
-class ClickhouseIndexConfig(BaseModel):
+class ClickhouseIndexConfig(BaseModel, DBCaseConfig):
 
     metric_type: MetricType | None = None
+    vector_data_type: str | None = "Float32"  # Data type of vectors. Can be Float32 or Float64 or BFloat16
+    create_index_before_load: bool = True
+    create_index_after_load: bool = False
 
     def parse_metric(self) -> str:
         if not self.metric_type:
@@ -35,26 +52,38 @@ class ClickhouseIndexConfig(BaseModel):
             return "L2Distance"
         if self.metric_type == MetricType.COSINE:
             return "cosineDistance"
-        msg = f"Not Support for {self.metric_type}"
-        raise RuntimeError(msg)
-        return None
+        return "cosineDistance"
+
+    @abstractmethod
+    def session_param(self):
+        pass
 
 
-class ClickhouseHNSWConfig(ClickhouseIndexConfig, DBCaseConfig):
-    M: int | None
-    efConstruction: int | None
+class ClickhouseHNSWConfig(ClickhouseIndexConfig):
+    M: int | None  # Default in clickhouse in 32
+    efConstruction: int | None  # Default in clickhouse in 128
     ef: int | None = None
     index: IndexType = IndexType.HNSW
+    quantization: str | None = "bf16"  # Default is bf16. Possible values are f64, f32, f16, bf16, or i8
+    granularity: int | None = 10_000_000  # Size of the index granules. By default, in CH it's equal 10.000.000
 
     def index_param(self) -> dict:
         return {
+            "vector_data_type": self.vector_data_type,
             "metric_type": self.parse_metric_str(),
             "index_type": self.index.value,
+            "quantization": self.quantization,
+            "granularity": self.granularity,
             "params": {"M": self.M, "efConstruction": self.efConstruction},
         }
 
     def search_param(self) -> dict:
         return {
-            "met˝ric_type": self.parse_metric_str(),
+            "metric_type": self.parse_metric_str(),
             "params": {"ef": self.ef},
         }
+
+    def session_param(self) -> dict:
+        return {
+            "allow_experimental_vector_similarity_index": 1,
+        }

vectordb_bench/backend/clients/milvus/config.py

@@ -1,6 +1,6 @@
 from pydantic import BaseModel, SecretStr, validator
 
-from ..api import DBCaseConfig, DBConfig, IndexType, MetricType
+from ..api import DBCaseConfig, DBConfig, IndexType, MetricType, SQType
 
 
 class MilvusConfig(DBConfig):
@@ -88,6 +88,88 @@ class HNSWConfig(MilvusIndexConfig, DBCaseConfig):
         }
 
 
+class HNSWSQConfig(HNSWConfig, DBCaseConfig):
+    index: IndexType = IndexType.HNSW_SQ
+    sq_type: SQType = SQType.SQ8
+    refine: bool = True
+    refine_type: SQType = SQType.FP32
+    refine_k: float = 1
+
+    def index_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "index_type": self.index.value,
+            "params": {
+                "M": self.M,
+                "efConstruction": self.efConstruction,
+                "sq_type": self.sq_type.value,
+                "refine": self.refine,
+                "refine_type": self.refine_type.value,
+            },
+        }
+
+    def search_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "params": {"ef": self.ef, "refine_k": self.refine_k},
+        }
+
+
+class HNSWPQConfig(HNSWConfig):
+    index: IndexType = IndexType.HNSW_PQ
+    m: int = 32
+    nbits: int = 8
+    refine: bool = True
+    refine_type: SQType = SQType.FP32
+    refine_k: float = 1
+
+    def index_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "index_type": self.index.value,
+            "params": {
+                "M": self.M,
+                "efConstruction": self.efConstruction,
+                "m": self.m,
+                "nbits": self.nbits,
+                "refine": self.refine,
+                "refine_type": self.refine_type.value,
+            },
+        }
+
+    def search_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "params": {"ef": self.ef, "refine_k": self.refine_k},
+        }
+
+
+class HNSWPRQConfig(HNSWPQConfig):
+    index: IndexType = IndexType.HNSW_PRQ
+    nrq: int = 2
+
+    def index_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "index_type": self.index.value,
+            "params": {
+                "M": self.M,
+                "efConstruction": self.efConstruction,
+                "m": self.m,
+                "nbits": self.nbits,
+                "nrq": self.nrq,
+                "refine": self.refine,
+                "refine_type": self.refine_type.value,
+            },
+        }
+
+    def search_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "params": {"ef": self.ef, "refine_k": self.refine_k},
+        }
+
+
 class DISKANNConfig(MilvusIndexConfig, DBCaseConfig):
     search_list: int | None = None
     index: IndexType = IndexType.DISKANN
@@ -125,6 +207,27 @@ class IVFFlatConfig(MilvusIndexConfig, DBCaseConfig):
         }
 
 
+class IVFPQConfig(MilvusIndexConfig, DBCaseConfig):
+    nlist: int
+    nprobe: int | None = None
+    m: int = 32
+    nbits: int = 8
+    index: IndexType = IndexType.IVFPQ
+
+    def index_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "index_type": self.index.value,
+            "params": {"nlist": self.nlist, "m": self.m, "nbits": self.nbits},
+        }
+
+    def search_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "params": {"nprobe": self.nprobe},
+        }
+
+
 class IVFSQ8Config(MilvusIndexConfig, DBCaseConfig):
     nlist: int
     nprobe: int | None = None
@@ -144,6 +247,31 @@ class IVFSQ8Config(MilvusIndexConfig, DBCaseConfig):
         }
 
 
+class IVFRABITQConfig(IVFSQ8Config):
+    index: IndexType = IndexType.IVF_RABITQ
+    rbq_bits_query: int = 0  # 0, 1, 2, ..., 8
+    refine: bool = True
+    refine_type: SQType = SQType.FP32
+    refine_k: float = 1
+
+    def index_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "index_type": self.index.value,
+            "params": {
+                "nlist": self.nlist,
+                "refine": self.refine,
+                "refine_type": self.refine_type.value,
+            },
+        }
+
+    def search_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "params": {"nprobe": self.nprobe, "rbq_bits_query": self.rbq_bits_query, "refine_k": self.refine_k},
+        }
+
+
 class FLATConfig(MilvusIndexConfig, DBCaseConfig):
     index: IndexType = IndexType.Flat
 
@@ -285,9 +413,14 @@ class GPUCAGRAConfig(MilvusIndexConfig, DBCaseConfig):
 _milvus_case_config = {
     IndexType.AUTOINDEX: AutoIndexConfig,
     IndexType.HNSW: HNSWConfig,
+    IndexType.HNSW_SQ: HNSWSQConfig,
+    IndexType.HNSW_PQ: HNSWPQConfig,
+    IndexType.HNSW_PRQ: HNSWPRQConfig,
     IndexType.DISKANN: DISKANNConfig,
     IndexType.IVFFlat: IVFFlatConfig,
+    IndexType.IVFPQ: IVFPQConfig,
     IndexType.IVFSQ8: IVFSQ8Config,
+    IndexType.IVF_RABITQ: IVFRABITQConfig,
     IndexType.Flat: FLATConfig,
     IndexType.GPU_IVF_FLAT: GPUIVFFlatConfig,
     IndexType.GPU_IVF_PQ: GPUIVFPQConfig,

vectordb_bench/backend/clients/milvus/milvus.py

@@ -61,6 +61,7 @@ class Milvus(VectorDB):
                 consistency_level="Session",
             )
 
+            log.info(f"{self.name} create index: index_params: {self.case_config.index_param()}")
             col.create_index(
                 self._vector_field,
                 self.case_config.index_param(),
@@ -71,7 +72,7 @@ class Milvus(VectorDB):
         connections.disconnect("default")
 
     @contextmanager
-    def init(self) -> None:
+    def init(self):
         """
         Examples:
             >>> with self.init():
@@ -126,6 +127,7 @@ class Milvus(VectorDB):
                 try:
                     self.col.compact()
                     self.col.wait_for_compaction_completed()
+                    log.info("compactation completed. waiting for the rest of index buliding.")
                 except Exception as e:
                     log.warning(f"{self.name} compact error: {e}")
                     if hasattr(e, "code"):

vectordb_bench/frontend/config/dbCaseConfigs.py

@@ -3,7 +3,7 @@ import typing
 from pydantic import BaseModel
 from vectordb_bench.backend.cases import CaseLabel, CaseType
 from vectordb_bench.backend.clients import DB
-from vectordb_bench.backend.clients.api import IndexType, MetricType
+from vectordb_bench.backend.clients.api import IndexType, MetricType, SQType
 from vectordb_bench.frontend.components.custom.getCustomConfig import get_custom_configs
 
 from vectordb_bench.models import CaseConfig, CaseConfigParamType
@@ -164,10 +164,14 @@ CaseConfigParamInput_IndexType = CaseConfigInput(
     inputConfig={
         "options": [
             IndexType.HNSW.value,
+            IndexType.HNSW_SQ.value,
+            IndexType.HNSW_PQ.value,
+            IndexType.HNSW_PRQ.value,
             IndexType.IVFFlat.value,
+            IndexType.IVFPQ.value,
             IndexType.IVFSQ8.value,
+            IndexType.IVF_RABITQ.value,
             IndexType.DISKANN.value,
-            IndexType.STREAMING_DISKANN.value,
             IndexType.Flat.value,
             IndexType.AUTOINDEX.value,
             IndexType.GPU_IVF_FLAT.value,
@@ -346,9 +350,16 @@ CaseConfigParamInput_M = CaseConfigInput(
         "max": 64,
         "value": 30,
     },
-    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [
+        IndexType.HNSW.value,
+        IndexType.HNSW_SQ.value,
+        IndexType.HNSW_PQ.value,
+        IndexType.HNSW_PRQ.value,
+    ],
 )
 
+
 CaseConfigParamInput_m = CaseConfigInput(
     label=CaseConfigParamType.m,
     inputType=InputType.Number,
@@ -369,7 +380,62 @@ CaseConfigParamInput_EFConstruction_Milvus = CaseConfigInput(
         "max": 512,
         "value": 360,
     },
-    isDisplayed=lambda config: config[CaseConfigParamType.IndexType] == IndexType.HNSW.value,
+    isDisplayed=lambda config: config[CaseConfigParamType.IndexType]
+    in [
+        IndexType.HNSW.value,
+        IndexType.HNSW_SQ.value,
+        IndexType.HNSW_PQ.value,
+        IndexType.HNSW_PRQ.value,
+    ],
+)
+
+CaseConfigParamInput_SQType = CaseConfigInput(
+    label=CaseConfigParamType.sq_type,
+    inputType=InputType.Option,
+    inputHelp="Scalar quantizer type.",
+    inputConfig={
+        "options": [SQType.SQ6.value, SQType.SQ8.value, SQType.BF16.value, SQType.FP16.value, SQType.FP32.value]
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) in [IndexType.HNSW_SQ.value],
+)
+
+CaseConfigParamInput_Refine = CaseConfigInput(
+    label=CaseConfigParamType.refine,
+    inputType=InputType.Option,
+    inputHelp="Whether refined data is reserved during index building.",
+    inputConfig={"options": [True, False]},
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [IndexType.HNSW_SQ.value, IndexType.HNSW_PQ.value, IndexType.HNSW_PRQ.value, IndexType.IVF_RABITQ.value],
+)
+
+CaseConfigParamInput_RefineType = CaseConfigInput(
+    label=CaseConfigParamType.refine_type,
+    inputType=InputType.Option,
+    inputHelp="The data type of the refine index.",
+    inputConfig={
+        "options": [SQType.FP32.value, SQType.FP16.value, SQType.BF16.value, SQType.SQ8.value, SQType.SQ6.value]
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [IndexType.HNSW_SQ.value, IndexType.HNSW_PQ.value, IndexType.HNSW_PRQ.value, IndexType.IVF_RABITQ.value]
+    and config.get(CaseConfigParamType.refine, True),
+)
+
+CaseConfigParamInput_RefineK = CaseConfigInput(
+    label=CaseConfigParamType.refine_k,
+    inputType=InputType.Float,
+    inputHelp="The magnification factor of refine compared to k.",
+    inputConfig={"min": 1.0, "max": 10000.0, "value": 1.0},
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [IndexType.HNSW_SQ.value, IndexType.HNSW_PQ.value, IndexType.HNSW_PRQ.value, IndexType.IVF_RABITQ.value]
+    and config.get(CaseConfigParamType.refine, True),
+)
+
+CaseConfigParamInput_RBQBitsQuery = CaseConfigInput(
+    label=CaseConfigParamType.rbq_bits_query,
+    inputType=InputType.Number,
+    inputHelp="The magnification factor of refine compared to k.",
+    inputConfig={"min": 0, "max": 8, "value": 0},
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) in [IndexType.IVF_RABITQ.value],
 )
 
 CaseConfigParamInput_EFConstruction_Weaviate = CaseConfigInput(
@@ -519,7 +585,13 @@ CaseConfigParamInput_EF_Milvus = CaseConfigInput(
         "max": MAX_STREAMLIT_INT,
         "value": 100,
     },
-    isDisplayed=lambda config: config[CaseConfigParamType.IndexType] == IndexType.HNSW.value,
+    isDisplayed=lambda config: config[CaseConfigParamType.IndexType]
+    in [
+        IndexType.HNSW.value,
+        IndexType.HNSW_SQ.value,
+        IndexType.HNSW_PQ.value,
+        IndexType.HNSW_PRQ.value,
+    ],
 )
 
 CaseConfigParamInput_EF_Weaviate = CaseConfigInput(
@@ -560,7 +632,9 @@ CaseConfigParamInput_Nlist = CaseConfigInput(
     isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
     in [
         IndexType.IVFFlat.value,
+        IndexType.IVFPQ.value,
         IndexType.IVFSQ8.value,
+        IndexType.IVF_RABITQ.value,
         IndexType.GPU_IVF_FLAT.value,
         IndexType.GPU_IVF_PQ.value,
         IndexType.GPU_BRUTE_FORCE.value,
@@ -578,7 +652,9 @@ CaseConfigParamInput_Nprobe = CaseConfigInput(
     isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
     in [
         IndexType.IVFFlat.value,
+        IndexType.IVFPQ.value,
         IndexType.IVFSQ8.value,
+        IndexType.IVF_RABITQ.value,
         IndexType.GPU_IVF_FLAT.value,
         IndexType.GPU_IVF_PQ.value,
         IndexType.GPU_BRUTE_FORCE.value,
@@ -589,11 +665,12 @@ CaseConfigParamInput_M_PQ = CaseConfigInput(
     label=CaseConfigParamType.m,
     inputType=InputType.Number,
     inputConfig={
-        "min": 0,
+        "min": 1,
         "max": 65536,
-        "value": 0,
+        "value": 32,
     },
-    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) in [IndexType.GPU_IVF_PQ.value],
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [IndexType.GPU_IVF_PQ.value, IndexType.HNSW_PQ.value, IndexType.HNSW_PRQ.value, IndexType.IVFPQ.value],
 )
 
 
@@ -605,7 +682,20 @@ CaseConfigParamInput_Nbits_PQ = CaseConfigInput(
         "max": 65536,
         "value": 8,
     },
-    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) in [IndexType.GPU_IVF_PQ.value],
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [IndexType.GPU_IVF_PQ.value, IndexType.HNSW_PQ.value, IndexType.HNSW_PRQ.value, IndexType.IVFPQ.value],
+)
+
+CaseConfigParamInput_NRQ = CaseConfigInput(
+    label=CaseConfigParamType.nrq,
+    inputType=InputType.Number,
+    inputHelp="The number of residual subquantizers.",
+    inputConfig={
+        "min": 1,
+        "max": 16,
+        "value": 2,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) in [IndexType.HNSW_PRQ.value],
 )
 
 CaseConfigParamInput_intermediate_graph_degree = CaseConfigInput(
@@ -1186,6 +1276,10 @@ MilvusLoadConfig = [
     CaseConfigParamInput_graph_degree,
     CaseConfigParamInput_build_algo,
     CaseConfigParamInput_cache_dataset_on_device,
+    CaseConfigParamInput_SQType,
+    CaseConfigParamInput_Refine,
+    CaseConfigParamInput_RefineType,
+    CaseConfigParamInput_NRQ,
 ]
 MilvusPerformanceConfig = [
     CaseConfigParamInput_IndexType,
@@ -1197,6 +1291,8 @@ MilvusPerformanceConfig = [
     CaseConfigParamInput_Nprobe,
     CaseConfigParamInput_M_PQ,
     CaseConfigParamInput_Nbits_PQ,
+    CaseConfigParamInput_RBQBitsQuery,
+    CaseConfigParamInput_NRQ,
     CaseConfigParamInput_intermediate_graph_degree,
     CaseConfigParamInput_graph_degree,
     CaseConfigParamInput_itopk_size,
@@ -1207,6 +1303,10 @@ MilvusPerformanceConfig = [
     CaseConfigParamInput_build_algo,
     CaseConfigParamInput_cache_dataset_on_device,
     CaseConfigParamInput_refine_ratio,
+    CaseConfigParamInput_SQType,
+    CaseConfigParamInput_Refine,
+    CaseConfigParamInput_RefineType,
+    CaseConfigParamInput_RefineK,
 ]
 
 WeaviateLoadConfig = [

vectordb_bench/models.py

@@ -55,6 +55,7 @@ class CaseConfigParamType(Enum):
     quantizedFetchLimit = "quantized_fetch_limit"
     m = "m"
     nbits = "nbits"
+    nrq = "nrq"
     intermediate_graph_degree = "intermediate_graph_degree"
     graph_degree = "graph_degree"
     itopk_size = "itopk_size"
@@ -65,6 +66,11 @@ class CaseConfigParamType(Enum):
     build_algo = "build_algo"
     cache_dataset_on_device = "cache_dataset_on_device"
     refine_ratio = "refine_ratio"
+    refine = "refine"
+    refine_type = "refine_type"
+    refine_k = "refine_k"
+    rbq_bits_query = "rbq_bits_query"
+    sq_type = "sq_type"
     level = "level"
     maintenance_work_mem = "maintenance_work_mem"
     max_parallel_workers = "max_parallel_workers"

{vectordb_bench-0.0.25.dist-info → vectordb_bench-0.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectordb-bench
-Version: 0.0.25
+Version: 0.0.26
 Summary: VectorDBBench is not just an offering of benchmark results for mainstream vector databases and cloud services, it's your go-to tool for the ultimate performance and cost-effectiveness comparison. Designed with ease-of-use in mind, VectorDBBench is devised to help users, even non-professionals, reproduce results or test new systems, making the hunt for the optimal choice amongst a plethora of cloud services and open-source vector databases a breeze.
 Author-email: XuanYang-cn <xuan.yang@zilliz.com>
 Project-URL: repository, https://github.com/zilliztech/VectorDBBench

{vectordb_bench-0.0.25.dist-info → vectordb_bench-0.0.26.dist-info}/RECORD

@@ -4,7 +4,7 @@ vectordb_bench/base.py,sha256=AgavIF0P9ku_RmCRk1KKziba-wI4ZpA2aJvjJzNhRSs,129
 vectordb_bench/interface.py,sha256=XaCjTgUeI17uVjsgOauPeVlkvnkuCyQOWyOaWhrgCt8,9811
 vectordb_bench/log_util.py,sha256=wDNaU_JBBOfKi_Z4vq7LDa0kOlLjoNNzDX3VZQn_Dxo,3239
 vectordb_bench/metric.py,sha256=pj-AxQHyIRHTaJY-wTIkTbC6TqEqMzt3kcEmMWEv71w,2063
-vectordb_bench/models.py,sha256=yj7WXKPpKgtyRXuLor7VbYdNQpQ5uIDT1EgWnLb9DIc,11339
+vectordb_bench/models.py,sha256=VCnmfvAr7Grtbe6EsixCq9aVdc2F14RBHXO7uJppuB4,11497
 vectordb_bench/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectordb_bench/backend/assembler.py,sha256=6GInRT7yBgfTaIPmo-XMkYX4pA8PJQmjMQInynwaunE,2047
 vectordb_bench/backend/cases.py,sha256=obDdY6g3p9Z2fog7qDwLLDuRMwo3LGQKMHsP66QZd2M,16296
@@ -14,7 +14,7 @@ vectordb_bench/backend/result_collector.py,sha256=mpROVdZ-HChKBVyMV5TZ5v7YGRb69b
 vectordb_bench/backend/task_runner.py,sha256=vlaXB0_25-G9w1Lj-F0SrvJzhXT7ceDWGIb2aKRXukU,11488
 vectordb_bench/backend/utils.py,sha256=R6THuJdZhiQYSSJTqv0Uegl2B20taV_QjwvFrun2yxE,1949
 vectordb_bench/backend/clients/__init__.py,sha256=M7qjlpe_65OJKttYXItC8szczqzCm_vptM-7XGtL_HA,10128
-vectordb_bench/backend/clients/api.py,sha256=6uPex7vc88tpCzFbFgd29zNHx9mOKJBQliGwfzjfll0,6278
+vectordb_bench/backend/clients/api.py,sha256=m-vEypHJZrSMr5Di5zs3ImOSzVV2O5imMM3jfUAQmSs,6516
 vectordb_bench/backend/clients/aliyun_elasticsearch/aliyun_elasticsearch.py,sha256=7yPYaWoHeHNxDMtpReGXsdEPFD1e4vQblFor7TmLq5o,770
 vectordb_bench/backend/clients/aliyun_elasticsearch/config.py,sha256=d9RCgfCgauKvy6z9ig_wBormgwiGtkh8POyoHloHnJA,505
 vectordb_bench/backend/clients/aliyun_opensearch/aliyun_opensearch.py,sha256=rwa4rtbbP2Kaczh7Bf0bc_lE_sGG5w9PhtfdFu7rQNs,13237
@@ -29,8 +29,8 @@ vectordb_bench/backend/clients/aws_opensearch/run.py,sha256=Ry5aAlielWjq0hx7Lnbd
 vectordb_bench/backend/clients/chroma/chroma.py,sha256=Aqo6AlSWd0TG0SR4cr9AEoLzXtOJ5VNhbIucHnm8NxY,3619
 vectordb_bench/backend/clients/chroma/config.py,sha256=8nXpPdecQ5HrNqcsQwAVgacSz6uLgI-BI7v4tB8CeDk,347
 vectordb_bench/backend/clients/clickhouse/cli.py,sha256=9tnDE9e1I-Mul40FAzFG8lViYyeXXgjV3dNDpikhEwg,2017
-vectordb_bench/backend/clients/clickhouse/clickhouse.py,sha256=_rnLPrbT3TzZicabz6zniDG0FdXlOQNDziW9EQVi-VE,4863
-vectordb_bench/backend/clients/clickhouse/config.py,sha256=okIS494l2cADvlTljVCJvOuQRfDHHkf8F1sHrwgPdQw,1650
+vectordb_bench/backend/clients/clickhouse/clickhouse.py,sha256=nRTFE5KQn-_juKrtI546rbbqn1INqPNDNKrpeuHpdlI,8904
+vectordb_bench/backend/clients/clickhouse/config.py,sha256=Bd2fqpaJU5YcPKTNOL0mzEFWpaoVyxVt_21-Jb_tHKk,2659
 vectordb_bench/backend/clients/elastic_cloud/config.py,sha256=_5Cz3__CbMU7zCizkhK1pGhH3TLJacn8efVueUZ0lnQ,1573
 vectordb_bench/backend/clients/elastic_cloud/elastic_cloud.py,sha256=FSslLDH2Yi9ZdUwaCbKC_IXxFbMvW-L1xB3YMU08MVI,5448
 vectordb_bench/backend/clients/mariadb/cli.py,sha256=nqV9V-gOSKGQ1y6VmxOMxGz0a3jz860Va55x7JBcuPk,2727
@@ -40,8 +40,8 @@ vectordb_bench/backend/clients/memorydb/cli.py,sha256=mUpBN0VoE6M55AAEwyd20uEtPk
 vectordb_bench/backend/clients/memorydb/config.py,sha256=D2Q-HkDwnmz98ek1e_iNu4o9CIRB14pOQWSZgRvd6oY,1500
 vectordb_bench/backend/clients/memorydb/memorydb.py,sha256=WrZhDYJqpwN173sk2lmPnOibHcQCPrq_PEAMFcL62U4,10219
 vectordb_bench/backend/clients/milvus/cli.py,sha256=junIvlQtDbOGscKqacferBETDR9SQ9FK3G7oVVO1_2s,9931
-vectordb_bench/backend/clients/milvus/config.py,sha256=hBqDfsFfQdCIKKMpDsD0FqcbHp61v9ISLqooa-LwKuc,8838
-vectordb_bench/backend/clients/milvus/milvus.py,sha256=VKINREpGJ6DBpykHzSQN0v2xF9B7vskEN3D9WYJ5gXQ,6867
+vectordb_bench/backend/clients/milvus/config.py,sha256=h4OKAVE5FoSmaoppdFRcgeEMS96YcPWZat04496MrrA,12730
+vectordb_bench/backend/clients/milvus/milvus.py,sha256=DmyhqoMgGawwge3CnftaR1x0nmKDvs0rx_nSFbQk0ys,7053
 vectordb_bench/backend/clients/mongodb/config.py,sha256=7DZCh0bjPiqJW2luPypfpNeGfvKxVC4mdHLqgcjF1hA,1745
 vectordb_bench/backend/clients/mongodb/mongodb.py,sha256=ts2gpAzUTarpkfMFnM5ANi6T-xvcjS8kc4-apPt9jug,7225
 vectordb_bench/backend/clients/pgdiskann/cli.py,sha256=o5ddAp1Be2TOnm8Wh9IyIWUxdnw5N6v92Ms1s6CEwBo,3135
@@ -116,7 +116,7 @@ vectordb_bench/frontend/components/run_test/hideSidebar.py,sha256=vb5kzIMmbMqWX6
 vectordb_bench/frontend/components/run_test/initStyle.py,sha256=osPUgfFfH7rRlVNHSMumvmZxvKWlLxmZiNqgnMiUJEU,723
 vectordb_bench/frontend/components/run_test/submitTask.py,sha256=VZjkopkCBNhqLwGqsoM0hbPEeF6Q5UOQcdFUaegerxc,4094
 vectordb_bench/frontend/components/tables/data.py,sha256=5DdnC64BB7Aj2z9acht2atsPB4NabzQCZKALfIUnqtQ,1233
-vectordb_bench/frontend/config/dbCaseConfigs.py,sha256=-ro_zxkpBYhJgF5eyt4em4L5kNGnFJVhpmQhFxnsbQA,42954
+vectordb_bench/frontend/config/dbCaseConfigs.py,sha256=1HjKl9s-ilJgPedaJEK8-hu3bCgOGZa7_53EuvfHHhQ,46715
 vectordb_bench/frontend/config/dbPrices.py,sha256=10aBKjVcEg8y7TPSda28opmBM1KmXNrvbU9WM_BsZcE,176
 vectordb_bench/frontend/config/styles.py,sha256=Iic14kvGrm0oW-uXNZegceLvEJErWuYpG7WZF_G1zvE,2544
 vectordb_bench/frontend/pages/concurrent.py,sha256=bvoSafRSIsRzBQkI3uBwwrdg8jnhRUQG-epZbrJhGiE,2082
@@ -142,9 +142,9 @@ vectordb_bench/results/WeaviateCloud/result_20230808_standard_weaviatecloud.json
 vectordb_bench/results/ZillizCloud/result_20230727_standard_zillizcloud.json,sha256=-Mdm4By65XDRCrmVOCF8yQXjcZtH4Xo4shcjoDoBUKU,18293
 vectordb_bench/results/ZillizCloud/result_20230808_standard_zillizcloud.json,sha256=77XlHT5zM_K7mG5HfDQKwXZnSCuR37VUbt6-P3J_amI,15737
 vectordb_bench/results/ZillizCloud/result_20240105_standard_202401_zillizcloud.json,sha256=TualfJ0664Hs-vdIW68bdkqAEYyzotXmu2P0yIN-GHk,42526
-vectordb_bench-0.0.25.dist-info/licenses/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
-vectordb_bench-0.0.25.dist-info/METADATA,sha256=yjnCGSTms5Oh9I0fcBc5q1CKONZk4_lsWUPypoAejLI,38061
-vectordb_bench-0.0.25.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-vectordb_bench-0.0.25.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
-vectordb_bench-0.0.25.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
-vectordb_bench-0.0.25.dist-info/RECORD,,
+vectordb_bench-0.0.26.dist-info/licenses/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
+vectordb_bench-0.0.26.dist-info/METADATA,sha256=lsc4Y28tVwbXr3fUrVHbppegppAtYWoH0rEV3pn820g,38061
+vectordb_bench-0.0.26.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+vectordb_bench-0.0.26.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
+vectordb_bench-0.0.26.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
+vectordb_bench-0.0.26.dist-info/RECORD,,

{vectordb_bench-0.0.25.dist-info → vectordb_bench-0.0.26.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any