vectordb-bench 0.0.30__py3-none-any.whl → 1.0.0__py3-none-any.whl

vectordb_bench/backend/task_runner.py

@@ -6,15 +6,14 @@ from enum import Enum, auto
 import numpy as np
 import psutil
 
-from vectordb_bench.base import BaseModel
-from vectordb_bench.metric import Metric
-from vectordb_bench.models import PerformanceTimeoutError, TaskConfig, TaskStage
-
+from ..base import BaseModel
+from ..metric import Metric
+from ..models import PerformanceTimeoutError, TaskConfig, TaskStage
 from . import utils
-from .cases import Case, CaseLabel
+from .cases import Case, CaseLabel, StreamingPerformanceCase
 from .clients import MetricType, api
 from .data_source import DatasetSource
-from .runner import MultiProcessingSearchRunner, SerialInsertRunner, SerialSearchRunner
+from .runner import MultiProcessingSearchRunner, ReadWriteRunner, SerialInsertRunner, SerialSearchRunner
 
 log = logging.getLogger(__name__)
 
@@ -48,6 +47,7 @@ class CaseRunner(BaseModel):
     serial_search_runner: SerialSearchRunner | None = None
     search_runner: MultiProcessingSearchRunner | None = None
     final_search_runner: MultiProcessingSearchRunner | None = None
+    read_write_runner: ReadWriteRunner | None = None
 
     def __eq__(self, obj: any):
         if isinstance(obj, CaseRunner):
@@ -63,6 +63,7 @@ class CaseRunner(BaseModel):
         c_dict = self.ca.dict(
             include={
                 "label": True,
+                "name": True,
                 "filters": True,
                 "dataset": {
                     "data": {
@@ -91,12 +92,13 @@ class CaseRunner(BaseModel):
             db_config=self.config.db_config.to_dict(),
             db_case_config=self.config.db_case_config,
             drop_old=drop_old,
+            with_scalar_labels=self.ca.with_scalar_labels,
         )
 
     def _pre_run(self, drop_old: bool = True):
         try:
             self.init_db(drop_old)
-            self.ca.dataset.prepare(self.dataset_source, filters=self.ca.filter_rate)
+            self.ca.dataset.prepare(self.dataset_source, filters=self.ca.filters)
         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
@@ -110,6 +112,8 @@ class CaseRunner(BaseModel):
             return self._run_capacity_case()
         if self.ca.label == CaseLabel.Performance:
             return self._run_perf_case(drop_old)
+        if self.ca.label == CaseLabel.Streaming:
+            return self._run_streaming_case()
         msg = f"unknown case type: {self.ca.label}"
         log.warning(msg)
         raise ValueError(msg)
@@ -127,6 +131,7 @@ class CaseRunner(BaseModel):
                 self.db,
                 self.ca.dataset,
                 self.normalize,
+                self.ca.filters,
                 self.ca.load_timeout,
             )
             count = runner.run_endlessness()
@@ -151,6 +156,8 @@ class CaseRunner(BaseModel):
                 if TaskStage.LOAD in self.config.stages:
                     _, load_dur = self._load_train_data()
                     build_dur = self._optimize()
+                    m.insert_duration = round(load_dur, 4)
+                    m.optimize_duration = round(build_dur, 4)
                     m.load_duration = round(load_dur + build_dur, 4)
                     log.info(
                         f"Finish loading the entire dataset into VectorDB,"
@@ -172,10 +179,6 @@ class CaseRunner(BaseModel):
                     ) = search_results
                 if TaskStage.SEARCH_SERIAL in self.config.stages:
                     search_results = self._serial_search()
-                    """
-                    m.recall = search_results.recall
-                    m.serial_latencies = search_results.serial_latencies
-                    """
                     m.recall, m.ndcg, m.serial_latency_p99 = search_results
 
         except Exception as e:
@@ -186,6 +189,19 @@ class CaseRunner(BaseModel):
             log.info(f"Performance case got result: {m}")
             return m
 
+    def _run_streaming_case(self) -> Metric:
+        log.info("Start streaming case")
+        try:
+            self._init_read_write_runner()
+            m = self.read_write_runner.run_read_write()
+        except Exception as e:
+            log.warning(f"Failed to run streaming case, reason = {e}")
+            traceback.print_exc()
+            raise e from None
+        else:
+            log.info(f"Streaming case got result: {m}")
+            return m
+
     @utils.time_it
     def _load_train_data(self):
         """Insert train data and get the insert_duration"""
@@ -194,6 +210,7 @@ class CaseRunner(BaseModel):
                 self.db,
                 self.ca.dataset,
                 self.normalize,
+                self.ca.filters,
                 self.ca.load_timeout,
             )
             runner.run()
@@ -207,7 +224,7 @@ class CaseRunner(BaseModel):
         calculate the recall, serial_latency_p99
 
         Returns:
-            tuple[float, float]: recall, serial_latency_p99
+            tuple[float, float, float]: recall, ndcg, serial_latency_p99
         """
         try:
             results, _ = self.serial_search_runner.run()
@@ -253,10 +270,12 @@ class CaseRunner(BaseModel):
                 raise e from None
 
     def _init_search_runner(self):
-        test_emb = np.stack(self.ca.dataset.test_data["emb"])
         if self.normalize:
+            test_emb = np.stack(self.ca.dataset.test_data)
             test_emb = test_emb / np.linalg.norm(test_emb, axis=1)[:, np.newaxis]
-        self.test_emb = test_emb.tolist()
+            self.test_emb = test_emb.tolist()
+        else:
+            self.test_emb = self.ca.dataset.test_data
 
         gt_df = self.ca.dataset.gt_data
 
@@ -279,6 +298,20 @@ class CaseRunner(BaseModel):
                 k=self.config.case_config.k,
             )
 
+    def _init_read_write_runner(self):
+        ca: StreamingPerformanceCase = self.ca
+        self.read_write_runner = ReadWriteRunner(
+            db=self.db,
+            dataset=ca.dataset,
+            insert_rate=ca.insert_rate,
+            search_stages=ca.search_stages,
+            optimize_after_write=ca.optimize_after_write,
+            read_dur_after_write=ca.read_dur_after_write,
+            concurrencies=ca.concurrencies,
+            k=self.config.case_config.k,
+            normalize=self.normalize,
+        )
+
     def stop(self):
         if self.search_runner:
             self.search_runner.stop()
@@ -316,12 +349,7 @@ class TaskRunner(BaseModel):
         fmt.append(DATA_FORMAT % ("-" * 11, "-" * 12, "-" * 20, "-" * 7, "-" * 7))
 
         for f in self.case_runners:
-            if f.ca.filter_rate != 0.0:
-                filters = f.ca.filter_rate
-            elif f.ca.filter_size != 0:
-                filters = f.ca.filter_size
-            else:
-                filters = "None"
+            filters = f.ca.filters.filter_rate
 
             ds_str = f"{f.ca.dataset.data.name}-{f.ca.dataset.data.label}-{utils.numerize(f.ca.dataset.data.size)}"
             fmt.append(

vectordb_bench/cli/cli.py

@@ -110,7 +110,7 @@ def click_parameter_decorators_from_typed_dict(
     return deco
 
 
-def click_arg_split(ctx: click.Context, param: click.core.Option, value):  # noqa: ANN001, ARG001
+def click_arg_split(ctx: click.Context, param: click.core.Option, value: any):  # noqa: ARG001
     """Will split a comma-separated list input into an actual list.
 
     Args:
@@ -455,6 +455,22 @@ class HNSWFlavor3(HNSWBaseRequiredTypedDict):
     ]
 
 
+class HNSWFlavor4(HNSWBaseRequiredTypedDict):
+    ef_search: Annotated[
+        int | None,
+        click.option("--ef-search", type=int, help="hnsw ef-search", required=True),
+    ]
+    index_type: Annotated[
+        str | None,
+        click.option(
+            "--index-type",
+            type=click.Choice(["HNSW", "HNSW_SQ", "HNSW_BQ"], case_sensitive=False),
+            help="Type of index to use. Supported values: HNSW, HNSW_SQ, HNSW_BQ",
+            required=True,
+        ),
+    ]
+
+
 class IVFFlatTypedDict(TypedDict):
     lists: Annotated[int | None, click.option("--lists", type=int, help="ivfflat lists")]
     probes: Annotated[int | None, click.option("--probes", type=int, help="ivfflat probes")]
@@ -471,6 +487,48 @@ class IVFFlatTypedDictN(TypedDict):
     ]
 
 
+class OceanBaseIVFTypedDict(TypedDict):
+    index_type: Annotated[
+        str | None,
+        click.option(
+            "--index-type",
+            type=click.Choice(["IVF_FLAT", "IVF_SQ8", "IVF_PQ"], case_sensitive=False),
+            help="Type of index to use. Supported values: IVF_FLAT, IVF_SQ8, IVF_PQ",
+            required=True,
+        ),
+    ]
+    nlist: Annotated[
+        int | None,
+        click.option("--nlist", "nlist", type=int, help="Number of cluster centers", required=True),
+    ]
+    sample_per_nlist: Annotated[
+        int | None,
+        click.option(
+            "--sample_per_nlist",
+            "sample_per_nlist",
+            type=int,
+            help="The cluster centers are calculated by total sampling sample_per_nlist * nlist vectors",
+            required=True,
+        ),
+    ]
+    ivf_nprobes: Annotated[
+        int | None,
+        click.option(
+            "--ivf_nprobes",
+            "ivf_nprobes",
+            type=str,
+            help="How many clustering centers to search during the query",
+            required=True,
+        ),
+    ]
+    m: Annotated[
+        int | None,
+        click.option(
+            "--m", "m", type=int, help="The number of sub-vectors that each data vector is divided into during IVF-PQ"
+        ),
+    ]
+
+
 @click.group()
 def cli(): ...
 

vectordb_bench/cli/vectordbbench.py

@@ -5,6 +5,7 @@ from ..backend.clients.lancedb.cli import LanceDB
 from ..backend.clients.mariadb.cli import MariaDBHNSW
 from ..backend.clients.memorydb.cli import MemoryDB
 from ..backend.clients.milvus.cli import MilvusAutoIndex
+from ..backend.clients.oceanbase.cli import OceanBaseHNSW, OceanBaseIVF
 from ..backend.clients.pgdiskann.cli import PgDiskAnn
 from ..backend.clients.pgvecto_rs.cli import PgVectoRSHNSW, PgVectoRSIVFFlat
 from ..backend.clients.pgvector.cli import PgVectorHNSW
@@ -33,6 +34,8 @@ cli.add_command(AWSOpenSearch)
 cli.add_command(PgVectorScaleDiskAnn)
 cli.add_command(PgDiskAnn)
 cli.add_command(AlloyDBScaNN)
+cli.add_command(OceanBaseHNSW)
+cli.add_command(OceanBaseIVF)
 cli.add_command(MariaDBHNSW)
 cli.add_command(TiDB)
 cli.add_command(Clickhouse)

vectordb_bench/frontend/components/check_results/data.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from dataclasses import asdict
-from vectordb_bench.metric import isLowerIsBetterMetric
+from vectordb_bench.metric import QPS_METRIC, isLowerIsBetterMetric
 from vectordb_bench.models import CaseResult, ResultLabel
 
 
@@ -22,8 +22,7 @@ def getFilterTasks(
     filterTasks = [
         task
         for task in tasks
-        if task.task_config.db_name in dbNames
-        and task.task_config.case_config.case_id.case_cls(task.task_config.case_config.custom_case).name in caseNames
+        if task.task_config.db_name in dbNames and task.task_config.case_config.case_name in caseNames
     ]
     return filterTasks
 
@@ -35,17 +34,22 @@ def mergeTasks(tasks: list[CaseResult]):
         db = task.task_config.db.value
         db_label = task.task_config.db_config.db_label or ""
         version = task.task_config.db_config.version or ""
-        case = task.task_config.case_config.case_id.case_cls(task.task_config.case_config.custom_case)
+        case = task.task_config.case_config.case
+        case_name = case.name
+        dataset_name = case.dataset.data.full_name
+        filter_rate = case.filter_rate
         dbCaseMetricsMap[db_name][case.name] = {
             "db": db,
             "db_label": db_label,
             "version": version,
+            "dataset_name": dataset_name,
+            "filter_rate": filter_rate,
             "metrics": mergeMetrics(
-                dbCaseMetricsMap[db_name][case.name].get("metrics", {}),
+                dbCaseMetricsMap[db_name][case_name].get("metrics", {}),
                 asdict(task.metrics),
             ),
             "label": getBetterLabel(
-                dbCaseMetricsMap[db_name][case.name].get("label", ResultLabel.FAILED),
+                dbCaseMetricsMap[db_name][case_name].get("label", ResultLabel.FAILED),
                 task.label,
             ),
         }
@@ -59,12 +63,16 @@ def mergeTasks(tasks: list[CaseResult]):
             db_label = metricInfo["db_label"]
             version = metricInfo["version"]
             label = metricInfo["label"]
+            dataset_name = metricInfo["dataset_name"]
+            filter_rate = metricInfo["filter_rate"]
             if label == ResultLabel.NORMAL:
                 mergedTasks.append(
                     {
                         "db_name": db_name,
                         "db": db,
                         "db_label": db_label,
+                        "dataset_name": dataset_name,
+                        "filter_rate": filter_rate,
                         "version": version,
                         "case_name": case_name,
                         "metricsSet": set(metrics.keys()),
@@ -77,12 +85,9 @@ def mergeTasks(tasks: list[CaseResult]):
     return mergedTasks, failedTasks
 
 
+# for same db-label, we use the results with the highest qps
 def mergeMetrics(metrics_1: dict, metrics_2: dict) -> dict:
-    metrics = {**metrics_1}
-    for key, value in metrics_2.items():
-        metrics[key] = getBetterMetric(key, value, metrics[key]) if key in metrics else value
-
-    return metrics
+    return metrics_1 if metrics_1.get(QPS_METRIC, 0) > metrics_2.get(QPS_METRIC, 0) else metrics_2
 
 
 def getBetterMetric(metric, value_1, value_2):

vectordb_bench/frontend/components/check_results/filters.py

@@ -1,14 +1,19 @@
 from vectordb_bench.backend.cases import Case
+from vectordb_bench.backend.dataset import DatasetWithSizeType
+from vectordb_bench.backend.filter import FilterOp
 from vectordb_bench.frontend.components.check_results.data import getChartData
-from vectordb_bench.frontend.components.check_results.expanderStyle import initSidebarExanderStyle
+from vectordb_bench.frontend.components.check_results.expanderStyle import (
+    initSidebarExanderStyle,
+)
 from vectordb_bench.frontend.config.dbCaseConfigs import CASE_NAME_ORDER
-from vectordb_bench.frontend.config.styles import *
+from vectordb_bench.frontend.config.styles import SIDEBAR_CONTROL_COLUMNS
 import streamlit as st
+from typing import Callable
 
 from vectordb_bench.models import CaseResult, TestResult
 
 
-def getshownData(results: list[TestResult], st):
+def getshownData(st, results: list[TestResult], filter_type: FilterOp = FilterOp.NonFilter, **kwargs):
     # hide the nav
     st.markdown(
         "<style> div[data-testid='stSidebarNav'] {display: none;} </style>",
@@ -17,15 +22,20 @@ def getshownData(results: list[TestResult], st):
 
     st.header("Filters")
 
-    shownResults = getshownResults(results, st)
-    showDBNames, showCaseNames = getShowDbsAndCases(shownResults, st)
+    shownResults = getshownResults(st, results, **kwargs)
+    showDBNames, showCaseNames = getShowDbsAndCases(st, shownResults, filter_type)
 
     shownData, failedTasks = getChartData(shownResults, showDBNames, showCaseNames)
 
     return shownData, failedTasks, showCaseNames
 
 
-def getshownResults(results: list[TestResult], st) -> list[CaseResult]:
+def getshownResults(
+    st,
+    results: list[TestResult],
+    case_results_filter: Callable[[CaseResult], bool] = lambda x: True,
+    **kwargs,
+) -> list[CaseResult]:
     resultSelectOptions = [
         result.task_label if result.task_label != result.run_id else f"res-{result.run_id[:4]}" for result in results
     ]
@@ -41,23 +51,18 @@ def getshownResults(results: list[TestResult], st) -> list[CaseResult]:
     )
     selectedResult: list[CaseResult] = []
     for option in selectedResultSelectedOptions:
-        result = results[resultSelectOptions.index(option)].results
-        selectedResult += result
+        case_results = results[resultSelectOptions.index(option)].results
+        selectedResult += [r for r in case_results if case_results_filter(r)]
 
     return selectedResult
 
 
-def getShowDbsAndCases(result: list[CaseResult], st) -> tuple[list[str], list[str]]:
+def getShowDbsAndCases(st, result: list[CaseResult], filter_type: FilterOp) -> tuple[list[str], list[str]]:
     initSidebarExanderStyle(st)
-    allDbNames = list(set({res.task_config.db_name for res in result}))
+    case_results = [res for res in result if res.task_config.case_config.case.filters.type == filter_type]
+    allDbNames = list(set({res.task_config.db_name for res in case_results}))
     allDbNames.sort()
-    allCases: list[Case] = [
-        res.task_config.case_config.case_id.case_cls(res.task_config.case_config.custom_case) for res in result
-    ]
-    allCaseNameSet = set({case.name for case in allCases})
-    allCaseNames = [case_name for case_name in CASE_NAME_ORDER if case_name in allCaseNameSet] + [
-        case_name for case_name in allCaseNameSet if case_name not in CASE_NAME_ORDER
-    ]
+    allCases: list[Case] = [res.task_config.case_config.case for res in case_results]
 
     # DB Filter
     dbFilterContainer = st.container()
@@ -67,15 +72,38 @@ def getShowDbsAndCases(result: list[CaseResult], st) -> tuple[list[str], list[st
         allDbNames,
         col=1,
     )
+    showCaseNames = []
+
+    if filter_type == FilterOp.NonFilter:
+        allCaseNameSet = set({case.name for case in allCases})
+        allCaseNames = [case_name for case_name in CASE_NAME_ORDER if case_name in allCaseNameSet] + [
+            case_name for case_name in allCaseNameSet if case_name not in CASE_NAME_ORDER
+        ]
+
+        # Case Filter
+        caseFilterContainer = st.container()
+        showCaseNames = filterView(
+            caseFilterContainer,
+            "Case Filter",
+            [caseName for caseName in allCaseNames],
+            col=1,
+        )
 
-    # Case Filter
-    caseFilterContainer = st.container()
-    showCaseNames = filterView(
-        caseFilterContainer,
-        "Case Filter",
-        [caseName for caseName in allCaseNames],
-        col=1,
-    )
+    if filter_type == FilterOp.StrEqual:
+        container = st.container()
+        datasetWithSizeTypes = [dataset_with_size_type for dataset_with_size_type in DatasetWithSizeType]
+        showDatasetWithSizeTypes = filterView(
+            container,
+            "Case Filter",
+            datasetWithSizeTypes,
+            col=1,
+            optionLables=[v.value for v in datasetWithSizeTypes],
+        )
+        datasets = [dataset_with_size_type.get_manager() for dataset_with_size_type in showDatasetWithSizeTypes]
+        showCaseNames = list(set([case.name for case in allCases if case.dataset in datasets]))
+
+    if filter_type == FilterOp.NumGE:
+        raise NotImplementedError
 
     return showDBNames, showCaseNames
 

vectordb_bench/frontend/components/check_results/headerIcon.py

@@ -4,19 +4,22 @@ from vectordb_bench.frontend.config.styles import HEADER_ICON
 def drawHeaderIcon(st):
     st.markdown(
         f"""
-<div class="headerIconContainer"></div>
+    <a href="/vdb_benchmark" target="_self">
+        <div class="headerIconContainer"></div>
+    </a>
 
-<style>
-.headerIconContainer {{
-    position: absolute;
-    top: -50px;
-    height: 50px;
-    width: 100%;
-    border-bottom: 2px solid #E8EAEE;
-    background-image: url({HEADER_ICON});
-    background-repeat: no-repeat;
-}}
-</style
-""",
+    <style>
+    .headerIconContainer {{
+        position: relative;
+        top: 0px;
+        height: 50px;
+        width: 100%;
+        border-bottom: 2px solid #E8EAEE;
+        background-image: url({HEADER_ICON});
+        background-repeat: no-repeat;
+        cursor: pointer; 
+    }}
+    </style>
+    """,
         unsafe_allow_html=True,
     )

vectordb_bench/frontend/components/check_results/nav.py

@@ -20,3 +20,23 @@ def NavToResults(st, key="nav-to-results"):
     navClick = st.button("< &nbsp;&nbsp;Back to Results", key=key)
     if navClick:
         switch_page("vdb benchmark")
+
+
+def NavToPages(st):
+    options = [
+        {"name": "Run Test", "link": "run_test"},
+        {"name": "Results", "link": "results"},
+        {"name": "Quries Per Dollar", "link": "quries_per_dollar"},
+        {"name": "Concurrent", "link": "concurrent"},
+        {"name": "Label Filter", "link": "label_filter"},
+        {"name": "Streaming", "link": "streaming"},
+        {"name": "Tables", "link": "tables"},
+        {"name": "Custom Dataset", "link": "custom"},
+    ]
+
+    html = ""
+    for i, option in enumerate(options):
+        html += f'<a href="/{option["link"]}" target="_self" style="text-decoration: none; padding: 0.1px 0.2px;">{option["name"]}</a>'
+        if i < len(options) - 1:
+            html += '<span style="color: #888; margin: 0 5px;">|</span>'
+    st.markdown(html, unsafe_allow_html=True)

vectordb_bench/frontend/components/custom/displayCustomCase.py

@@ -12,7 +12,7 @@ def displayCustomCase(customCase: CustomCaseConfig, st, key):
         "Folder Path", key=f"{key}_dir", value=customCase.dataset_config.dir
     )
 
-    columns = st.columns(4)
+    columns = st.columns(3)
     customCase.dataset_config.dim = columns[0].number_input(
         "dim", key=f"{key}_dim", value=customCase.dataset_config.dim
     )
@@ -22,16 +22,51 @@ def displayCustomCase(customCase: CustomCaseConfig, st, key):
     customCase.dataset_config.metric_type = columns[2].selectbox(
         "metric type", key=f"{key}_metric_type", options=["L2", "Cosine", "IP"]
     )
-    customCase.dataset_config.file_count = columns[3].number_input(
-        "train file count", key=f"{key}_file_count", value=customCase.dataset_config.file_count
+
+    columns = st.columns(3)
+    customCase.dataset_config.train_name = columns[0].text_input(
+        "train file name",
+        key=f"{key}_train_name",
+        value=customCase.dataset_config.train_name,
+    )
+    customCase.dataset_config.test_name = columns[1].text_input(
+        "test file name", key=f"{key}_test_name", value=customCase.dataset_config.test_name
+    )
+    customCase.dataset_config.gt_name = columns[2].text_input(
+        "ground truth file name", key=f"{key}_gt_name", value=customCase.dataset_config.gt_name
+    )
+
+    columns = st.columns([1, 1, 2, 2])
+    customCase.dataset_config.train_id_name = columns[0].text_input(
+        "train id name", key=f"{key}_train_id_name", value=customCase.dataset_config.train_id_name
+    )
+    customCase.dataset_config.train_col_name = columns[1].text_input(
+        "train emb name", key=f"{key}_train_col_name", value=customCase.dataset_config.train_col_name
+    )
+    customCase.dataset_config.test_col_name = columns[2].text_input(
+        "test emb name", key=f"{key}_test_col_name", value=customCase.dataset_config.test_col_name
+    )
+    customCase.dataset_config.gt_col_name = columns[3].text_input(
+        "ground truth emb name", key=f"{key}_gt_col_name", value=customCase.dataset_config.gt_col_name
     )
 
-    columns = st.columns(4)
-    customCase.dataset_config.use_shuffled = columns[0].checkbox(
-        "use shuffled data", key=f"{key}_use_shuffled", value=customCase.dataset_config.use_shuffled
+    columns = st.columns(2)
+    customCase.dataset_config.scalar_labels_name = columns[0].text_input(
+        "scalar labels file name",
+        key=f"{key}_scalar_labels_file_name",
+        value=customCase.dataset_config.scalar_labels_name,
     )
-    customCase.dataset_config.with_gt = columns[1].checkbox(
-        "with groundtruth", key=f"{key}_with_gt", value=customCase.dataset_config.with_gt
+    default_label_percentages = ",".join(map(str, customCase.dataset_config.with_label_percentages))
+    label_percentage_input = columns[1].text_input(
+        "label percentages",
+        key=f"{key}_label_percantages",
+        value=default_label_percentages,
     )
+    try:
+        customCase.dataset_config.label_percentages = [
+            float(item.strip()) for item in label_percentage_input.split(",") if item.strip()
+        ]
+    except ValueError as e:
+        st.write(f"<span style='color:red'>{e},please input correct number</span>", unsafe_allow_html=True)
 
     customCase.description = st.text_area("description", key=f"{key}_description", value=customCase.description)

vectordb_bench/frontend/components/custom/displaypPrams.py

@@ -2,13 +2,18 @@ def displayParams(st):
     st.markdown(
         """
 - `Folder Path` - The path to the folder containing all the files. Please ensure that all files in the folder are in the `Parquet` format.
-  - Vectors data files: The file must be named `train.parquet` and should have two columns: `id` as an incrementing `int` and `emb` as an array of `float32`.
-  - Query test vectors: The file must be named `test.parquet` and should have two columns: `id` as an incrementing `int` and `emb` as an array of `float32`. 
-  - Ground truth file: The file must be named `neighbors.parquet` and should have two columns: `id` corresponding to query vectors and `neighbors_id` as an array of `int`.
+  - Vectors data files: The file should have two kinds of columns: `id` as an incrementing `int` and `emb` as an array of `float32`. The name of two columns could be defined on your own.
+  - Query test vectors: The file could be named on your own and should have two kinds of columns: `id` as an incrementing `int` and `emb` as an array of `float32`. The `id` column must be named as `id`, and `emb` column could be defined on your own.  
+  - Ground truth file: The file could be named on your own and should have two kinds of columns: `id` corresponding to query vectors and `neighbors_id` as an array of `int`. The `id` column must be named as `id`, and `neighbors_id` column could be defined on your own.
 
-- `Train File Count` - If the vector file is too large, you can consider splitting it into multiple files. The naming format for the split files should be `train-[index]-of-[file_count].parquet`. For example, `train-01-of-10.parquet` represents the second file (0-indexed) among 10 split files.
+- `Train File Name` - If the number of train file is `more than one`, please input all your train file name and `split with ','` without the `.parquet` file extensionthe. For example, if there are two train file and the name of them are `train1.parquet` and `train2.parquet`, then input `train1,train2`.
+
+- `Ground Truth Emb Name` - No matter whether filter file is applied or not, the `neighbors_id` column in ground truth file must have the same name.
+
+- `Scalar Labels File Name ` - If there is a scalar labels file, please input the filename without the .parquet extension. The file should have two columns: `id` as an incrementing `int` and `labels` as an array of `string`. The `id` column must correspond one-to-one with the `id` column in train file..
+
+- `Label percentages` - If you have filter file, please input label percentage you want to real run and `split with ','` when it's `more than one`. If you `don't have` filter file, than `keep the text vacant.`
 
-- `Use Shuffled Data` - If you check this option, the vector data files need to be modified. VectorDBBench will load the data labeled with `shuffle`. For example, use `shuffle_train.parquet` instead of `train.parquet` and `shuffle_train-04-of-10.parquet` instead of `train-04-of-10.parquet`. The `id` column in the shuffled data can be in any order.
 """
     )
     st.caption(

vectordb_bench/frontend/components/custom/getCustomConfig.py

@@ -14,6 +14,16 @@ class CustomDatasetConfig(BaseModel):
     file_count: int = 1
     use_shuffled: bool = False
     with_gt: bool = True
+    train_name: str = "train"
+    test_name: str = "test"
+    gt_name: str = "neighbors"
+    train_id_name: str = "id"
+    train_col_name: str = "emb"
+    test_col_name: str = "emb"
+    gt_col_name: str = "neighbors_id"
+    scalar_labels_name: str = "scalar_labels"
+    label_percentages: list[str] = []
+    with_label_percentages: list[float] = [0.001, 0.02, 0.5]
 
 
 class CustomCaseConfig(BaseModel):