vectordb-bench 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

vectordb_bench/backend/dataset.py

@@ -22,7 +22,7 @@ from .data_source import DatasetSource, DatasetReader
 log = logging.getLogger(__name__)
 
 
-SizeLabel = namedtuple('SizeLabel', ['size', 'label', 'files'])
+SizeLabel = namedtuple('SizeLabel', ['size', 'label', 'file_count'])
 
 
 class BaseDataset(BaseModel):
@@ -31,6 +31,7 @@ class BaseDataset(BaseModel):
     dim: int
     metric_type: MetricType
     use_shuffled: bool
+    with_gt: bool = False
     _size_label: dict[int, SizeLabel] = PrivateAttr()
 
     @validator("size")
@@ -48,34 +49,8 @@ class BaseDataset(BaseModel):
         return f"{self.name}_{self.label}_{utils.numerize(self.size)}".lower()
 
     @property
-    def files(self) -> str:
-        return self._size_label.get(self.size).files
-
-
-def get_files(train_count: int, use_shuffled: bool, with_gt: bool = True) -> list[str]:
-    prefix = "shuffle_train" if use_shuffled else "train"
-    middle = f"of-{train_count}"
-    surfix = "parquet"
-
-    train_files = []
-    if train_count > 1:
-        just_size = len(str(train_count))
-        for i in range(train_count):
-            sub_file = f"{prefix}-{str(i).rjust(just_size, '0')}-{middle}.{surfix}"
-            train_files.append(sub_file)
-    else:
-        train_files.append(f"{prefix}.{surfix}")
-
-    files = ['test.parquet']
-    if with_gt:
-        files.extend([
-            'neighbors.parquet',
-            'neighbors_tail_1p.parquet',
-            'neighbors_head_1p.parquet',
-        ])
-
-    files.extend(train_files)
-    return files
+    def file_count(self) -> int:
+        return self._size_label.get(self.size).file_count
 
 
 class LAION(BaseDataset):
@@ -83,8 +58,9 @@ class LAION(BaseDataset):
     dim: int = 768
     metric_type: MetricType = MetricType.L2
     use_shuffled: bool = False
+    with_gt: bool = True
     _size_label: dict = {
-        100_000_000: SizeLabel(100_000_000, "LARGE", get_files(100, False)),
+        100_000_000: SizeLabel(100_000_000, "LARGE", 100),
     }
 
 
@@ -94,8 +70,8 @@ class GIST(BaseDataset):
     metric_type: MetricType = MetricType.L2
     use_shuffled: bool = False
     _size_label: dict = {
-        100_000: SizeLabel(100_000, "SMALL", get_files(1, False, False)),
-        1_000_000: SizeLabel(1_000_000, "MEDIUM", get_files(1, False, False)),
+        100_000: SizeLabel(100_000, "SMALL", 1),
+        1_000_000: SizeLabel(1_000_000, "MEDIUM", 1),
     }
 
 
@@ -104,10 +80,11 @@ class Cohere(BaseDataset):
     dim: int = 768
     metric_type: MetricType = MetricType.COSINE
     use_shuffled: bool = config.USE_SHUFFLED_DATA
+    with_gt: bool = True,
     _size_label: dict = {
-        100_000: SizeLabel(100_000, "SMALL", get_files(1, config.USE_SHUFFLED_DATA)),
-        1_000_000: SizeLabel(1_000_000, "MEDIUM", get_files(1, config.USE_SHUFFLED_DATA)),
-        10_000_000: SizeLabel(10_000_000, "LARGE", get_files(10, config.USE_SHUFFLED_DATA)),
+        100_000: SizeLabel(100_000, "SMALL", 1),
+        1_000_000: SizeLabel(1_000_000, "MEDIUM", 1),
+        10_000_000: SizeLabel(10_000_000, "LARGE", 10),
     }
 
 
@@ -116,7 +93,7 @@ class Glove(BaseDataset):
     dim: int = 200
     metric_type: MetricType = MetricType.COSINE
     use_shuffled: bool = False
-    _size_label: dict = {1_000_000: SizeLabel(1_000_000, "MEDIUM", get_files(1, False, False))}
+    _size_label: dict = {1_000_000: SizeLabel(1_000_000, "MEDIUM", 1)}
 
 
 class SIFT(BaseDataset):
@@ -125,9 +102,9 @@ class SIFT(BaseDataset):
     metric_type: MetricType = MetricType.L2
     use_shuffled: bool = False
     _size_label: dict = {
-        500_000: SizeLabel(500_000, "SMALL", get_files(1, False, False)),
-        5_000_000: SizeLabel(5_000_000, "MEDIUM", get_files(1, False, False)),
-        #  50_000_000: SizeLabel(50_000_000, "LARGE", get_files(50, False, False)),
+        500_000: SizeLabel(500_000, "SMALL", 1,),
+        5_000_000: SizeLabel(5_000_000, "MEDIUM", 1),
+        #  50_000_000: SizeLabel(50_000_000, "LARGE", 50),
     }
 
 
@@ -136,10 +113,11 @@ class OpenAI(BaseDataset):
     dim: int = 1536
     metric_type: MetricType = MetricType.COSINE
     use_shuffled: bool = config.USE_SHUFFLED_DATA
+    with_gt: bool = True,
     _size_label: dict = {
-        50_000: SizeLabel(50_000, "SMALL", get_files(1, config.USE_SHUFFLED_DATA)),
-        500_000: SizeLabel(500_000, "MEDIUM", get_files(1, config.USE_SHUFFLED_DATA)),
-        5_000_000: SizeLabel(5_000_000, "LARGE", get_files(10, config.USE_SHUFFLED_DATA)),
+        50_000: SizeLabel(50_000, "SMALL", 1),
+        500_000: SizeLabel(500_000, "MEDIUM", 1),
+        5_000_000: SizeLabel(5_000_000, "LARGE", 10),
     }
 
 
@@ -155,6 +133,7 @@ class DatasetManager(BaseModel):
     """
     data:   BaseDataset
     test_data: pd.DataFrame | None = None
+    gt_data: pd.DataFrame | None = None
     train_files : list[str] = []
     reader: DatasetReader | None = None
 
@@ -180,49 +159,48 @@ class DatasetManager(BaseModel):
     def __iter__(self):
         return DataSetIterator(self)
 
-    def prepare(self, source: DatasetSource=DatasetSource.S3, check: bool=True) -> bool:
+    # TODO passing use_shuffle from outside
+    def prepare(self,
+        source: DatasetSource=DatasetSource.S3,
+        filters: int | float | str | None = None,
+    ) -> bool:
         """Download the dataset from DatasetSource
          url = f"{source}/{self.data.dir_name}"
 
-         download files from url to self.data_dir, there'll be 4 types of files in the data_dir
-             - train*.parquet: for training
-             - test.parquet: for testing
-             - neighbors.parquet: ground_truth of the test.parquet
-             - neighbors_head_1p.parquet: ground_truth of the test.parquet after filtering 1% data
-             - neighbors_99p.parquet: ground_truth of the test.parquet after filtering 99% data
-
         Args:
             source(DatasetSource): S3 or AliyunOSS, default as S3
-            check(bool): Whether to do etags check
+            filters(Optional[int | float | str]): combined with dataset's with_gt to
+              compose the correct ground_truth file
 
         Returns:
             bool: whether the dataset is successfully prepared
 
         """
+        file_count, use_shuffled = self.data.file_count, self.data.use_shuffled
+
+        train_files = utils.compose_train_files(file_count, use_shuffled)
+        all_files = train_files
+
+        gt_file, test_file = None, None
+        if self.data.with_gt:
+            gt_file, test_file = utils.compose_gt_file(filters), "test.parquet"
+            all_files.extend([gt_file, test_file])
+
         source.reader().read(
             dataset=self.data.dir_name.lower(),
-            files=self.data.files,
+            files=all_files,
             local_ds_root=self.data_dir,
         )
 
-        prefix = "shuffle_train" if self.data.use_shuffled else "train"
+        if gt_file is not None and test_file is not None:
+            self.test_data = self._read_file(test_file)
+            self.gt_data = self._read_file(gt_file)
+
+        prefix = "shuffle_train" if use_shuffled else "train"
         self.train_files = sorted([f.name for f in self.data_dir.glob(f'{prefix}*.parquet')])
         log.debug(f"{self.data.name}: available train files {self.train_files}")
-        self.test_data = self._read_file("test.parquet")
-        return True
 
-    def get_ground_truth(self, filters: int | float | None = None) -> pd.DataFrame:
-
-        file_name = ""
-        if filters is None:
-            file_name = "neighbors.parquet"
-        elif filters == 0.01:
-            file_name = "neighbors_head_1p.parquet"
-        elif filters == 0.99:
-            file_name = "neighbors_tail_1p.parquet"
-        else:
-            raise ValueError(f"Filters not supported: {filters}")
-        return self._read_file(file_name)
+        return True
 
     def _read_file(self, file_name: str) -> pd.DataFrame:
         """read one file from disk into memory"""

vectordb_bench/backend/runner/serial_runner.py

@@ -40,7 +40,7 @@ class SerialInsertRunner:
                 emb_np = np.stack(data_df['emb'])
                 if self.normalize:
                     log.debug("normalize the 100k train data")
-                    all_embeddings = emb_np / np.linalg.norm(emb_np, axis=1)[:, np.newaxis].tolist()
+                    all_embeddings = (emb_np / np.linalg.norm(emb_np, axis=1)[:, np.newaxis]).tolist()
                 else:
                     all_embeddings = emb_np.tolist()
                 del(emb_np)

vectordb_bench/backend/task_runner.py

@@ -84,7 +84,7 @@ class CaseRunner(BaseModel):
     def _pre_run(self, drop_old: bool = True):
         try:
             self.init_db(drop_old)
-            self.ca.dataset.prepare(self.dataset_source)
+            self.ca.dataset.prepare(self.dataset_source, filters=self.ca.filter_rate)
         except ModuleNotFoundError as e:
             log.warning(f"pre run case error: please install client for db: {self.config.db}, error={e}")
             raise e from None
@@ -215,7 +215,7 @@ class CaseRunner(BaseModel):
             test_emb = test_emb / np.linalg.norm(test_emb, axis=1)[:, np.newaxis]
         self.test_emb = test_emb.tolist()
 
-        gt_df = self.ca.dataset.get_ground_truth(self.ca.filter_rate)
+        gt_df = self.ca.dataset.gt_data
 
         self.serial_search_runner = SerialSearchRunner(
             db=self.db,

vectordb_bench/backend/utils.py

@@ -42,3 +42,33 @@ def time_it(func):
         delta = time.perf_counter() - pref
         return result, delta
     return inner
+
+
+def compose_train_files(train_count: int, use_shuffled: bool) -> list[str]:
+    prefix = "shuffle_train" if use_shuffled else "train"
+    middle = f"of-{train_count}"
+    surfix = "parquet"
+
+    train_files = []
+    if train_count > 1:
+        just_size = 2
+        for i in range(train_count):
+            sub_file = f"{prefix}-{str(i).rjust(just_size, '0')}-{middle}.{surfix}"
+            train_files.append(sub_file)
+    else:
+        train_files.append(f"{prefix}.{surfix}")
+
+    return train_files
+
+
+def compose_gt_file(filters: int | float | str | None = None) -> str:
+    if filters is None:
+        return "neighbors.parquet"
+
+    if filters == 0.01:
+        return "neighbors_head_1p.parquet"
+
+    if filters == 0.99:
+        return "neighbors_tail_1p.parquet"
+
+    raise ValueError(f"Filters not supported: {filters}")

vectordb_bench/frontend/components/run_test/caseSelector.py

@@ -59,7 +59,7 @@ def caseConfigSetting(st, allCaseConfigs, case, activedDbList):
         )
         caseConfig = allCaseConfigs[db][case]
         k = 0
-        for config in CASE_CONFIG_MAP.get(db, {}).get(case, []):
+        for config in CASE_CONFIG_MAP.get(db, {}).get(case.case_cls().label, []):
             if config.isDisplayed(caseConfig):
                 column = columns[1 + k % CASE_CONFIG_SETTING_COLUMNS]
                 key = "%s-%s-%s" % (db, case, config.label.value)

vectordb_bench/frontend/const/dbCaseConfigs.py

@@ -1,7 +1,7 @@
 from enum import IntEnum
 import typing
 from pydantic import BaseModel
-from vectordb_bench.backend.cases import CaseType
+from vectordb_bench.backend.cases import CaseLabel, CaseType
 from vectordb_bench.backend.clients import DB
 from vectordb_bench.backend.clients.api import IndexType
 
@@ -60,6 +60,7 @@ CaseConfigParamInput_IndexType = CaseConfigInput(
         "options": [
             IndexType.HNSW.value,
             IndexType.IVFFlat.value,
+            IndexType.IVFSQ8.value,
             IndexType.DISKANN.value,
             IndexType.Flat.value,
             IndexType.AUTOINDEX.value,
@@ -197,6 +198,7 @@ CaseConfigParamInput_Nlist = CaseConfigInput(
     isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
     in [
         IndexType.IVFFlat.value,
+        IndexType.IVFSQ8.value,
         IndexType.GPU_IVF_FLAT.value,
         IndexType.GPU_IVF_PQ.value,
     ],
@@ -213,6 +215,7 @@ CaseConfigParamInput_Nprobe = CaseConfigInput(
     isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
     in [
         IndexType.IVFFlat.value,
+        IndexType.IVFSQ8.value,
         IndexType.GPU_IVF_FLAT.value,
         IndexType.GPU_IVF_PQ.value,
     ],
@@ -394,6 +397,11 @@ CaseConfigParamInput_QuantizationType_PgVectoRS = CaseConfigInput(
     inputConfig={
         "options": ["trivial", "scalar", "product"],
     },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [
+        IndexType.HNSW.value,
+        IndexType.IVFFlat.value,
+    ],
 )
 
 CaseConfigParamInput_QuantizationRatio_PgVectoRS = CaseConfigInput(
@@ -403,7 +411,21 @@ CaseConfigParamInput_QuantizationRatio_PgVectoRS = CaseConfigInput(
         "options": ["x4", "x8", "x16", "x32", "x64"],
     },
     isDisplayed=lambda config: config.get(CaseConfigParamType.quantizationType, None)
-    == "product",
+    == "product" and config.get(CaseConfigParamType.IndexType, None)
+    in [
+        IndexType.HNSW.value,
+        IndexType.IVFFlat.value,
+    ],
+)
+
+CaseConfigParamInput_ZillizLevel = CaseConfigInput(
+    label=CaseConfigParamType.level,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 1,
+        "max": 3,
+        "value": 1,
+    },
 )
 
 MilvusLoadConfig = [
@@ -479,90 +501,32 @@ PgVectoRSPerformanceConfig = [
     CaseConfigParamInput_QuantizationRatio_PgVectoRS,
 ]
 
+ZillizCloudPerformanceConfig = [
+    CaseConfigParamInput_ZillizLevel,
+]
+
 CASE_CONFIG_MAP = {
     DB.Milvus: {
-        CaseType.CapacityDim960: MilvusLoadConfig,
-        CaseType.CapacityDim128: MilvusLoadConfig,
-        CaseType.Performance768D100M: MilvusPerformanceConfig,
-        CaseType.Performance768D10M: MilvusPerformanceConfig,
-        CaseType.Performance768D1M: MilvusPerformanceConfig,
-        CaseType.Performance768D10M1P: MilvusPerformanceConfig,
-        CaseType.Performance768D1M1P: MilvusPerformanceConfig,
-        CaseType.Performance768D10M99P: MilvusPerformanceConfig,
-        CaseType.Performance768D1M99P: MilvusPerformanceConfig,
-        CaseType.Performance1536D5M: MilvusPerformanceConfig,
-        CaseType.Performance1536D500K: MilvusPerformanceConfig,
-        CaseType.Performance1536D5M1P: MilvusPerformanceConfig,
-        CaseType.Performance1536D500K1P: MilvusPerformanceConfig,
-        CaseType.Performance1536D5M99P: MilvusPerformanceConfig,
-        CaseType.Performance1536D500K99P: MilvusPerformanceConfig,
+        CaseLabel.Load: MilvusLoadConfig,
+        CaseLabel.Performance: MilvusPerformanceConfig,
+    },
+    DB.ZillizCloud: {
+        CaseLabel.Performance: ZillizCloudPerformanceConfig,
     },
     DB.WeaviateCloud: {
-        CaseType.CapacityDim960: WeaviateLoadConfig,
-        CaseType.CapacityDim128: WeaviateLoadConfig,
-        CaseType.Performance768D100M: WeaviatePerformanceConfig,
-        CaseType.Performance768D10M: WeaviatePerformanceConfig,
-        CaseType.Performance768D1M: WeaviatePerformanceConfig,
-        CaseType.Performance768D10M1P: WeaviatePerformanceConfig,
-        CaseType.Performance768D1M1P: WeaviatePerformanceConfig,
-        CaseType.Performance768D10M99P: WeaviatePerformanceConfig,
-        CaseType.Performance768D1M99P: WeaviatePerformanceConfig,
-        CaseType.Performance1536D5M: WeaviatePerformanceConfig,
-        CaseType.Performance1536D500K: WeaviatePerformanceConfig,
-        CaseType.Performance1536D5M1P: WeaviatePerformanceConfig,
-        CaseType.Performance1536D500K1P: WeaviatePerformanceConfig,
-        CaseType.Performance1536D5M99P: WeaviatePerformanceConfig,
-        CaseType.Performance1536D500K99P: WeaviatePerformanceConfig,
+        CaseLabel.Load: WeaviateLoadConfig,
+        CaseLabel.Performance: WeaviatePerformanceConfig,
     },
     DB.ElasticCloud: {
-        CaseType.CapacityDim960: ESLoadingConfig,
-        CaseType.CapacityDim128: ESLoadingConfig,
-        CaseType.Performance768D100M: ESPerformanceConfig,
-        CaseType.Performance768D10M: ESPerformanceConfig,
-        CaseType.Performance768D1M: ESPerformanceConfig,
-        CaseType.Performance768D10M1P: ESPerformanceConfig,
-        CaseType.Performance768D1M1P: ESPerformanceConfig,
-        CaseType.Performance768D10M99P: ESPerformanceConfig,
-        CaseType.Performance768D1M99P: ESPerformanceConfig,
-        CaseType.Performance1536D5M: ESPerformanceConfig,
-        CaseType.Performance1536D500K: ESPerformanceConfig,
-        CaseType.Performance1536D5M1P: ESPerformanceConfig,
-        CaseType.Performance1536D500K1P: ESPerformanceConfig,
-        CaseType.Performance1536D5M99P: ESPerformanceConfig,
-        CaseType.Performance1536D500K99P: ESPerformanceConfig,
+        CaseLabel.Load: ESLoadingConfig,
+        CaseLabel.Performance: ESPerformanceConfig,
     },
     DB.PgVector: {
-        CaseType.CapacityDim960: PgVectorLoadingConfig,
-        CaseType.CapacityDim128: PgVectorLoadingConfig,
-        CaseType.Performance768D100M: PgVectorPerformanceConfig,
-        CaseType.Performance768D10M: PgVectorPerformanceConfig,
-        CaseType.Performance768D1M: PgVectorPerformanceConfig,
-        CaseType.Performance768D10M1P: PgVectorPerformanceConfig,
-        CaseType.Performance768D1M1P: PgVectorPerformanceConfig,
-        CaseType.Performance768D10M99P: PgVectorPerformanceConfig,
-        CaseType.Performance768D1M99P: PgVectorPerformanceConfig,
-        CaseType.Performance1536D5M: PgVectorPerformanceConfig,
-        CaseType.Performance1536D500K: PgVectorPerformanceConfig,
-        CaseType.Performance1536D5M1P: PgVectorPerformanceConfig,
-        CaseType.Performance1536D500K1P: PgVectorPerformanceConfig,
-        CaseType.Performance1536D5M99P: PgVectorPerformanceConfig,
-        CaseType.Performance1536D500K99P: PgVectorPerformanceConfig,
+        CaseLabel.Load: PgVectorLoadingConfig,
+        CaseLabel.Performance: PgVectorPerformanceConfig,
     },
     DB.PgVectoRS: {
-        CaseType.CapacityDim960: PgVectoRSLoadingConfig,
-        CaseType.CapacityDim128: PgVectoRSLoadingConfig,
-        CaseType.Performance768D100M: PgVectoRSPerformanceConfig,
-        CaseType.Performance768D10M: PgVectoRSPerformanceConfig,
-        CaseType.Performance768D1M: PgVectoRSPerformanceConfig,
-        CaseType.Performance768D10M1P: PgVectoRSPerformanceConfig,
-        CaseType.Performance768D1M1P: PgVectoRSPerformanceConfig,
-        CaseType.Performance768D10M99P: PgVectoRSPerformanceConfig,
-        CaseType.Performance768D1M99P: PgVectoRSPerformanceConfig,
-        CaseType.Performance1536D5M: PgVectoRSPerformanceConfig,
-        CaseType.Performance1536D500K: PgVectoRSPerformanceConfig,
-        CaseType.Performance1536D5M1P: PgVectoRSPerformanceConfig,
-        CaseType.Performance1536D500K1P: PgVectoRSPerformanceConfig,
-        CaseType.Performance1536D5M99P: PgVectorPerformanceConfig,
-        CaseType.Performance1536D500K99P: PgVectoRSPerformanceConfig,
+        CaseLabel.Load: PgVectoRSLoadingConfig,
+        CaseLabel.Performance: PgVectoRSPerformanceConfig,
     },
 }

vectordb_bench/models.py

@@ -59,6 +59,7 @@ class CaseConfigParamType(Enum):
     build_algo = "build_algo"
     cache_dataset_on_device = "cache_dataset_on_device"
     refine_ratio = "refine_ratio"
+    level = "level"
 
 
 class CustomizedCase(BaseModel):

vectordb_bench/results/PgVector/result_20230727_standard_pgvector.json

@@ -20,6 +20,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "L2",
           "lists": 10,
           "probes": 2
@@ -49,6 +50,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "L2",
           "lists": 10,
           "probes": 2
@@ -78,6 +80,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "COSINE",
           "lists": 10,
           "probes": 2
@@ -107,6 +110,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "COSINE",
           "lists": 10,
           "probes": 2
@@ -136,6 +140,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "COSINE",
           "lists": 10,
           "probes": 2
@@ -165,6 +170,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "COSINE",
           "lists": 10,
           "probes": 2
@@ -194,6 +200,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "COSINE",
           "lists": 10,
           "probes": 2
@@ -223,6 +230,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "COSINE",
           "lists": 10,
           "probes": 2

vectordb_bench/results/PgVector/result_20230808_standard_pgvector.json

@@ -20,6 +20,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "L2",
           "lists": 10,
           "probes": 2
@@ -51,7 +52,8 @@
         "db_case_config": {
           "metric_type": "L2",
           "lists": 10,
-          "probes": 2
+          "probes": 2,
+          "index": "IVF_FLAT"
         },
         "case_config": {
           "case_id": 11,
@@ -80,7 +82,8 @@
         "db_case_config": {
           "metric_type": "L2",
           "lists": 10,
-          "probes": 2
+          "probes": 2,
+          "index": "IVF_FLAT"
         },
         "case_config": {
           "case_id": 12,
@@ -107,6 +110,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "L2",
           "lists": 10,
           "probes": 2
@@ -136,6 +140,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "L2",
           "lists": 10,
           "probes": 2
@@ -165,6 +170,7 @@
           "db_name": "**********"
         },
         "db_case_config": {
+          "index": "IVF_FLAT",
           "metric_type": "L2",
           "lists": 10,
           "probes": 2
@@ -178,4 +184,4 @@
     }
   ],
   "file_fmt": "result_{}_{}_{}.json"
-}
+}