refactor(vibe): integrate OOP scalar quantizer and streamline preset grid

- Update DegANN in module.py to calibrate and reuse ScalarQuantizerInt8 instance for base vectors and queries
- Support automatic query feature quantization via base-calibrated quantizer
- Clean up unused preset parameters in presets.py
- Normalize query_dtype validation and logging across main.py and module.py"

Author: Neiko2002

examples/vibe/main.py

@@ -194,7 +194,7 @@ def main():
         print(f"\n--- System & Distance Config ---")
         print(f"Metric: {metric_str} ({metric_enum.name}), Dimensions: {dims}")
         print(f"Vector Space Type: FloatSpace ({instruction_set})")
-        print(f"Query Dtype: {args.query_dtype.upper()}")
+        print(f"Query Dtype: {args.query_dtype.upper() if args.query_dtype else 'FROM CONFIG.YML'}")
         print(f"Hardware AVX: {avx_usable()}, AVX-512: {avx512_usable()}")
 
         # Linear scan baseline
@@ -225,15 +225,13 @@ def main():
                 threads=args.build_threads,
                 query_dtype=query_dtype,
             )
-            print(
-                f"\n--- [{cfg_idx + 1}/{len(configs_to_run)}] Fitting / Loading Index: K={k}, Opt={opt_target}, Threads={args.build_threads}, QueryType={query_dtype}, PruneNonRNG={is_pruned} ---"
-            )
+            print(f"\n--- [{cfg_idx + 1}/{len(configs_to_run)}] Processing Graph Configuration ---")
             adapter.fit(base_vecs)
 
             deglib.analysis.analyze_graph(adapter.graph)
 
-            # Determine rerank factors to evaluate
-            if query_dtype == "int8":
+            # Determine rerank factors to evaluate (for all quantized formats)
+            if query_dtype != "float32":
                 factors_to_eval = cfg.get("rerank_size_factors", [1.0, 1.2, 1.5, 2.0])
             else:
                 factors_to_eval = [1.0]

examples/vibe/module.py

@@ -29,6 +29,8 @@ class BaseANN:
     "streamingdata": deglib.builder.OptimizationTarget.StreamingData,
 }
 
+_VALID_QUERY_DTYPES = ("float32", "int8")
+
 
 class DegANN(BaseANN):
     """
@@ -38,7 +40,7 @@ class DegANN(BaseANN):
       - k: Degree / edges per vertex (e.g. 16, 24, 30, 40, 48)
       - opt_target: 'HighLID' (for Cosine/IP/Normalized), 'LowLID' (for Euclidean), or 'StreamingData'
       - threads: CPU threads during graph build
-      - query_dtype: Dtype used to search graph ('float32', 'float16', 'int8')
+      - query_dtype: Dtype used to search graph ('float32', 'int8')
       - prune_non_rng: Optional MRNG edge pruning
     """
 
@@ -58,14 +60,14 @@ def __init__(
         self.needs_normalization: bool = (self.metric == "cosine")
 
         self.k = int(k)
-        self.opt_target = str(opt_target)
         self.extend_k = 60
         self.extend_eps = 0.1
+        self.opt_target = str(opt_target)
         self.prune_non_rng = bool(prune_non_rng)
         self.threads = int(threads)
         self.query_dtype = query_dtype.lower().strip()
-        if self.query_dtype not in ("float32", "int8"):
-            raise ValueError(f"Unsupported dtype '{self.query_dtype}'. Choose from: 'float32', 'int8'")
+        if self.query_dtype not in _VALID_QUERY_DTYPES:
+            raise ValueError(f"Unsupported dtype '{self.query_dtype}'. Choose from: {_VALID_QUERY_DTYPES}")
         self.search_eps: float = 0.1
         self.rerank_size_factor: float = 1.0
 
@@ -75,6 +77,7 @@ def __init__(
         self.metric_enum = self.query_metric_enum
         self.opt_enum = self._map_opt_target(self.opt_target)
 
+        self.quantizer = None
         self.graph: deglib.ReadOnlyGraph | None = None
         self.original_features_fp16: np.ndarray | None = None
         self.rerank_space_fp16: deglib.FloatSpace | None = None
@@ -163,25 +166,46 @@ def _resolve_graph_path(self, n_vectors: int, dims: int) -> Path:
         filename = f"{dims}D_{build_metric_str}_K{self.k}_AddK{self.extend_k}Eps{self.extend_eps:.1f}_{self.opt_target}_FLAS.deg"
         return deg_dir / filename
 
+    def _init_and_calibrate_quantizer(self, X_f32: np.ndarray) -> np.ndarray | None:
+        """Calibrates the appropriate quantizer on base vectors and returns the quantized features."""
+        if self.query_dtype == "float32":
+            self.quantizer = None
+            return None
+        elif self.query_dtype == "int8":
+            self.quantizer = deglib.optimization.make_scalar_quantizer_int8(X_f32)
+            return self.quantizer.quantize(X_f32, num_threads=self.threads)
+        else:
+            raise ValueError(f"Unknown query_dtype: {self.query_dtype}")
+
     def fit(self, X: np.ndarray):
         """Builds or loads the DEG graph for corpus X, applies optional pruning and quantizes for search."""
         X_f32 = self._prepare_input(X)
         n_vectors, dims = X_f32.shape
 
-        # Store original features in FP16 for fast and memory-efficient reranking
-        if self.query_dtype == "int8":
-            self.original_features_fp16 = deglib.distances.floats_to_fp16(X_f32)
-            self.rerank_space_fp16 = deglib.FloatSpace.create(dim=dims, metric=_METRIC_MAP[(self.is_l2, "float16")])
-
         # Automatically resolve graph save/load path
         graph_path = self._resolve_graph_path(n_vectors, dims)
 
+        print(
+            f"Index Configuration: K={self.k}, ExtendK={self.extend_k}, ExtendEps={self.extend_eps:.2f}, "
+            f"Opt={self.opt_target}, Threads={self.threads}, QueryType={self.query_dtype}, "
+            f"PruneNonRNG={self.prune_non_rng}"
+        )
+
+        # Always calibrate quantizer on base dataset (even when loading cached graph)
+        quantized_features = self._init_and_calibrate_quantizer(X_f32)
+
+        # Store original features in FP16 for fast and memory-efficient reranking if quantized
+        if self.query_dtype != "float32":
+            self.original_features_fp16 = deglib.distances.floats_to_fp16(X_f32)
+            self.rerank_space_fp16 = deglib.FloatSpace.create(dim=dims, metric=_METRIC_MAP[(self.is_l2, "float16")])
+
         # 1. Obtain base graph in FP32 (either by loading cached file or by building)
         if graph_path and graph_path.is_file():
             load_fn = deglib.load_mutable_graph if self.prune_non_rng else deglib.load_readonly_graph
             print(f"Loading cached DEG graph from: {graph_path}")
             graph = load_fn(str(graph_path))
         else:
+            print(f"No cached graph found at {graph_path}. Building from scratch...")
             graph = self._build_graph(X_f32, graph_path=graph_path)
 
         # 2. Optional MRNG edge pruning on SizeBoundedGraph (MutableGraph)
@@ -193,11 +217,10 @@ def fit(self, X: np.ndarray):
             graph = mut_graph
 
         # 3. Finalize ReadOnlyGraph with query_dtype features
-        if self.query_dtype == "int8":
-            print(f"Finalizing ReadOnlyGraph with INT8 (Metric: {self.query_metric_enum.name})...")
-            int8_features = deglib.optimization.quantize_int8(X_f32, num_threads=self.threads)
+        if quantized_features is not None:
+            print(f"Finalizing ReadOnlyGraph with {self.query_dtype.upper()} (Metric: {self.query_metric_enum.name})...")
             target_space = deglib.FloatSpace.create(dim=dims, metric=self.query_metric_enum)
-            self.graph = graph.to_readonly(target_space, int8_features)
+            self.graph = graph.to_readonly(target_space, quantized_features)
         else:
             self.graph = graph if not graph.is_mutable() else graph.to_readonly()
 
@@ -206,14 +229,23 @@ def set_query_arguments(self, search_eps: float, rerank_size_factor: float = 1.0
         self.search_eps = float(search_eps)
         self.rerank_size_factor = float(rerank_size_factor)
 
+    def _prepare_query_vectors(self, q_f32: np.ndarray, threads: int = 1) -> np.ndarray:
+        """Transforms query vectors using the base-calibrated quantizer."""
+        if self.query_dtype == "float32":
+            return q_f32
+        elif self.quantizer is not None:
+            return self.quantizer.quantize(q_f32, num_threads=threads)
+        else:
+            return q_f32
+
     def _search_and_rerank(self, queries: np.ndarray, n: int, threads: int = 1) -> np.ndarray:
         """Unified search and optional FP16 reranking engine."""
         if self.graph is None:
             raise RuntimeError("Index not fitted. Call fit(X) first.")
 
         fetch_k = max(n, int(round(n * self.rerank_size_factor)))
         q_f32 = self._prepare_input(queries)
-        query_mat = deglib.optimization.quantize_int8(q_f32, num_threads=threads) if self.query_dtype == "int8" else q_f32
+        query_mat = self._prepare_query_vectors(q_f32, threads=threads)
         res = self.graph.search(query_mat, eps=self.search_eps, k=fetch_k, threads=threads, return_distances=False, unsorted=True)
         indices = res[0] if isinstance(res, tuple) else res
 

examples/vibe/presets.py

@@ -19,11 +19,7 @@ def load_vibe_config(config_path: Path | None = None) -> Dict[str, Any]:
 
     return {
         "k_list": args.get("k", [30]),
-        "extend_k_list": args.get("extend_k", [60]),
-        "extend_eps_list": args.get("extend_eps", args.get("build_eps", [0.1])),
         "opt_target_list": args.get("opt_target", ["HighLID"]),
-        "improve_k_list": args.get("improve_k", [0]),
-        "improve_eps_list": args.get("improve_eps", [0.0]),
         "prune_non_rng_list": args.get("prune_non_rng", [False]),
         "threads_list": args.get("threads", [1]),
         "query_dtype_list": args.get("query_dtype", ["float32"]),
@@ -53,25 +49,17 @@ def get_config_grid_presets(dataset_key: str) -> List[Dict[str, Any]]:
             resolved_opt_targets.append(target_name)
 
     grid = []
-    # Cartesian product: iterate over opt_target first, then all k, improvement, pruning and query_dtype variants
-    for opt_target, k, extend_k, extend_eps, imp_k, imp_eps, prune_non_rng, q_dtype in itertools.product(
+    # Cartesian product: iterate over opt_target first, then all k, pruning and query_dtype variants
+    for opt_target, k, prune_non_rng, q_dtype in itertools.product(
         resolved_opt_targets,
         cfg["k_list"],
-        cfg["extend_k_list"],
-        cfg["extend_eps_list"],
-        cfg["improve_k_list"],
-        cfg["improve_eps_list"],
         cfg["prune_non_rng_list"],
         cfg["query_dtype_list"],
     ):
         grid.append(
             {
                 "k": k,
-                "extend_k": extend_k,
-                "extend_eps": extend_eps,
                 "optimization_target": opt_target,
-                "improve_k": imp_k,
-                "improve_eps": imp_eps,
                 "prune_non_rng": prune_non_rng,
                 "query_dtype": q_dtype,
                 "anns_k": 100,
@@ -90,13 +78,9 @@ def get_default_config_preset(dataset_key: str) -> Dict[str, Any]:
         if presets
         else {
             "k": 30,
-            "extend_k": 60,
-            "extend_eps": 0.1,
             "optimization_target": "LowLID"
             if ("euclidean" in dataset_key.lower() or "agnews" in dataset_key.lower())
             else "HighLID",
-            "improve_k": 0,
-            "improve_eps": 0.0,
             "prune_non_rng": False,
             "query_dtype": "float32",
             "anns_k": 100,