faiss 0.1.4 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4541b0c40468723a8bed3db80d5778fb156afa999cbbd14b83653285b3ae6267
-  data.tar.gz: 2beeacbad82a578e2a410938bc4447d73699ef3998c146b4309e4b44816f5e33
+  metadata.gz: 6ee0d4a001e68d64f406740bab3bb62f8f2813f8f58e6c9ea93261514cfaec47
+  data.tar.gz: a5ddc48f022b0d9b72499766af6f3eaa52c4a36cb2a21d72b333654795539799
 SHA512:
-  metadata.gz: 92d87492ff627e094ef29a48c8e4579dd976846ec9a95d94c45b816391dcea332d370a5fbde9c3f2bdc11964e061557d0e150b223ab6ac0209c092f1e1cd4a6e
-  data.tar.gz: 86fc2aaf3151545f24128429cf1369074809f8449f277a2676e9dacea76c156191b3d6df6df83f0d7ac0f061bfdf537b81ef57f6cbbb861e4ba4b592d06e8ca2
+  metadata.gz: 242636e52ae8fb025cf212fd41e3d27c06d17e05eb59469dd400ab8cf5412e61a1b88d582e0ea188985f3281a90eac0dd2b0ecbefb957864600cda22d9b3900a
+  data.tar.gz: 503c4da4a25fa905ef108e564ac715030aa9d10f2df5b1b80a35da99020c11eda3b8ed4ab067324f0d2029b0b90e7ce65d330343ee49d6761c4d98b0fb27655e

data/CHANGELOG.md

@@ -1,4 +1,29 @@
-## 0.1.4 (2020-02-04)
+## 0.2.1 (2021-06-07)
+
+- Updated Faiss to 1.7.1
+
+## 0.2.0 (2021-05-23)
+
+- Improved performance
+- Updated to Rice 4
+- Dropped support for Ruby < 2.6
+
+## 0.1.7 (2021-03-26)
+
+- Added `IndexScalarQuantizer` and `IndexIVFScalarQuantizer`
+
+## 0.1.6 (2021-03-21)
+
+- Added support for inner product to `IndexIVFFlat` and `IndexIVFPQ`
+- Added `ParameterSpace`
+- Added `nprobe=` method
+
+## 0.1.5 (2021-03-14)
+
+- Added `--with-optflags` option
+- Added support for inner product to `IndexHNSWFlat`
+
+## 0.1.4 (2021-02-04)
 
 - Updated Faiss to 1.7.0
 

data/README.md

@@ -24,7 +24,7 @@ Add this line to your application’s Gemfile:
 gem 'faiss'
 ```
 
-Faiss is not available for Windows
+It can take a few minutes to compile the gem. Faiss is not available for Windows.
 
 ## Getting Started
 
@@ -97,12 +97,24 @@ Locality-sensitive hashing
 Faiss::IndexLSH.new(d, nbits)
 ```
 
+Scalar quantizer (SQ) in flat mode
+
+```rb
+Faiss::IndexScalarQuantizer.new(d, qtype)
+```
+
 Product quantizer (PQ) in flat mode
 
 ```rb
 Faiss::IndexPQ.new(d, m, nbits)
 ```
 
+IVF and scalar quantizer
+
+```rb
+Faiss::IndexIVFScalarQuantizer.new(quantizer, d, nlists, qtype)
+```
+
 IVFADC (coarse quantizer+PQ on residuals)
 
 ```rb
@@ -200,10 +212,10 @@ Data can be an array of arrays
 [[1, 2, 3], [4, 5, 6]]
 ```
 
-Or a Numo NArray
+Or a Numo array
 
 ```ruby
-Numo::SFloat.new(3, 2).seq
+Numo::NArray.cast([[1, 2, 3], [4, 5, 6]])
 ```
 
 ## History

data/ext/faiss/ext.cpp

@@ -1,315 +1,19 @@
-#include <faiss/IndexFlat.h>
-#include <faiss/IndexHNSW.h>
-#include <faiss/IndexIVFFlat.h>
-#include <faiss/IndexLSH.h>
-#include <faiss/IndexScalarQuantizer.h>
-#include <faiss/IndexPQ.h>
-#include <faiss/IndexIVFPQ.h>
-#include <faiss/IndexIVFPQR.h>
+#include "utils.h"
 
-#include <faiss/IndexBinaryFlat.h>
-#include <faiss/IndexBinaryIVF.h>
-#include <faiss/index_factory.h>
-#include <faiss/index_io.h>
-
-#include <faiss/Clustering.h>
-#include <faiss/VectorTransform.h>
-
-#include <rice/Array.hpp>
-#include <rice/Class.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
-
-float* float_array(Rice::Object o)
-{
-  Rice::String s = o.call("to_binary");
-  return (float*) s.c_str();
-}
-
-uint8_t* uint8_array(Rice::Object o)
-{
-  Rice::String s = o.call("to_binary");
-  return (uint8_t*) s.c_str();
-}
-
-// TODO return Numo::SFloat
-Rice::String result(float* ptr, int64_t length)
-{
-  return Rice::String(std::string((char*) ptr, length * sizeof(float)));
-}
-
-// TODO return Numo::UInt8
-Rice::String result(uint8_t* ptr, int64_t length)
-{
-  return Rice::String(std::string((char*) ptr, length * sizeof(uint8_t)));
-}
-
-// TODO return Numo::Int32
-Rice::String result(int32_t* ptr, int64_t length)
-{
-  return Rice::String(std::string((char*) ptr, length * sizeof(int32_t)));
-}
-
-// TODO return Numo::Int64
-Rice::String result(int64_t* ptr, int64_t length)
-{
-  return Rice::String(std::string((char*) ptr, length * sizeof(int64_t)));
-}
+void init_index(Rice::Module& m);
+void init_index_binary(Rice::Module& m);
+void init_kmeans(Rice::Module& m);
+void init_pca_matrix(Rice::Module& m);
+void init_product_quantizer(Rice::Module& m);
 
 extern "C"
 void Init_ext()
 {
-  Rice::Module rb_mFaiss = Rice::define_module("Faiss")
-    .define_singleton_method(
-      "index_binary_factory",
-      *[](int d, const char *description) {
-        return faiss::index_binary_factory(d, description);
-      });
-
-  Rice::define_class_under<faiss::Index>(rb_mFaiss, "Index")
-    .define_method(
-      "d",
-      *[](faiss::Index &self) {
-        return self.d;
-      })
-    .define_method(
-      "trained?",
-      *[](faiss::Index &self) {
-        return self.is_trained;
-      })
-    .define_method(
-      "ntotal",
-      *[](faiss::Index &self) {
-        return self.ntotal;
-      })
-    .define_method(
-      "_train",
-      *[](faiss::Index &self, int64_t n, Rice::Object o) {
-        const float *x = float_array(o);
-        self.train(n, x);
-      })
-    .define_method(
-      "_add",
-      *[](faiss::Index &self, int64_t n, Rice::Object o) {
-        const float *x = float_array(o);
-        self.add(n, x);
-      })
-    .define_method(
-      "_search",
-      *[](faiss::Index &self, int64_t n, Rice::Object o, int64_t k) {
-        const float *x = float_array(o);
-        float *distances = new float[k * n];
-        int64_t *labels = new int64_t[k * n];
-
-        self.search(n, x, k, distances, labels);
-
-        auto dstr = result(distances, k * n);
-        auto lstr = result(labels, k * n);
-
-        Rice::Array ret;
-        ret.push(dstr);
-        ret.push(lstr);
-        return ret;
-      })
-    .define_method(
-      "save",
-      *[](faiss::Index &self, const char *fname) {
-        faiss::write_index(&self, fname);
-      })
-    .define_singleton_method(
-      "load",
-      *[](const char *fname) {
-        return faiss::read_index(fname);
-      });
-
-  Rice::define_class_under<faiss::IndexBinary>(rb_mFaiss, "IndexBinary")
-    .define_method(
-      "d",
-      *[](faiss::Index &self) {
-        return self.d;
-      })
-    .define_method(
-      "trained?",
-      *[](faiss::IndexBinary &self) {
-        return self.is_trained;
-      })
-    .define_method(
-      "ntotal",
-      *[](faiss::IndexBinary &self) {
-        return self.ntotal;
-      })
-    .define_method(
-      "_train",
-      *[](faiss::IndexBinary &self, int64_t n, Rice::Object o) {
-        const uint8_t *x = uint8_array(o);
-        self.train(n, x);
-      })
-    .define_method(
-      "_add",
-      *[](faiss::IndexBinary &self, int64_t n, Rice::Object o) {
-        const uint8_t *x = uint8_array(o);
-        self.add(n, x);
-      })
-    .define_method(
-      "_search",
-      *[](faiss::IndexBinary &self, int64_t n, Rice::Object o, int64_t k) {
-        const uint8_t *x = uint8_array(o);
-        int32_t *distances = new int32_t[k * n];
-        int64_t *labels = new int64_t[k * n];
-
-        self.search(n, x, k, distances, labels);
-
-        auto dstr = result(distances, k * n);
-        auto lstr = result(labels, k * n);
-
-        Rice::Array ret;
-        ret.push(dstr);
-        ret.push(lstr);
-        return ret;
-      })
-    .define_method(
-      "save",
-      *[](faiss::IndexBinary &self, const char *fname) {
-        faiss::write_index_binary(&self, fname);
-      })
-    .define_singleton_method(
-      "load",
-      *[](const char *fname) {
-        return faiss::read_index_binary(fname);
-      });
-
-  Rice::define_class_under<faiss::IndexFlatL2, faiss::Index>(rb_mFaiss, "IndexFlatL2")
-    .define_constructor(Rice::Constructor<faiss::IndexFlatL2, int64_t>());
-
-  Rice::define_class_under<faiss::IndexFlatIP, faiss::Index>(rb_mFaiss, "IndexFlatIP")
-    .define_constructor(Rice::Constructor<faiss::IndexFlatIP, int64_t>());
-
-  Rice::define_class_under<faiss::IndexHNSWFlat, faiss::Index>(rb_mFaiss, "IndexHNSWFlat")
-    .define_constructor(Rice::Constructor<faiss::IndexHNSWFlat, int, int>());
-
-  Rice::define_class_under<faiss::IndexIVFFlat, faiss::Index>(rb_mFaiss, "IndexIVFFlat")
-    .define_constructor(Rice::Constructor<faiss::IndexIVFFlat, faiss::Index*, size_t, size_t>());
-
-  Rice::define_class_under<faiss::IndexLSH, faiss::Index>(rb_mFaiss, "IndexLSH")
-    .define_constructor(Rice::Constructor<faiss::IndexLSH, int64_t, int>());
-
-  Rice::define_class_under<faiss::IndexScalarQuantizer, faiss::Index>(rb_mFaiss, "IndexScalarQuantizer")
-    .define_constructor(Rice::Constructor<faiss::IndexScalarQuantizer, int, faiss::ScalarQuantizer::QuantizerType>());
-
-  Rice::define_class_under<faiss::IndexPQ, faiss::Index>(rb_mFaiss, "IndexPQ")
-    .define_constructor(Rice::Constructor<faiss::IndexPQ, int, size_t, size_t>());
-
-  Rice::define_class_under<faiss::IndexIVFScalarQuantizer, faiss::Index>(rb_mFaiss, "IndexIVFScalarQuantizer")
-    .define_constructor(Rice::Constructor<faiss::IndexIVFScalarQuantizer, faiss::Index*, size_t, size_t, faiss::ScalarQuantizer::QuantizerType>());
-
-  Rice::define_class_under<faiss::IndexIVFPQ, faiss::Index>(rb_mFaiss, "IndexIVFPQ")
-    .define_constructor(Rice::Constructor<faiss::IndexIVFPQ, faiss::Index*, size_t, size_t, size_t, size_t>());
-
-  Rice::define_class_under<faiss::IndexIVFPQR, faiss::Index>(rb_mFaiss, "IndexIVFPQR")
-    .define_constructor(Rice::Constructor<faiss::IndexIVFPQR, faiss::Index*, size_t, size_t, size_t, size_t, size_t, size_t>());
-
-  Rice::define_class_under<faiss::IndexBinaryFlat, faiss::IndexBinary>(rb_mFaiss, "IndexBinaryFlat")
-    .define_constructor(Rice::Constructor<faiss::IndexBinaryFlat, int64_t>());
-
-  Rice::define_class_under<faiss::IndexBinaryIVF, faiss::IndexBinary>(rb_mFaiss, "IndexBinaryIVF")
-    .define_constructor(Rice::Constructor<faiss::IndexBinaryIVF, faiss::IndexBinary*, size_t, size_t>());
-
-  Rice::define_class_under<faiss::Clustering>(rb_mFaiss, "Kmeans")
-    .define_constructor(Rice::Constructor<faiss::Clustering, int, int>())
-    .define_method(
-      "d",
-      *[](faiss::Clustering &self) {
-        return self.d;
-      })
-    .define_method(
-      "k",
-      *[](faiss::Clustering &self) {
-        return self.k;
-      })
-    .define_method(
-      "_centroids",
-      *[](faiss::Clustering &self) {
-        float *centroids = new float[self.k * self.d];
-        for (size_t i = 0; i < self.centroids.size(); i++) {
-          centroids[i] = self.centroids[i];
-        }
-        return result(centroids, self.k * self.d);
-      })
-    .define_method(
-      "_train",
-      *[](faiss::Clustering &self, int64_t n, Rice::Object o, faiss::Index & index) {
-        const float *x = float_array(o);
-        self.train(n, x, index);
-      });
-
-  Rice::define_class_under<faiss::PCAMatrix>(rb_mFaiss, "PCAMatrix")
-    .define_constructor(Rice::Constructor<faiss::PCAMatrix, int, int>())
-    .define_method(
-      "d_in",
-      *[](faiss::PCAMatrix &self) {
-        return self.d_in;
-      })
-    .define_method(
-      "d_out",
-      *[](faiss::PCAMatrix &self) {
-        return self.d_out;
-      })
-    .define_method(
-      "_train",
-      *[](faiss::PCAMatrix &self, int64_t n, Rice::Object o) {
-        const float *x = float_array(o);
-        self.train(n, x);
-      })
-    .define_method(
-      "_apply",
-      *[](faiss::PCAMatrix &self, int64_t n, Rice::Object o) {
-        const float *x = float_array(o);
-        float* res = self.apply(n, x);
-        return result(res, n * self.d_out);
-      });
+  auto m = Rice::define_module("Faiss");
 
-  Rice::define_class_under<faiss::ProductQuantizer>(rb_mFaiss, "ProductQuantizer")
-    .define_constructor(Rice::Constructor<faiss::ProductQuantizer, size_t, size_t, size_t>())
-    .define_method(
-      "d",
-      *[](faiss::ProductQuantizer &self) {
-        return self.d;
-      })
-    .define_method(
-      "m",
-      *[](faiss::ProductQuantizer &self) {
-        return self.M;
-      })
-    .define_method(
-      "_train",
-      *[](faiss::ProductQuantizer &self, int n, Rice::Object o) {
-        const float *x = float_array(o);
-        self.train(n, x);
-      })
-    .define_method(
-      "_compute_codes",
-      *[](faiss::ProductQuantizer &self, int n, Rice::Object o) {
-        const float *x = float_array(o);
-        uint8_t *codes = new uint8_t[n * self.M];
-        self.compute_codes(x, codes, n);
-        return result(codes, n * self.M);
-      })
-    .define_method(
-      "_decode",
-      *[](faiss::ProductQuantizer &self, int n, Rice::Object o) {
-        const uint8_t *codes = uint8_array(o);
-        float *x = new float[n * self.d];
-        self.decode(codes, x, n);
-        return result(x, n * self.d);
-      })
-    .define_method(
-      "save",
-      *[](faiss::ProductQuantizer &self, const char *fname) {
-        faiss::write_ProductQuantizer(&self, fname);
-      })
-    .define_singleton_method(
-      "load",
-      *[](const char *fname) {
-        return faiss::read_ProductQuantizer(fname);
-      });
+  init_index(m);
+  init_index_binary(m);
+  init_kmeans(m);
+  init_pca_matrix(m);
+  init_product_quantizer(m);
 }

data/ext/faiss/extconf.rb

@@ -4,14 +4,17 @@ abort "BLAS not found" unless have_library("blas")
 abort "LAPACK not found" unless have_library("lapack")
 abort "OpenMP not found" unless have_library("omp") || have_library("gomp")
 
-$CXXFLAGS << " -std=c++11 -march=native -DFINTEGER=int"
+numo = $LOAD_PATH.find { |v| File.exist?("#{v}/numo/numo/narray.h") }
+abort "Numo not found" unless numo && find_header("numo/narray.h", "#{numo}/numo")
+
+$CXXFLAGS << " -std=c++17 $(optflags) -DFINTEGER=int " << with_config("optflags", "-march=native")
 
 ext = File.expand_path(".", __dir__)
 vendor = File.expand_path("../../vendor/faiss", __dir__)
 
 $srcs = Dir["{#{ext},#{vendor}/faiss,#{vendor}/faiss/{impl,invlists,utils}}/*.{cpp}"]
 $objs = $srcs.map { |v| v.sub(/cpp\z/, "o") }
-$INCFLAGS << " -I#{vendor}"
+abort "Faiss not found" unless find_header("faiss/Index.h", vendor)
 $VPATH << vendor
 
 create_makefile("faiss/ext")

data/ext/faiss/index.cpp

@@ -0,0 +1,189 @@
+#include <faiss/Index.h>
+#include <faiss/IndexFlat.h>
+#include <faiss/IndexHNSW.h>
+#include <faiss/IndexIVFFlat.h>
+#include <faiss/IndexLSH.h>
+#include <faiss/IndexScalarQuantizer.h>
+#include <faiss/IndexPQ.h>
+#include <faiss/IndexIVFPQ.h>
+#include <faiss/IndexIVFPQR.h>
+#include <faiss/index_io.h>
+#include <faiss/AutoTune.h>
+
+#include "utils.h"
+
+namespace Rice::detail {
+  template<>
+  struct Type<faiss::MetricType>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<faiss::MetricType>
+  {
+  public:
+    From_Ruby() = default;
+
+    From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    faiss::MetricType convert(VALUE x)
+    {
+      if (x == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
+        return this->arg_->defaultValue<faiss::MetricType>();
+      }
+
+      auto s = Object(x).to_s().str();
+      if (s == "inner_product") {
+        return faiss::METRIC_INNER_PRODUCT;
+      } else if (s == "l2") {
+        return faiss::METRIC_L2;
+      } else {
+        throw Rice::Exception(rb_eArgError, "Invalid metric: %s", s.c_str());
+      }
+    }
+
+  private:
+    Arg* arg_;
+  };
+
+  template<>
+  struct Type<faiss::ScalarQuantizer::QuantizerType>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<faiss::ScalarQuantizer::QuantizerType>
+  {
+  public:
+    faiss::ScalarQuantizer::QuantizerType convert(VALUE x)
+    {
+      auto s = Object(x).to_s().str();
+      if (s == "qt_8bit") {
+        return faiss::ScalarQuantizer::QT_8bit;
+      } else if (s == "qt_4bit") {
+        return faiss::ScalarQuantizer::QT_4bit;
+      } else if (s == "qt_8bit_uniform") {
+        return faiss::ScalarQuantizer::QT_8bit_uniform;
+      } else if (s == "qt_4bit_uniform") {
+        return faiss::ScalarQuantizer::QT_4bit_uniform;
+      } else if (s == "qt_fp16") {
+        return faiss::ScalarQuantizer::QT_fp16;
+      } else if (s == "qt_8bit_direct") {
+        return faiss::ScalarQuantizer::QT_8bit_direct;
+      } else if (s == "qt_6bit") {
+        return faiss::ScalarQuantizer::QT_6bit;
+      } else {
+        throw Rice::Exception(rb_eArgError, "Invalid quantizer type: %s", s.c_str());
+      }
+    }
+  };
+}
+
+void init_index(Rice::Module& m) {
+  Rice::define_class_under<faiss::Index>(m, "Index")
+    .define_method(
+      "d",
+      [](faiss::Index &self) {
+        return self.d;
+      })
+    .define_method(
+      "trained?",
+      [](faiss::Index &self) {
+        return self.is_trained;
+      })
+    .define_method(
+      "ntotal",
+      [](faiss::Index &self) {
+        return self.ntotal;
+      })
+    .define_method(
+      "train",
+      [](faiss::Index &self, numo::SFloat objects) {
+        auto n = check_shape(objects, self.d);
+        self.train(n, objects.read_ptr());
+      })
+    .define_method(
+      "add",
+      [](faiss::Index &self, numo::SFloat objects) {
+        auto n = check_shape(objects, self.d);
+        self.add(n, objects.read_ptr());
+      })
+    .define_method(
+      "search",
+      [](faiss::Index &self, numo::SFloat objects, size_t k) {
+        auto n = check_shape(objects, self.d);
+
+        auto distances = numo::SFloat({n, k});
+        auto labels = numo::Int64({n, k});
+
+        self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+
+        Rice::Array ret;
+        ret.push(distances);
+        ret.push(labels);
+        return ret;
+      })
+    .define_method(
+      "nprobe=",
+      [](faiss::Index &self, double val) {
+        faiss::ParameterSpace().set_index_parameter(&self, "nprobe", val);
+      })
+    .define_method(
+      "save",
+      [](faiss::Index &self, const char *fname) {
+        faiss::write_index(&self, fname);
+      })
+    .define_singleton_function(
+      "load",
+      [](const char *fname) {
+        return faiss::read_index(fname);
+      });
+
+  Rice::define_class_under<faiss::IndexFlatL2, faiss::Index>(m, "IndexFlatL2")
+    .define_constructor(Rice::Constructor<faiss::IndexFlatL2, int64_t>());
+
+  Rice::define_class_under<faiss::IndexFlatIP, faiss::Index>(m, "IndexFlatIP")
+    .define_constructor(Rice::Constructor<faiss::IndexFlatIP, int64_t>());
+
+  Rice::define_class_under<faiss::IndexHNSWFlat, faiss::Index>(m, "IndexHNSWFlat")
+    .define_constructor(Rice::Constructor<faiss::IndexHNSWFlat, int, int, faiss::MetricType>(), Rice::Arg("d"), Rice::Arg("M"), Rice::Arg("metric") = faiss::METRIC_L2);
+
+  Rice::define_class_under<faiss::IndexIVFFlat, faiss::Index>(m, "IndexIVFFlat")
+    .define_constructor(Rice::Constructor<faiss::IndexIVFFlat, faiss::Index*, size_t, size_t, faiss::MetricType>(), Rice::Arg("quantizer"), Rice::Arg("d"), Rice::Arg("nlist"), Rice::Arg("metric") = faiss::METRIC_L2);
+
+  Rice::define_class_under<faiss::IndexLSH, faiss::Index>(m, "IndexLSH")
+    .define_constructor(Rice::Constructor<faiss::IndexLSH, int64_t, int>());
+
+  Rice::define_class_under<faiss::IndexScalarQuantizer, faiss::Index>(m, "IndexScalarQuantizer")
+    .define_constructor(Rice::Constructor<faiss::IndexScalarQuantizer, int, faiss::ScalarQuantizer::QuantizerType>());
+
+  Rice::define_class_under<faiss::IndexPQ, faiss::Index>(m, "IndexPQ")
+    .define_constructor(Rice::Constructor<faiss::IndexPQ, int, size_t, size_t>());
+
+  Rice::define_class_under<faiss::IndexIVFScalarQuantizer, faiss::Index>(m, "IndexIVFScalarQuantizer")
+    .define_constructor(Rice::Constructor<faiss::IndexIVFScalarQuantizer, faiss::Index*, size_t, size_t, faiss::ScalarQuantizer::QuantizerType>());
+
+  Rice::define_class_under<faiss::IndexIVFPQ, faiss::Index>(m, "IndexIVFPQ")
+    .define_constructor(Rice::Constructor<faiss::IndexIVFPQ, faiss::Index*, size_t, size_t, size_t, size_t, faiss::MetricType>(), Rice::Arg("quantizer"), Rice::Arg("d"), Rice::Arg("nlist"), Rice::Arg("M"), Rice::Arg("nbits_per_idx"), Rice::Arg("metric") = faiss::METRIC_L2);
+
+  Rice::define_class_under<faiss::IndexIVFPQR, faiss::Index>(m, "IndexIVFPQR")
+    .define_constructor(Rice::Constructor<faiss::IndexIVFPQR, faiss::Index*, size_t, size_t, size_t, size_t, size_t, size_t>());
+
+  Rice::define_class_under<faiss::ParameterSpace>(m, "ParameterSpace")
+    .define_constructor(Rice::Constructor<faiss::ParameterSpace>())
+    .define_method(
+      "set_index_parameter",
+      [](faiss::ParameterSpace& self, faiss::Index* index, const std::string& name, double val) {
+        self.set_index_parameter(index, name, val);
+      });
+}