Fix a flaky unit test:testMultiFieldsKnnIndex, which was failing due …

…to inconsistent merge behaviors (opensearch-project#1924)

Signed-off-by: Navneet Verma <navneev@amazon.com>

Quantization Framework Implementation with 1bit, 2bit and 4bit Binary Quantizer

src/main/java/org/opensearch/knn/quantization/factory/QuantizerFactory.java

@@ -41,7 +41,7 @@ private static void ensureRegistered() {
      * @param <Q>    the type of the quantized output
      * @return an instance of {@link Quantizer} corresponding to the provided parameters
      */
-    public static <P extends QuantizationParams, Q> Quantizer<P, Q> getQuantizer(P params) {
+    public static <P extends QuantizationParams, Q> Quantizer<P, Q> getQuantizer(final P params) {
         if (params == null) {
             throw new IllegalArgumentException("Quantization parameters must not be null.");
         }

src/main/java/org/opensearch/knn/quantization/factory/QuantizerRegistry.java

@@ -36,10 +36,10 @@ private QuantizerRegistry() {}
      * @param quantizerSupplier a supplier that provides instances of the quantizer
      * @param <P>               the type of quantization parameters
      */
-    public static <P extends QuantizationParams> void register(Class<P> paramClass,
-                                                               QuantizationType quantizationType,
-                                                               SQTypes sqType,
-                                                               Supplier<? extends Quantizer<?, ?>> quantizerSupplier) {
+    public static <P extends QuantizationParams> void register( final Class<P> paramClass,
+                                                                final QuantizationType quantizationType,
+                                                                final SQTypes sqType,
+                                                                final Supplier<? extends Quantizer<?, ?>> quantizerSupplier) {
         String identifier = quantizationType.name() + "_" + sqType.name();
         // Ensure that the quantizer for this identifier is registered only once
         registry.computeIfAbsent(identifier, key -> quantizerSupplier);
@@ -54,7 +54,7 @@ public static <P extends QuantizationParams> void register(Class<P> paramClass,
      * @return an instance of {@link Quantizer} corresponding to the provided parameters
      * @throws IllegalArgumentException if no quantizer is registered for the given parameters
      */
-    public static <P extends QuantizationParams, Q> Quantizer<P, Q> getQuantizer(P params) {
+    public static <P extends QuantizationParams, Q> Quantizer<P, Q> getQuantizer(final P params) {
         String identifier = params.getTypeIdentifier();
         Supplier<? extends Quantizer<?, ?>> supplier = registry.get(identifier);
         if (supplier == null) {

src/main/java/org/opensearch/knn/quantization/models/quantizationOutput/BinaryQuantizationOutput.java

@@ -17,7 +17,7 @@ public class BinaryQuantizationOutput implements QuantizationOutput<byte[]> {
      *
      * @param quantizedVector the quantized vector represented as a byte array.
      */
-    public BinaryQuantizationOutput(byte[] quantizedVector) {
+    public BinaryQuantizationOutput(final byte[] quantizedVector) {
         if (quantizedVector == null) {
             throw new IllegalArgumentException("Quantized vector cannot be null");
         }

src/main/java/org/opensearch/knn/quantization/models/quantizationParams/SQParams.java

@@ -22,7 +22,7 @@ public class SQParams implements QuantizationParams {
      *
      * @param sqType The specific type of scalar quantization (e.g., ONE_BIT, TWO_BIT, FOUR_BIT).
      */
-    public SQParams(SQTypes sqType) {
+    public SQParams(final SQTypes sqType) {
         this.sqType = sqType;
     }
 

src/main/java/org/opensearch/knn/quantization/models/quantizationState/DefaultQuantizationState.java

@@ -19,7 +19,7 @@ public class DefaultQuantizationState implements QuantizationState {
 
     private final QuantizationParams params;
 
-    public DefaultQuantizationState(QuantizationParams params) {
+    public DefaultQuantizationState(final QuantizationParams params) {
         this.params = params;
     }
 

src/main/java/org/opensearch/knn/quantization/models/quantizationState/MultiBitScalarQuantizationState.java

@@ -25,7 +25,7 @@ public final class MultiBitScalarQuantizationState implements QuantizationState
      * @param thresholds         the threshold values for multi-bit quantization, organized as a 2D array
      *                           where each row corresponds to a different bit level.
      */
-    public MultiBitScalarQuantizationState(SQParams quantizationParams, float[][] thresholds) {
+    public MultiBitScalarQuantizationState(final SQParams quantizationParams, final float[][] thresholds) {
         this.quantizationParams = quantizationParams;
         this.thresholds = thresholds;
     }
@@ -49,7 +49,7 @@ public byte[] toByteArray() throws IOException {
         return QuantizationStateSerializer.serialize(this, thresholds);
     }
 
-    public static MultiBitScalarQuantizationState fromByteArray(byte[] bytes) throws IOException, ClassNotFoundException {
+    public static MultiBitScalarQuantizationState fromByteArray(final byte[] bytes) throws IOException, ClassNotFoundException {
         return (MultiBitScalarQuantizationState)
                 QuantizationStateSerializer.deserialize(bytes, (parentParams, specificData) ->
                         new MultiBitScalarQuantizationState(

src/main/java/org/opensearch/knn/quantization/models/quantizationState/OneBitScalarQuantizationState.java

@@ -24,7 +24,7 @@ public final class OneBitScalarQuantizationState implements QuantizationState {
      * @param quantizationParams the scalar quantization parameters.
      * @param mean               the mean values for each dimension.
      */
-    public OneBitScalarQuantizationState(SQParams quantizationParams, float[] mean) {
+    public OneBitScalarQuantizationState(final SQParams quantizationParams, final float[] mean) {
         this.quantizationParams = quantizationParams;
         this.mean = mean;
     }
@@ -48,7 +48,7 @@ public byte[] toByteArray() throws IOException {
         return QuantizationStateSerializer.serialize(this, mean);
     }
 
-    public static OneBitScalarQuantizationState fromByteArray(byte[] bytes) throws IOException, ClassNotFoundException {
+    public static OneBitScalarQuantizationState fromByteArray(final byte[] bytes) throws IOException, ClassNotFoundException {
         return (OneBitScalarQuantizationState) QuantizationStateSerializer.deserialize(
                 bytes,
                 (parentParams, specificData) ->

src/main/java/org/opensearch/knn/quantization/quantizer/MultiBitScalarQuantizer.java

@@ -35,7 +35,7 @@ public class MultiBitScalarQuantizer implements Quantizer<float[], byte[]> {
      *
      * @param bitsPerCoordinate the number of bits used per coordinate for quantization.
      */
-    public MultiBitScalarQuantizer(int bitsPerCoordinate) {
+    public MultiBitScalarQuantizer(final int bitsPerCoordinate) {
         if (bitsPerCoordinate < 2) {
             throw new IllegalArgumentException("bitsPerCoordinate must be greater than 2 for multibit quantizer.");
         }
@@ -51,7 +51,7 @@ public MultiBitScalarQuantizer(int bitsPerCoordinate) {
      * @return a MultiBitScalarQuantizationState containing the computed thresholds.
      */
     @Override
-    public QuantizationState train(TrainingRequest<float[]> trainingRequest) {
+    public QuantizationState train(final TrainingRequest<float[]> trainingRequest) {
         if (!IS_TRAINING_REQUIRED) {
             return new DefaultQuantizationState(trainingRequest.getParams());
         }
@@ -77,7 +77,7 @@ public QuantizationState train(TrainingRequest<float[]> trainingRequest) {
      * @return a BinaryQuantizationOutput containing the quantized data.
      */
     @Override
-    public QuantizationOutput<byte[]> quantize(float[] vector, QuantizationState state) {
+    public QuantizationOutput<byte[]> quantize(final float[] vector, final QuantizationState state) {
         if (state instanceof DefaultQuantizationState) {
             return quantize(vector);
         }
@@ -113,7 +113,11 @@ public QuantizationOutput<byte[]> quantize(float[] vector, QuantizationState sta
      * @param dimension the number of dimensions in the vectors.
      * @return the thresholds for quantization.
      */
-    private float[][] calculateThresholds(float[] mean, float[] stdDev, int dimension) {
+    private float[][] calculateThresholds(
+            final float[] mean,
+            final float[] stdDev,
+            final int dimension
+    ) {
         float[][] thresholds = new float[bitsPerCoordinate][dimension];
         float coef = bitsPerCoordinate + 1;
         for (int i = 0; i < bitsPerCoordinate; i++) {
@@ -135,7 +139,7 @@ private float[][] calculateThresholds(float[] mean, float[] stdDev, int dimensio
      * @return a {@link QuantizationOutput} containing the byte array representation of the quantized vector
      * @throws UnsupportedOperationException if the quantization state is not available
      */
-    private QuantizationOutput<byte[]> quantize(float[] vector) {
+    private QuantizationOutput<byte[]> quantize(final float[] vector) {
         throw new UnsupportedOperationException("Quantization state is required for OneBitScalar Quantizer.");
     }
 }

src/main/java/org/opensearch/knn/quantization/quantizer/OneBitScalarQuantizer.java

@@ -36,7 +36,7 @@ public class OneBitScalarQuantizer implements Quantizer<float[], byte[]> {
      * @return a OneBitScalarQuantizationState containing the calculated means.
      */
     @Override
-    public QuantizationState train(TrainingRequest<float[]> trainingRequest) {
+    public QuantizationState train(final TrainingRequest<float[]> trainingRequest) {
         if (!IS_TRAINING_REQUIRED) {
             return new DefaultQuantizationState(trainingRequest.getParams());
         }
@@ -56,7 +56,7 @@ public QuantizationState train(TrainingRequest<float[]> trainingRequest) {
      * @return a BinaryQuantizationOutput containing the quantized data.
      */
     @Override
-    public QuantizationOutput<byte[]> quantize(float[] vector, QuantizationState state) {
+    public QuantizationOutput<byte[]> quantize(final float[] vector, final QuantizationState state) {
         if (state instanceof DefaultQuantizationState) {
             return quantize(vector);
         }
@@ -88,7 +88,7 @@ public QuantizationOutput<byte[]> quantize(float[] vector, QuantizationState sta
      * @return a {@link QuantizationOutput} containing the byte array representation of the quantized vector
      * @throws UnsupportedOperationException if the quantization state is not available
      */
-    private QuantizationOutput<byte[]> quantize(float[] vector) {
+    private QuantizationOutput<byte[]> quantize(final float[] vector) {
         throw new UnsupportedOperationException("Quantization state is required for OneBitScalar Quantizer.");
     }
 }

src/main/java/org/opensearch/knn/quantization/sampler/ReservoirSampler.java

@@ -29,7 +29,7 @@ final class ReservoirSampler implements Sampler {
      * @return an array of sampled indices.
      */
     @Override
-    public int[] sample(int totalNumberOfVectors, int sampleSize) {
+    public int[] sample(final int totalNumberOfVectors, final int sampleSize) {
         if (totalNumberOfVectors <= sampleSize) {
             return IntStream.range(0, totalNumberOfVectors).toArray();
         }
@@ -45,7 +45,7 @@ public int[] sample(int totalNumberOfVectors, int sampleSize) {
      * @param sampleSize the number of indices to sample.
      * @return an array of sampled indices.
      */
-    private int[] reservoirSampleIndices(int numVectors, int sampleSize) {
+    private int[] reservoirSampleIndices(final int numVectors, final int sampleSize) {
         int[] indices = IntStream.range(0, sampleSize).toArray();
         for (int i = sampleSize; i < numVectors; i++) {
             int j = random.nextInt(i + 1);

src/main/java/org/opensearch/knn/quantization/sampler/SamplingFactory.java

@@ -34,7 +34,7 @@ public enum SamplerType {
      * @return a Sampler instance.
      * @throws IllegalArgumentException if the sampler type is not supported.
      */
-    public static Sampler getSampler(SamplerType samplerType) {
+    public static Sampler getSampler(final SamplerType samplerType) {
         switch (samplerType) {
             case RESERVOIR:
                 return new ReservoirSampler();