faiss 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94cc2ecdeb397dfce274b08f07006ec7d6d13290f4149d8fca0b9d1a3f2312c6
-  data.tar.gz: a32b28f7bc57f9bad918b0411855617951ce8013af7f1ca9dfc72978f5eb1f78
+  metadata.gz: 67b63e8dcaa5dcd8c8d08f823c3e1e063906b4a20ad70b28c2fd396e8cccdf48
+  data.tar.gz: 7e9fddc693db40a58c71b5a5ca6b89638b5cc1db708b30ea32a897519d48b970
 SHA512:
-  metadata.gz: 317786c14bbd6803a8abd506881e7072dbd8bfaacce3968c8c26705de45f1840177f5fb3ce189b464e5f1bbffd07a277d6f454a977e1e2aef72bdfb7d7cd04a7
-  data.tar.gz: 4de11b05b094b18beaa0326e5d4bf2d7a71c1928b7bd7d12f28f430f7b40b023c6c7b7a4da73f74bc39b0be44c85677113597cf6b60ae4029a96bd11a41f706c
+  metadata.gz: 10b9b0efa35ab53fefd3cea964339c856b67af1f7c773f421952f247d16fbd50d76b29cf59eec9e3b77b1a091e96fccb58c1f24afde7d233f298f06ecc90b3b3
+  data.tar.gz: 70037e0611a6f6adddf30f95710b0e1f1c17ffadfe561c3010db8e66265692da17b49a07756ee946d70eed6602ddfbd2107248c01be353d58d3544b6bbc2b15e

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.4.2 (2025-08-13)
+
+- Updated Faiss to 1.12.0
+
 ## 0.4.1 (2025-06-18)
 
 - Fixed error with Rice 4.6

data/lib/faiss/version.rb

@@ -1,3 +1,3 @@
 module Faiss
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/vendor/faiss/faiss/AutoTune.cpp

@@ -14,30 +14,21 @@
 #include <faiss/AutoTune.h>
 
 #include <cinttypes>
-#include <cmath>
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/random.h>
 #include <faiss/utils/utils.h>
 
-#include <faiss/IndexFlat.h>
 #include <faiss/IndexHNSW.h>
 #include <faiss/IndexIVF.h>
 #include <faiss/IndexIVFFlat.h>
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/IndexIVFPQR.h>
-#include <faiss/IndexLSH.h>
 #include <faiss/IndexPQ.h>
 #include <faiss/IndexPreTransform.h>
 #include <faiss/IndexRefine.h>
-#include <faiss/IndexScalarQuantizer.h>
 #include <faiss/IndexShardsIVF.h>
 #include <faiss/MetaIndexes.h>
-#include <faiss/VectorTransform.h>
-
-#include <faiss/IndexBinaryFlat.h>
-#include <faiss/IndexBinaryHNSW.h>
-#include <faiss/IndexBinaryIVF.h>
 
 namespace faiss {
 
@@ -137,8 +128,9 @@ bool OperatingPoints::add(
         int i;
         // stricto sensu this should be a bissection
         for (i = 0; i < a.size(); i++) {
-            if (a[i].perf >= perf)
+            if (a[i].perf >= perf) {
                 break;
+            }
         }
         assert(i < a.size());
         if (t < a[i].t) {
@@ -166,8 +158,9 @@ int OperatingPoints::merge_with(
     int n_add = 0;
     for (int i = 0; i < other.all_pts.size(); i++) {
         const OperatingPoint& op = other.all_pts[i];
-        if (add(op.perf, op.t, prefix + op.key, op.cno))
+        if (add(op.perf, op.t, prefix + op.key, op.cno)) {
             n_add++;
+        }
     }
     return n_add;
 }
@@ -175,15 +168,17 @@ int OperatingPoints::merge_with(
 /// get time required to obtain a given performance measure
 double OperatingPoints::t_for_perf(double perf) const {
     const std::vector<OperatingPoint>& a = optimal_pts;
-    if (perf > a.back().perf)
+    if (perf > a.back().perf) {
         return 1e50;
+    }
     int i0 = -1, i1 = a.size() - 1;
     while (i0 + 1 < i1) {
         int imed = (i0 + i1 + 1) / 2;
-        if (a[imed].perf < perf)
+        if (a[imed].perf < perf) {
             i0 = imed;
-        else
+        } else {
             i1 = imed;
+        }
     }
     return a[i1].t;
 }
@@ -273,8 +268,9 @@ ParameterSpace::ParameterSpace (Index *index):
 
 size_t ParameterSpace::n_combinations() const {
     size_t n = 1;
-    for (int i = 0; i < parameter_ranges.size(); i++)
+    for (int i = 0; i < parameter_ranges.size(); i++) {
         n *= parameter_ranges[i].values.size();
+    }
     return n;
 }
 
@@ -304,8 +300,9 @@ bool ParameterSpace::combination_ge(size_t c1, size_t c2) const {
         int nval = parameter_ranges[i].values.size();
         size_t j1 = c1 % nval;
         size_t j2 = c2 % nval;
-        if (!(j1 >= j2))
+        if (!(j1 >= j2)) {
             return false;
+        }
         c1 /= nval;
         c2 /= nval;
     }
@@ -318,8 +315,9 @@ static void init_pq_ParameterRange(
     if (pq.code_size % 4 == 0) {
         // Polysemous not supported for code sizes that are not a
         // multiple of 4
-        for (int i = 2; i <= pq.code_size * 8 / 2; i += 2)
+        for (int i = 2; i <= pq.code_size * 8 / 2; i += 2) {
             pr.values.push_back(i);
+        }
     }
     pr.values.push_back(pq.code_size * 8);
 }
@@ -360,8 +358,9 @@ void ParameterSpace::initialize(const Index* index) {
             ParameterRange& pr = add_range("nprobe");
             for (int i = 0; i < 13; i++) {
                 size_t nprobe = 1 << i;
-                if (nprobe >= ix->nlist)
+                if (nprobe >= ix->nlist) {
                     break;
+                }
                 pr.values.push_back(nprobe);
             }
         }
@@ -599,12 +598,14 @@ void ParameterSpace::update_bounds(
         double* upper_bound_perf,
         double* lower_bound_t) const {
     if (combination_ge(cno, op.cno)) {
-        if (op.t > *lower_bound_t)
+        if (op.t > *lower_bound_t) {
             *lower_bound_t = op.t;
+        }
     }
     if (combination_ge(op.cno, cno)) {
-        if (op.perf < *upper_bound_perf)
+        if (op.perf < *upper_bound_perf) {
             *upper_bound_perf = op.perf;
+        }
     }
 }
 
@@ -633,7 +634,7 @@ void ParameterSpace::explore(
 
             bool keep = ops->add(perf, t_search, combination_name(cno), cno);
 
-            if (verbose)
+            if (verbose) {
                 printf("  %zd/%zd: %s perf=%.3f t=%.3f s %s\n",
                        cno,
                        n_comb,
@@ -641,14 +642,16 @@ void ParameterSpace::explore(
                        perf,
                        t_search,
                        keep ? "*" : "");
+            }
         }
         return;
     }
 
     int n_exp = n_experiments;
 
-    if (n_exp > n_comb)
+    if (n_exp > n_comb) {
         n_exp = n_comb;
+    }
     FAISS_THROW_IF_NOT(n_comb == 1 || n_exp > 2);
     std::vector<int> perm(n_comb);
     // make sure the slowest and fastest experiment are run
@@ -656,19 +659,21 @@ void ParameterSpace::explore(
     if (n_comb > 1) {
         perm[1] = n_comb - 1;
         rand_perm(&perm[2], n_comb - 2, 1234);
-        for (int i = 2; i < perm.size(); i++)
+        for (int i = 2; i < perm.size(); i++) {
             perm[i]++;
+        }
     }
 
     for (size_t xp = 0; xp < n_exp; xp++) {
         size_t cno = perm[xp];
 
-        if (verbose)
+        if (verbose) {
             printf("  %zd/%d: cno=%zd %s ",
                    xp,
                    n_exp,
                    cno,
                    combination_name(cno).c_str());
+        }
 
         {
             double lower_bound_t = 0.0;
@@ -681,13 +686,15 @@ void ParameterSpace::explore(
                         &lower_bound_t);
             }
             double best_t = ops->t_for_perf(upper_bound_perf);
-            if (verbose)
+            if (verbose) {
                 printf("bounds [perf<=%.3f t>=%.3f] %s",
                        upper_bound_perf,
                        lower_bound_t,
                        best_t <= lower_bound_t ? "skip\n" : "");
-            if (best_t <= lower_bound_t)
+            }
+            if (best_t <= lower_bound_t) {
                 continue;
+            }
         }
 
         set_index_parameters(index, cno);
@@ -704,8 +711,9 @@ void ParameterSpace::explore(
 #pragma omp parallel for
                 for (idx_t q0 = 0; q0 < nq; q0 += batchsize) {
                     size_t q1 = q0 + batchsize;
-                    if (q1 > nq)
+                    if (q1 > nq) {
                         q1 = nq;
+                    }
                     index->search(
                             q1 - q0,
                             xq + q0 * index->d,
@@ -716,8 +724,9 @@ void ParameterSpace::explore(
             } else {
                 for (size_t q0 = 0; q0 < nq; q0 += batchsize) {
                     size_t q1 = q0 + batchsize;
-                    if (q1 > nq)
+                    if (q1 > nq) {
                         q1 = nq;
+                    }
                     index->search(
                             q1 - q0,
                             xq + q0 * index->d,
@@ -737,13 +746,14 @@ void ParameterSpace::explore(
 
         bool keep = ops->add(perf, t_search, combination_name(cno), cno);
 
-        if (verbose)
+        if (verbose) {
             printf(" perf %.3f t %.3f (%d %s) %s\n",
                    perf,
                    t_search,
                    nrun,
                    nrun >= 2 ? "runs" : "run",
                    keep ? "*" : "");
+        }
     }
 }
 

data/vendor/faiss/faiss/Clustering.cpp

@@ -39,8 +39,9 @@ void Clustering::post_process_centroids() {
     }
 
     if (int_centroids) {
-        for (size_t i = 0; i < centroids.size(); i++)
+        for (size_t i = 0; i < centroids.size(); i++) {
             centroids[i] = roundf(centroids[i]);
+        }
     }
 }
 
@@ -530,8 +531,9 @@ void Clustering::train_encoded(
             InterruptCallback::check();
         }
 
-        if (verbose)
+        if (verbose) {
             printf("\n");
+        }
         if (nredo > 1) {
             if ((lower_is_better && obj < best_obj) ||
                 (!lower_is_better && obj > best_obj)) {

data/vendor/faiss/faiss/IVFlib.cpp

@@ -155,8 +155,9 @@ void search_and_return_centroids(
             n, x, nprobe, cent_dis.data(), cent_nos.data());
 
     if (query_centroid_ids) {
-        for (size_t i = 0; i < n; i++)
+        for (size_t i = 0; i < n; i++) {
             query_centroid_ids[i] = cent_nos[i * nprobe];
+        }
     }
 
     index_ivf->search_preassigned(
@@ -165,13 +166,15 @@ void search_and_return_centroids(
     for (size_t i = 0; i < n * k; i++) {
         idx_t label = labels[i];
         if (label < 0) {
-            if (result_centroid_ids)
+            if (result_centroid_ids) {
                 result_centroid_ids[i] = -1;
+            }
         } else {
             long list_no = lo_listno(label);
             long list_index = lo_offset(label);
-            if (result_centroid_ids)
+            if (result_centroid_ids) {
                 result_centroid_ids[i] = list_no;
+            }
             labels[i] = index_ivf->invlists->get_single_id(list_no, list_index);
         }
     }
@@ -192,10 +195,11 @@ static void shift_and_add(
         std::vector<T>& dst,
         size_t remove,
         const std::vector<T>& src) {
-    if (remove > 0)
+    if (remove > 0) {
         memmove(dst.data(),
                 dst.data() + remove,
                 (dst.size() - remove) * sizeof(T));
+    }
     size_t insert_point = dst.size() - remove;
     dst.resize(insert_point + src.size());
     memcpy(dst.data() + insert_point, src.data(), src.size() * sizeof(T));
@@ -206,10 +210,11 @@ static void shift_and_add(
         MaybeOwnedVector<T>& dst,
         size_t remove,
         const MaybeOwnedVector<T>& src) {
-    if (remove > 0)
+    if (remove > 0) {
         memmove(dst.data(),
                 dst.data() + remove,
                 (dst.size() - remove) * sizeof(T));
+    }
     size_t insert_point = dst.size() - remove;
     dst.resize(insert_point + src.size());
     memcpy(dst.data() + insert_point, src.data(), src.size() * sizeof(T));
@@ -217,14 +222,16 @@ static void shift_and_add(
 
 template <class T>
 static void remove_from_begin(std::vector<T>& v, size_t remove) {
-    if (remove > 0)
+    if (remove > 0) {
         v.erase(v.begin(), v.begin() + remove);
+    }
 }
 
 template <class T>
 static void remove_from_begin(MaybeOwnedVector<T>& v, size_t remove) {
-    if (remove > 0)
+    if (remove > 0) {
         v.erase(v.begin(), v.begin() + remove);
+    }
 }
 
 void SlidingIndexWindow::step(const Index* sub_index, bool remove_oldest) {

data/vendor/faiss/faiss/Index.h

@@ -11,13 +11,13 @@
 #define FAISS_INDEX_H
 
 #include <faiss/MetricType.h>
+#include <faiss/impl/FaissAssert.h>
+
 #include <cstdio>
 #include <sstream>
-#include <string>
-#include <typeinfo>
 
 #define FAISS_VERSION_MAJOR 1
-#define FAISS_VERSION_MINOR 11
+#define FAISS_VERSION_MINOR 12
 #define FAISS_VERSION_PATCH 0
 
 // Macro to combine the version components into a single string
@@ -56,6 +56,28 @@ struct IDSelector;
 struct RangeSearchResult;
 struct DistanceComputer;
 
+enum NumericType {
+    Float32,
+    Float16,
+    UInt8,
+    Int8,
+};
+
+inline size_t get_numeric_type_size(NumericType numeric_type) {
+    switch (numeric_type) {
+        case NumericType::Float32:
+            return 4;
+        case NumericType::Float16:
+            return 2;
+        case NumericType::UInt8:
+        case NumericType::Int8:
+            return 1;
+        default:
+            FAISS_THROW_MSG(
+                    "Unknown Numeric Type. Only supports Float32, Float16");
+    }
+}
+
 /** Parent class for the optional search paramenters.
  *
  * Sub-classes with additional search parameters should inherit this class.
@@ -107,6 +129,14 @@ struct Index {
      */
     virtual void train(idx_t n, const float* x);
 
+    virtual void trainEx(idx_t n, const void* x, NumericType numeric_type) {
+        if (numeric_type == NumericType::Float32) {
+            train(n, static_cast<const float*>(x));
+        } else {
+            FAISS_THROW_MSG("Index::train: unsupported numeric type");
+        }
+    }
+
     /** Add n vectors of dimension d to the index.
      *
      * Vectors are implicitly assigned labels ntotal .. ntotal + n - 1
@@ -117,6 +147,14 @@ struct Index {
      */
     virtual void add(idx_t n, const float* x) = 0;
 
+    virtual void addEx(idx_t n, const void* x, NumericType numeric_type) {
+        if (numeric_type == NumericType::Float32) {
+            add(n, static_cast<const float*>(x));
+        } else {
+            FAISS_THROW_MSG("Index::add: unsupported numeric type");
+        }
+    }
+
     /** Same as add, but stores xids instead of sequential ids.
      *
      * The default implementation fails with an assertion, as it is
@@ -127,6 +165,17 @@ struct Index {
      * @param xids      if non-null, ids to store for the vectors (size n)
      */
     virtual void add_with_ids(idx_t n, const float* x, const idx_t* xids);
+    virtual void add_with_idsEx(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            const idx_t* xids) {
+        if (numeric_type == NumericType::Float32) {
+            add_with_ids(n, static_cast<const float*>(x), xids);
+        } else {
+            FAISS_THROW_MSG("Index::add_with_ids: unsupported numeric type");
+        }
+    }
 
     /** query n vectors of dimension d to the index.
      *
@@ -147,6 +196,26 @@ struct Index {
             idx_t* labels,
             const SearchParameters* params = nullptr) const = 0;
 
+    virtual void searchEx(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            idx_t k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const {
+        if (numeric_type == NumericType::Float32) {
+            search(n,
+                   static_cast<const float*>(x),
+                   k,
+                   distances,
+                   labels,
+                   params);
+        } else {
+            FAISS_THROW_MSG("Index::search: unsupported numeric type");
+        }
+    }
+
     /** query n vectors of dimension d to the index.
      *
      * return all vectors with distance < radius. Note that many

data/vendor/faiss/faiss/Index2Layer.cpp

@@ -9,10 +9,7 @@
 
 #include <faiss/Index2Layer.h>
 
-#include <faiss/impl/platform_macros.h>
-#include <cassert>
 #include <cinttypes>
-#include <cmath>
 #include <cstdint>
 #include <cstdio>
 
@@ -93,13 +90,14 @@ void Index2Layer::train(idx_t n, const float* x) {
                 x + i * d, residuals.data() + i * d, assign[i]);
     }
 
-    if (verbose)
+    if (verbose) {
         printf("training %zdx%zd product quantizer on %" PRId64
                " vectors in %dD\n",
                pq.M,
                pq.ksub,
                n,
                d);
+    }
     pq.verbose = verbose;
     pq.train(n, residuals.data());
 

data/vendor/faiss/faiss/IndexAdditiveQuantizer.cpp

@@ -221,7 +221,6 @@ FlatCodesDistanceComputer* IndexAdditiveQuantizer::
                     return new AQDistanceComputerLUT<
                             false,
                             AdditiveQuantizer::ST_norm_cqint8>(*this);
-                    break;
 #undef DISPATCH
                 default:
                     FAISS_THROW_FMT(

data/vendor/faiss/faiss/IndexAdditiveQuantizer.h

@@ -181,6 +181,7 @@ struct AdditiveCoarseQuantizer : Index {
             const SearchParameters* params = nullptr) const override;
 
     void reconstruct(idx_t key, float* recons) const override;
+
     void train(idx_t n, const float* x) override;
 
     /// N/A

data/vendor/faiss/faiss/IndexBinary.h

@@ -8,10 +8,8 @@
 #ifndef FAISS_INDEX_BINARY_H
 #define FAISS_INDEX_BINARY_H
 
+#include <cstdint>
 #include <cstdio>
-#include <sstream>
-#include <string>
-#include <typeinfo>
 
 #include <faiss/Index.h>
 
@@ -54,6 +52,13 @@ struct IndexBinary {
      * @param x      training vecors, size n * d / 8
      */
     virtual void train(idx_t n, const uint8_t* x);
+    virtual void trainEx(idx_t n, const void* x, NumericType numeric_type) {
+        if (numeric_type == NumericType::UInt8) {
+            train(n, static_cast<const uint8_t*>(x));
+        } else {
+            FAISS_THROW_MSG("IndexBinary::train: unsupported numeric type");
+        }
+    };
 
     /** Add n vectors of dimension d to the index.
      *
@@ -61,6 +66,13 @@ struct IndexBinary {
      * @param x      input matrix, size n * d / 8
      */
     virtual void add(idx_t n, const uint8_t* x) = 0;
+    virtual void addEx(idx_t n, const void* x, NumericType numeric_type) {
+        if (numeric_type == NumericType::UInt8) {
+            add(n, static_cast<const uint8_t*>(x));
+        } else {
+            FAISS_THROW_MSG("IndexBinary::add: unsupported numeric type");
+        }
+    };
 
     /** Same as add, but stores xids instead of sequential ids.
      *
@@ -70,6 +82,18 @@ struct IndexBinary {
      * @param xids if non-null, ids to store for the vectors (size n)
      */
     virtual void add_with_ids(idx_t n, const uint8_t* x, const idx_t* xids);
+    virtual void add_with_idsEx(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            const idx_t* xids) {
+        if (numeric_type == NumericType::UInt8) {
+            add_with_ids(n, static_cast<const uint8_t*>(x), xids);
+        } else {
+            FAISS_THROW_MSG(
+                    "IndexBinary::add_with_ids: unsupported numeric type");
+        }
+    };
 
     /** Query n vectors of dimension d to the index.
      *
@@ -87,6 +111,25 @@ struct IndexBinary {
             int32_t* distances,
             idx_t* labels,
             const SearchParameters* params = nullptr) const = 0;
+    virtual void searchEx(
+            idx_t n,
+            const void* x,
+            NumericType numeric_type,
+            idx_t k,
+            int32_t* distances,
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const {
+        if (numeric_type == NumericType::UInt8) {
+            search(n,
+                   static_cast<const uint8_t*>(x),
+                   k,
+                   distances,
+                   labels,
+                   params);
+        } else {
+            FAISS_THROW_MSG("IndexBinary::search: unsupported numeric type");
+        }
+    };
 
     /** Query n vectors of dimension d to the index.
      *