faiss 0.1.5 → 0.2.2

data/vendor/faiss/faiss/IndexRefine.h

@@ -9,32 +9,29 @@
 
 #include <faiss/Index.h>
 
-
 namespace faiss {
 
-
 /** Index that queries in a base_index (a fast one) and refines the
  *  results with an exact search, hopefully improving the results.
  */
-struct IndexRefine: Index {
-
+struct IndexRefine : Index {
     /// faster index to pre-select the vectors that should be filtered
-    Index *base_index;
+    Index* base_index;
 
     /// refinement index
-    Index *refine_index;
+    Index* refine_index;
 
-    bool own_fields;         ///< should the base index be deallocated?
-    bool own_refine_index;   ///< same with the refinement index
+    bool own_fields;       ///< should the base index be deallocated?
+    bool own_refine_index; ///< same with the refinement index
 
     /// factor between k requested in search and the k requested from
     /// the base_index (should be >= 1)
     float k_factor = 1;
 
-    /// intitialize from empty index
-    IndexRefine (Index *base_index, Index *refine_index);
+    /// initialize from empty index
+    IndexRefine(Index* base_index, Index* refine_index);
 
-    IndexRefine ();
+    IndexRefine();
 
     void train(idx_t n, const float* x) override;
 
@@ -43,31 +40,33 @@ struct IndexRefine: Index {
     void reset() override;
 
     void search(
-        idx_t n, const float* x, idx_t k,
-        float* distances, idx_t* labels) const override;
+            idx_t n,
+            const float* x,
+            idx_t k,
+            float* distances,
+            idx_t* labels) const override;
 
     // reconstruct is routed to the refine_index
-    void reconstruct (idx_t key, float * recons) const override;
+    void reconstruct(idx_t key, float* recons) const override;
 
     ~IndexRefine() override;
 };
 
-
 /** Version where the refinement index is an IndexFlat. It has one additional
  * constructor that takes a table of elements to add to the flat refinement
  * index */
-struct IndexRefineFlat: IndexRefine {
-    explicit IndexRefineFlat (Index *base_index);
-    IndexRefineFlat(Index *base_index, const float *xb);
+struct IndexRefineFlat : IndexRefine {
+    explicit IndexRefineFlat(Index* base_index);
+    IndexRefineFlat(Index* base_index, const float* xb);
 
     IndexRefineFlat();
 
     void search(
-        idx_t n, const float* x, idx_t k,
-        float* distances, idx_t* labels) const override;
-
+            idx_t n,
+            const float* x,
+            idx_t k,
+            float* distances,
+            idx_t* labels) const override;
 };
 
-
-
 } // namespace faiss

data/vendor/faiss/faiss/IndexReplicas.cpp

@@ -14,202 +14,196 @@ namespace faiss {
 
 template <typename IndexT>
 IndexReplicasTemplate<IndexT>::IndexReplicasTemplate(bool threaded)
-    : ThreadedIndex<IndexT>(threaded) {
-}
+        : ThreadedIndex<IndexT>(threaded) {}
 
 template <typename IndexT>
 IndexReplicasTemplate<IndexT>::IndexReplicasTemplate(idx_t d, bool threaded)
-    : ThreadedIndex<IndexT>(d, threaded) {
-}
+        : ThreadedIndex<IndexT>(d, threaded) {}
 
 template <typename IndexT>
 IndexReplicasTemplate<IndexT>::IndexReplicasTemplate(int d, bool threaded)
-    : ThreadedIndex<IndexT>(d, threaded) {
-}
+        : ThreadedIndex<IndexT>(d, threaded) {}
 
 template <typename IndexT>
-void
-IndexReplicasTemplate<IndexT>::onAfterAddIndex(IndexT* index) {
-  // Make sure that the parameters are the same for all prior indices, unless
-  // we're the first index to be added
-  if (this->count() > 0 && this->at(0) != index) {
-    auto existing = this->at(0);
-
-    FAISS_THROW_IF_NOT_FMT(index->ntotal == existing->ntotal,
-                           "IndexReplicas: newly added index does "
-                           "not have same number of vectors as prior index; "
-                           "prior index has %" PRId64 " vectors, new index has %" PRId64,
-                           existing->ntotal, index->ntotal);
-
-    FAISS_THROW_IF_NOT_MSG(index->is_trained == existing->is_trained,
-                           "IndexReplicas: newly added index does "
-                           "not have same train status as prior index");
-
-    FAISS_THROW_IF_NOT_MSG(index->d == existing->d,
-                           "IndexReplicas: newly added index does "
-                           "not have same dimension as prior index");
-  } else {
-    syncWithSubIndexes();
-  }
+void IndexReplicasTemplate<IndexT>::onAfterAddIndex(IndexT* index) {
+    // Make sure that the parameters are the same for all prior indices, unless
+    // we're the first index to be added
+    if (this->count() > 0 && this->at(0) != index) {
+        auto existing = this->at(0);
+
+        FAISS_THROW_IF_NOT_FMT(
+                index->ntotal == existing->ntotal,
+                "IndexReplicas: newly added index does "
+                "not have same number of vectors as prior index; "
+                "prior index has %" PRId64 " vectors, new index has %" PRId64,
+                existing->ntotal,
+                index->ntotal);
+
+        FAISS_THROW_IF_NOT_MSG(
+                index->is_trained == existing->is_trained,
+                "IndexReplicas: newly added index does "
+                "not have same train status as prior index");
+
+        FAISS_THROW_IF_NOT_MSG(
+                index->d == existing->d,
+                "IndexReplicas: newly added index does "
+                "not have same dimension as prior index");
+    } else {
+        syncWithSubIndexes();
+    }
 }
 
 template <typename IndexT>
-void
-IndexReplicasTemplate<IndexT>::onAfterRemoveIndex(IndexT* index) {
-  syncWithSubIndexes();
+void IndexReplicasTemplate<IndexT>::onAfterRemoveIndex(IndexT* index) {
+    syncWithSubIndexes();
 }
 
 template <typename IndexT>
-void
-IndexReplicasTemplate<IndexT>::train(idx_t n, const component_t* x) {
-  auto fn =
-    [n, x](int i, IndexT* index) {
-      if (index->verbose) {
-        printf("begin train replica %d on %" PRId64 " points\n", i, n);
-      }
-
-      index->train(n, x);
-
-      if (index->verbose) {
-        printf("end train replica %d\n", i);
-      }
+void IndexReplicasTemplate<IndexT>::train(idx_t n, const component_t* x) {
+    auto fn = [n, x](int i, IndexT* index) {
+        if (index->verbose) {
+            printf("begin train replica %d on %" PRId64 " points\n", i, n);
+        }
+
+        index->train(n, x);
+
+        if (index->verbose) {
+            printf("end train replica %d\n", i);
+        }
     };
 
-  this->runOnIndex(fn);
-  syncWithSubIndexes();
+    this->runOnIndex(fn);
+    syncWithSubIndexes();
 }
 
 template <typename IndexT>
-void
-IndexReplicasTemplate<IndexT>::add(idx_t n, const component_t* x) {
-  auto fn =
-    [n, x](int i, IndexT* index) {
-      if (index->verbose) {
-        printf("begin add replica %d on %" PRId64 " points\n", i, n);
-      }
-
-      index->add(n, x);
-
-      if (index->verbose) {
-        printf("end add replica %d\n", i);
-      }
+void IndexReplicasTemplate<IndexT>::add(idx_t n, const component_t* x) {
+    auto fn = [n, x](int i, IndexT* index) {
+        if (index->verbose) {
+            printf("begin add replica %d on %" PRId64 " points\n", i, n);
+        }
+
+        index->add(n, x);
+
+        if (index->verbose) {
+            printf("end add replica %d\n", i);
+        }
     };
 
-  this->runOnIndex(fn);
-  syncWithSubIndexes();
+    this->runOnIndex(fn);
+    syncWithSubIndexes();
 }
 
 template <typename IndexT>
-void
-IndexReplicasTemplate<IndexT>::reconstruct(idx_t n, component_t* x) const {
-  FAISS_THROW_IF_NOT_MSG(this->count() > 0, "no replicas in index");
+void IndexReplicasTemplate<IndexT>::reconstruct(idx_t n, component_t* x) const {
+    FAISS_THROW_IF_NOT_MSG(this->count() > 0, "no replicas in index");
 
-  // Just pass to the first replica
-  this->at(0)->reconstruct(n, x);
+    // Just pass to the first replica
+    this->at(0)->reconstruct(n, x);
 }
 
 template <typename IndexT>
-void
-IndexReplicasTemplate<IndexT>::search(idx_t n,
-                                      const component_t* x,
-                                      idx_t k,
-                                      distance_t* distances,
-                                      idx_t* labels) const {
-  FAISS_THROW_IF_NOT_MSG(this->count() > 0, "no replicas in index");
-
-  if (n == 0) {
-    return;
-  }
-
-  auto dim = this->d;
-  size_t componentsPerVec =
-    sizeof(component_t) == 1 ? (dim + 7) / 8 : dim;
-
-  // Partition the query by the number of indices we have
-  faiss::Index::idx_t queriesPerIndex =
-    (faiss::Index::idx_t) (n + this->count() - 1) /
-    (faiss::Index::idx_t) this->count();
-  FAISS_ASSERT(n / queriesPerIndex <= this->count());
-
-  auto fn =
-    [queriesPerIndex, componentsPerVec,
-     n, x, k, distances, labels](int i, const IndexT* index) {
-      faiss::Index::idx_t base = (faiss::Index::idx_t) i * queriesPerIndex;
-
-      if (base < n) {
-        auto numForIndex = std::min(queriesPerIndex, n - base);
-
-        if (index->verbose) {
-          printf("begin search replica %d on %" PRId64 " points\n",
-                 i, numForIndex);
-        }
-
-        index->search(numForIndex,
-                      x + base * componentsPerVec,
-                      k,
-                      distances + base * k,
-                      labels + base * k);
-
-        if (index->verbose) {
-          printf("end search replica %d\n", i);
+void IndexReplicasTemplate<IndexT>::search(
+        idx_t n,
+        const component_t* x,
+        idx_t k,
+        distance_t* distances,
+        idx_t* labels) const {
+    FAISS_THROW_IF_NOT(k > 0);
+
+    FAISS_THROW_IF_NOT_MSG(this->count() > 0, "no replicas in index");
+
+    if (n == 0) {
+        return;
+    }
+
+    auto dim = this->d;
+    size_t componentsPerVec = sizeof(component_t) == 1 ? (dim + 7) / 8 : dim;
+
+    // Partition the query by the number of indices we have
+    faiss::Index::idx_t queriesPerIndex =
+            (faiss::Index::idx_t)(n + this->count() - 1) /
+            (faiss::Index::idx_t)this->count();
+    FAISS_ASSERT(n / queriesPerIndex <= this->count());
+
+    auto fn = [queriesPerIndex, componentsPerVec, n, x, k, distances, labels](
+                      int i, const IndexT* index) {
+        faiss::Index::idx_t base = (faiss::Index::idx_t)i * queriesPerIndex;
+
+        if (base < n) {
+            auto numForIndex = std::min(queriesPerIndex, n - base);
+
+            if (index->verbose) {
+                printf("begin search replica %d on %" PRId64 " points\n",
+                       i,
+                       numForIndex);
+            }
+
+            index->search(
+                    numForIndex,
+                    x + base * componentsPerVec,
+                    k,
+                    distances + base * k,
+                    labels + base * k);
+
+            if (index->verbose) {
+                printf("end search replica %d\n", i);
+            }
         }
-      }
     };
 
-  this->runOnIndex(fn);
+    this->runOnIndex(fn);
 }
 
 // FIXME: assumes that nothing is currently running on the sub-indexes, which is
 // true with the normal API, but should use the runOnIndex API instead
 template <typename IndexT>
-void
-IndexReplicasTemplate<IndexT>::syncWithSubIndexes() {
-  if (!this->count()) {
-    this->is_trained = false;
-    this->ntotal = 0;
-
-    return;
-  }
-
-  auto firstIndex = this->at(0);
-  this->metric_type = firstIndex->metric_type;
-  this->is_trained = firstIndex->is_trained;
-  this->ntotal = firstIndex->ntotal;
-
-  for (int i = 1; i < this->count(); ++i) {
-    auto index = this->at(i);
-    FAISS_THROW_IF_NOT(this->metric_type == index->metric_type);
-    FAISS_THROW_IF_NOT(this->d == index->d);
-    FAISS_THROW_IF_NOT(this->is_trained == index->is_trained);
-    FAISS_THROW_IF_NOT(this->ntotal == index->ntotal);
-  }
+void IndexReplicasTemplate<IndexT>::syncWithSubIndexes() {
+    if (!this->count()) {
+        this->is_trained = false;
+        this->ntotal = 0;
+
+        return;
+    }
+
+    auto firstIndex = this->at(0);
+    this->metric_type = firstIndex->metric_type;
+    this->is_trained = firstIndex->is_trained;
+    this->ntotal = firstIndex->ntotal;
+
+    for (int i = 1; i < this->count(); ++i) {
+        auto index = this->at(i);
+        FAISS_THROW_IF_NOT(this->metric_type == index->metric_type);
+        FAISS_THROW_IF_NOT(this->d == index->d);
+        FAISS_THROW_IF_NOT(this->is_trained == index->is_trained);
+        FAISS_THROW_IF_NOT(this->ntotal == index->ntotal);
+    }
 }
 
 // No metric_type for IndexBinary
 template <>
-void
-IndexReplicasTemplate<IndexBinary>::syncWithSubIndexes() {
-  if (!this->count()) {
-    this->is_trained = false;
-    this->ntotal = 0;
-
-    return;
-  }
-
-  auto firstIndex = this->at(0);
-  this->is_trained = firstIndex->is_trained;
-  this->ntotal = firstIndex->ntotal;
-
-  for (int i = 1; i < this->count(); ++i) {
-    auto index = this->at(i);
-    FAISS_THROW_IF_NOT(this->d == index->d);
-    FAISS_THROW_IF_NOT(this->is_trained == index->is_trained);
-    FAISS_THROW_IF_NOT(this->ntotal == index->ntotal);
-  }
+void IndexReplicasTemplate<IndexBinary>::syncWithSubIndexes() {
+    if (!this->count()) {
+        this->is_trained = false;
+        this->ntotal = 0;
+
+        return;
+    }
+
+    auto firstIndex = this->at(0);
+    this->is_trained = firstIndex->is_trained;
+    this->ntotal = firstIndex->ntotal;
+
+    for (int i = 1; i < this->count(); ++i) {
+        auto index = this->at(i);
+        FAISS_THROW_IF_NOT(this->d == index->d);
+        FAISS_THROW_IF_NOT(this->is_trained == index->is_trained);
+        FAISS_THROW_IF_NOT(this->ntotal == index->ntotal);
+    }
 }
 
 // explicit instantiations
 template struct IndexReplicasTemplate<Index>;
 template struct IndexReplicasTemplate<IndexBinary>;
 
-} // namespace
+} // namespace faiss

data/vendor/faiss/faiss/IndexReplicas.h

@@ -19,64 +19,70 @@ namespace faiss {
 /// Each index is managed by a separate CPU thread.
 template <typename IndexT>
 class IndexReplicasTemplate : public ThreadedIndex<IndexT> {
- public:
-  using idx_t = typename IndexT::idx_t;
-  using component_t = typename IndexT::component_t;
-  using distance_t = typename IndexT::distance_t;
-
-  /// The dimension that all sub-indices must share will be the dimension of the
-  /// first sub-index added
-  /// @param threaded do we use one thread per sub-index or do queries
-  /// sequentially?
-  explicit IndexReplicasTemplate(bool threaded = true);
-
-  /// @param d the dimension that all sub-indices must share
-  /// @param threaded do we use one thread per sub index or do queries
-  /// sequentially?
-  explicit IndexReplicasTemplate(idx_t d, bool threaded = true);
-
-  /// int version due to the implicit bool conversion ambiguity of int as
-  /// dimension
-  explicit IndexReplicasTemplate(int d, bool threaded = true);
-
-  /// Alias for addIndex()
-  void add_replica(IndexT* index) { this->addIndex(index); }
-
-  /// Alias for removeIndex()
-  void remove_replica(IndexT* index) { this->removeIndex(index); }
-
-  /// faiss::Index API
-  /// All indices receive the same call
-  void train(idx_t n, const component_t* x) override;
-
-  /// faiss::Index API
-  /// All indices receive the same call
-  void add(idx_t n, const component_t* x) override;
-
-  /// faiss::Index API
-  /// Query is partitioned into a slice for each sub-index
-  /// split by ceil(n / #indices) for our sub-indices
-  void search(idx_t n,
-              const component_t* x,
-              idx_t k,
-              distance_t* distances,
-              idx_t* labels) const override;
-
-  /// reconstructs from the first index
-  void reconstruct(idx_t, component_t *v) const override;
-
-  /// Synchronize the top-level index (IndexShards) with data in the sub-indices
-  void syncWithSubIndexes();
-
- protected:
-  /// Called just after an index is added
-  void onAfterAddIndex(IndexT* index) override;
-
-  /// Called just after an index is removed
-  void onAfterRemoveIndex(IndexT* index) override;
+   public:
+    using idx_t = typename IndexT::idx_t;
+    using component_t = typename IndexT::component_t;
+    using distance_t = typename IndexT::distance_t;
+
+    /// The dimension that all sub-indices must share will be the dimension of
+    /// the first sub-index added
+    /// @param threaded do we use one thread per sub-index or do queries
+    /// sequentially?
+    explicit IndexReplicasTemplate(bool threaded = true);
+
+    /// @param d the dimension that all sub-indices must share
+    /// @param threaded do we use one thread per sub index or do queries
+    /// sequentially?
+    explicit IndexReplicasTemplate(idx_t d, bool threaded = true);
+
+    /// int version due to the implicit bool conversion ambiguity of int as
+    /// dimension
+    explicit IndexReplicasTemplate(int d, bool threaded = true);
+
+    /// Alias for addIndex()
+    void add_replica(IndexT* index) {
+        this->addIndex(index);
+    }
+
+    /// Alias for removeIndex()
+    void remove_replica(IndexT* index) {
+        this->removeIndex(index);
+    }
+
+    /// faiss::Index API
+    /// All indices receive the same call
+    void train(idx_t n, const component_t* x) override;
+
+    /// faiss::Index API
+    /// All indices receive the same call
+    void add(idx_t n, const component_t* x) override;
+
+    /// faiss::Index API
+    /// Query is partitioned into a slice for each sub-index
+    /// split by ceil(n / #indices) for our sub-indices
+    void search(
+            idx_t n,
+            const component_t* x,
+            idx_t k,
+            distance_t* distances,
+            idx_t* labels) const override;
+
+    /// reconstructs from the first index
+    void reconstruct(idx_t, component_t* v) const override;
+
+    /// Synchronize the top-level index (IndexShards) with data in the
+    /// sub-indices
+    void syncWithSubIndexes();
+
+   protected:
+    /// Called just after an index is added
+    void onAfterAddIndex(IndexT* index) override;
+
+    /// Called just after an index is removed
+    void onAfterRemoveIndex(IndexT* index) override;
 };
 
 using IndexReplicas = IndexReplicasTemplate<Index>;
 using IndexBinaryReplicas = IndexReplicasTemplate<IndexBinary>;
 
-} // namespace
+} // namespace faiss