feat(quantization): expose uniform uint7 and add uint8

Author: luoxiaojian

src/core/interface/index.cc

@@ -180,8 +180,11 @@ int Index::CreateAndInitConverterReformer(const QuantizerParam &param,
         case QuantizerType::kRabitq:
           // no converter here
           return 0;
-        case QuantizerType::kUniformInt8:
-          converter_name = "UniformInt8StreamingConverter";
+        case QuantizerType::kUniformUint7:
+          converter_name = "UniformUint7StreamingConverter";
+          break;
+        case QuantizerType::kUniformUint8:
+          converter_name = "UniformUint8StreamingConverter";
           break;
         default:
           LOG_ERROR("Unsupported quantizer type: ");

src/core/interface/index_param.cc

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <string_view>
 #include <zvec/ailego/logger/logger.h>
 #include <zvec/core/interface/index_param.h>
 #include "core/interface/utils/utils.h"
@@ -340,4 +341,4 @@ bool QuantizerParam::DeserializeFromJsonObject(
 
 
 }  // namespace core_interface
-}  // namespace zvec
+}  // namespace zvec

src/core/metric/metric_params.h

@@ -34,9 +34,13 @@ static const std::string QUANTIZED_INTEGER_METRIC_ORIGIN_METRIC_NAME =
 static const std::string QUANTIZED_INTEGER_METRIC_ORIGIN_METRIC_PARAMS =
     "proxima.quantized_integer.metric.origin_metric_params";
 
-//! UniformInt8 Metric
-static const std::string UNIFORM_INT8_METRIC_ORIGIN_METRIC_NAME =
-    "proxima.uniform_int8.metric.origin_metric_name";
+//! UniformUint7 Metric
+static const std::string UNIFORM_UINT7_METRIC_ORIGIN_METRIC_NAME =
+    "proxima.uniform_uint7.metric.origin_metric_name";
+
+//! UniformUint8 Metric
+static const std::string UNIFORM_UINT8_METRIC_ORIGIN_METRIC_NAME =
+    "proxima.uniform_uint8.metric.origin_metric_name";
 
 }  // namespace core
-}  // namespace zvec
+}  // namespace zvec

src/core/metric/uniform_int8_metric.cc src/core/metric/uniform_uint7_metric.ccsrc/core/metric/uniform_int8_metric.cc renamed to src/core/metric/uniform_uint7_metric.cc

@@ -22,40 +22,40 @@
 namespace zvec {
 namespace core {
 
-/*! Index Metric for Uniform Int8 Quantization (Global Scale)
+/*! Index Metric for Uniform Uint7 Quantization (Global Scale)
  *
  * Uses direct int8 L2 distance computation. Since all vectors share
  * a single global scale/bias, no per-vector reconstruction is needed.
  * This is the key benefit: distance = sum((a[i] - b[i])^2) on raw int8
  * values, with optional post-scaling by 1/scale^2 for real L2 distances.
  */
-class UniformInt8Metric : public IndexMetric {
+class UniformUint7Metric : public IndexMetric {
  public:
   //! Initialize Metric
   int init(const IndexMeta &meta, const ailego::Params &index_params) override {
     if (meta.data_type() != IndexMeta::DataType::DT_INT8) {
-      LOG_ERROR("UniformInt8Metric: unsupported type %d", meta.data_type());
+      LOG_ERROR("UniformUint7Metric: unsupported type %d", meta.data_type());
       return IndexError_Unsupported;
     }
 
     std::string metric_name;
-    index_params.get(UNIFORM_INT8_METRIC_ORIGIN_METRIC_NAME, &metric_name);
+    index_params.get(UNIFORM_UINT7_METRIC_ORIGIN_METRIC_NAME, &metric_name);
     if (metric_name.empty()) {
-      LOG_ERROR("UniformInt8Metric: param %s is required",
-                UNIFORM_INT8_METRIC_ORIGIN_METRIC_NAME.c_str());
+      LOG_ERROR("UniformUint7Metric: param %s is required",
+                UNIFORM_UINT7_METRIC_ORIGIN_METRIC_NAME.c_str());
       return IndexError_InvalidArgument;
     }
 
     if (metric_name != "SquaredEuclidean") {
-      LOG_ERROR("UniformInt8Metric: only SquaredEuclidean supported, got %s",
+      LOG_ERROR("UniformUint7Metric: only SquaredEuclidean supported, got %s",
                 metric_name.c_str());
       return IndexError_Unsupported;
     }
 
     meta_ = meta;
     params_ = index_params;
 
-    LOG_INFO("UniformInt8Metric initialized: dimension=%u", meta_.dimension());
+    LOG_INFO("UniformUint7Metric initialized: dimension=%u", meta_.dimension());
     return 0;
   }
 
@@ -152,7 +152,7 @@ class UniformInt8Metric : public IndexMetric {
   ailego::Params params_{};
 };
 
-INDEX_FACTORY_REGISTER_METRIC_ALIAS(UniformInt8, UniformInt8Metric);
+INDEX_FACTORY_REGISTER_METRIC_ALIAS(UniformUint7, UniformUint7Metric);
 
 }  // namespace core
 }  // namespace zvec

src/core/metric/uniform_uint8_metric.cc

@@ -0,0 +1,134 @@
+// Copyright 2025-present the zvec project
+//
+// 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.
+
+#include <cstdint>
+#include <zvec/core/framework/index_error.h>
+#include <zvec/core/framework/index_factory.h>
+#include "metric_params.h"
+
+namespace zvec {
+namespace core {
+
+namespace {
+
+void UniformUint8SquaredEuclidean(const void *lhs_data, const void *rhs_data,
+                                  size_t dimension, float *distance) {
+  const auto *lhs = static_cast<const int8_t *>(lhs_data);
+  const auto *rhs = static_cast<const int8_t *>(rhs_data);
+  int64_t sum = 0;
+  for (size_t i = 0; i < dimension; ++i) {
+    // Both operands store uint8 codes shifted by -128. Widen before
+    // subtraction so the full [-255, 255] difference remains exact.
+    const int difference = static_cast<int>(lhs[i]) - static_cast<int>(rhs[i]);
+    sum += static_cast<int64_t>(difference) * difference;
+  }
+  *distance = static_cast<float>(sum);
+}
+
+void UniformUint8SquaredEuclideanBatch(const void *const *vectors,
+                                       const void *query, size_t count,
+                                       size_t dimension, float *distances) {
+  for (size_t i = 0; i < count; ++i) {
+    UniformUint8SquaredEuclidean(vectors[i], query, dimension, distances + i);
+  }
+}
+
+}  // namespace
+
+class UniformUint8Metric : public IndexMetric {
+ public:
+  int init(const IndexMeta &meta, const ailego::Params &params) override {
+    if (meta.data_type() != IndexMeta::DataType::DT_INT8) {
+      LOG_ERROR("UniformUint8Metric: unsupported type %d", meta.data_type());
+      return IndexError_Unsupported;
+    }
+
+    std::string metric_name;
+    params.get(UNIFORM_UINT8_METRIC_ORIGIN_METRIC_NAME, &metric_name);
+    if (metric_name.empty()) {
+      LOG_ERROR("UniformUint8Metric: param %s is required",
+                UNIFORM_UINT8_METRIC_ORIGIN_METRIC_NAME.c_str());
+      return IndexError_InvalidArgument;
+    }
+    if (metric_name != "SquaredEuclidean") {
+      LOG_ERROR("UniformUint8Metric: only SquaredEuclidean supported, got %s",
+                metric_name.c_str());
+      return IndexError_Unsupported;
+    }
+
+    meta_ = meta;
+    params_ = params;
+    return 0;
+  }
+
+  int cleanup(void) override {
+    return 0;
+  }
+
+  bool is_matched(const IndexMeta &meta) const override {
+    return meta.data_type() == meta_.data_type() &&
+           meta.unit_size() == meta_.unit_size() &&
+           meta.dimension() == meta_.dimension();
+  }
+
+  bool is_matched(const IndexMeta &meta,
+                  const IndexQueryMeta &query_meta) const override {
+    return is_matched(meta) && query_meta.data_type() == meta_.data_type() &&
+           query_meta.unit_size() == meta_.unit_size() &&
+           query_meta.dimension() == meta_.dimension();
+  }
+
+  MatrixDistance distance(void) const override {
+    return UniformUint8SquaredEuclidean;
+  }
+
+  MatrixDistance distance_matrix(size_t rows, size_t columns) const override {
+    return rows == 1 && columns == 1 ? UniformUint8SquaredEuclidean : nullptr;
+  }
+
+  MatrixBatchDistance batch_distance(void) const override {
+    return UniformUint8SquaredEuclideanBatch;
+  }
+
+  const ailego::Params &params(void) const override {
+    return params_;
+  }
+
+  int train(const void * /*vector*/, size_t /*dimension*/) override {
+    return 0;
+  }
+
+  bool support_train(void) const override {
+    return false;
+  }
+
+  void normalize(float * /*score*/) const override {}
+
+  bool support_normalize(void) const override {
+    return false;
+  }
+
+  Pointer query_metric(void) const override {
+    return nullptr;
+  }
+
+ private:
+  IndexMeta meta_{};
+  ailego::Params params_{};
+};
+
+INDEX_FACTORY_REGISTER_METRIC_ALIAS(UniformUint8, UniformUint8Metric);
+
+}  // namespace core
+}  // namespace zvec

src/core/quantizer/quantizer_params.h

@@ -119,11 +119,17 @@ static const std::string INTEGER_STREAMING_REFORMER_ENABLE_NORMALIZE =
 static const std::string INTEGER_STREAMING_REFORMER_IS_EUCLIDEAN =
     "integer_streaming.reformer.is_euclidean";
 
-//! UniformInt8StreamingConverter / Reformer
-static const std::string UNIFORM_INT8_REFORMER_SCALE =
-    "uniform_int8.reformer.scale";
-static const std::string UNIFORM_INT8_REFORMER_BIAS =
-    "uniform_int8.reformer.bias";
+//! UniformUint7StreamingConverter / Reformer
+static const std::string UNIFORM_UINT7_REFORMER_SCALE =
+    "uniform_uint7.reformer.scale";
+static const std::string UNIFORM_UINT7_REFORMER_BIAS =
+    "uniform_uint7.reformer.bias";
+
+//! UniformUint8StreamingConverter / Reformer
+static const std::string UNIFORM_UINT8_REFORMER_SCALE =
+    "uniform_uint8.reformer.scale";
+static const std::string UNIFORM_UINT8_REFORMER_BIAS =
+    "uniform_uint8.reformer.bias";
 
 //! DoubleBitConverter
 static const std::string DOUBLE_BIT_CONVERTER_TRAIN_SAMPLE_COUNT =
@@ -140,4 +146,4 @@ static const std::string DOUBLE_BIT_REFORMER_B_VALUE =
     "double_bit.reformer.b_value";
 
 }  // namespace core
-}  // namespace zvec
+}  // namespace zvec