umappp 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6213e0c925f92536e1a2698650ac79440f65c3d240eabc1943bd3e9b0f2a116e
-  data.tar.gz: 3595cbb5a91b88787479355ba6abd5037aee31a83f57c958d9800bc4602fbb24
+  metadata.gz: 652d8cf10c9054b45a567638d8f04f42f8915944bc980c6e28b9e71f0a0f76af
+  data.tar.gz: 2d9f36babd30db2554e6e02753d16d777dabcb2c163f1558f369035317fd1398
 SHA512:
-  metadata.gz: 6cfa4967ccebe20f71dd61601e75cff681afb0de4688af74ce75353514d50834466a04a921c62bb2de00feb77493106b36278557bd60e544cee7749683da23da
-  data.tar.gz: 84d6a55992cd0f0ec9847da7a106cd6e60edbdcf438e44941cb32d9e4bea831c5b836cec40cd0138379e4f83040cae3b86958ea50fc3eb28ecc6425bad8b87bd
+  metadata.gz: 45fe9afc8e8a0917429901ee7cfca09596a4ec6d3e292717aa2035f0ba992e570da604bd22879abfc924ff75e200e2d37513ed82ab7b8d547df9234d025a8429
+  data.tar.gz: 267b65e8883f039e1876a4b4b629cd77b506212641d602bf97f1787103b99457148618188dd6aafdb5c8d96df1e22fa2a2dc0d73a052d4375c6b731288532784

data/ext/umappp/umappp.cpp

@@ -18,7 +18,7 @@ using namespace Rice;
 
 // This function is used to view default parameters from Ruby.
 
-Hash umap_default_parameters(Object self)
+Hash umappp_default_parameters(Object self)
 {
   Hash d;
   d[Symbol("local_connectivity")] = Umap::Defaults::local_connectivity;
@@ -42,7 +42,7 @@ Hash umap_default_parameters(Object self)
 
 // Function to perform umap.
 
-Object umap_run(
+Object umappp_run(
     Object self,
     Hash params,
     numo::SFloat data,
@@ -51,120 +51,115 @@ Object umap_run(
     int tick = 0)
 {
   // Parameters are taken from a Ruby Hash object.
-  // If there is no key, set the default value.
+  // If there is key, set the value.
   
+  auto umap_ptr = new Umap;
+
   double local_connectivity = Umap::Defaults::local_connectivity;
   if (RTEST(params.call("has_key?", Symbol("local_connectivity"))))
   {
     local_connectivity = params.get<double>(Symbol("local_connectivity"));
+    umap_ptr->set_local_connectivity(local_connectivity);
   }
 
   double bandwidth = Umap::Defaults::bandwidth;
   if (RTEST(params.call("has_key?", Symbol("bandwidth"))))
   {
     bandwidth = params.get<double>(Symbol("bandwidth"));
+    umap_ptr->set_bandwidth(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"));
+    umap_ptr->set_mix_ratio(mix_ratio);
   }
 
   double spread = Umap::Defaults::spread;
   if (RTEST(params.call("has_key?", Symbol("spread"))))
   {
     spread = params.get<double>(Symbol("spread"));
+    umap_ptr->set_spread(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"));
+    umap_ptr->set_min_dist(min_dist);
   }
 
   double a = Umap::Defaults::a;
   if (RTEST(params.call("has_key?", Symbol("a"))))
   {
     a = params.get<double>(Symbol("a"));
+    umap_ptr->set_a(a);
   }
 
   double b = Umap::Defaults::b;
   if (RTEST(params.call("has_key?", Symbol("b"))))
   {
     b = params.get<double>(Symbol("b"));
+    umap_ptr->set_b(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"));
+    umap_ptr->set_repulsion_strength(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"));
+    umap_ptr->set_num_epochs(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"));
+    umap_ptr->set_learning_rate(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"));
+    umap_ptr->set_negative_sample_rate(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"));
+    umap_ptr->set_num_neighbors(num_neighbors);
   }
 
   int seed = Umap::Defaults::seed;
   if (RTEST(params.call("has_key?", Symbol("seed"))))
   {
     seed = params.get<int>(Symbol("seed"));
+    umap_ptr->set_seed(seed);
   }
 
   bool batch = Umap::Defaults::batch;
   if (RTEST(params.call("has_key?", Symbol("batch"))))
   {
     batch = params.get<bool>(Symbol("batch"));
+    umap_ptr->set_batch(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"));
+    umap_ptr->set_num_threads(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();
@@ -220,6 +215,6 @@ 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);
+          .define_singleton_method("umappp_run", &umappp_run)
+          .define_singleton_method("umappp_default_parameters", &umappp_default_parameters);
 }

data/lib/umappp/version.rb

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

data/lib/umappp.rb

@@ -7,7 +7,18 @@ require_relative "umappp/umappp"
 # Uniform Manifold Approximation and Projection
 module Umappp
 
-  # Run UMAP
+  # Make wrapper methods for the C++ function generated by Rice private
+  private_class_method :umappp_run
+  private_class_method :umappp_default_parameters
+
+  # View the default parameters defined within the Umappp C++ library structure.
+  def self.default_parameters
+    # {method: :annoy, ndim: 2, tick: 0}.merge
+    umappp_default_parameters
+  end
+
+  # Runs the Uniform Manifold Approximation and Projection (UMAP) dimensional 
+  # reduction technique. 
   # @param embedding [Array, Numo::SFloat] 
   # @param method [Symbol]
   # @param ndim [Integer]
@@ -28,14 +39,14 @@ module Umappp
   # @param batch [Boolean]
   # @param num_threads [Integer]
 
-  def self.run(ary, method: :annoy, ndim: 2, tick: 0, **params)
+  def self.run(embedding, 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)
+    data     = Numo::SFloat.cast(embedding)
 
-    Umappp.umap_run(params, data, ndim, nnmethod, tick)
+    umappp_run(params, data, ndim, nnmethod, tick)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: umappp
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - kojix2