faiss 0.5.2 → 0.6.0

data/vendor/faiss/faiss/IndexRefine.cpp

@@ -58,36 +58,6 @@ void IndexRefine::reset() {
     ntotal = 0;
 }
 
-namespace {
-
-using idx_t = faiss::idx_t;
-
-template <class C>
-static void reorder_2_heaps(
-        idx_t n,
-        idx_t k,
-        idx_t* __restrict labels,
-        float* __restrict distances,
-        idx_t k_base,
-        const idx_t* __restrict base_labels,
-        const float* __restrict base_distances) {
-#pragma omp parallel for if (n > 1)
-    for (idx_t i = 0; i < n; i++) {
-        idx_t* idxo = labels + i * k;
-        float* diso = distances + i * k;
-        const idx_t* idxi = base_labels + i * k_base;
-        const float* disi = base_distances + i * k_base;
-
-        heap_heapify<C>(k, diso, idxo, disi, idxi, k);
-        if (k_base != k) { // add remaining elements
-            heap_addn<C>(k, diso, idxo, disi + k, idxi + k, k_base - k);
-        }
-        heap_reorder<C>(k, diso, idxo);
-    }
-}
-
-} // anonymous namespace
-
 void IndexRefine::search(
         idx_t n,
         const float* x,

data/vendor/faiss/faiss/IndexShards.cpp

@@ -22,7 +22,7 @@ namespace {
 
 // IndexBinary needs to update the code_size when d is set...
 
-void sync_d(Index* index) {}
+void sync_d(Index* /*index*/) {}
 
 void sync_d(IndexBinary* index) {
     FAISS_THROW_IF_NOT(index->d % 8 == 0);
@@ -71,13 +71,12 @@ IndexShardsTemplate<IndexT>::IndexShardsTemplate(
 }
 
 template <typename IndexT>
-void IndexShardsTemplate<IndexT>::onAfterAddIndex(IndexT* index /* unused */) {
+void IndexShardsTemplate<IndexT>::onAfterAddIndex(IndexT* /*index*/) {
     syncWithSubIndexes();
 }
 
 template <typename IndexT>
-void IndexShardsTemplate<IndexT>::onAfterRemoveIndex(
-        IndexT* index /* unused */) {
+void IndexShardsTemplate<IndexT>::onAfterRemoveIndex(IndexT* /*index*/) {
     syncWithSubIndexes();
 }
 

data/vendor/faiss/faiss/MetricType.h

@@ -12,6 +12,9 @@
 
 #include <cstdint>
 #include <cstdio>
+#include <cstdlib>
+
+#include <faiss/impl/FaissAssert.h>
 
 namespace faiss {
 
@@ -20,6 +23,8 @@ namespace faiss {
 /// Most algorithms support both inner product and L2, with the flat
 /// (brute-force) indices supporting additional metric types for vector
 /// comparison.
+///
+/// NOTE: when adding or removing values, update metric_type_from_int() below.
 enum MetricType {
     METRIC_INNER_PRODUCT = 0, ///< maximum inner product search
     METRIC_L2 = 1,            ///< squared L2 search
@@ -52,6 +57,17 @@ constexpr bool is_similarity_metric(MetricType metric_type) {
             (metric_type == METRIC_Jaccard));
 }
 
+/// Convert an integer to MetricType with range validation.
+/// Throws FaissException if the value is not a valid MetricType.
+inline MetricType metric_type_from_int(int x) {
+    FAISS_THROW_IF_NOT_FMT(
+            (x >= METRIC_INNER_PRODUCT && x <= METRIC_Lp) ||
+                    (x >= METRIC_Canberra && x <= METRIC_GOWER),
+            "invalid metric type %d",
+            x);
+    return static_cast<MetricType>(x);
+}
+
 } // namespace faiss
 
 #endif

data/vendor/faiss/faiss/VectorTransform.cpp

@@ -352,6 +352,126 @@ void RandomRotationMatrix::train(idx_t /*n*/, const float* /*x*/) {
     init(12345);
 }
 
+/*********************************************
+ * HadamardRotation
+ *********************************************/
+
+// In-place Fast Walsh-Hadamard Transform. n must be a power of 2.
+// Applies the unnormalized Hadamard butterfly: O(n log n) add/sub, no
+// multiplies.
+static void fwht_inplace(float* buf, size_t n) {
+    for (size_t step = 1; step < n; step *= 2) {
+        for (size_t i = 0; i < n; i += step * 2) {
+            for (size_t j = i; j < i + step; j++) {
+                float a = buf[j];
+                float b = buf[j + step];
+                buf[j] = a + b;
+                buf[j + step] = a - b;
+            }
+        }
+    }
+}
+
+// Smallest power of 2 >= n.
+static int next_power_of_2(int n) {
+    int p = 1;
+    while (p < n) {
+        p *= 2;
+    }
+    return p;
+}
+
+// Generate three sign-flip vectors from the given seed.
+static void generate_signs(
+        uint32_t seed,
+        size_t p,
+        std::vector<float>& s1,
+        std::vector<float>& s2,
+        std::vector<float>& s3) {
+    FAISS_THROW_IF_NOT(p > 0);
+    SplitMix64RandomGenerator rng(seed);
+    s1.resize(p);
+    s2.resize(p);
+    s3.resize(p);
+    for (size_t j = 0; j < p; j++) {
+        s1[j] = (rng.rand_int(2) == 0) ? -1.0f : 1.0f;
+    }
+    for (size_t j = 0; j < p; j++) {
+        s2[j] = (rng.rand_int(2) == 0) ? -1.0f : 1.0f;
+    }
+    for (size_t j = 0; j < p; j++) {
+        s3[j] = (rng.rand_int(2) == 0) ? -1.0f : 1.0f;
+    }
+}
+
+HadamardRotation::HadamardRotation(int d, uint32_t seed_in)
+        : VectorTransform(d, next_power_of_2(d)), seed(seed_in) {
+    init(seed_in);
+}
+
+void HadamardRotation::init(uint32_t seed_in) {
+    seed = seed_in;
+    is_trained = true;
+    generate_signs(seed, d_out, signs1, signs2, signs3);
+}
+
+void HadamardRotation::train(idx_t, const float*) {
+    init(seed != 0 ? seed : 12345);
+}
+
+void HadamardRotation::apply_noalloc(idx_t n, const float* x, float* xt) const {
+    FAISS_THROW_IF_NOT_MSG(is_trained, "Transformation not trained yet");
+
+    size_t d = d_in;
+    size_t p = d_out;
+    FAISS_THROW_IF_NOT(signs1.size() == p);
+    FAISS_THROW_IF_NOT(signs2.size() == p);
+    FAISS_THROW_IF_NOT(signs3.size() == p);
+
+    // Each unnormalized FWHT scales norms by sqrt(p).
+    // Three rounds scale by p^(3/2). Normalize once at the end.
+    float total_scale = 1.0f / (p * std::sqrt(static_cast<float>(p)));
+
+#pragma omp parallel for schedule(dynamic)
+    for (idx_t i = 0; i < n; i++) {
+        const float* xi = x + i * d;
+        float* xo = xt + i * p;
+
+        // Round 1: copy + zero-pad + sign-flip + FWHT
+        for (size_t j = 0; j < d; j++) {
+            xo[j] = xi[j] * signs1[j];
+        }
+        for (size_t j = d; j < p; j++) {
+            xo[j] = 0.0f;
+        }
+        fwht_inplace(xo, p);
+
+        // Round 2: sign-flip + FWHT
+        for (size_t j = 0; j < p; j++) {
+            xo[j] *= signs2[j];
+        }
+        fwht_inplace(xo, p);
+
+        // Round 3: sign-flip + FWHT + normalize
+        for (size_t j = 0; j < p; j++) {
+            xo[j] *= signs3[j];
+        }
+        fwht_inplace(xo, p);
+
+        for (size_t j = 0; j < p; j++) {
+            xo[j] *= total_scale;
+        }
+    }
+}
+
+void HadamardRotation::check_identical(const VectorTransform& other) const {
+    auto* hr = dynamic_cast<const HadamardRotation*>(&other);
+    FAISS_THROW_IF_NOT(hr);
+    FAISS_THROW_IF_NOT(d_in == hr->d_in);
+    FAISS_THROW_IF_NOT(d_out == hr->d_out);
+    FAISS_THROW_IF_NOT(seed == hr->seed);
+}
+
 /*********************************************
  * PCAMatrix
  *********************************************/

data/vendor/faiss/faiss/VectorTransform.h

@@ -126,6 +126,29 @@ struct RandomRotationMatrix : LinearTransform {
     RandomRotationMatrix() {}
 };
 
+/** Three rounds of random sign-flip + Fast Walsh-Hadamard Transform.
+ * Produces a pseudo-random rotation in O(d log d) time.
+ * d_out is the smallest power of 2 >= d_in (zero-padded as needed).
+ */
+struct HadamardRotation : VectorTransform {
+    uint32_t seed{};
+
+    /// Sign-flip vectors, each of size d_out, generated from seed.
+    std::vector<float> signs1, signs2, signs3;
+
+    explicit HadamardRotation(int d, uint32_t seed = 12345);
+
+    void init(uint32_t seed_in);
+
+    void train(idx_t n, const float* x) override;
+
+    void apply_noalloc(idx_t n, const float* x, float* xt) const override;
+
+    void check_identical(const VectorTransform& other) const override;
+
+    HadamardRotation() {}
+};
+
 /** Applies a principal component analysis on a set of vectors,
  *  with optionally whitening and random rotation. */
 struct PCAMatrix : LinearTransform {

data/vendor/faiss/faiss/clone_index.cpp

@@ -27,6 +27,8 @@
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/IndexIVFPQFastScan.h>
 #include <faiss/IndexIVFPQR.h>
+#include <faiss/IndexIVFRaBitQ.h>
+#include <faiss/IndexIVFRaBitQFastScan.h>
 #include <faiss/IndexIVFSpectralHash.h>
 #include <faiss/IndexLSH.h>
 #include <faiss/IndexLattice.h>
@@ -41,11 +43,11 @@
 #include <faiss/MetaIndexes.h>
 #include <faiss/VectorTransform.h>
 
+#include <faiss/impl/CodePacker.h>
 #include <faiss/impl/LocalSearchQuantizer.h>
 #include <faiss/impl/ProductQuantizer.h>
 #include <faiss/impl/ResidualQuantizer.h>
 #include <faiss/impl/ScalarQuantizer.h>
-#include <faiss/impl/pq4_fast_scan.h>
 
 #include <faiss/invlists/BlockInvertedLists.h>
 
@@ -96,6 +98,9 @@ IndexIVF* Cloner::clone_IndexIVF(const IndexIVF* ivf) {
     TRYCLONE(IndexIVFResidualQuantizerFastScan, ivf)
     TRYCLONE(IndexIVFPQFastScan, ivf)
 
+    TRYCLONE(IndexIVFRaBitQFastScan, ivf)
+    TRYCLONE(IndexIVFRaBitQ, ivf)
+
     TRYCLONE(IndexIVFFlatDedup, ivf)
     TRYCLONE(IndexIVFFlat, ivf)
     TRYCLONE(IndexIVFFlatPanorama, ivf)
@@ -257,9 +262,7 @@ InvertedLists* clone_InvertedLists(const InvertedLists* invlists) {
     if (auto* bils = dynamic_cast<const BlockInvertedLists*>(invlists)) {
         auto* bils2 = new BlockInvertedLists(*bils);
         if (bils->packer) {
-            auto* packerPQ4 = dynamic_cast<const CodePackerPQ4*>(bils->packer);
-            FAISS_THROW_IF_NOT(packerPQ4);
-            bils2->packer = new CodePackerPQ4(*packerPQ4);
+            bils2->packer = bils->packer->clone();
         }
         return bils2;
     }

data/vendor/faiss/faiss/{cppcontrib/factory_tools.cpp → factory_tools.cpp}

@@ -7,7 +7,7 @@
 
 // -*- c++ -*-
 
-#include <faiss/cppcontrib/factory_tools.h>
+#include <faiss/factory_tools.h>
 
 #include <map>
 

data/vendor/faiss/faiss/gpu/GpuCloner.cpp

@@ -64,7 +64,7 @@ void ToCPUCloner::merge_index(Index* dst, Index* src, bool successive_ids) {
         FAISS_ASSERT(ifl2);
         ifl->merge_from(*ifl2, successive_ids ? ifl->ntotal : 0);
     } else {
-        FAISS_ASSERT(!"merging not implemented for this type of class");
+        FAISS_ASSERT(false && "merging not implemented for this type of class");
     }
 }
 

data/vendor/faiss/faiss/impl/AdditiveQuantizer.cpp

@@ -21,6 +21,7 @@
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/LocalSearchQuantizer.h>
 #include <faiss/impl/ResidualQuantizer.h>
+#include <faiss/impl/simd_dispatch.h>
 #include <faiss/utils/Heap.h>
 #include <faiss/utils/distances.h>
 #include <faiss/utils/hamming.h>
@@ -66,8 +67,10 @@ void AdditiveQuantizer::set_derived_values() {
     codebook_offsets.resize(M + 1, 0);
     for (int i = 0; i < M; i++) {
         int nbit = nbits[i];
-        size_t k = 1 << nbit;
-        codebook_offsets[i + 1] = codebook_offsets[i] + k;
+        FAISS_CHECK_RANGE(nbit, 0, 31);
+        size_t k = (size_t)1 << nbit;
+        codebook_offsets[i + 1] =
+                add_no_overflow(codebook_offsets[i], k, "codebook_offsets");
         tot_bits += nbit;
         if (nbit != 0) {
             only_8bit = false;
@@ -153,12 +156,24 @@ void AdditiveQuantizer::train_norm(size_t n, const float* norms) {
 
 void AdditiveQuantizer::compute_codebook_tables() {
     centroid_norms.resize(total_codebook_size);
+    FAISS_THROW_IF_NOT_FMT(
+            codebooks.size() >=
+                    mul_no_overflow(
+                            total_codebook_size, d, "codebooks validation"),
+            "codebooks size %zd too small for total_codebook_size=%zd * d=%zd",
+            codebooks.size(),
+            total_codebook_size,
+            d);
     fvec_norms_L2sqr(
             centroid_norms.data(), codebooks.data(), d, total_codebook_size);
     size_t cross_table_size = 0;
     for (int m = 0; m < M; m++) {
+        FAISS_CHECK_RANGE(nbits[m], 0, 31);
         size_t K = (size_t)1 << nbits[m];
-        cross_table_size += K * codebook_offsets[m];
+        size_t product =
+                mul_no_overflow(K, codebook_offsets[m], "cross_table_size");
+        cross_table_size = add_no_overflow(
+                cross_table_size, product, "cross_table_size accumulation");
     }
     codebook_cross_products.resize(cross_table_size);
     size_t ofs = 0;
@@ -167,7 +182,16 @@ void AdditiveQuantizer::compute_codebook_tables() {
         FINTEGER kk = codebook_offsets[m];
         FINTEGER di = d;
         float zero = 0, one = 1;
-        assert(ofs + ki * kk <= cross_table_size);
+        size_t step_size = (size_t)ki * (size_t)kk;
+        FAISS_THROW_IF_NOT_FMT(
+                add_no_overflow(ofs, step_size, "cross product table offset") <=
+                        cross_table_size,
+                "cross product table overflow at step %d: "
+                "%zd + %zd > %zd",
+                m,
+                ofs,
+                step_size,
+                cross_table_size);
         sgemm_("Transposed",
                "Not transposed",
                &ki,
@@ -181,7 +205,7 @@ void AdditiveQuantizer::compute_codebook_tables() {
                &zero,
                codebook_cross_products.data() + ofs,
                &ki);
-        ofs += ki * kk;
+        ofs += step_size;
     }
 }
 
@@ -348,15 +372,17 @@ AdditiveQuantizer::~AdditiveQuantizer() {}
 void AdditiveQuantizer::compute_centroid_norms(float* norms) const {
     size_t ntotal = (size_t)1 << tot_bits;
     // TODO: make tree of partial sums
+    with_simd_level([&]<SIMDLevel SL>() {
 #pragma omp parallel
-    {
-        std::vector<float> tmp(d);
+        {
+            std::vector<float> tmp(d);
 #pragma omp for
-        for (int64_t i = 0; i < ntotal; i++) {
-            decode_64bit(i, tmp.data());
-            norms[i] = fvec_norm_L2sqr(tmp.data(), d);
+            for (int64_t i = 0; i < ntotal; i++) {
+                decode_64bit(i, tmp.data());
+                norms[i] = fvec_norm_L2sqr<SL>(tmp.data(), d);
+            }
         }
-    }
+    });
 }
 
 void AdditiveQuantizer::decode_64bit(idx_t bits, float* xi) const {

data/vendor/faiss/faiss/impl/AuxIndexStructures.h

@@ -169,34 +169,6 @@ struct TimeoutCallback : InterruptCallback {
     static void reset(double timeout_in_seconds);
 };
 
-/// set implementation optimized for fast access.
-struct VisitedTable {
-    std::vector<uint8_t> visited;
-    uint8_t visno;
-
-    explicit VisitedTable(int size) : visited(size), visno(1) {}
-
-    /// set flag #no to true
-    void set(int no) {
-        visited[no] = visno;
-    }
-
-    /// get flag #no
-    bool get(int no) const {
-        return visited[no] == visno;
-    }
-
-    /// reset all flags to false
-    void advance() {
-        visno++;
-        if (visno == 250) {
-            // 250 rather than 255 because sometimes we use visno and visno+1
-            memset(visited.data(), 0, sizeof(visited[0]) * visited.size());
-            visno = 1;
-        }
-    }
-};
-
 } // namespace faiss
 
 #endif