Quantization Config support

src/main/java/ru/rt/restream/reindexer/Reindexer.java

@@ -282,28 +282,16 @@ public <T> Query<T> query(String namespaceName, Class<T> clazz) {
         return new Query<>(this, namespace, null);
     }
 
-    /**
-     * ONLY FOR TEST PURPOSES!
-     */
-    @Deprecated
     public void addIndex(String namespaceName, ReindexerIndex index) {
         IndexDefinition indexDefinition = IndexDefinition.fromIndex(index);
         binding.addIndex(namespaceName, indexDefinition);
     }
 
-    /**
-     * ONLY FOR TEST PURPOSES!
-     */
-    @Deprecated
     public void updateIndex(String namespaceName, ReindexerIndex index) {
         IndexDefinition indexDefinition = IndexDefinition.fromIndex(index);
         binding.updateIndex(namespaceName, indexDefinition);
     }
 
-    /**
-     * ONLY FOR TEST PURPOSES!
-     */
-    @Deprecated
     public void dropIndex(String namespaceName, String indexName) {
         binding.dropIndex(namespaceName, indexName);
     }

src/main/java/ru/rt/restream/reindexer/annotations/Hnsw.java

@@ -79,4 +79,40 @@
      */
     boolean multithreading() default false;
 
+    /**
+     * Optional quantization configuration for HNSW index.
+     *
+     * <p>When {@code quantizationConfig.quantizationType} is empty, the whole block is ignored.
+     *
+     * <p>Currently supported type: {@code scalar_quantization_8_bit}.
+     */
+    QuantizationConfig quantizationConfig() default @QuantizationConfig;
+
+    /**
+     * Nested annotation representing {@code quantization_config} block.
+     */
+    @interface QuantizationConfig {
+        /**
+         * Quantization type.
+         *
+         * <p>Currently supported: {@code scalar_quantization_8_bit}.
+         */
+        String quantizationType() default "";
+
+        /**
+         * Quantile for scalar quantization.
+         */
+        float quantile() default -1.0f;
+
+        /**
+         * Sample size for estimating quantile(s).
+         */
+        int sampleSize() default 20_000;
+
+        /**
+         * Minimal number of points in the index required to enable quantization.
+         */
+        int quantizationThreshold() default 100_000;
+    }
+
 }

src/main/java/ru/rt/restream/reindexer/vector/HnswConfig.java

@@ -63,4 +63,47 @@ public class HnswConfig implements IndexConfig {
      * Enable multithreading insert mode.
      */
     private int multithreading;
+
+    /**
+     * Optional quantization configuration for HNSW index.
+     *
+     * <p>
+     * When this value is {@code null} the {@code quantization_config} block is not
+     * serialized.
+     */
+    private QuantizationConfig quantizationConfig;
+
+    @Setter
+    @Getter
+    @EqualsAndHashCode
+    @NoArgsConstructor(access = AccessLevel.PACKAGE)
+    public static class QuantizationConfig {
+        /**
+         * Quantization type.
+         *
+         * <p>
+         * Currently supported: {@code scalar_quantization_8_bit}.
+         */
+        private String quantizationType;
+
+        /**
+         * Quantile for scalar quantization.
+         *
+         * <p>
+         * If this field is {@code null}, quantile is expected to be computed
+         * automatically
+         * by Reindexer.
+         */
+        private Float quantile;
+
+        /**
+         * Sample size for estimating quantile(s).
+         */
+        private int sampleSize;
+
+        /**
+         * Minimal number of samples/points required to enable quantization.
+         */
+        private int quantizationThreshold;
+    }
 }

src/main/java/ru/rt/restream/reindexer/vector/HnswConfigs.java

@@ -30,6 +30,11 @@ public class HnswConfigs {
             new IllegalArgumentException("HNSW index should have 'm' parameter in range [2, 128]");
     public static final IllegalArgumentException EF_CONSTRUCTION_NOT_IN_RANGE_EX =
             new IllegalArgumentException("HNSW index should have 'efConstruction' parameter in range [4, 1024]");
+    public static final IllegalArgumentException QUANTIZATION_TYPE_NOT_SUPPORTED_EX =
+            new IllegalArgumentException("Only 'scalar_quantization_8_bit' is supported for HNSW quantization_config.");
+    public static final IllegalArgumentException QUANTILE_OUT_OF_RANGE_EX =
+            new IllegalArgumentException("Quantile for scalar quantization must be in range [0.95, 1.0].");
+    private static final float QUANTILE_UNSET = -1.0f;
 
     public static HnswConfig of(Hnsw annotation) {
         if (annotation.metric() == null) {
@@ -52,6 +57,28 @@ public static HnswConfig of(Hnsw annotation) {
         config.setM(annotation.m());
         config.setEfConstruction(annotation.efConstruction());
         config.setMultithreading(annotation.multithreading() ? 1 : 0);
+
+        String quantizationType = annotation.quantizationConfig().quantizationType();
+        float quantile = annotation.quantizationConfig().quantile();
+        int sampleSize = annotation.quantizationConfig().sampleSize();
+        int quantizationThreshold = annotation.quantizationConfig().quantizationThreshold();
+
+        if (quantizationType != null && !quantizationType.isEmpty()) {
+            if (!"scalar_quantization_8_bit".equals(quantizationType)) {
+                throw QUANTIZATION_TYPE_NOT_SUPPORTED_EX;
+            }
+            HnswConfig.QuantizationConfig quantizationConfig = new HnswConfig.QuantizationConfig();
+            quantizationConfig.setQuantizationType(quantizationType);
+            if (quantile != QUANTILE_UNSET) {
+                if (quantile < 0.95f || quantile > 1.0f) {
+                    throw QUANTILE_OUT_OF_RANGE_EX;
+                }
+                quantizationConfig.setQuantile(quantile);
+            }
+            quantizationConfig.setSampleSize(sampleSize);
+            quantizationConfig.setQuantizationThreshold(quantizationThreshold);
+            config.setQuantizationConfig(quantizationConfig);
+        }
         return config;
     }
 

src/test/java/ru/rt/restream/reindexer/connector/BuiltinHnswQuantizationConfigUpdateTest.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020 Restream
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ru.rt.restream.reindexer.connector;
+
+import ru.rt.restream.category.BuiltinTest;
+
+@BuiltinTest
+public class BuiltinHnswQuantizationConfigUpdateTest extends HnswQuantizationConfigUpdateTest {
+}
+

src/test/java/ru/rt/restream/reindexer/connector/CprotoHnswQuantizationConfigUpdateTest.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020 Restream
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package ru.rt.restream.reindexer.connector;
+
+import ru.rt.restream.category.CprotoTest;
+
+@CprotoTest
+public class CprotoHnswQuantizationConfigUpdateTest extends HnswQuantizationConfigUpdateTest {
+}
+