faiss 0.2.6 → 0.2.7

data/vendor/faiss/faiss/IndexIVF.h

@@ -31,19 +31,23 @@ namespace faiss {
  * of the lists (especially training)
  */
 struct Level1Quantizer {
-    Index* quantizer; ///< quantizer that maps vectors to inverted lists
-    size_t nlist;     ///< number of possible key values
+    /// quantizer that maps vectors to inverted lists
+    Index* quantizer = nullptr;
+
+    /// number of inverted lists
+    size_t nlist = 0;
 
     /**
      * = 0: use the quantizer as index in a kmeans training
      * = 1: just pass on the training set to the train() of the quantizer
      * = 2: kmeans training on a flat index + add the centroids to the quantizer
      */
-    char quantizer_trains_alone;
-    bool own_fields; ///< whether object owns the quantizer (false by default)
+    char quantizer_trains_alone = 0;
+    bool own_fields = false; ///< whether object owns the quantizer
 
     ClusteringParameters cp; ///< to override default clustering params
-    Index* clustering_index; ///< to override index used during clustering
+    /// to override index used during clustering
+    Index* clustering_index = nullptr;
 
     /// Trains the quantizer and calls train_residual to train sub-quantizers
     void train_q1(
@@ -54,8 +58,8 @@ struct Level1Quantizer {
 
     /// compute the number of bytes required to store list ids
     size_t coarse_code_size() const;
-    void encode_listno(Index::idx_t list_no, uint8_t* code) const;
-    Index::idx_t decode_listno(const uint8_t* code) const;
+    void encode_listno(idx_t list_no, uint8_t* code) const;
+    idx_t decode_listno(const uint8_t* code) const;
 
     Level1Quantizer(Index* quantizer, size_t nlist);
 
@@ -65,11 +69,10 @@ struct Level1Quantizer {
 };
 
 struct SearchParametersIVF : SearchParameters {
-    size_t nprobe;    ///< number of probes at query time
-    size_t max_codes; ///< max nb of codes to visit to do a query
+    size_t nprobe = 1;    ///< number of probes at query time
+    size_t max_codes = 0; ///< max nb of codes to visit to do a query
     SearchParameters* quantizer_params = nullptr;
 
-    SearchParametersIVF() : nprobe(1), max_codes(0) {}
     virtual ~SearchParametersIVF() {}
 };
 
@@ -78,6 +81,75 @@ using IVFSearchParameters = SearchParametersIVF;
 
 struct InvertedListScanner;
 struct IndexIVFStats;
+struct CodePacker;
+
+struct IndexIVFInterface : Level1Quantizer {
+    size_t nprobe = 1;    ///< number of probes at query time
+    size_t max_codes = 0; ///< max nb of codes to visit to do a query
+
+    explicit IndexIVFInterface(Index* quantizer = nullptr, size_t nlist = 0)
+            : Level1Quantizer(quantizer, nlist) {}
+
+    /** search a set of vectors, that are pre-quantized by the IVF
+     *  quantizer. Fill in the corresponding heaps with the query
+     *  results. The default implementation uses InvertedListScanners
+     *  to do the search.
+     *
+     * @param n      nb of vectors to query
+     * @param x      query vectors, size nx * d
+     * @param assign coarse quantization indices, size nx * nprobe
+     * @param centroid_dis
+     *               distances to coarse centroids, size nx * nprobe
+     * @param distance
+     *               output distances, size n * k
+     * @param labels output labels, size n * k
+     * @param store_pairs store inv list index + inv list offset
+     *                     instead in upper/lower 32 bit of result,
+     *                     instead of ids (used for reranking).
+     * @param params used to override the object's search parameters
+     * @param stats  search stats to be updated (can be null)
+     */
+    virtual void search_preassigned(
+            idx_t n,
+            const float* x,
+            idx_t k,
+            const idx_t* assign,
+            const float* centroid_dis,
+            float* distances,
+            idx_t* labels,
+            bool store_pairs,
+            const IVFSearchParameters* params = nullptr,
+            IndexIVFStats* stats = nullptr) const = 0;
+
+    /** Range search a set of vectors, that are pre-quantized by the IVF
+     *  quantizer. Fill in the RangeSearchResults results. The default
+     * implementation uses InvertedListScanners to do the search.
+     *
+     * @param n      nb of vectors to query
+     * @param x      query vectors, size nx * d
+     * @param assign coarse quantization indices, size nx * nprobe
+     * @param centroid_dis
+     *               distances to coarse centroids, size nx * nprobe
+     * @param result Output results
+     * @param store_pairs store inv list index + inv list offset
+     *                     instead in upper/lower 32 bit of result,
+     *                     instead of ids (used for reranking).
+     * @param params used to override the object's search parameters
+     * @param stats  search stats to be updated (can be null)
+     */
+    virtual void range_search_preassigned(
+            idx_t nx,
+            const float* x,
+            float radius,
+            const idx_t* keys,
+            const float* coarse_dis,
+            RangeSearchResult* result,
+            bool store_pairs = false,
+            const IVFSearchParameters* params = nullptr,
+            IndexIVFStats* stats = nullptr) const = 0;
+
+    virtual ~IndexIVFInterface() {}
+};
 
 /** Index based on a inverted file (IVF)
  *
@@ -99,16 +171,12 @@ struct IndexIVFStats;
  * Sub-classes implement a post-filtering of the index that refines
  * the distance estimation from the query to databse vectors.
  */
-struct IndexIVF : Index, Level1Quantizer {
+struct IndexIVF : Index, IndexIVFInterface {
     /// Access to the actual data
-    InvertedLists* invlists;
-    bool own_invlists;
-
-    size_t code_size; ///< code size per vector in bytes
-
-    size_t nprobe;    ///< number of probes at query time
-    size_t max_codes; ///< max nb of codes to visit to do a query
+    InvertedLists* invlists = nullptr;
+    bool own_invlists = false;
 
+    size_t code_size = 0; ///< code size per vector in bytes
     /** Parallel mode determines how queries are parallelized with OpenMP
      *
      * 0 (default): split over queries
@@ -119,7 +187,7 @@ struct IndexIVF : Index, Level1Quantizer {
      * PARALLEL_MODE_NO_HEAP_INIT: binary or with the previous to
      * prevent the heap to be initialized and finalized
      */
-    int parallel_mode;
+    int parallel_mode = 0;
     const int PARALLEL_MODE_NO_HEAP_INIT = 1024;
 
     /** optional map that maps back ids to invlist entries. This
@@ -188,26 +256,7 @@ struct IndexIVF : Index, Level1Quantizer {
     /// does nothing by default
     virtual void train_residual(idx_t n, const float* x);
 
-    /** search a set of vectors, that are pre-quantized by the IVF
-     *  quantizer. Fill in the corresponding heaps with the query
-     *  results. The default implementation uses InvertedListScanners
-     *  to do the search.
-     *
-     * @param n      nb of vectors to query
-     * @param x      query vectors, size nx * d
-     * @param assign coarse quantization indices, size nx * nprobe
-     * @param centroid_dis
-     *               distances to coarse centroids, size nx * nprobe
-     * @param distance
-     *               output distances, size n * k
-     * @param labels output labels, size n * k
-     * @param store_pairs store inv list index + inv list offset
-     *                     instead in upper/lower 32 bit of result,
-     *                     instead of ids (used for reranking).
-     * @param params used to override the object's search parameters
-     * @param stats  search stats to be updated (can be null)
-     */
-    virtual void search_preassigned(
+    void search_preassigned(
             idx_t n,
             const float* x,
             idx_t k,
@@ -217,7 +266,18 @@ struct IndexIVF : Index, Level1Quantizer {
             idx_t* labels,
             bool store_pairs,
             const IVFSearchParameters* params = nullptr,
-            IndexIVFStats* stats = nullptr) const;
+            IndexIVFStats* stats = nullptr) const override;
+
+    void range_search_preassigned(
+            idx_t nx,
+            const float* x,
+            float radius,
+            const idx_t* keys,
+            const float* coarse_dis,
+            RangeSearchResult* result,
+            bool store_pairs = false,
+            const IVFSearchParameters* params = nullptr,
+            IndexIVFStats* stats = nullptr) const override;
 
     /** assign the vectors, then call search_preassign */
     void search(
@@ -235,17 +295,6 @@ struct IndexIVF : Index, Level1Quantizer {
             RangeSearchResult* result,
             const SearchParameters* params = nullptr) const override;
 
-    void range_search_preassigned(
-            idx_t nx,
-            const float* x,
-            float radius,
-            const idx_t* keys,
-            const float* coarse_dis,
-            RangeSearchResult* result,
-            bool store_pairs = false,
-            const IVFSearchParameters* params = nullptr,
-            IndexIVFStats* stats = nullptr) const;
-
     /** Get a scanner for this index (store_pairs means ignore labels)
      *
      * The default search implementation uses this to compute the distances
@@ -317,16 +366,15 @@ struct IndexIVF : Index, Level1Quantizer {
 
     virtual void merge_from(Index& otherIndex, idx_t add_id) override;
 
+    // returns a new instance of a CodePacker
+    virtual CodePacker* get_CodePacker() const;
+
     /** copy a subset of the entries index to the other index
-     *
-     * if subset_type == 0: copies ids in [a1, a2)
-     * if subset_type == 1: copies ids if id % a1 == a2
-     * if subset_type == 2: copies inverted lists such that a1
-     *                      elements are left before and a2 elements are after
+     * see Invlists::copy_subset_to for the meaning of subset_type
      */
     virtual void copy_subset_to(
             IndexIVF& other,
-            int subset_type,
+            InvertedLists::subset_type_t subset_type,
             idx_t a1,
             idx_t a2) const;
 
@@ -339,7 +387,7 @@ struct IndexIVF : Index, Level1Quantizer {
     /// are the ids sorted?
     bool check_ids_sorted() const;
 
-    /** intialize a direct map
+    /** initialize a direct map
      *
      * @param new_maintain_direct_map    if true, create a direct map,
      *                                   else clear it
@@ -353,7 +401,6 @@ struct IndexIVF : Index, Level1Quantizer {
 
     /* The standalone codec interface (except sa_decode that is specific) */
     size_t sa_code_size() const override;
-
     void sa_encode(idx_t n, const float* x, uint8_t* bytes) const override;
 
     IndexIVF();
@@ -366,8 +413,6 @@ struct RangeQueryResult;
  * distance_to_code and scan_codes can be called in multiple
  * threads */
 struct InvertedListScanner {
-    using idx_t = Index::idx_t;
-
     idx_t list_no = -1;    ///< remember current list
     bool keep_max = false; ///< keep maximum instead of minimum
     /// store positions in invlists rather than labels
@@ -413,6 +458,14 @@ struct InvertedListScanner {
             idx_t* labels,
             size_t k) const;
 
+    // same as scan_codes, using an iterator
+    virtual size_t iterate_codes(
+            InvertedListsIterator* iterator,
+            float* distances,
+            idx_t* labels,
+            size_t k,
+            size_t& list_size) const;
+
     /** scan a set of codes, compute distances to current query and
      * update results if distances are below radius
      *
@@ -424,6 +477,13 @@ struct InvertedListScanner {
             float radius,
             RangeQueryResult& result) const;
 
+    // same as scan_codes_range, using an iterator
+    virtual void iterate_codes_range(
+            InvertedListsIterator* iterator,
+            float radius,
+            RangeQueryResult& result,
+            size_t& list_size) const;
+
     virtual ~InvertedListScanner() {}
 };
 

data/vendor/faiss/faiss/IndexIVFAdditiveQuantizer.cpp

@@ -51,7 +51,7 @@ void IndexIVFAdditiveQuantizer::train_residual(idx_t n, const float* x) {
     ScopeDeleter<float> del_x(x_in == x ? nullptr : x);
 
     if (by_residual) {
-        std::vector<Index::idx_t> idx(n);
+        std::vector<idx_t> idx(n);
         quantizer->assign(n, x, idx.data());
 
         std::vector<float> residuals(n * d);
@@ -145,7 +145,7 @@ struct AQInvertedListScanner : InvertedListScanner {
             : ia(ia), aq(*ia.aq) {
         this->store_pairs = store_pairs;
         this->code_size = ia.code_size;
-        keep_max = ia.metric_type == METRIC_INNER_PRODUCT;
+        keep_max = is_similarity_metric(ia.metric_type);
         tmp.resize(ia.d);
     }
 

data/vendor/faiss/faiss/IndexIVFFastScan.cpp

@@ -69,7 +69,14 @@ void IndexIVFFastScan::init_fastscan(
     code_size = M2 / 2;
 
     is_trained = false;
-    replace_invlists(new BlockInvertedLists(nlist, bbs, bbs * M2 / 2), true);
+    replace_invlists(new BlockInvertedLists(nlist, get_CodePacker()), true);
+}
+
+void IndexIVFFastScan::init_code_packer() {
+    auto bil = dynamic_cast<BlockInvertedLists*>(invlists);
+    FAISS_THROW_IF_NOT(bil);
+    delete bil->packer; // in case there was one before
+    bil->packer = get_CodePacker();
 }
 
 IndexIVFFastScan::~IndexIVFFastScan() {}
@@ -112,17 +119,9 @@ void IndexIVFFastScan::add_with_ids(
     }
     InterruptCallback::check();
 
-    AlignedTable<uint8_t> codes(n * code_size);
     direct_map.check_can_add(xids);
     std::unique_ptr<idx_t[]> idx(new idx_t[n]);
     quantizer->assign(n, x, idx.get());
-    size_t nadd = 0, nminus1 = 0;
-
-    for (size_t i = 0; i < n; i++) {
-        if (idx[i] < 0) {
-            nminus1++;
-        }
-    }
 
     AlignedTable<uint8_t> flat_codes(n * code_size);
     encode_vectors(n, x, idx.get(), flat_codes.get());
@@ -170,7 +169,6 @@ void IndexIVFFastScan::add_with_ids(
             memcpy(list_codes.data() + (i - i0) * code_size,
                    flat_codes.data() + order[i] * code_size,
                    code_size);
-            nadd++;
         }
         pq4_pack_codes_range(
                 list_codes.data(),
@@ -187,6 +185,10 @@ void IndexIVFFastScan::add_with_ids(
     ntotal += n;
 }
 
+CodePacker* IndexIVFFastScan::get_CodePacker() const {
+    return new CodePackerPQ4(M, bbs);
+}
+
 /*********************************************************
  * search
  *********************************************************/
@@ -229,7 +231,6 @@ void estimators_from_tables_generic(
     }
 }
 
-using idx_t = Index::idx_t;
 using namespace quantize_lut;
 
 } // anonymous namespace

data/vendor/faiss/faiss/IndexIVFFastScan.h

@@ -67,6 +67,9 @@ struct IndexIVFFastScan : IndexIVF {
             MetricType metric,
             int bbs);
 
+    // initialize the CodePacker in the InvertedLists
+    void init_code_packer();
+
     ~IndexIVFFastScan() override;
 
     /// orig's inverted lists (for debugging)
@@ -166,7 +169,7 @@ struct IndexIVFFastScan : IndexIVF {
             size_t* nlist_out,
             const Scaler& scaler) const;
 
-    // implem 14 is mukltithreaded internally across nprobes and queries
+    // implem 14 is multithreaded internally across nprobes and queries
     template <class C, class Scaler>
     void search_implem_14(
             idx_t n,
@@ -181,6 +184,8 @@ struct IndexIVFFastScan : IndexIVF {
     void reconstruct_from_offset(int64_t list_no, int64_t offset, float* recons)
             const override;
 
+    CodePacker* get_CodePacker() const override;
+
     // reconstruct orig invlists (for debugging)
     void reconstruct_orig_invlists();
 };