faiss 0.2.3 → 0.2.5

data/vendor/faiss/faiss/IndexScalarQuantizer.h

@@ -13,26 +13,19 @@
 #include <stdint.h>
 #include <vector>
 
+#include <faiss/IndexFlatCodes.h>
 #include <faiss/IndexIVF.h>
 #include <faiss/impl/ScalarQuantizer.h>
 
 namespace faiss {
 
 /**
- * The uniform quantizer has a range [vmin, vmax]. The range can be
- * the same for all dimensions (uniform) or specific per dimension
- * (default).
+ * Flat index built on a scalar quantizer.
  */
-
-struct IndexScalarQuantizer : Index {
+struct IndexScalarQuantizer : IndexFlatCodes {
     /// Used to encode the vectors
     ScalarQuantizer sq;
 
-    /// Codes. Size ntotal * pq.code_size
-    std::vector<uint8_t> codes;
-
-    size_t code_size;
-
     /** Constructor.
      *
      * @param d      dimensionality of the input vectors
@@ -48,26 +41,17 @@ struct IndexScalarQuantizer : Index {
 
     void train(idx_t n, const float* x) override;
 
-    void add(idx_t n, const float* x) override;
-
     void search(
             idx_t n,
             const float* x,
             idx_t k,
             float* distances,
-            idx_t* labels) const override;
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
 
-    void reset() override;
-
-    void reconstruct_n(idx_t i0, idx_t ni, float* recons) const override;
-
-    void reconstruct(idx_t key, float* recons) const override;
-
-    DistanceComputer* get_distance_computer() const override;
+    FlatCodesDistanceComputer* get_FlatCodesDistanceComputer() const override;
 
     /* standalone codec interface */
-    size_t sa_code_size() const override;
-
     void sa_encode(idx_t n, const float* x, uint8_t* bytes) const override;
 
     void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
@@ -109,7 +93,8 @@ struct IndexIVFScalarQuantizer : IndexIVF {
             const idx_t* precomputed_idx) override;
 
     InvertedListScanner* get_InvertedListScanner(
-            bool store_pairs) const override;
+            bool store_pairs,
+            const IDSelector* sel) const override;
 
     void reconstruct_from_offset(int64_t list_no, int64_t offset, float* recons)
             const override;

data/vendor/faiss/faiss/IndexShards.cpp

@@ -288,7 +288,10 @@ void IndexShardsTemplate<IndexT>::search(
         const component_t* x,
         idx_t k,
         distance_t* distances,
-        idx_t* labels) const {
+        idx_t* labels,
+        const SearchParameters* params) const {
+    FAISS_THROW_IF_NOT_MSG(
+            !params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
 
     long nshard = this->count();

data/vendor/faiss/faiss/IndexShards.h

@@ -87,7 +87,8 @@ struct IndexShardsTemplate : public ThreadedIndex<IndexT> {
             const component_t* x,
             idx_t k,
             distance_t* distances,
-            idx_t* labels) const override;
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
 
     void train(idx_t n, const component_t* x) override;
 

data/vendor/faiss/faiss/MetaIndexes.cpp

@@ -16,188 +16,12 @@
 
 #include <faiss/impl/AuxIndexStructures.h>
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/IDSelector.h>
 #include <faiss/utils/Heap.h>
 #include <faiss/utils/WorkerThread.h>
 
 namespace faiss {
 
-namespace {} // namespace
-
-/*****************************************************
- * IndexIDMap implementation
- *******************************************************/
-
-template <typename IndexT>
-IndexIDMapTemplate<IndexT>::IndexIDMapTemplate(IndexT* index)
-        : index(index), own_fields(false) {
-    FAISS_THROW_IF_NOT_MSG(index->ntotal == 0, "index must be empty on input");
-    this->is_trained = index->is_trained;
-    this->metric_type = index->metric_type;
-    this->verbose = index->verbose;
-    this->d = index->d;
-}
-
-template <typename IndexT>
-void IndexIDMapTemplate<IndexT>::add(
-        idx_t,
-        const typename IndexT::component_t*) {
-    FAISS_THROW_MSG(
-            "add does not make sense with IndexIDMap, "
-            "use add_with_ids");
-}
-
-template <typename IndexT>
-void IndexIDMapTemplate<IndexT>::train(
-        idx_t n,
-        const typename IndexT::component_t* x) {
-    index->train(n, x);
-    this->is_trained = index->is_trained;
-}
-
-template <typename IndexT>
-void IndexIDMapTemplate<IndexT>::reset() {
-    index->reset();
-    id_map.clear();
-    this->ntotal = 0;
-}
-
-template <typename IndexT>
-void IndexIDMapTemplate<IndexT>::add_with_ids(
-        idx_t n,
-        const typename IndexT::component_t* x,
-        const typename IndexT::idx_t* xids) {
-    index->add(n, x);
-    for (idx_t i = 0; i < n; i++)
-        id_map.push_back(xids[i]);
-    this->ntotal = index->ntotal;
-}
-
-template <typename IndexT>
-void IndexIDMapTemplate<IndexT>::search(
-        idx_t n,
-        const typename IndexT::component_t* x,
-        idx_t k,
-        typename IndexT::distance_t* distances,
-        typename IndexT::idx_t* labels) const {
-    index->search(n, x, k, distances, labels);
-    idx_t* li = labels;
-#pragma omp parallel for
-    for (idx_t i = 0; i < n * k; i++) {
-        li[i] = li[i] < 0 ? li[i] : id_map[li[i]];
-    }
-}
-
-template <typename IndexT>
-void IndexIDMapTemplate<IndexT>::range_search(
-        typename IndexT::idx_t n,
-        const typename IndexT::component_t* x,
-        typename IndexT::distance_t radius,
-        RangeSearchResult* result) const {
-    index->range_search(n, x, radius, result);
-#pragma omp parallel for
-    for (idx_t i = 0; i < result->lims[result->nq]; i++) {
-        result->labels[i] = result->labels[i] < 0 ? result->labels[i]
-                                                  : id_map[result->labels[i]];
-    }
-}
-
-namespace {
-
-struct IDTranslatedSelector : IDSelector {
-    const std::vector<int64_t>& id_map;
-    const IDSelector& sel;
-    IDTranslatedSelector(
-            const std::vector<int64_t>& id_map,
-            const IDSelector& sel)
-            : id_map(id_map), sel(sel) {}
-    bool is_member(idx_t id) const override {
-        return sel.is_member(id_map[id]);
-    }
-};
-
-} // namespace
-
-template <typename IndexT>
-size_t IndexIDMapTemplate<IndexT>::remove_ids(const IDSelector& sel) {
-    // remove in sub-index first
-    IDTranslatedSelector sel2(id_map, sel);
-    size_t nremove = index->remove_ids(sel2);
-
-    int64_t j = 0;
-    for (idx_t i = 0; i < this->ntotal; i++) {
-        if (sel.is_member(id_map[i])) {
-            // remove
-        } else {
-            id_map[j] = id_map[i];
-            j++;
-        }
-    }
-    FAISS_ASSERT(j == index->ntotal);
-    this->ntotal = j;
-    id_map.resize(this->ntotal);
-    return nremove;
-}
-
-template <typename IndexT>
-IndexIDMapTemplate<IndexT>::~IndexIDMapTemplate() {
-    if (own_fields)
-        delete index;
-}
-
-/*****************************************************
- * IndexIDMap2 implementation
- *******************************************************/
-
-template <typename IndexT>
-IndexIDMap2Template<IndexT>::IndexIDMap2Template(IndexT* index)
-        : IndexIDMapTemplate<IndexT>(index) {}
-
-template <typename IndexT>
-void IndexIDMap2Template<IndexT>::add_with_ids(
-        idx_t n,
-        const typename IndexT::component_t* x,
-        const typename IndexT::idx_t* xids) {
-    size_t prev_ntotal = this->ntotal;
-    IndexIDMapTemplate<IndexT>::add_with_ids(n, x, xids);
-    for (size_t i = prev_ntotal; i < this->ntotal; i++) {
-        rev_map[this->id_map[i]] = i;
-    }
-}
-
-template <typename IndexT>
-void IndexIDMap2Template<IndexT>::construct_rev_map() {
-    rev_map.clear();
-    for (size_t i = 0; i < this->ntotal; i++) {
-        rev_map[this->id_map[i]] = i;
-    }
-}
-
-template <typename IndexT>
-size_t IndexIDMap2Template<IndexT>::remove_ids(const IDSelector& sel) {
-    // This is quite inefficient
-    size_t nremove = IndexIDMapTemplate<IndexT>::remove_ids(sel);
-    construct_rev_map();
-    return nremove;
-}
-
-template <typename IndexT>
-void IndexIDMap2Template<IndexT>::reconstruct(
-        idx_t key,
-        typename IndexT::component_t* recons) const {
-    try {
-        this->index->reconstruct(rev_map.at(key), recons);
-    } catch (const std::out_of_range& e) {
-        FAISS_THROW_FMT("key %" PRId64 " not found", key);
-    }
-}
-
-// explicit template instantiations
-
-template struct IndexIDMapTemplate<Index>;
-template struct IndexIDMapTemplate<IndexBinary>;
-template struct IndexIDMap2Template<Index>;
-template struct IndexIDMap2Template<IndexBinary>;
-
 /*****************************************************
  * IndexSplitVectors implementation
  *******************************************************/
@@ -235,7 +59,10 @@ void IndexSplitVectors::search(
         const float* x,
         idx_t k,
         float* distances,
-        idx_t* labels) const {
+        idx_t* labels,
+        const SearchParameters* params) const {
+    FAISS_THROW_IF_NOT_MSG(
+            !params, "search params not supported for this index");
     FAISS_THROW_IF_NOT_MSG(k == 1, "search implemented only for k=1");
     FAISS_THROW_IF_NOT_MSG(
             sum_d == d, "not enough indexes compared to # dimensions");

data/vendor/faiss/faiss/MetaIndexes.h

@@ -11,92 +11,13 @@
 #define META_INDEXES_H
 
 #include <faiss/Index.h>
+#include <faiss/IndexIDMap.h>
 #include <faiss/IndexReplicas.h>
 #include <faiss/IndexShards.h>
-#include <unordered_map>
 #include <vector>
 
 namespace faiss {
 
-/** Index that translates search results to ids */
-template <typename IndexT>
-struct IndexIDMapTemplate : IndexT {
-    using idx_t = typename IndexT::idx_t;
-    using component_t = typename IndexT::component_t;
-    using distance_t = typename IndexT::distance_t;
-
-    IndexT* index;   ///! the sub-index
-    bool own_fields; ///! whether pointers are deleted in destructo
-    std::vector<idx_t> id_map;
-
-    explicit IndexIDMapTemplate(IndexT* index);
-
-    /// @param xids if non-null, ids to store for the vectors (size n)
-    void add_with_ids(idx_t n, const component_t* x, const idx_t* xids)
-            override;
-
-    /// this will fail. Use add_with_ids
-    void add(idx_t n, const component_t* x) override;
-
-    void search(
-            idx_t n,
-            const component_t* x,
-            idx_t k,
-            distance_t* distances,
-            idx_t* labels) const override;
-
-    void train(idx_t n, const component_t* x) override;
-
-    void reset() override;
-
-    /// remove ids adapted to IndexFlat
-    size_t remove_ids(const IDSelector& sel) override;
-
-    void range_search(
-            idx_t n,
-            const component_t* x,
-            distance_t radius,
-            RangeSearchResult* result) const override;
-
-    ~IndexIDMapTemplate() override;
-    IndexIDMapTemplate() {
-        own_fields = false;
-        index = nullptr;
-    }
-};
-
-using IndexIDMap = IndexIDMapTemplate<Index>;
-using IndexBinaryIDMap = IndexIDMapTemplate<IndexBinary>;
-
-/** same as IndexIDMap but also provides an efficient reconstruction
- *  implementation via a 2-way index */
-template <typename IndexT>
-struct IndexIDMap2Template : IndexIDMapTemplate<IndexT> {
-    using idx_t = typename IndexT::idx_t;
-    using component_t = typename IndexT::component_t;
-    using distance_t = typename IndexT::distance_t;
-
-    std::unordered_map<idx_t, idx_t> rev_map;
-
-    explicit IndexIDMap2Template(IndexT* index);
-
-    /// make the rev_map from scratch
-    void construct_rev_map();
-
-    void add_with_ids(idx_t n, const component_t* x, const idx_t* xids)
-            override;
-
-    size_t remove_ids(const IDSelector& sel) override;
-
-    void reconstruct(idx_t key, component_t* recons) const override;
-
-    ~IndexIDMap2Template() override {}
-    IndexIDMap2Template() {}
-};
-
-using IndexIDMap2 = IndexIDMap2Template<Index>;
-using IndexBinaryIDMap2 = IndexIDMap2Template<IndexBinary>;
-
 /** splits input vectors in segments and assigns each segment to a sub-index
  * used to distribute a MultiIndexQuantizer
  */
@@ -118,7 +39,8 @@ struct IndexSplitVectors : Index {
             const float* x,
             idx_t k,
             float* distances,
-            idx_t* labels) const override;
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
 
     void train(idx_t n, const float* x) override;
 

data/vendor/faiss/faiss/VectorTransform.cpp

@@ -149,6 +149,10 @@ void VectorTransform::reverse_transform(idx_t, const float*, float*) const {
     FAISS_THROW_MSG("reverse transform not implemented");
 }
 
+void VectorTransform::check_identical(const VectorTransform& other) const {
+    FAISS_THROW_IF_NOT(other.d_in == d_in && other.d_in == d_in);
+}
+
 /*********************************************
  * LinearTransform
  *********************************************/
@@ -308,6 +312,13 @@ void LinearTransform::print_if_verbose(
     printf("]\n");
 }
 
+void LinearTransform::check_identical(const VectorTransform& other_in) const {
+    VectorTransform::check_identical(other_in);
+    auto other = dynamic_cast<const LinearTransform*>(&other_in);
+    FAISS_THROW_IF_NOT(other);
+    FAISS_THROW_IF_NOT(other->A == A && other->b == b);
+}
+
 /*********************************************
  * RandomRotationMatrix
  *********************************************/
@@ -357,6 +368,7 @@ PCAMatrix::PCAMatrix(
     is_trained = false;
     max_points_per_d = 1000;
     balanced_bins = 0;
+    epsilon = 0;
 }
 
 namespace {
@@ -620,7 +632,7 @@ void PCAMatrix::prepare_Ab() {
         if (eigen_power != 0) {
             float* ai = A.data();
             for (int i = 0; i < d_out; i++) {
-                float factor = pow(eigenvalues[i], eigen_power);
+                float factor = pow(eigenvalues[i] + epsilon, eigen_power);
                 for (int j = 0; j < d_in; j++)
                     *ai++ *= factor;
             }
@@ -965,6 +977,14 @@ void ITQTransform::apply_noalloc(Index::idx_t n, const float* x, float* xt)
     pca_then_itq.apply_noalloc(n, x_norm.get(), xt);
 }
 
+void ITQTransform::check_identical(const VectorTransform& other_in) const {
+    VectorTransform::check_identical(other_in);
+    auto other = dynamic_cast<const ITQTransform*>(&other_in);
+    FAISS_THROW_IF_NOT(other);
+    pca_then_itq.check_identical(other->pca_then_itq);
+    FAISS_THROW_IF_NOT(other->mean == mean);
+}
+
 /*********************************************
  * OPQMatrix
  *********************************************/
@@ -1225,6 +1245,14 @@ void NormalizationTransform::reverse_transform(
     memcpy(x, xt, sizeof(xt[0]) * n * d_in);
 }
 
+void NormalizationTransform::check_identical(
+        const VectorTransform& other_in) const {
+    VectorTransform::check_identical(other_in);
+    auto other = dynamic_cast<const NormalizationTransform*>(&other_in);
+    FAISS_THROW_IF_NOT(other);
+    FAISS_THROW_IF_NOT(other->norm == norm);
+}
+
 /*********************************************
  * CenteringTransform
  *********************************************/
@@ -1270,6 +1298,14 @@ void CenteringTransform::reverse_transform(idx_t n, const float* xt, float* x)
     }
 }
 
+void CenteringTransform::check_identical(
+        const VectorTransform& other_in) const {
+    VectorTransform::check_identical(other_in);
+    auto other = dynamic_cast<const CenteringTransform*>(&other_in);
+    FAISS_THROW_IF_NOT(other);
+    FAISS_THROW_IF_NOT(other->mean == mean);
+}
+
 /*********************************************
  * RemapDimensionsTransform
  *********************************************/
@@ -1334,3 +1370,11 @@ void RemapDimensionsTransform::reverse_transform(
         xt += d_out;
     }
 }
+
+void RemapDimensionsTransform::check_identical(
+        const VectorTransform& other_in) const {
+    VectorTransform::check_identical(other_in);
+    auto other = dynamic_cast<const RemapDimensionsTransform*>(&other_in);
+    FAISS_THROW_IF_NOT(other);
+    FAISS_THROW_IF_NOT(other->map == map);
+}

data/vendor/faiss/faiss/VectorTransform.h

@@ -43,19 +43,27 @@ struct VectorTransform {
      */
     virtual void train(idx_t n, const float* x);
 
-    /** apply the random rotation, return new allocated matrix
-     * @param     x size n * d_in
-     * @return    size n * d_out
+    /** apply the transformation and return the result in an allocated pointer
+     * @param     n number of vectors to transform
+     * @param     x input vectors, size n * d_in
+     * @return    output vectors, size n * d_out
      */
     float* apply(idx_t n, const float* x) const;
 
-    /// same as apply, but result is pre-allocated
+    /** apply the transformation and return the result in a provided matrix
+     * @param     n number of vectors to transform
+     * @param     x input vectors, size n * d_in
+     * @param    xt output vectors, size n * d_out
+     */
     virtual void apply_noalloc(idx_t n, const float* x, float* xt) const = 0;
 
     /// reverse transformation. May not be implemented or may return
     /// approximate result
     virtual void reverse_transform(idx_t n, const float* xt, float* x) const;
 
+    // check that the two transforms are identical (to merge indexes)
+    virtual void check_identical(const VectorTransform& other) const = 0;
+
     virtual ~VectorTransform() {}
 };
 
@@ -100,6 +108,8 @@ struct LinearTransform : VectorTransform {
             int n,
             int d) const;
 
+    void check_identical(const VectorTransform& other) const override;
+
     ~LinearTransform() override {}
 };
 
@@ -129,6 +139,9 @@ struct PCAMatrix : LinearTransform {
      */
     float eigen_power;
 
+    /// value added to eigenvalues to avoid division by 0 when whitening
+    float epsilon;
+
     /// random rotation after PCA
     bool random_rotation;
 
@@ -204,6 +217,8 @@ struct ITQTransform : VectorTransform {
     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;
 };
 
 struct ProductQuantizer;
@@ -257,6 +272,8 @@ struct RemapDimensionsTransform : VectorTransform {
     void reverse_transform(idx_t n, const float* xt, float* x) const override;
 
     RemapDimensionsTransform() {}
+
+    void check_identical(const VectorTransform& other) const override;
 };
 
 /** per-vector normalization */
@@ -270,6 +287,8 @@ struct NormalizationTransform : VectorTransform {
 
     /// Identity transform since norm is not revertible
     void reverse_transform(idx_t n, const float* xt, float* x) const override;
+
+    void check_identical(const VectorTransform& other) const override;
 };
 
 /** Subtract the mean of each component from the vectors. */
@@ -287,6 +306,8 @@ struct CenteringTransform : VectorTransform {
 
     /// add the mean
     void reverse_transform(idx_t n, const float* xt, float* x) const override;
+
+    void check_identical(const VectorTransform& other) const override;
 };
 
 } // namespace faiss

data/vendor/faiss/faiss/clone_index.cpp

@@ -15,6 +15,7 @@
 #include <faiss/impl/FaissAssert.h>
 
 #include <faiss/Index2Layer.h>
+#include <faiss/IndexAdditiveQuantizer.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexHNSW.h>
 #include <faiss/IndexIVF.h>
@@ -27,11 +28,15 @@
 #include <faiss/IndexNSG.h>
 #include <faiss/IndexPQ.h>
 #include <faiss/IndexPreTransform.h>
-#include <faiss/IndexResidual.h>
 #include <faiss/IndexScalarQuantizer.h>
 #include <faiss/MetaIndexes.h>
 #include <faiss/VectorTransform.h>
 
+#include <faiss/impl/LocalSearchQuantizer.h>
+#include <faiss/impl/ProductQuantizer.h>
+#include <faiss/impl/ResidualQuantizer.h>
+#include <faiss/impl/ScalarQuantizer.h>
+
 namespace faiss {
 
 /*************************************************************
@@ -80,9 +85,10 @@ Index* Cloner::clone_Index(const Index* index) {
     TRYCLONE(IndexFlatIP, index)
     TRYCLONE(IndexFlat, index)
     TRYCLONE(IndexLattice, index)
-    TRYCLONE(IndexResidual, index)
+    TRYCLONE(IndexResidualQuantizer, index)
     TRYCLONE(IndexScalarQuantizer, index)
     TRYCLONE(MultiIndexQuantizer, index)
+    TRYCLONE(ResidualCoarseQuantizer, index)
     if (const IndexIVF* ivf = dynamic_cast<const IndexIVF*>(index)) {
         IndexIVF* res = clone_IndexIVF(ivf);
         if (ivf->invlists == nullptr) {
@@ -116,7 +122,9 @@ Index* Cloner::clone_Index(const Index* index) {
         return res;
     } else if (
             const IndexIDMap* idmap = dynamic_cast<const IndexIDMap*>(index)) {
-        IndexIDMap* res = new IndexIDMap(*idmap);
+        const IndexIDMap2* idmap2 = dynamic_cast<const IndexIDMap2*>(index);
+        IndexIDMap* res =
+                idmap2 ? new IndexIDMap2(*idmap2) : new IndexIDMap(*idmap);
         res->own_fields = true;
         res->index = clone_Index(idmap->index);
         return res;
@@ -136,6 +144,13 @@ Index* Cloner::clone_Index(const Index* index) {
         res->own_fields = true;
         res->storage = clone_Index(insg->storage);
         return res;
+    } else if (
+            const IndexNNDescent* innd =
+                    dynamic_cast<const IndexNNDescent*>(index)) {
+        IndexNNDescent* res = new IndexNNDescent(*innd);
+        res->own_fields = true;
+        res->storage = clone_Index(innd->storage);
+        return res;
     } else if (
             const Index2Layer* i2l = dynamic_cast<const Index2Layer*>(index)) {
         Index2Layer* res = new Index2Layer(*i2l);
@@ -148,4 +163,12 @@ Index* Cloner::clone_Index(const Index* index) {
     return nullptr;
 }
 
+Quantizer* clone_Quantizer(const Quantizer* quant) {
+    TRYCLONE(ResidualQuantizer, quant)
+    TRYCLONE(LocalSearchQuantizer, quant)
+    TRYCLONE(ProductQuantizer, quant)
+    TRYCLONE(ScalarQuantizer, quant)
+    FAISS_THROW_MSG("Did not recognize quantizer to clone");
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/clone_index.h

@@ -16,6 +16,7 @@ namespace faiss {
 struct Index;
 struct IndexIVF;
 struct VectorTransform;
+struct Quantizer;
 
 /* cloning functions */
 Index* clone_index(const Index*);
@@ -30,4 +31,6 @@ struct Cloner {
     virtual ~Cloner() {}
 };
 
+Quantizer* clone_Quantizer(const Quantizer* quant);
+
 } // namespace faiss