Revert "[Java]Binary and scalar quantization (#1104)" (#1274)

This reverts commit 989c994.

The changes in #1104 were merged by accident, ahead of higher priority features.  This change is to revert #1104, to reduce rework on the other PRs.

Java support for Quantization will be revisited when prioritized. The changes in #1104 can be rebased then.

Authors:
  - MithunR (https://github.com/mythrocks)

Approvers:
  - Corey J. Nolet (https://github.com/cjnolet)

URL: #1274

Author: mythrocks

cpp/include/cuvs/preprocessing/quantize/binary.h

@@ -30,7 +30,7 @@ extern "C" {
  * and sampling_median thresholds are calculated separately for each dimension.
  *
  */
-typedef enum { ZERO, MEAN, SAMPLING_MEDIAN } cuvsBinaryQuantizerThreshold;
+enum cuvsBinaryQuantizerThreshold { ZERO, MEAN, SAMPLING_MEDIAN };
 
 /**
  * @brief Binary quantizer parameters.
@@ -39,12 +39,12 @@ struct cuvsBinaryQuantizerParams {
   /*
    * specifies the threshold to set a bit in cuvsBinaryQuantizerTransform
    */
-  cuvsBinaryQuantizerThreshold threshold;
+  cuvsBinaryQuantizerThreshold threshold = MEAN;
 
   /*
    * specifies the sampling ratio
    */
-  float sampling_ratio;
+  float sampling_ratio = 0.1;
 };
 
 typedef struct cuvsBinaryQuantizerParams* cuvsBinaryQuantizerParams_t;

java/cuvs-java/src/main/java/com/nvidia/cuvs/BinaryQuantizer.java

@@ -247,14 +247,6 @@ interface Builder {
      */
     Builder withIndexParams(CagraIndexParams cagraIndexParameters);
 
-    /**
-     * Sets the quantizer to use for building the index with quantized data.
-     *
-     * @param quantizer The quantizer to apply to the dataset during index construction
-     * @return An instance of this Builder
-     */
-    Builder withQuantizer(CuVSQuantizer quantizer);
-
     /**
      * Builds and returns an instance of CagraIndex.
      *

java/cuvs-java/src/main/java/com/nvidia/cuvs/CagraIndex.java

@@ -15,15 +15,14 @@
  */
 package com.nvidia.cuvs;
 
-import com.nvidia.cuvs.CuVSMatrix.DataType;
 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.Objects;
 import java.util.function.LongToIntFunction;
 
 /**
- * CagraQuery holds the search parameters plus either raw float[][] vectors
- * or a quantized {@link CuVSMatrix} for querying a CAGRA index.
+ * CagraQuery holds the CagraSearchParams and the query vectors to be used while
+ * invoking search.
  *
  * <p><strong>Thread Safety:</strong> Each CagraQuery instance should use its own
  * CuVSResources object that is not shared with other threads. Sharing CuVSResources
@@ -34,9 +33,8 @@
 public class CagraQuery {
 
   private final CagraSearchParams cagraSearchParameters;
-  private final float[][] queryVectors;
-  private final CuVSMatrix quantizedQueries;
   private final LongToIntFunction mapping;
+  private final float[][] queryVectors;
   private final int topK;
   private final BitSet prefilter;
   private final int numDocs;
@@ -49,37 +47,30 @@ public class CagraQuery {
    * @param cagraSearchParameters an instance of {@link CagraSearchParams} holding
    *                              the search parameters
    * @param queryVectors          2D float query vector array
-   * @param quantizedQueries      2D quantized query vector array
    * @param mapping               a function mapping ordinals (neighbor IDs) to custom user IDs
    * @param topK                  the top k results to return
    * @param prefilter             A single BitSet to use as filter while searching the CAGRA index
    * @param numDocs               Total number of dataset vectors; used to align the prefilter correctly
    * @param resources             CuVSResources instance to use for this query
    */
-  private CagraQuery(
+  public CagraQuery(
       CagraSearchParams cagraSearchParameters,
       float[][] queryVectors,
-      CuVSMatrix quantizedQueries,
       LongToIntFunction mapping,
       int topK,
       BitSet prefilter,
       int numDocs,
       CuVSResources resources) {
+    super();
     this.cagraSearchParameters = cagraSearchParameters;
     this.queryVectors = queryVectors;
-    this.quantizedQueries = quantizedQueries;
     this.mapping = mapping;
     this.topK = topK;
     this.prefilter = prefilter;
     this.numDocs = numDocs;
     this.resources = resources;
   }
 
-  /** Start building a new CagraQuery. */
-  public static Builder newBuilder(CuVSResources resources) {
-    return new Builder(resources);
-  }
-
   /**
    * Gets the instance of CagraSearchParams initially set.
    *
@@ -90,35 +81,14 @@ public CagraSearchParams getCagraSearchParameters() {
   }
 
   /**
-   * If this query was built without a quantizer, returns the original float vectors.
-   * Otherwise returns null.
+   * Gets the query vector 2D float array.
+   *
+   * @return 2D float array
    */
   public float[][] getQueryVectors() {
     return queryVectors;
   }
 
-  /**
-   * If this query was built with a quantizer, returns the quantized Dataset.
-   * Otherwise returns null.
-   */
-  public CuVSMatrix getQuantizedQueries() {
-    return quantizedQueries;
-  }
-
-  /** True if this query carries a quantized Dataset instead of float[][] */
-  public boolean hasQuantizedQueries() {
-    return quantizedQueries != null;
-  }
-
-  /**
-   * Returns the data type of the query payload:
-   * - 32 for float32 queries
-   * - 8 for quantized queries
-   */
-  public DataType getQueryDataType() {
-    return quantizedQueries != null ? quantizedQueries.dataType() : DataType.FLOAT;
-  }
-
   /**
    * Gets the function mapping ordinals (neighbor IDs) to custom user IDs
    */
@@ -164,13 +134,10 @@ public CuVSResources getResources() {
 
   @Override
   public String toString() {
-    return "CagraQuery["
-        + "params="
+    return "CuVSQuery [cagraSearchParameters="
         + cagraSearchParameters
-        + ", floatVectors="
-        + (queryVectors != null ? Arrays.toString(queryVectors) : "null")
-        + ", quantized="
-        + (quantizedQueries != null ? ("Dataset@" + quantizedQueries.dataType() + "-bit") : "false")
+        + ", queryVectors="
+        + Arrays.toString(queryVectors)
         + ", mapping="
         + mapping
         + ", topK="
@@ -189,7 +156,6 @@ public static class Builder {
     private int topK = 2;
     private BitSet prefilter;
     private int numDocs;
-    private CuVSQuantizer quantizer;
     private final CuVSResources resources;
 
     /**
@@ -208,12 +174,12 @@ public Builder(CuVSResources resources) {
     /**
      * Sets the instance of configured CagraSearchParams to be passed for search.
      *
-     * @param params an instance of the configured CagraSearchParams to
-     *               be used for this query
+     * @param cagraSearchParams an instance of the configured CagraSearchParams to
+     *                          be used for this query
      * @return an instance of this Builder
      */
-    public Builder withSearchParams(CagraSearchParams params) {
-      this.cagraSearchParams = params;
+    public Builder withSearchParams(CagraSearchParams cagraSearchParams) {
+      this.cagraSearchParams = cagraSearchParams;
       return this;
     }
 
@@ -267,47 +233,13 @@ public Builder withPrefilter(BitSet prefilter, int numDocs) {
     }
 
     /**
-     * Specify a quantizer to automatically transform the float[][] queryVectors
-     * into a quantized {@link CuVSMatrix} using the same quantizer used for training.
-     */
-    public Builder withQuantizer(CuVSQuantizer quantizer) {
-      this.quantizer = quantizer;
-      return this;
-    }
-
-    /**
-     * Builds the CagraQuery. If a quantizer was provided, queryVectors is ignored
-     * and a quantized Dataset is produced instead.
+     * Builds an instance of CuVSQuery.
+     *
+     * @return an instance of CuVSQuery
      */
-    public CagraQuery build() throws Throwable {
-      if (queryVectors == null) {
-        throw new IllegalArgumentException("Query vectors must be provided");
-      }
-
-      CuVSMatrix quantized = null;
-      float[][] floatsForQuery = queryVectors;
-
-      if (quantizer != null) {
-        // wrap float[][] in a CuVSMatrix and quantize
-        try (CuVSMatrix tmp = CuVSMatrix.ofArray(queryVectors)) {
-          if (tmp.dataType() != DataType.FLOAT) {
-            throw new IllegalArgumentException(
-                "Query quantization requires FLOAT input, got " + tmp.dataType());
-          }
-          quantized = quantizer.transform(tmp);
-        }
-        floatsForQuery = null;
-      }
-
+    public CagraQuery build() {
       return new CagraQuery(
-          cagraSearchParams,
-          floatsForQuery,
-          quantized,
-          mapping,
-          topK,
-          prefilter,
-          numDocs,
-          resources);
+          cagraSearchParams, queryVectors, mapping, topK, prefilter, numDocs, resources);
     }
   }
 }

java/cuvs-java/src/main/java/com/nvidia/cuvs/CagraQuery.java

@@ -69,17 +69,6 @@ static CuVSMatrix ofArray(byte[][] vectors) {
     return CuVSProvider.provider().newMatrixFromArray(vectors);
   }
 
-  /**
-   * Returns the data type of this matrix.
-   *
-   * <p>DataType provides the fundamental type information needed for all operations.
-   * FLOAT represents 32-bit floating point data, INT represents 32-bit integer data,
-   * and BYTE represents 8-bit data (used for quantized values).
-   *
-   * @return The DataType of this matrix
-   */
-  DataType dataType();
-
   interface Builder {
     /**
      * Add a single vector to the dataset.
@@ -163,13 +152,6 @@ static CuVSMatrix.Builder builder(int size, int columns, DataType dataType) {
    */
   void toArray(byte[][] array);
 
-  /**
-   * Gets where the content is stored
-   *
-   * @return MemoryKind whether HOST or DEVICE
-   */
-  CuVSMatrix.MemoryKind memoryKind();
-
   @Override
   void close();
 }