faiss 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3306dbb81c9168dcd82435c99d3404ab8501ac9b948adb2db7238ab89c01003
-  data.tar.gz: b14a120e9cc67baba96816b52cf34388aae79fa690fc511918543921b64380d5
+  metadata.gz: 8ab397b95262fa87d28a4f08098de35f487b44e6240682ec8e98c4efc823c4df
+  data.tar.gz: 719490d3f20bad4531f588e9469d3fa9ec2362cc18f800e913725ffb6b0aeca0
 SHA512:
-  metadata.gz: b7af3f6540d283d886301137e5fed5dff32b0c0659e9c46d6c45808439e94a0a91f8c953d5897b480568169ec23cacc4224db523d6ab9b3737d7f0df1ce8190c
-  data.tar.gz: fbe44473d9e3c61427aee597fed40264ba83a8184c0fe5280b6bf181d9bcc396583f033a69e8d3ec643ee0d41ef435dfeef4aa4441ade67703cbd8259326cb81
+  metadata.gz: 56e16fad10a1ba95c9727f2e356470e984ca29b44406cf125b1ab529c83fee2c9bf15efa564a543cda331489dbdc56c9c44f4eda4ad53178979370987b6fbf9e
+  data.tar.gz: 691e9a843eaac7e699dafc15d5505f6febf783ae6d474ee0409cb01d1b1f1575477db13cb7290a4d2cc639692503099fa7d4ff767d3c3034838d05ea0476521a

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.5.2 (2026-01-02)
+
+- Fixed error with Rice 4.8
+
+## 0.5.1 (2025-12-20)
+
+- Updated Faiss to 1.13.2
+- Added `reconstruct` method
+
 ## 0.5.0 (2025-11-12)
 
 - Updated Faiss to 1.13.0

data/README.md

@@ -53,6 +53,8 @@ Search
 distances, ids = index.search(objects, 3)
 ```
 
+> Use `index.freeze` to release the GVL for searches
+
 Save an index
 
 ```ruby

data/ext/faiss/index.cpp

@@ -31,13 +31,9 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+    double is_convertible(VALUE value) { return Convertible::Exact; }
 
     faiss::MetricType convert(VALUE x) {
-      if (x == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
-        return this->arg_->defaultValue<faiss::MetricType>();
-      }
-
       auto s = Object(x).to_s().str();
       if (s == "inner_product") {
         return faiss::METRIC_INNER_PRODUCT;
@@ -64,7 +60,7 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+    double is_convertible(VALUE value) { return Convertible::Exact; }
 
     faiss::ScalarQuantizer::QuantizerType convert(VALUE x) {
       auto s = Object(x).to_s().str();
@@ -169,6 +165,14 @@ void init_index(Rice::Module& m) {
         auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         faiss::ParameterSpace().set_index_parameter(&self, "nprobe", val);
       })
+    .define_method(
+      "reconstruct",
+      [](faiss::Index &self, int64_t key) {
+        auto d = static_cast<std::size_t>(self.d);
+        auto recons = numo::SFloat({d});
+        self.reconstruct(key, recons.write_ptr());
+        return recons;
+      })
     .define_method(
       "save",
       [](faiss::Index &self, Rice::String fname) {
@@ -187,10 +191,12 @@ void init_index(Rice::Module& m) {
     .define_constructor(Rice::Constructor<faiss::IndexFlatIP, int64_t>());
 
   Rice::define_class_under<faiss::IndexHNSWFlat, faiss::Index>(m, "IndexHNSWFlat")
-    .define_constructor(Rice::Constructor<faiss::IndexHNSWFlat, int, int, faiss::MetricType>(), Rice::Arg("_d"), Rice::Arg("_M"), Rice::Arg("_metric") = faiss::METRIC_L2);
+    .define_constructor(Rice::Constructor<faiss::IndexHNSWFlat, int, int>())
+    .define_constructor(Rice::Constructor<faiss::IndexHNSWFlat, int, int, faiss::MetricType>());
 
   Rice::define_class_under<faiss::IndexIVFFlat, faiss::Index>(m, "IndexIVFFlat")
-    .define_constructor(Rice::Constructor<faiss::IndexIVFFlat, faiss::Index*, size_t, size_t, faiss::MetricType>(), Rice::Arg("_quantizer"), Rice::Arg("_d"), Rice::Arg("_nlist"), Rice::Arg("_metric") = faiss::METRIC_L2);
+    .define_constructor(Rice::Constructor<faiss::IndexIVFFlat, faiss::Index*, size_t, size_t>())
+    .define_constructor(Rice::Constructor<faiss::IndexIVFFlat, faiss::Index*, size_t, size_t, faiss::MetricType>());
 
   Rice::define_class_under<faiss::IndexLSH, faiss::Index>(m, "IndexLSH")
     .define_constructor(Rice::Constructor<faiss::IndexLSH, int64_t, int>());
@@ -205,7 +211,8 @@ void init_index(Rice::Module& m) {
     .define_constructor(Rice::Constructor<faiss::IndexIVFScalarQuantizer, faiss::Index*, size_t, size_t, faiss::ScalarQuantizer::QuantizerType>());
 
   Rice::define_class_under<faiss::IndexIVFPQ, faiss::Index>(m, "IndexIVFPQ")
-    .define_constructor(Rice::Constructor<faiss::IndexIVFPQ, faiss::Index*, size_t, size_t, size_t, size_t, faiss::MetricType>(), Rice::Arg("_quantizer"), Rice::Arg("_d"), Rice::Arg("_nlist"), Rice::Arg("_M"), Rice::Arg("_nbits_per_idx"), Rice::Arg("_metric") = faiss::METRIC_L2);
+    .define_constructor(Rice::Constructor<faiss::IndexIVFPQ, faiss::Index*, size_t, size_t, size_t, size_t>())
+    .define_constructor(Rice::Constructor<faiss::IndexIVFPQ, faiss::Index*, size_t, size_t, size_t, size_t, faiss::MetricType>());
 
   Rice::define_class_under<faiss::IndexIVFPQR, faiss::Index>(m, "IndexIVFPQR")
     .define_constructor(Rice::Constructor<faiss::IndexIVFPQR, faiss::Index*, size_t, size_t, size_t, size_t, size_t, size_t>());

data/ext/faiss/numo.hpp

@@ -1,5 +1,5 @@
 /*!
- * Numo.hpp v0.2.1
+ * Numo.hpp v0.3.0
  * https://github.com/ankane/numo.hpp
  * BSD-2-Clause License
  */
@@ -460,12 +460,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::NArray>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -506,12 +506,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::SFloat>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -552,12 +552,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::DFloat>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -598,12 +598,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int8>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -644,12 +644,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int16>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -690,12 +690,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int32>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -736,12 +736,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int64>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -782,12 +782,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt8>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -828,12 +828,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt16>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -874,12 +874,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt32>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -920,12 +920,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt64>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -966,12 +966,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::SComplex>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1012,12 +1012,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::DComplex>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1058,12 +1058,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Bit>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1104,12 +1104,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::RObject>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }

data/lib/faiss/version.rb

@@ -1,3 +1,3 @@
 module Faiss
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

data/vendor/faiss/faiss/IVFlib.cpp

@@ -558,19 +558,6 @@ void handle_ivf(
         const std::string& filename_template,
         ShardingFunction* sharding_function,
         bool generate_ids) {
-    std::vector<faiss::IndexIVF*> sharded_indexes(shard_count);
-    auto clone = static_cast<faiss::IndexIVF*>(faiss::clone_index(index));
-    clone->quantizer->reset();
-    for (int64_t i = 0; i < shard_count; i++) {
-        sharded_indexes[i] =
-                static_cast<faiss::IndexIVF*>(faiss::clone_index(clone));
-        if (generate_ids) {
-            // Assume the quantizer does not natively support add_with_ids.
-            sharded_indexes[i]->quantizer =
-                    new IndexIDMap2(sharded_indexes[i]->quantizer);
-        }
-    }
-
     // assign centroids to each sharded Index based on sharding_function, and
     // add them to the quantizer of each sharded index
     std::vector<std::vector<float>> sharded_centroids(shard_count);
@@ -588,27 +575,29 @@ void handle_ivf(
                 &reconstructed[index->quantizer->d]);
         delete[] reconstructed;
     }
+
+    auto clone = static_cast<faiss::IndexIVF*>(faiss::clone_index(index));
+    clone->quantizer->reset();
     for (int64_t i = 0; i < shard_count; i++) {
+        auto sharded_index =
+                static_cast<faiss::IndexIVF*>(faiss::clone_index(clone));
         if (generate_ids) {
-            sharded_indexes[i]->quantizer->add_with_ids(
+            // Assume the quantizer does not natively support add_with_ids.
+            sharded_index->quantizer =
+                    new IndexIDMap2(sharded_index->quantizer);
+            sharded_index->quantizer->add_with_ids(
                     sharded_centroids[i].size() / index->quantizer->d,
                     sharded_centroids[i].data(),
                     xids[i].data());
         } else {
-            sharded_indexes[i]->quantizer->add(
+            sharded_index->quantizer->add(
                     sharded_centroids[i].size() / index->quantizer->d,
                     sharded_centroids[i].data());
         }
-    }
-
-    for (int64_t i = 0; i < shard_count; i++) {
         char fname[256];
         snprintf(fname, 256, filename_template.c_str(), i);
-        faiss::write_index(sharded_indexes[i], fname);
-    }
-
-    for (int64_t i = 0; i < shard_count; i++) {
-        delete sharded_indexes[i];
+        faiss::write_index(sharded_index, fname);
+        delete sharded_index;
     }
 }
 
@@ -618,22 +607,6 @@ void handle_binary_ivf(
         const std::string& filename_template,
         ShardingFunction* sharding_function,
         bool generate_ids) {
-    std::vector<faiss::IndexBinaryIVF*> sharded_indexes(shard_count);
-
-    auto clone = static_cast<faiss::IndexBinaryIVF*>(
-            faiss::clone_binary_index(index));
-    clone->quantizer->reset();
-
-    for (int64_t i = 0; i < shard_count; i++) {
-        sharded_indexes[i] = static_cast<faiss::IndexBinaryIVF*>(
-                faiss::clone_binary_index(clone));
-        if (generate_ids) {
-            // Assume the quantizer does not natively support add_with_ids.
-            sharded_indexes[i]->quantizer =
-                    new IndexBinaryIDMap2(sharded_indexes[i]->quantizer);
-        }
-    }
-
     // assign centroids to each sharded Index based on sharding_function, and
     // add them to the quantizer of each sharded index
     int64_t reconstruction_size = index->quantizer->d / 8;
@@ -652,27 +625,30 @@ void handle_binary_ivf(
                 &reconstructed[reconstruction_size]);
         delete[] reconstructed;
     }
+
+    auto clone = static_cast<faiss::IndexBinaryIVF*>(
+            faiss::clone_binary_index(index));
+    clone->quantizer->reset();
     for (int64_t i = 0; i < shard_count; i++) {
+        auto sharded_index = static_cast<faiss::IndexBinaryIVF*>(
+                faiss::clone_binary_index(clone));
         if (generate_ids) {
-            sharded_indexes[i]->quantizer->add_with_ids(
+            // Assume the quantizer does not natively support add_with_ids.
+            sharded_index->quantizer =
+                    new IndexBinaryIDMap2(sharded_index->quantizer);
+            sharded_index->quantizer->add_with_ids(
                     sharded_centroids[i].size() / reconstruction_size,
                     sharded_centroids[i].data(),
                     xids[i].data());
         } else {
-            sharded_indexes[i]->quantizer->add(
+            sharded_index->quantizer->add(
                     sharded_centroids[i].size() / reconstruction_size,
                     sharded_centroids[i].data());
         }
-    }
-
-    for (int64_t i = 0; i < shard_count; i++) {
         char fname[256];
         snprintf(fname, 256, filename_template.c_str(), i);
-        faiss::write_index_binary(sharded_indexes[i], fname);
-    }
-
-    for (int64_t i = 0; i < shard_count; i++) {
-        delete sharded_indexes[i];
+        faiss::write_index_binary(sharded_index, fname);
+        delete sharded_index;
     }
 }
 

data/vendor/faiss/faiss/Index.cpp

@@ -104,6 +104,17 @@ void Index::search_and_reconstruct(
     }
 }
 
+void Index::search_subset(
+        idx_t n,
+        const float* x,
+        idx_t k_base,
+        const idx_t* base_labels,
+        idx_t k,
+        float* distances,
+        idx_t* labels) const {
+    FAISS_THROW_MSG("search_subset not implemented for this type of index");
+}
+
 void Index::compute_residual(const float* x, float* residual, idx_t key) const {
     reconstruct(key, residual);
     for (size_t i = 0; i < d; i++) {

data/vendor/faiss/faiss/Index.h

@@ -18,7 +18,7 @@
 
 #define FAISS_VERSION_MAJOR 1
 #define FAISS_VERSION_MINOR 13
-#define FAISS_VERSION_PATCH 0
+#define FAISS_VERSION_PATCH 2
 
 // Macro to combine the version components into a single string
 #ifndef FAISS_STRINGIFY
@@ -304,6 +304,29 @@ struct Index {
             float* recons,
             const SearchParameters* params = nullptr) const;
 
+    /** Similar to search, but operates on a potentially different subset
+     * of the dataset for each query.
+     *
+     * The default implementation fails with an assertion, as it is
+     * not supported by all indexes.
+     *
+     * @param n           number of vectors
+     * @param x           input vectors, size n * d
+     * @param k_base      number of vectors to search from
+     * @param base_labels ids of the vectors to search from
+     * @param k           desired number of results per query
+     * @param distances   output pairwise distances, size n*k
+     * @param labels      output labels of the NNs, size n*k
+     */
+    virtual void search_subset(
+            idx_t n,
+            const float* x,
+            idx_t k_base,
+            const idx_t* base_labels,
+            idx_t k,
+            float* distances,
+            idx_t* labels) const;
+
     /** Computes a residual vector after indexing encoding.
      *
      * The residual vector is the difference between a vector and the

data/vendor/faiss/faiss/IndexAdditiveQuantizer.cpp

@@ -86,6 +86,7 @@ struct AQDistanceComputerLUT : FlatCodesDistanceComputer {
 
     float bias;
     void set_query(const float* x) final {
+        q = x;
         // this is quite sub-optimal for multiple queries
         aq.compute_LUT(1, x, LUT.data());
         if (is_IP) {

data/vendor/faiss/faiss/IndexBinaryHNSW.cpp

@@ -227,7 +227,11 @@ void IndexBinaryHNSW::search(
         for (idx_t i = 0; i < n; i++) {
             res.begin(i);
             dis->set_query((float*)(x + i * code_size));
-            hnsw.search(*dis, res, vt);
+            // Given that IndexBinaryHNSW is not an IndexHNSW, we pass nullptr
+            // as the index parameter. This state does not get used in the
+            // search function, as it is merely there to to enable Panorama
+            // execution for IndexHNSWFlatPanorama.
+            hnsw.search(*dis, nullptr, res, vt);
             res.end();
         }
     }

data/vendor/faiss/faiss/IndexFastScan.cpp

@@ -199,7 +199,7 @@ void estimators_from_tables_generic(
 } // anonymous namespace
 
 // Default implementation of make_knn_handler with centralized fallback logic
-void* IndexFastScan::make_knn_handler(
+SIMDResultHandlerToFloat* IndexFastScan::make_knn_handler(
         bool is_max,
         int impl,
         idx_t n,

data/vendor/faiss/faiss/IndexFastScan.h

@@ -15,13 +15,8 @@ namespace faiss {
 
 struct CodePacker;
 struct NormTableScaler;
-
-// Forward declarations for result handlers
-namespace simd_result_handlers {
-template <class C, bool with_id_map>
-struct ResultHandlerCompare;
-}
 struct IDSelector;
+struct SIMDResultHandlerToFloat;
 
 /** Fast scan version of IndexPQ and IndexAQ. Works for 4-bit PQ and AQ for now.
  *
@@ -141,10 +136,10 @@ struct IndexFastScan : Index {
      * @param distances    output distances array
      * @param labels       output labels array
      * @param sel          optional ID selector
-     * @param query_offset query offset for batch processing
+     * @param context      processing context for distance post-processing
      * @return             pointer to created handler (never returns nullptr)
      */
-    virtual void* make_knn_handler(
+    virtual SIMDResultHandlerToFloat* make_knn_handler(
             bool is_max,
             int impl,
             idx_t n,