faiss 0.2.0 → 0.2.1

data/vendor/faiss/faiss/gpu/GpuIndexFlat.h

@@ -5,7 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
 #pragma once
 
 #include <faiss/gpu/GpuIndex.h>
@@ -17,189 +16,201 @@ struct IndexFlat;
 struct IndexFlatL2;
 struct IndexFlatIP;
 
-}
+} // namespace faiss
 
-namespace faiss { namespace gpu {
+namespace faiss {
+namespace gpu {
 
 class FlatIndex;
 
 struct GpuIndexFlatConfig : public GpuIndexConfig {
-  inline GpuIndexFlatConfig()
-      : useFloat16(false),
-        storeTransposed(false) {
-  }
-
-  /// Whether or not data is stored as float16
-  bool useFloat16;
-
-  /// Whether or not data is stored (transparently) in a transposed
-  /// layout, enabling use of the NN GEMM call, which is ~10% faster.
-  /// This will improve the speed of the flat index, but will
-  /// substantially slow down any add() calls made, as all data must
-  /// be transposed, and will increase storage requirements (we store
-  /// data in both transposed and non-transposed layouts).
-  bool storeTransposed;
+    inline GpuIndexFlatConfig() : useFloat16(false), storeTransposed(false) {}
+
+    /// Whether or not data is stored as float16
+    bool useFloat16;
+
+    /// Whether or not data is stored (transparently) in a transposed
+    /// layout, enabling use of the NN GEMM call, which is ~10% faster.
+    /// This will improve the speed of the flat index, but will
+    /// substantially slow down any add() calls made, as all data must
+    /// be transposed, and will increase storage requirements (we store
+    /// data in both transposed and non-transposed layouts).
+    bool storeTransposed;
 };
 
 /// Wrapper around the GPU implementation that looks like
 /// faiss::IndexFlat; copies over centroid data from a given
 /// faiss::IndexFlat
 class GpuIndexFlat : public GpuIndex {
- public:
-  /// Construct from a pre-existing faiss::IndexFlat instance, copying
-  /// data over to the given GPU
-  GpuIndexFlat(GpuResourcesProvider* provider,
-               const faiss::IndexFlat* index,
-               GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  GpuIndexFlat(std::shared_ptr<GpuResources> resources,
-               const faiss::IndexFlat* index,
-               GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  /// Construct an empty instance that can be added to
-  GpuIndexFlat(GpuResourcesProvider* provider,
-               int dims,
-               faiss::MetricType metric,
-               GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  GpuIndexFlat(std::shared_ptr<GpuResources> resources,
-               int dims,
-               faiss::MetricType metric,
-               GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  ~GpuIndexFlat() override;
-
-  /// Initialize ourselves from the given CPU index; will overwrite
-  /// all data in ourselves
-  void copyFrom(const faiss::IndexFlat* index);
-
-  /// Copy ourselves to the given CPU index; will overwrite all data
-  /// in the index instance
-  void copyTo(faiss::IndexFlat* index) const;
-
-  /// Returns the number of vectors we contain
-  size_t getNumVecs() const;
-
-  /// Clears all vectors from this index
-  void reset() override;
-
-  /// This index is not trained, so this does nothing
-  void train(Index::idx_t n, const float* x) override;
-
-  /// Overrides to avoid excessive copies
-  void add(Index::idx_t, const float* x) override;
-
-  /// Reconstruction methods; prefer the batch reconstruct as it will
-  /// be more efficient
-  void reconstruct(Index::idx_t key, float* out) const override;
-
-  /// Batch reconstruction method
-  void reconstruct_n(Index::idx_t i0,
-                     Index::idx_t num,
-                     float* out) const override;
-
-  /// Compute residual
-  void compute_residual(const float* x,
-                        float* residual,
-                        Index::idx_t key) const override;
-
-  /// Compute residual (batch mode)
-  void compute_residual_n(Index::idx_t n,
-                          const float* xs,
-                          float* residuals,
-                          const Index::idx_t* keys) const override;
-
-  /// For internal access
-  inline FlatIndex* getGpuData() { return data_.get(); }
-
- protected:
-  /// Flat index does not require IDs as there is no storage available for them
-  bool addImplRequiresIDs_() const override;
-
-  /// Called from GpuIndex for add
-  void addImpl_(int n,
-                const float* x,
-                const Index::idx_t* ids) override;
-
-  /// Called from GpuIndex for search
-  void searchImpl_(int n,
-                   const float* x,
-                   int k,
-                   float* distances,
-                   Index::idx_t* labels) const override;
-
- protected:
-  /// Our configuration options
-  const GpuIndexFlatConfig flatConfig_;
-
-  /// Holds our GPU data containing the list of vectors
-  std::unique_ptr<FlatIndex> data_;
+   public:
+    /// Construct from a pre-existing faiss::IndexFlat instance, copying
+    /// data over to the given GPU
+    GpuIndexFlat(
+            GpuResourcesProvider* provider,
+            const faiss::IndexFlat* index,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    GpuIndexFlat(
+            std::shared_ptr<GpuResources> resources,
+            const faiss::IndexFlat* index,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    /// Construct an empty instance that can be added to
+    GpuIndexFlat(
+            GpuResourcesProvider* provider,
+            int dims,
+            faiss::MetricType metric,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    GpuIndexFlat(
+            std::shared_ptr<GpuResources> resources,
+            int dims,
+            faiss::MetricType metric,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    ~GpuIndexFlat() override;
+
+    /// Initialize ourselves from the given CPU index; will overwrite
+    /// all data in ourselves
+    void copyFrom(const faiss::IndexFlat* index);
+
+    /// Copy ourselves to the given CPU index; will overwrite all data
+    /// in the index instance
+    void copyTo(faiss::IndexFlat* index) const;
+
+    /// Returns the number of vectors we contain
+    size_t getNumVecs() const;
+
+    /// Clears all vectors from this index
+    void reset() override;
+
+    /// This index is not trained, so this does nothing
+    void train(Index::idx_t n, const float* x) override;
+
+    /// Overrides to avoid excessive copies
+    void add(Index::idx_t, const float* x) override;
+
+    /// Reconstruction methods; prefer the batch reconstruct as it will
+    /// be more efficient
+    void reconstruct(Index::idx_t key, float* out) const override;
+
+    /// Batch reconstruction method
+    void reconstruct_n(Index::idx_t i0, Index::idx_t num, float* out)
+            const override;
+
+    /// Compute residual
+    void compute_residual(const float* x, float* residual, Index::idx_t key)
+            const override;
+
+    /// Compute residual (batch mode)
+    void compute_residual_n(
+            Index::idx_t n,
+            const float* xs,
+            float* residuals,
+            const Index::idx_t* keys) const override;
+
+    /// For internal access
+    inline FlatIndex* getGpuData() {
+        return data_.get();
+    }
+
+   protected:
+    /// Flat index does not require IDs as there is no storage available for
+    /// them
+    bool addImplRequiresIDs_() const override;
+
+    /// Called from GpuIndex for add
+    void addImpl_(int n, const float* x, const Index::idx_t* ids) override;
+
+    /// Called from GpuIndex for search
+    void searchImpl_(
+            int n,
+            const float* x,
+            int k,
+            float* distances,
+            Index::idx_t* labels) const override;
+
+   protected:
+    /// Our configuration options
+    const GpuIndexFlatConfig flatConfig_;
+
+    /// Holds our GPU data containing the list of vectors
+    std::unique_ptr<FlatIndex> data_;
 };
 
 /// Wrapper around the GPU implementation that looks like
 /// faiss::IndexFlatL2; copies over centroid data from a given
 /// faiss::IndexFlat
 class GpuIndexFlatL2 : public GpuIndexFlat {
- public:
-  /// Construct from a pre-existing faiss::IndexFlatL2 instance, copying
-  /// data over to the given GPU
-  GpuIndexFlatL2(GpuResourcesProvider* provider,
-                 faiss::IndexFlatL2* index,
-                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  GpuIndexFlatL2(std::shared_ptr<GpuResources> resources,
-                 faiss::IndexFlatL2* index,
-                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  /// Construct an empty instance that can be added to
-  GpuIndexFlatL2(GpuResourcesProvider* provider,
-                 int dims,
-                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  GpuIndexFlatL2(std::shared_ptr<GpuResources> resources,
-                 int dims,
-                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  /// Initialize ourselves from the given CPU index; will overwrite
-  /// all data in ourselves
-  void copyFrom(faiss::IndexFlat* index);
-
-  /// Copy ourselves to the given CPU index; will overwrite all data
-  /// in the index instance
-  void copyTo(faiss::IndexFlat* index);
+   public:
+    /// Construct from a pre-existing faiss::IndexFlatL2 instance, copying
+    /// data over to the given GPU
+    GpuIndexFlatL2(
+            GpuResourcesProvider* provider,
+            faiss::IndexFlatL2* index,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    GpuIndexFlatL2(
+            std::shared_ptr<GpuResources> resources,
+            faiss::IndexFlatL2* index,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    /// Construct an empty instance that can be added to
+    GpuIndexFlatL2(
+            GpuResourcesProvider* provider,
+            int dims,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    GpuIndexFlatL2(
+            std::shared_ptr<GpuResources> resources,
+            int dims,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    /// Initialize ourselves from the given CPU index; will overwrite
+    /// all data in ourselves
+    void copyFrom(faiss::IndexFlat* index);
+
+    /// Copy ourselves to the given CPU index; will overwrite all data
+    /// in the index instance
+    void copyTo(faiss::IndexFlat* index);
 };
 
 /// Wrapper around the GPU implementation that looks like
 /// faiss::IndexFlatIP; copies over centroid data from a given
 /// faiss::IndexFlat
 class GpuIndexFlatIP : public GpuIndexFlat {
- public:
-  /// Construct from a pre-existing faiss::IndexFlatIP instance, copying
-  /// data over to the given GPU
-  GpuIndexFlatIP(GpuResourcesProvider* provider,
-                 faiss::IndexFlatIP* index,
-                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  GpuIndexFlatIP(std::shared_ptr<GpuResources> resources,
-                 faiss::IndexFlatIP* index,
-                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  /// Construct an empty instance that can be added to
-  GpuIndexFlatIP(GpuResourcesProvider* provider,
-                 int dims,
-                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  GpuIndexFlatIP(std::shared_ptr<GpuResources> resources,
-                 int dims,
-                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
-
-  /// Initialize ourselves from the given CPU index; will overwrite
-  /// all data in ourselves
-  void copyFrom(faiss::IndexFlat* index);
-
-  /// Copy ourselves to the given CPU index; will overwrite all data
-  /// in the index instance
-  void copyTo(faiss::IndexFlat* index);
+   public:
+    /// Construct from a pre-existing faiss::IndexFlatIP instance, copying
+    /// data over to the given GPU
+    GpuIndexFlatIP(
+            GpuResourcesProvider* provider,
+            faiss::IndexFlatIP* index,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    GpuIndexFlatIP(
+            std::shared_ptr<GpuResources> resources,
+            faiss::IndexFlatIP* index,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    /// Construct an empty instance that can be added to
+    GpuIndexFlatIP(
+            GpuResourcesProvider* provider,
+            int dims,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    GpuIndexFlatIP(
+            std::shared_ptr<GpuResources> resources,
+            int dims,
+            GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+    /// Initialize ourselves from the given CPU index; will overwrite
+    /// all data in ourselves
+    void copyFrom(faiss::IndexFlat* index);
+
+    /// Copy ourselves to the given CPU index; will overwrite all data
+    /// in the index instance
+    void copyTo(faiss::IndexFlat* index);
 };
 
-} } // namespace
+} // namespace gpu
+} // namespace faiss

data/vendor/faiss/faiss/gpu/GpuIndexIVF.h

@@ -5,102 +5,105 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
 #pragma once
 
+#include <faiss/Clustering.h>
 #include <faiss/gpu/GpuIndex.h>
 #include <faiss/gpu/GpuIndexFlat.h>
 #include <faiss/gpu/GpuIndicesOptions.h>
-#include <faiss/Clustering.h>
 
-namespace faiss { struct IndexIVF; }
+namespace faiss {
+struct IndexIVF;
+}
 
-namespace faiss { namespace gpu {
+namespace faiss {
+namespace gpu {
 
 class GpuIndexFlat;
 
 struct GpuIndexIVFConfig : public GpuIndexConfig {
-  inline GpuIndexIVFConfig()
-      : indicesOptions(INDICES_64_BIT) {
-  }
+    inline GpuIndexIVFConfig() : indicesOptions(INDICES_64_BIT) {}
 
-  /// Index storage options for the GPU
-  IndicesOptions indicesOptions;
+    /// Index storage options for the GPU
+    IndicesOptions indicesOptions;
 
-  /// Configuration for the coarse quantizer object
-  GpuIndexFlatConfig flatConfig;
+    /// Configuration for the coarse quantizer object
+    GpuIndexFlatConfig flatConfig;
 };
 
 class GpuIndexIVF : public GpuIndex {
- public:
-  GpuIndexIVF(GpuResourcesProvider* provider,
-              int dims,
-              faiss::MetricType metric,
-              float metricArg,
-              int nlist,
-              GpuIndexIVFConfig config = GpuIndexIVFConfig());
+   public:
+    GpuIndexIVF(
+            GpuResourcesProvider* provider,
+            int dims,
+            faiss::MetricType metric,
+            float metricArg,
+            int nlist,
+            GpuIndexIVFConfig config = GpuIndexIVFConfig());
 
-  ~GpuIndexIVF() override;
+    ~GpuIndexIVF() override;
 
- private:
-  /// Shared initialization functions
-  void init_();
+   private:
+    /// Shared initialization functions
+    void init_();
 
- public:
-  /// Copy what we need from the CPU equivalent
-  void copyFrom(const faiss::IndexIVF* index);
+   public:
+    /// Copy what we need from the CPU equivalent
+    void copyFrom(const faiss::IndexIVF* index);
 
-  /// Copy what we have to the CPU equivalent
-  void copyTo(faiss::IndexIVF* index) const;
+    /// Copy what we have to the CPU equivalent
+    void copyTo(faiss::IndexIVF* index) const;
 
-  /// Returns the number of inverted lists we're managing
-  int getNumLists() const;
+    /// Returns the number of inverted lists we're managing
+    int getNumLists() const;
 
-  /// Returns the number of vectors present in a particular inverted list
-  virtual int getListLength(int listId) const = 0;
+    /// Returns the number of vectors present in a particular inverted list
+    virtual int getListLength(int listId) const = 0;
 
-  /// Return the encoded vector data contained in a particular inverted list,
-  /// for debugging purposes.
-  /// If gpuFormat is true, the data is returned as it is encoded in the
-  /// GPU-side representation.
-  /// Otherwise, it is converted to the CPU format.
-  /// compliant format, while the native GPU format may differ.
-  virtual std::vector<uint8_t>
-  getListVectorData(int listId, bool gpuFormat = false) const = 0;
+    /// Return the encoded vector data contained in a particular inverted list,
+    /// for debugging purposes.
+    /// If gpuFormat is true, the data is returned as it is encoded in the
+    /// GPU-side representation.
+    /// Otherwise, it is converted to the CPU format.
+    /// compliant format, while the native GPU format may differ.
+    virtual std::vector<uint8_t> getListVectorData(
+            int listId,
+            bool gpuFormat = false) const = 0;
 
-  /// Return the vector indices contained in a particular inverted list, for
-  /// debugging purposes.
-  virtual std::vector<Index::idx_t> getListIndices(int listId) const = 0;
+    /// Return the vector indices contained in a particular inverted list, for
+    /// debugging purposes.
+    virtual std::vector<Index::idx_t> getListIndices(int listId) const = 0;
 
-  /// Return the quantizer we're using
-  GpuIndexFlat* getQuantizer();
+    /// Return the quantizer we're using
+    GpuIndexFlat* getQuantizer();
 
-  /// Sets the number of list probes per query
-  void setNumProbes(int nprobe);
+    /// Sets the number of list probes per query
+    void setNumProbes(int nprobe);
 
-  /// Returns our current number of list probes per query
-  int getNumProbes() const;
+    /// Returns our current number of list probes per query
+    int getNumProbes() const;
 
- protected:
-  bool addImplRequiresIDs_() const override;
-  void trainQuantizer_(Index::idx_t n, const float* x);
+   protected:
+    bool addImplRequiresIDs_() const override;
+    void trainQuantizer_(Index::idx_t n, const float* x);
 
- public:
-  /// Exposing this like the CPU version for manipulation
-  ClusteringParameters cp;
+   public:
+    /// Exposing this like the CPU version for manipulation
+    ClusteringParameters cp;
 
-  /// Exposing this like the CPU version for query
-  int nlist;
+    /// Exposing this like the CPU version for query
+    int nlist;
 
-  /// Exposing this like the CPU version for manipulation
-  int nprobe;
+    /// Exposing this like the CPU version for manipulation
+    int nprobe;
 
-  /// Exposeing this like the CPU version for query
-  GpuIndexFlat* quantizer;
+    /// Exposeing this like the CPU version for query
+    GpuIndexFlat* quantizer;
 
- protected:
-  /// Our configuration options
-  const GpuIndexIVFConfig ivfConfig_;
+   protected:
+    /// Our configuration options
+    const GpuIndexIVFConfig ivfConfig_;
 };
 
-} } // namespace
+} // namespace gpu
+} // namespace faiss