vectordb-bench 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

vectordb_bench/__init__.py

@@ -1,11 +1,13 @@
-import environs
 import inspect
 import pathlib
-from . import log_util
 
+import environs
+
+from . import log_util
 
 env = environs.Env()
-env.read_env(".env")
+env.read_env(".env", False)
+
 
 class config:
     ALIYUN_OSS_URL = "assets.zilliz.com.cn/benchmark/"
@@ -19,9 +21,21 @@ class config:
 
     DROP_OLD = env.bool("DROP_OLD", True)
     USE_SHUFFLED_DATA = env.bool("USE_SHUFFLED_DATA", True)
-    NUM_CONCURRENCY = [1, 5, 10, 15, 20, 25, 30, 35]
 
-    RESULTS_LOCAL_DIR = pathlib.Path(__file__).parent.joinpath("results")
+    NUM_CONCURRENCY = env.list("NUM_CONCURRENCY",  [1, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100], subcast=int )
+
+    CONCURRENCY_DURATION = 30
+
+    RESULTS_LOCAL_DIR = env.path(
+        "RESULTS_LOCAL_DIR", pathlib.Path(__file__).parent.joinpath("results")
+    )
+    CONFIG_LOCAL_DIR = env.path(
+        "CONFIG_LOCAL_DIR", pathlib.Path(__file__).parent.joinpath("config-files")
+    )
+
+
+    K_DEFAULT = 100  # default return top k nearest neighbors during search
+    CUSTOM_CONFIG_DIR = pathlib.Path(__file__).parent.joinpath("custom/custom_case.json")
 
     CAPACITY_TIMEOUT_IN_SECONDS = 24 * 3600 # 24h
     LOAD_TIMEOUT_DEFAULT        = 2.5 * 3600 # 2.5h

vectordb_bench/backend/assembler.py

@@ -14,7 +14,7 @@ class Assembler:
     def assemble(cls, run_id , task: TaskConfig, source: DatasetSource) -> CaseRunner:
         c_cls = task.case_config.case_id.case_cls
 
-        c = c_cls()
+        c = c_cls(task.case_config.custom_case)
         if type(task.db_case_config) != EmptyDBCaseConfig:
             task.db_case_config.metric_type = c.dataset.data.metric_type
 

vectordb_bench/backend/cases.py

@@ -1,17 +1,20 @@
 import typing
 import logging
 from enum import Enum, auto
+from typing import Type
 
 from vectordb_bench import config
+from vectordb_bench.backend.clients.api import MetricType
 from vectordb_bench.base import BaseModel
+from vectordb_bench.frontend.components.custom.getCustomConfig import (
+    CustomDatasetConfig,
+)
 
-from .dataset import Dataset, DatasetManager
+from .dataset import CustomDataset, Dataset, DatasetManager
 
 
 log = logging.getLogger(__name__)
 
-Case = typing.TypeVar("Case")
-
 
 class CaseType(Enum):
     """
@@ -42,24 +45,27 @@ class CaseType(Enum):
     Performance1536D500K99P = 14
     Performance1536D5M99P = 15
 
+    Performance1536D50K = 50
+
     Custom = 100
+    PerformanceCustomDataset = 101
 
-    @property
-    def case_cls(self, custom_configs: dict | None = None) -> Case:
-        return type2case.get(self)
+    def case_cls(self, custom_configs: dict | None = None) -> Type["Case"]:
+        if custom_configs is None:
+            return type2case.get(self)()
+        else:
+            return type2case.get(self)(**custom_configs)
 
-    @property
-    def case_name(self) -> str:
-        c = self.case_cls
+    def case_name(self, custom_configs: dict | None = None) -> str:
+        c = self.case_cls(custom_configs)
         if c is not None:
-            return c().name
+            return c.name
         raise ValueError("Case unsupported")
 
-    @property
-    def case_description(self) -> str:
-        c = self.case_cls
+    def case_description(self, custom_configs: dict | None = None) -> str:
+        c = self.case_cls(custom_configs)
         if c is not None:
-            return c().description
+            return c.description
         raise ValueError("Case unsupported")
 
 
@@ -69,7 +75,7 @@ class CaseLabel(Enum):
 
 
 class Case(BaseModel):
-    """Undifined case
+    """Undefined case
 
     Fields:
         case_id(CaseType): default 9 case type plus one custom cases.
@@ -86,9 +92,9 @@ class Case(BaseModel):
     dataset: DatasetManager
 
     load_timeout: float | int
-    optimize_timeout: float | int | None
+    optimize_timeout: float | int | None = None
 
-    filter_rate: float | None
+    filter_rate: float | None = None
 
     @property
     def filters(self) -> dict | None:
@@ -115,20 +121,23 @@ class PerformanceCase(Case, BaseModel):
     load_timeout: float | int = config.LOAD_TIMEOUT_DEFAULT
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_DEFAULT
 
+
 class CapacityDim960(CapacityCase):
     case_id: CaseType = CaseType.CapacityDim960
     dataset: DatasetManager = Dataset.GIST.manager(100_000)
     name: str = "Capacity Test (960 Dim Repeated)"
-    description: str = """This case tests the vector database's loading capacity by repeatedly inserting large-dimension vectors (GIST 100K vectors, <b>960 dimensions</b>) until it is fully loaded.
-Number of inserted vectors will be reported."""
+    description: str = """This case tests the vector database's loading capacity by repeatedly inserting large-dimension 
+     vectors (GIST 100K vectors, <b>960 dimensions</b>) until it is fully loaded. Number of inserted vectors will be 
+     reported."""
 
 
 class CapacityDim128(CapacityCase):
     case_id: CaseType = CaseType.CapacityDim128
     dataset: DatasetManager = Dataset.SIFT.manager(500_000)
     name: str = "Capacity Test (128 Dim Repeated)"
-    description: str = """This case tests the vector database's loading capacity by repeatedly inserting small-dimension vectors (SIFT 100K vectors, <b>128 dimensions</b>) until it is fully loaded.
-Number of inserted vectors will be reported."""
+    description: str = """This case tests the vector database's loading capacity by repeatedly inserting small-dimension
+     vectors (SIFT 100K vectors, <b>128 dimensions</b>) until it is fully loaded. Number of inserted vectors will be 
+     reported."""
 
 
 class Performance768D10M(PerformanceCase):
@@ -238,6 +247,7 @@ Results will show index building time, recall, and maximum QPS."""
     load_timeout: float | int = config.LOAD_TIMEOUT_1536D_500K
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_500K
 
+
 class Performance1536D5M1P(PerformanceCase):
     case_id: CaseType = CaseType.Performance1536D5M1P
     filter_rate: float | int | None = 0.01
@@ -248,6 +258,7 @@ Results will show index building time, recall, and maximum QPS."""
     load_timeout: float | int = config.LOAD_TIMEOUT_1536D_5M
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_5M
 
+
 class Performance1536D500K99P(PerformanceCase):
     case_id: CaseType = CaseType.Performance1536D500K99P
     filter_rate: float | int | None = 0.99
@@ -258,6 +269,7 @@ Results will show index building time, recall, and maximum QPS."""
     load_timeout: float | int = config.LOAD_TIMEOUT_1536D_500K
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_500K
 
+
 class Performance1536D5M99P(PerformanceCase):
     case_id: CaseType = CaseType.Performance1536D5M99P
     filter_rate: float | int | None = 0.99
@@ -269,26 +281,80 @@ Results will show index building time, recall, and maximum QPS."""
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_5M
 
 
+class Performance1536D50K(PerformanceCase):
+    case_id: CaseType = CaseType.Performance1536D50K
+    filter_rate: float | int | None = None
+    dataset: DatasetManager = Dataset.OPENAI.manager(50_000)
+    name: str = "Search Performance Test (50K Dataset, 1536 Dim)"
+    description: str = """This case tests the search performance of a vector database with a medium 50K dataset (<b>OpenAI 50K vectors</b>, 1536 dimensions), at varying parallel levels.
+Results will show index building time, recall, and maximum QPS."""
+    load_timeout: float | int = 3600
+    optimize_timeout: float | int | None = 15 * 60
+
+
+def metric_type_map(s: str) -> MetricType:
+    if s.lower() == "cosine":
+        return MetricType.COSINE
+    if s.lower() == "l2" or s.lower() == "euclidean":
+        return MetricType.L2
+    if s.lower() == "ip":
+        return MetricType.IP
+    err_msg = f"Not support metric_type: {s}"
+    log.error(err_msg)
+    raise RuntimeError(err_msg)
+
+
+class PerformanceCustomDataset(PerformanceCase):
+    case_id: CaseType = CaseType.PerformanceCustomDataset
+    name: str = "Performance With Custom Dataset"
+    description: str = ""
+    dataset: DatasetManager
+
+    def __init__(
+        self,
+        name,
+        description,
+        load_timeout,
+        optimize_timeout,
+        dataset_config,
+        **kwargs,
+    ):
+        dataset_config = CustomDatasetConfig(**dataset_config)
+        dataset = CustomDataset(
+            name=dataset_config.name,
+            size=dataset_config.size,
+            dim=dataset_config.dim,
+            metric_type=metric_type_map(dataset_config.metric_type),
+            use_shuffled=dataset_config.use_shuffled,
+            with_gt=dataset_config.with_gt,
+            dir=dataset_config.dir,
+            file_num=dataset_config.file_count,
+        )
+        super().__init__(
+            name=name,
+            description=description,
+            load_timeout=load_timeout,
+            optimize_timeout=optimize_timeout,
+            dataset=DatasetManager(data=dataset),
+        )
+
+
 type2case = {
     CaseType.CapacityDim960: CapacityDim960,
     CaseType.CapacityDim128: CapacityDim128,
-
     CaseType.Performance768D100M: Performance768D100M,
     CaseType.Performance768D10M: Performance768D10M,
     CaseType.Performance768D1M: Performance768D1M,
-
     CaseType.Performance768D10M1P: Performance768D10M1P,
     CaseType.Performance768D1M1P: Performance768D1M1P,
     CaseType.Performance768D10M99P: Performance768D10M99P,
     CaseType.Performance768D1M99P: Performance768D1M99P,
-
     CaseType.Performance1536D500K: Performance1536D500K,
     CaseType.Performance1536D5M: Performance1536D5M,
-
     CaseType.Performance1536D500K1P: Performance1536D500K1P,
     CaseType.Performance1536D5M1P: Performance1536D5M1P,
-
     CaseType.Performance1536D500K99P: Performance1536D500K99P,
     CaseType.Performance1536D5M99P: Performance1536D5M99P,
-
+    CaseType.Performance1536D50K: Performance1536D50K,
+    CaseType.PerformanceCustomDataset: PerformanceCustomDataset,
 }

vectordb_bench/backend/clients/__init__.py

@@ -32,6 +32,8 @@ class DB(Enum):
     PgVectoRS = "PgVectoRS"
     Redis = "Redis"
     Chroma = "Chroma"
+    AWSOpenSearch = "OpenSearch"
+    Test = "test"
 
 
     @property
@@ -77,6 +79,10 @@ class DB(Enum):
             from .chroma.chroma import ChromaClient
             return ChromaClient
 
+        if self == DB.AWSOpenSearch:
+            from .aws_opensearch.aws_opensearch import AWSOpenSearch
+            return AWSOpenSearch
+
     @property
     def config_cls(self) -> Type[DBConfig]:
         """Import while in use"""
@@ -120,6 +126,10 @@ class DB(Enum):
             from .chroma.config import ChromaConfig
             return ChromaConfig
 
+        if self == DB.AWSOpenSearch:
+            from .aws_opensearch.config import AWSOpenSearchConfig
+            return AWSOpenSearchConfig
+
     def case_config_cls(self, index_type: IndexType | None = None) -> Type[DBCaseConfig]:
         if self == DB.Milvus:
             from .milvus.config import _milvus_case_config
@@ -149,6 +159,10 @@ class DB(Enum):
             from .pgvecto_rs.config import _pgvecto_rs_case_config
             return _pgvecto_rs_case_config.get(index_type)
 
+        if self == DB.AWSOpenSearch:
+            from .aws_opensearch.config import AWSOpenSearchIndexConfig
+            return AWSOpenSearchIndexConfig
+
         # DB.Pinecone, DB.Chroma, DB.Redis
         return EmptyDBCaseConfig
 

vectordb_bench/backend/clients/api.py

@@ -47,7 +47,7 @@ class DBConfig(ABC, BaseModel):
     def not_empty_field(cls, v, field):
         if field.name == "db_label":
             return v
-        if isinstance(v, (str, SecretStr)) and len(v) == 0:
+        if not v and isinstance(v, (str, SecretStr)):
             raise ValueError("Empty string!")
         return v
 

vectordb_bench/backend/clients/aws_opensearch/aws_opensearch.py

@@ -0,0 +1,159 @@
+import logging
+from contextlib import contextmanager
+import time
+from typing import Iterable, Type
+from ..api import VectorDB, DBCaseConfig, DBConfig, IndexType
+from .config import AWSOpenSearchConfig, AWSOpenSearchIndexConfig
+from opensearchpy import OpenSearch
+from opensearchpy.helpers import bulk
+
+log = logging.getLogger(__name__)
+
+
+class AWSOpenSearch(VectorDB):
+    def __init__(
+        self,
+        dim: int,
+        db_config: dict,
+        db_case_config: AWSOpenSearchIndexConfig,
+        index_name: str = "vdb_bench_index",  # must be lowercase
+        id_col_name: str = "id",
+        vector_col_name: str = "embedding",
+        drop_old: bool = False,
+        **kwargs,
+    ):
+        self.dim = dim
+        self.db_config = db_config
+        self.case_config = db_case_config
+        self.index_name = index_name
+        self.id_col_name = id_col_name
+        self.category_col_names = [
+            f"scalar-{categoryCount}" for categoryCount in [2, 5, 10, 100, 1000]
+        ]
+        self.vector_col_name = vector_col_name
+
+        log.info(f"AWS_OpenSearch client config: {self.db_config}")
+        client = OpenSearch(**self.db_config)
+        if drop_old:
+            log.info(f"AWS_OpenSearch client drop old index: {self.index_name}")
+            is_existed = client.indices.exists(index=self.index_name)
+            if is_existed:
+                client.indices.delete(index=self.index_name)
+            self._create_index(client)
+
+    @classmethod
+    def config_cls(cls) -> AWSOpenSearchConfig:
+        return AWSOpenSearchConfig
+
+    @classmethod
+    def case_config_cls(
+        cls, index_type: IndexType | None = None
+    ) -> AWSOpenSearchIndexConfig:
+        return AWSOpenSearchIndexConfig
+
+    def _create_index(self, client: OpenSearch):
+        settings = {
+            "index": {
+                "knn": True,
+                # "number_of_shards": 5,
+                # "refresh_interval": "600s",
+            }
+        }
+        mappings = {
+            "properties": {
+                self.id_col_name: {"type": "integer"},
+                **{
+                    categoryCol: {"type": "keyword"}
+                    for categoryCol in self.category_col_names
+                },
+                self.vector_col_name: {
+                    "type": "knn_vector",
+                    "dimension": self.dim,
+                    "method": self.case_config.index_param(),
+                },
+            }
+        }
+        try:
+            client.indices.create(
+                index=self.index_name, body=dict(settings=settings, mappings=mappings)
+            )
+        except Exception as e:
+            log.warning(f"Failed to create index: {self.index_name} error: {str(e)}")
+            raise e from None
+
+    @contextmanager
+    def init(self) -> None:
+        """connect to elasticsearch"""
+        self.client = OpenSearch(**self.db_config)
+
+        yield
+        # self.client.transport.close()
+        self.client = None
+        del self.client
+
+    def insert_embeddings(
+        self,
+        embeddings: Iterable[list[float]],
+        metadata: list[int],
+        **kwargs,
+    ) -> tuple[int, Exception]:
+        """Insert the embeddings to the elasticsearch."""
+        assert self.client is not None, "should self.init() first"
+
+        insert_data = []
+        for i in range(len(embeddings)):
+            insert_data.append({"index": {"_index": self.index_name, "_id": metadata[i]}})
+            insert_data.append({self.vector_col_name: embeddings[i]})
+        try:
+            resp = self.client.bulk(insert_data)
+            log.info(f"AWS_OpenSearch adding documents: {len(resp['items'])}")
+            resp = self.client.indices.stats(self.index_name)
+            log.info(f"Total document count in index: {resp['_all']['primaries']['indexing']['index_total']}")
+            return (len(embeddings), None)
+        except Exception as e:
+            log.warning(f"Failed to insert data: {self.index_name} error: {str(e)}")
+            time.sleep(10)
+            return self.insert_embeddings(embeddings, metadata)
+
+    def search_embedding(
+        self,
+        query: list[float],
+        k: int = 100,
+        filters: dict | None = None,
+    ) -> list[int]:
+        """Get k most similar embeddings to query vector.
+
+        Args:
+            query(list[float]): query embedding to look up documents similar to.
+            k(int): Number of most similar embeddings to return. Defaults to 100.
+            filters(dict, optional): filtering expression to filter the data while searching.
+
+        Returns:
+            list[tuple[int, float]]: list of k most similar embeddings in (id, score) tuple to the query embedding.
+        """
+        assert self.client is not None, "should self.init() first"
+
+        body = {
+            "size": k,
+            "query": {"knn": {self.vector_col_name: {"vector": query, "k": k}}},
+        }
+        try:
+            resp = self.client.search(index=self.index_name, body=body)
+            log.info(f'Search took: {resp["took"]}')
+            log.info(f'Search shards: {resp["_shards"]}')
+            log.info(f'Search hits total: {resp["hits"]["total"]}')
+            result = [int(d["_id"]) for d in resp["hits"]["hits"]]
+            # log.info(f'success! length={len(res)}')
+
+            return result
+        except Exception as e:
+            log.warning(f"Failed to search: {self.index_name} error: {str(e)}")
+            raise e from None
+
+    def optimize(self):
+        """optimize will be called between insertion and search in performance cases."""
+        pass
+
+    def ready_to_load(self):
+        """ready_to_load will be called before load in load cases."""
+        pass

vectordb_bench/backend/clients/aws_opensearch/cli.py

@@ -0,0 +1,44 @@
+from typing import Annotated, TypedDict, Unpack
+
+import click
+from pydantic import SecretStr
+
+from ....cli.cli import (
+    CommonTypedDict,
+    HNSWFlavor2,
+    cli,
+    click_parameter_decorators_from_typed_dict,
+    run,
+)
+from .. import DB
+
+
+class AWSOpenSearchTypedDict(TypedDict):
+    host: Annotated[
+        str, click.option("--host", type=str, help="Db host", required=True)
+    ]
+    port: Annotated[int, click.option("--port", type=int, default=443, help="Db Port")]
+    user: Annotated[str, click.option("--user", type=str, default="admin", help="Db User")]
+    password: Annotated[str, click.option("--password", type=str, help="Db password")]
+
+
+class AWSOpenSearchHNSWTypedDict(CommonTypedDict, AWSOpenSearchTypedDict, HNSWFlavor2):
+    ...
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(AWSOpenSearchHNSWTypedDict)
+def AWSOpenSearch(**parameters: Unpack[AWSOpenSearchHNSWTypedDict]):
+    from .config import AWSOpenSearchConfig, AWSOpenSearchIndexConfig
+    run(
+        db=DB.AWSOpenSearch,
+        db_config=AWSOpenSearchConfig(
+            host=parameters["host"],
+            port=parameters["port"],
+            user=parameters["user"],
+            password=SecretStr(parameters["password"]),
+        ),
+        db_case_config=AWSOpenSearchIndexConfig(
+        ),
+        **parameters,
+    )

vectordb_bench/backend/clients/aws_opensearch/config.py

@@ -0,0 +1,58 @@
+from enum import Enum
+from pydantic import SecretStr, BaseModel
+
+from ..api import DBConfig, DBCaseConfig, MetricType, IndexType
+
+
+class AWSOpenSearchConfig(DBConfig, BaseModel):
+    host: str = ""
+    port: int = 443
+    user: str = ""
+    password: SecretStr = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "hosts": [{'host': self.host, 'port': self.port}],
+            "http_auth": (self.user, self.password.get_secret_value()),
+            "use_ssl": True,
+            "http_compress": True,
+            "verify_certs": True,
+            "ssl_assert_hostname": False,
+            "ssl_show_warn": False,
+            "timeout": 600,
+        }
+
+
+class AWSOS_Engine(Enum):
+    nmslib = "nmslib"
+    faiss = "faiss"
+    lucene = "Lucene"
+
+
+class AWSOpenSearchIndexConfig(BaseModel, DBCaseConfig):
+    metric_type: MetricType = MetricType.L2
+    engine: AWSOS_Engine = AWSOS_Engine.nmslib
+    efConstruction: int = 360
+    M: int = 30
+
+    def parse_metric(self) -> str:
+        if self.metric_type == MetricType.IP:
+            return "innerproduct"  # only support faiss / nmslib, not for Lucene.
+        elif self.metric_type == MetricType.COSINE:
+            return "cosinesimil"
+        return "l2"
+
+    def index_param(self) -> dict:
+        params = {
+            "name": "hnsw",
+            "space_type": self.parse_metric(),
+            "engine": self.engine.value,
+            "parameters": {
+                "ef_construction": self.efConstruction,
+                "m": self.M
+            }
+        }
+        return params
+
+    def search_param(self) -> dict:
+        return {}