fasttext 0.1.0

data/vendor/fastText/src/productquantizer.h

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstring>
+#include <istream>
+#include <ostream>
+#include <random>
+#include <vector>
+
+#include "real.h"
+#include "vector.h"
+
+namespace fasttext {
+
+class ProductQuantizer {
+ protected:
+  const int32_t nbits_ = 8;
+  const int32_t ksub_ = 1 << nbits_;
+  const int32_t max_points_per_cluster_ = 256;
+  const int32_t max_points_ = max_points_per_cluster_ * ksub_;
+  const int32_t seed_ = 1234;
+  const int32_t niter_ = 25;
+  const real eps_ = 1e-7;
+
+  int32_t dim_;
+  int32_t nsubq_;
+  int32_t dsub_;
+  int32_t lastdsub_;
+
+  std::vector<real> centroids_;
+
+  std::minstd_rand rng;
+
+ public:
+  ProductQuantizer() {}
+  ProductQuantizer(int32_t, int32_t);
+
+  real* get_centroids(int32_t, uint8_t);
+  const real* get_centroids(int32_t, uint8_t) const;
+
+  real assign_centroid(const real*, const real*, uint8_t*, int32_t) const;
+  void Estep(const real*, const real*, uint8_t*, int32_t, int32_t) const;
+  void MStep(const real*, real*, const uint8_t*, int32_t, int32_t);
+  void kmeans(const real*, real*, int32_t, int32_t);
+  void train(int, const real*);
+
+  real mulcode(const Vector&, const uint8_t*, int32_t, real) const;
+  void addcode(Vector&, const uint8_t*, int32_t, real) const;
+  void compute_code(const real*, uint8_t*) const;
+  void compute_codes(const real*, uint8_t*, int32_t) const;
+
+  void save(std::ostream&) const;
+  void load(std::istream&);
+};
+
+} // namespace fasttext

data/vendor/fastText/src/quantmatrix.cc

@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "quantmatrix.h"
+
+#include <assert.h>
+#include <iostream>
+#include <stdexcept>
+
+namespace fasttext {
+
+QuantMatrix::QuantMatrix() : Matrix(), qnorm_(false), codesize_(0) {}
+
+QuantMatrix::QuantMatrix(DenseMatrix&& mat, int32_t dsub, bool qnorm)
+    : Matrix(mat.size(0), mat.size(1)),
+      qnorm_(qnorm),
+      codesize_(mat.size(0) * ((mat.size(1) + dsub - 1) / dsub)) {
+  codes_.resize(codesize_);
+  pq_ = std::unique_ptr<ProductQuantizer>(new ProductQuantizer(n_, dsub));
+  if (qnorm_) {
+    norm_codes_.resize(m_);
+    npq_ = std::unique_ptr<ProductQuantizer>(new ProductQuantizer(1, 1));
+  }
+  quantize(std::forward<DenseMatrix>(mat));
+}
+
+void QuantMatrix::quantizeNorm(const Vector& norms) {
+  assert(qnorm_);
+  assert(norms.size() == m_);
+  auto dataptr = norms.data();
+  npq_->train(m_, dataptr);
+  npq_->compute_codes(dataptr, norm_codes_.data(), m_);
+}
+
+void QuantMatrix::quantize(DenseMatrix&& mat) {
+  if (qnorm_) {
+    Vector norms(mat.size(0));
+    mat.l2NormRow(norms);
+    mat.divideRow(norms);
+    quantizeNorm(norms);
+  }
+  auto dataptr = mat.data();
+  pq_->train(m_, dataptr);
+  pq_->compute_codes(dataptr, codes_.data(), m_);
+}
+
+real QuantMatrix::dotRow(const Vector& vec, int64_t i) const {
+  assert(i >= 0);
+  assert(i < m_);
+  assert(vec.size() == n_);
+  real norm = 1;
+  if (qnorm_) {
+    norm = npq_->get_centroids(0, norm_codes_[i])[0];
+  }
+  return pq_->mulcode(vec, codes_.data(), i, norm);
+}
+
+void QuantMatrix::addVectorToRow(const Vector&, int64_t, real) {
+  throw std::runtime_error("Operation not permitted on quantized matrices.");
+}
+
+void QuantMatrix::addRowToVector(Vector& x, int32_t i, real a) const {
+  real norm = 1;
+  if (qnorm_) {
+    norm = npq_->get_centroids(0, norm_codes_[i])[0];
+  }
+  pq_->addcode(x, codes_.data(), i, a * norm);
+}
+
+void QuantMatrix::addRowToVector(Vector& x, int32_t i) const {
+  real norm = 1;
+  if (qnorm_) {
+    norm = npq_->get_centroids(0, norm_codes_[i])[0];
+  }
+  pq_->addcode(x, codes_.data(), i, norm);
+}
+
+void QuantMatrix::save(std::ostream& out) const {
+  out.write((char*)&qnorm_, sizeof(qnorm_));
+  out.write((char*)&m_, sizeof(m_));
+  out.write((char*)&n_, sizeof(n_));
+  out.write((char*)&codesize_, sizeof(codesize_));
+  out.write((char*)codes_.data(), codesize_ * sizeof(uint8_t));
+  pq_->save(out);
+  if (qnorm_) {
+    out.write((char*)norm_codes_.data(), m_ * sizeof(uint8_t));
+    npq_->save(out);
+  }
+}
+
+void QuantMatrix::load(std::istream& in) {
+  in.read((char*)&qnorm_, sizeof(qnorm_));
+  in.read((char*)&m_, sizeof(m_));
+  in.read((char*)&n_, sizeof(n_));
+  in.read((char*)&codesize_, sizeof(codesize_));
+  codes_ = std::vector<uint8_t>(codesize_);
+  in.read((char*)codes_.data(), codesize_ * sizeof(uint8_t));
+  pq_ = std::unique_ptr<ProductQuantizer>(new ProductQuantizer());
+  pq_->load(in);
+  if (qnorm_) {
+    norm_codes_ = std::vector<uint8_t>(m_);
+    in.read((char*)norm_codes_.data(), m_ * sizeof(uint8_t));
+    npq_ = std::unique_ptr<ProductQuantizer>(new ProductQuantizer());
+    npq_->load(in);
+  }
+}
+
+void QuantMatrix::dump(std::ostream&) const {
+  throw std::runtime_error("Operation not permitted on quantized matrices.");
+}
+
+} // namespace fasttext

data/vendor/fastText/src/quantmatrix.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <istream>
+#include <ostream>
+
+#include <memory>
+#include <vector>
+
+#include "real.h"
+
+#include "densematrix.h"
+#include "matrix.h"
+#include "vector.h"
+
+#include "productquantizer.h"
+
+namespace fasttext {
+
+class QuantMatrix : public Matrix {
+ protected:
+  std::unique_ptr<ProductQuantizer> pq_;
+  std::unique_ptr<ProductQuantizer> npq_;
+
+  std::vector<uint8_t> codes_;
+  std::vector<uint8_t> norm_codes_;
+
+  bool qnorm_;
+  int32_t codesize_;
+
+ public:
+  QuantMatrix();
+  QuantMatrix(DenseMatrix&&, int32_t, bool);
+  QuantMatrix(const QuantMatrix&) = delete;
+  QuantMatrix(QuantMatrix&&) = delete;
+  QuantMatrix& operator=(const QuantMatrix&) = delete;
+  QuantMatrix& operator=(QuantMatrix&&) = delete;
+  virtual ~QuantMatrix() noexcept override = default;
+
+  void quantizeNorm(const Vector&);
+  void quantize(DenseMatrix&& mat);
+
+  real dotRow(const Vector&, int64_t) const override;
+  void addVectorToRow(const Vector&, int64_t, real) override;
+  void addRowToVector(Vector& x, int32_t i) const override;
+  void addRowToVector(Vector& x, int32_t i, real a) const override;
+  void save(std::ostream&) const override;
+  void load(std::istream&) override;
+  void dump(std::ostream&) const override;
+};
+
+} // namespace fasttext

data/vendor/fastText/src/real.h

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+namespace fasttext {
+
+typedef float real;
+
+}

data/vendor/fastText/src/utils.cc

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "utils.h"
+
+#include <ios>
+
+namespace fasttext {
+
+namespace utils {
+
+int64_t size(std::ifstream& ifs) {
+  ifs.seekg(std::streamoff(0), std::ios::end);
+  return ifs.tellg();
+}
+
+void seek(std::ifstream& ifs, int64_t pos) {
+  ifs.clear();
+  ifs.seekg(std::streampos(pos));
+}
+} // namespace utils
+
+} // namespace fasttext

data/vendor/fastText/src/utils.h

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include "real.h"
+
+#include <algorithm>
+#include <fstream>
+#include <vector>
+
+#if defined(__clang__) || defined(__GNUC__)
+#define FASTTEXT_DEPRECATED(msg) __attribute__((__deprecated__(msg)))
+#elif defined(_MSC_VER)
+#define FASTTEXT_DEPRECATED(msg) __declspec(deprecated(msg))
+#else
+#define FASTTEXT_DEPRECATED(msg)
+#endif
+
+namespace fasttext {
+
+using Predictions = std::vector<std::pair<real, int32_t>>;
+
+namespace utils {
+
+int64_t size(std::ifstream&);
+
+void seek(std::ifstream&, int64_t);
+
+template <typename T>
+bool contains(const std::vector<T>& container, const T& value) {
+  return std::find(container.begin(), container.end(), value) !=
+      container.end();
+}
+
+} // namespace utils
+
+} // namespace fasttext

data/vendor/fastText/src/vector.cc

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "vector.h"
+
+#include <assert.h>
+
+#include <cmath>
+#include <iomanip>
+#include <utility>
+
+#include "matrix.h"
+
+namespace fasttext {
+
+Vector::Vector(int64_t m) : data_(m) {}
+
+void Vector::zero() {
+  std::fill(data_.begin(), data_.end(), 0.0);
+}
+
+real Vector::norm() const {
+  real sum = 0;
+  for (int64_t i = 0; i < size(); i++) {
+    sum += data_[i] * data_[i];
+  }
+  return std::sqrt(sum);
+}
+
+void Vector::mul(real a) {
+  for (int64_t i = 0; i < size(); i++) {
+    data_[i] *= a;
+  }
+}
+
+void Vector::addVector(const Vector& source) {
+  assert(size() == source.size());
+  for (int64_t i = 0; i < size(); i++) {
+    data_[i] += source.data_[i];
+  }
+}
+
+void Vector::addVector(const Vector& source, real s) {
+  assert(size() == source.size());
+  for (int64_t i = 0; i < size(); i++) {
+    data_[i] += s * source.data_[i];
+  }
+}
+
+void Vector::addRow(const Matrix& A, int64_t i, real a) {
+  assert(i >= 0);
+  assert(i < A.size(0));
+  assert(size() == A.size(1));
+  A.addRowToVector(*this, i, a);
+}
+
+void Vector::addRow(const Matrix& A, int64_t i) {
+  assert(i >= 0);
+  assert(i < A.size(0));
+  assert(size() == A.size(1));
+  A.addRowToVector(*this, i);
+}
+
+void Vector::mul(const Matrix& A, const Vector& vec) {
+  assert(A.size(0) == size());
+  assert(A.size(1) == vec.size());
+  for (int64_t i = 0; i < size(); i++) {
+    data_[i] = A.dotRow(vec, i);
+  }
+}
+
+int64_t Vector::argmax() {
+  real max = data_[0];
+  int64_t argmax = 0;
+  for (int64_t i = 1; i < size(); i++) {
+    if (data_[i] > max) {
+      max = data_[i];
+      argmax = i;
+    }
+  }
+  return argmax;
+}
+
+std::ostream& operator<<(std::ostream& os, const Vector& v) {
+  os << std::setprecision(5);
+  for (int64_t j = 0; j < v.size(); j++) {
+    os << v[j] << ' ';
+  }
+  return os;
+}
+
+} // namespace fasttext

data/vendor/fastText/src/vector.h

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <ostream>
+#include <vector>
+
+#include "real.h"
+
+namespace fasttext {
+
+class Matrix;
+
+class Vector {
+ protected:
+  std::vector<real> data_;
+
+ public:
+  explicit Vector(int64_t);
+  Vector(const Vector&) = default;
+  Vector(Vector&&) noexcept = default;
+  Vector& operator=(const Vector&) = default;
+  Vector& operator=(Vector&&) = default;
+
+  inline real* data() {
+    return data_.data();
+  }
+  inline const real* data() const {
+    return data_.data();
+  }
+  inline real& operator[](int64_t i) {
+    return data_[i];
+  }
+  inline const real& operator[](int64_t i) const {
+    return data_[i];
+  }
+
+  inline int64_t size() const {
+    return data_.size();
+  }
+  void zero();
+  void mul(real);
+  real norm() const;
+  void addVector(const Vector& source);
+  void addVector(const Vector&, real);
+  void addRow(const Matrix&, int64_t);
+  void addRow(const Matrix&, int64_t, real);
+  void mul(const Matrix&, const Vector&);
+  int64_t argmax();
+};
+
+std::ostream& operator<<(std::ostream&, const Vector&);
+
+} // namespace fasttext