umappp 0.1.2

data/ext/umappp/umappp.cpp

@@ -0,0 +1,225 @@
+// Uniform Manifold Approximation and Projection for Ruby
+// https://github.com/kojix2/ruby-umappp
+
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+#include "numo.hpp"
+#include "Umap.hpp"
+
+typedef float Float;
+typedef typename umappp::Umap<Float> Umap;
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+using namespace Rice;
+
+// This function is used to view default parameters from Ruby.
+
+Hash umap_default_parameters(Object self)
+{
+  Hash d;
+  d[Symbol("local_connectivity")] = Umap::Defaults::local_connectivity;
+  d[Symbol("bandwidth")] = Umap::Defaults::bandwidth;
+  d[Symbol("mix_ratio")] = Umap::Defaults::mix_ratio;
+  d[Symbol("spread")] = Umap::Defaults::spread;
+  d[Symbol("min_dist")] = Umap::Defaults::min_dist;
+  d[Symbol("a")] = Umap::Defaults::a;
+  d[Symbol("b")] = Umap::Defaults::b;
+  d[Symbol("repulsion_strength")] = Umap::Defaults::repulsion_strength;
+  d[Symbol("num_epochs")] = Umap::Defaults::num_epochs;
+  d[Symbol("learning_rate")] = Umap::Defaults::learning_rate;
+  d[Symbol("negative_sample_rate")] = Umap::Defaults::negative_sample_rate;
+  d[Symbol("num_neighbors")] = Umap::Defaults::num_neighbors;
+  d[Symbol("seed")] = Umap::Defaults::seed;
+  d[Symbol("batch")] = Umap::Defaults::batch;
+  d[Symbol("num_threads")] = Umap::Defaults::num_threads;
+
+  return d;
+}
+
+// Function to perform umap.
+
+Object umap_run(
+    Object self,
+    Hash params,
+    numo::SFloat data,
+    int ndim,
+    int nn_method,
+    int tick = 0)
+{
+  // Parameters are taken from a Ruby Hash object.
+  // If there is no key, set the default value.
+  
+  double local_connectivity = Umap::Defaults::local_connectivity;
+  if (RTEST(params.call("has_key?", Symbol("local_connectivity"))))
+  {
+    local_connectivity = params.get<double>(Symbol("local_connectivity"));
+  }
+
+  double bandwidth = Umap::Defaults::bandwidth;
+  if (RTEST(params.call("has_key?", Symbol("bandwidth"))))
+  {
+    bandwidth = params.get<double>(Symbol("bandwidth"));
+  }
+
+  double mix_ratio = Umap::Defaults::mix_ratio;
+  if (RTEST(params.call("has_key?", Symbol("mix_ratio"))))
+  {
+    mix_ratio = params.get<double>(Symbol("mix_ratio"));
+  }
+
+  double spread = Umap::Defaults::spread;
+  if (RTEST(params.call("has_key?", Symbol("spread"))))
+  {
+    spread = params.get<double>(Symbol("spread"));
+  }
+
+  double min_dist = Umap::Defaults::min_dist;
+  if (RTEST(params.call("has_key?", Symbol("min_dist"))))
+  {
+    min_dist = params.get<double>(Symbol("min_dist"));
+  }
+
+  double a = Umap::Defaults::a;
+  if (RTEST(params.call("has_key?", Symbol("a"))))
+  {
+    a = params.get<double>(Symbol("a"));
+  }
+
+  double b = Umap::Defaults::b;
+  if (RTEST(params.call("has_key?", Symbol("b"))))
+  {
+    b = params.get<double>(Symbol("b"));
+  }
+
+  double repulsion_strength = Umap::Defaults::repulsion_strength;
+  if (RTEST(params.call("has_key?", Symbol("repulsion_strength"))))
+  {
+    repulsion_strength = params.get<double>(Symbol("repulsion_strength"));
+  }
+
+  int num_epochs = Umap::Defaults::num_epochs;
+  if (RTEST(params.call("has_key?", Symbol("num_epochs"))))
+  {
+    num_epochs = params.get<int>(Symbol("num_epochs"));
+  }
+
+  double learning_rate = Umap::Defaults::learning_rate;
+  if (RTEST(params.call("has_key?", Symbol("learning_rate"))))
+  {
+    learning_rate = params.get<double>(Symbol("learning_rate"));
+  }
+
+  double negative_sample_rate = Umap::Defaults::negative_sample_rate;
+  if (RTEST(params.call("has_key?", Symbol("negative_sample_rate"))))
+  {
+    negative_sample_rate = params.get<double>(Symbol("negative_sample_rate"));
+  }
+
+  int num_neighbors = Umap::Defaults::num_neighbors;
+  if (RTEST(params.call("has_key?", Symbol("num_neighbors"))))
+  {
+    num_neighbors = params.get<int>(Symbol("num_neighbors"));
+  }
+
+  int seed = Umap::Defaults::seed;
+  if (RTEST(params.call("has_key?", Symbol("seed"))))
+  {
+    seed = params.get<int>(Symbol("seed"));
+  }
+
+  bool batch = Umap::Defaults::batch;
+  if (RTEST(params.call("has_key?", Symbol("batch"))))
+  {
+    batch = params.get<bool>(Symbol("batch"));
+  }
+
+  int num_threads = Umap::Defaults::num_threads;
+  if (RTEST(params.call("has_key?", Symbol("num_threads"))))
+  {
+    num_threads = params.get<int>(Symbol("num_threads"));
+  }
+
+  // setup_parameters
+
+  auto umap_ptr = new Umap;
+  umap_ptr->set_local_connectivity(local_connectivity);
+  umap_ptr->set_bandwidth(bandwidth);
+  umap_ptr->set_mix_ratio(mix_ratio);
+  umap_ptr->set_spread(spread);
+  umap_ptr->set_min_dist(min_dist);
+  umap_ptr->set_a(a);
+  umap_ptr->set_b(b);
+
+  umap_ptr->set_repulsion_strength(repulsion_strength);
+  umap_ptr->set_num_epochs(num_epochs);
+  umap_ptr->set_learning_rate(learning_rate);
+  umap_ptr->set_negative_sample_rate(negative_sample_rate);
+
+  umap_ptr->set_num_neighbors(num_neighbors);
+  umap_ptr->set_seed(seed);
+  umap_ptr->set_batch(batch);
+
+  umap_ptr->set_num_threads(num_threads);
+
+  // initialize_from_matrix
+
+  const float *y = data.read_ptr();
+  size_t *shape = data.shape();
+
+  int nd = shape[1];
+  int nobs = shape[0];
+
+  std::unique_ptr<knncolle::Base<int, Float>> knncolle_ptr;
+  if (nn_method == 0)
+  {
+    knncolle_ptr.reset(new knncolle::AnnoyEuclidean<int, Float>(nd, nobs, y));
+  }
+  else if (nn_method == 1)
+  {
+    knncolle_ptr.reset(new knncolle::KmknnEuclidean<int, Float>(nd, nobs, y));
+  }
+
+  std::vector<Float> embedding(ndim * nobs);
+
+  auto status = umap_ptr->initialize(knncolle_ptr.get(), ndim, embedding.data());
+
+  if (tick == 0)
+  {
+    status.run(ndim, embedding.data(), 0);
+
+    auto na = numo::SFloat({(uint)nobs, (uint)ndim});
+    std::copy(embedding.begin(), embedding.end(), na.write_ptr());
+
+    return na;
+  }
+  else
+  {
+    VALUE ret = rb_ary_new();
+
+    while (status.epoch() < status.num_epochs())
+    {
+      int epoch_limit = status.epoch() + tick;
+
+      status.run(ndim, embedding.data(), epoch_limit);
+
+      auto na = numo::SFloat({(uint)nobs, (uint)ndim});
+      std::copy(embedding.begin(), embedding.end(), na.write_ptr());
+
+      rb_ary_push(ret, na.value());
+    }
+
+    return ret;
+  }
+}
+
+extern "C" void Init_umappp()
+{
+  Module rb_mUmappp =
+      define_module("Umappp")
+          .define_singleton_method("umap_run", &umap_run)
+          .define_singleton_method("default_parameters", &umap_default_parameters);
+}

data/lib/umappp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Umappp
+  VERSION = "0.1.2"
+end

data/lib/umappp.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "numo/narray"
+require_relative "umappp/version"
+require_relative "umappp/umappp"
+
+# Uniform Manifold Approximation and Projection
+module Umappp
+
+  # Run UMAP
+  # @param embedding [Array, Numo::SFloat] 
+  # @param method [Symbol]
+  # @param ndim [Integer]
+  # @param tick [Integer]
+  # @param local_connectivity [Numeric]
+  # @param bandwidth [Numeric]
+  # @param mix_ratio [Numeric]
+  # @param spread [Numeric]
+  # @param min_dist [Numeric]
+  # @param a [Numeric]
+  # @param b [Numeric]
+  # @param repulsion_strength [Numeric]
+  # @param num_epochs [Integer]
+  # @param learning_rate [Numeric]
+  # @param negative_sample_rate [Numeric]
+  # @param num_neighbors [Integer]
+  # @param seed [Integer]
+  # @param batch [Boolean]
+  # @param num_threads [Integer]
+
+  def self.run(ary, method: :annoy, ndim: 2, tick: 0, **params)
+    unless (u = (params.keys - default_parameters.keys)).empty?
+      raise ArgumentError, "[umappp.rb] unknown option : #{u.inspect}"
+    end
+
+    nnmethod = %i[annoy vptree].index(method.to_sym)
+    data     = Numo::SFloat.cast(ary)
+
+    Umappp.umap_run(params, data, ndim, nnmethod, tick)
+  end
+end

data/vendor/Eigen/Cholesky

@@ -0,0 +1,45 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLESKY_MODULE_H
+#define EIGEN_CHOLESKY_MODULE_H
+
+#include "Core"
+#include "Jacobi"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Cholesky_Module Cholesky module
+  *
+  *
+  *
+  * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
+  * Those decompositions are also accessible via the following methods:
+  *  - MatrixBase::llt()
+  *  - MatrixBase::ldlt()
+  *  - SelfAdjointView::llt()
+  *  - SelfAdjointView::ldlt()
+  *
+  * \code
+  * #include <Eigen/Cholesky>
+  * \endcode
+  */
+
+#include "src/Cholesky/LLT.h"
+#include "src/Cholesky/LDLT.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/Cholesky/LLT_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CHOLESKY_MODULE_H

data/vendor/Eigen/CholmodSupport

@@ -0,0 +1,48 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
+#define EIGEN_CHOLMODSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+  #include <cholmod.h>
+}
+
+/** \ingroup Support_modules
+  * \defgroup CholmodSupport_Module CholmodSupport module
+  *
+  * This module provides an interface to the Cholmod library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  * It provides the two following main factorization classes:
+  * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization.
+  * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial).
+  *
+  * For the sake of completeness, this module also propose the two following classes:
+  * - class CholmodSimplicialLLT
+  * - class CholmodSimplicialLDLT
+  * Note that these classes does not bring any particular advantage compared to the built-in
+  * SimplicialLLT and SimplicialLDLT factorization classes.
+  *
+  * \code
+  * #include <Eigen/CholmodSupport>
+  * \endcode
+  *
+  * In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies.
+  * The dependencies depend on how cholmod has been compiled.
+  * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task.
+  *
+  */
+
+#include "src/CholmodSupport/CholmodSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CHOLMODSUPPORT_MODULE_H
+