rumale 0.12.8 → 0.12.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbe91a2e4b8e16a5cf37ae8141ad73a760dbeac2
-  data.tar.gz: eac618abc865d6a9a8458afeec91b8f86fcc7b98
+  metadata.gz: c55e2ab90432838616c16fdf35d4eac150cc02b8
+  data.tar.gz: c605feef7c8d3d7dce4e8330419ba88288d17f74
 SHA512:
-  metadata.gz: d980b9f3fb0d13bd71a672b4cdc39cef616ec354df5581ec7fb3e793059c0847be8d008a50297328b9a78b7a2b0c146b65aa667b72b9becf56e0f9b1fb279955
-  data.tar.gz: 3a24e75f869e64a922202b5e81122f8c19a813fade58914788cd5c239c0c53a27ce5e9bbb7ed1c8c62a11d1f0fa54eb43244e52502f45c4907866b92fd01b405
+  metadata.gz: f3ec59d17a66d74d978860537271c0d7c8881924cce6589345d43079897879ac603b6c01c7b0884419457e4bf6a99187345d203e8638be6d96aabe1ce513560f
+  data.tar.gz: 86f0cbf4c92b72b9caff2e5a9ed39b47013e4c11bdacf6661148a01f3c69a72253bc8690fa5c28207888461b8bc1070f39b87bc23df11866b9018d61cd37b2fd

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.12.9
+- Add class for K-Medoids clustering.
+- Fix extension codes of decision tree regressor for using Numo::NArray.
+
 # 0.12.8
 - Fix bug that fails to build and install on Windows again. Fix extconf to add Numo::NArray libraries to $lib.
 

data/README.md

@@ -6,14 +6,14 @@
 [![Coverage Status](https://coveralls.io/repos/github/yoshoku/rumale/badge.svg?branch=master)](https://coveralls.io/github/yoshoku/rumale?branch=master)
 [![Gem Version](https://badge.fury.io/rb/rumale.svg)](https://badge.fury.io/rb/rumale)
 [![BSD 2-Clause License](https://img.shields.io/badge/License-BSD%202--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/master/LICENSE.txt)
-[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/rumale/0.12.8)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/rumale/0.12.9)
 
 Rumale (**Ru**by **ma**chine **le**arning) is a machine learning library in Ruby.
 Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
 Rumale supports Linear / Kernel Support Vector Machine,
 Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
 Naive Bayes, Decision Tree, AdaBoost, Gradient Tree Boosting, Random Forest, Extra-Trees, K-nearest neighbor classifier,
-K-Means, Gaussian Mixture Model, DBSCAN, Power Iteration Clustering,
+K-Means, K-Medoids, Gaussian Mixture Model, DBSCAN, Power Iteration Clustering,
 Mutidimensional Scaling, t-SNE, Principal Component Analysis, and Non-negative Matrix Factorization.
 
 This project was formerly known as "SVMKit".

data/ext/rumale/rumale.c

@@ -131,9 +131,9 @@ calc_impurity_cls(const char* criterion, VALUE histogram, const long n_elements)
 }
 
 double
-calc_impurity_reg(VALUE criterion, VALUE target_vecs, VALUE sum_vec)
+calc_impurity_reg(const char* criterion, VALUE target_vecs, VALUE sum_vec)
 {
-  if (strcmp(StringValuePtr(criterion), "mae") == 0) {
+  if (strcmp(criterion, "mae") == 0) {
     return calc_mae(target_vecs, sum_vec);
   }
   return calc_mse(target_vecs, sum_vec);
@@ -286,83 +286,115 @@ find_split_params_cls(VALUE self, VALUE criterion, VALUE impurity, VALUE order,
 
 /**
  * @!visibility private
- * Find for split point with maximum information gain.
- *
- * @overload find_split_params(criterion, impurity, sorted_features, sorted_targets) -> Array<Float>
- *
- * @param criterion [String] The function to evaluate spliting point. Supported criteria are 'mae' and 'mse'.
- * @param impurity [Float] The impurity of whole dataset.
- * @param sorted_features [Numo::DFloat] (shape: [n_samples]) The feature values sorted in ascending order.
- * @param sorted_targets [Numo::DFloat] (shape: [n_samples, n_outputs]) The target values sorted according to feature values.
- * @return [Float] The array consists of optimal parameters including impurities of child nodes, threshold, and gain.
  */
-static VALUE
-find_split_params_reg(VALUE self, VALUE criterion, VALUE whole_impurity, VALUE sorted_f, VALUE sorted_y)
+typedef struct {
+  char* criterion;
+  double impurity;
+} split_opts_reg;
+/**
+ * @!visibility private
+ */
+static void
+iter_find_split_params_reg(na_loop_t const* lp)
 {
-  const long n_elements = RARRAY_LEN(sorted_f);
-  const long n_dimensions = RARRAY_LEN(rb_ary_entry(sorted_y, 0));
-  const double w_impurity = NUM2DBL(whole_impurity);
-  long iter = 0;
+  const int32_t* o = (int32_t*)NDL_PTR(lp, 0);
+  const double* f = (double*)NDL_PTR(lp, 1);
+  const double* y = (double*)NDL_PTR(lp, 2);
+  const long n_elements = NDL_SHAPE(lp, 0)[0];
+  const long n_outputs = NDL_SHAPE(lp, 2)[1];
+  const char* criterion = ((split_opts_reg*)lp->opt_ptr)->criterion;
+  const double w_impurity = ((split_opts_reg*)lp->opt_ptr)->impurity;
+  double* params = (double*)NDL_PTR(lp, 3);
+  long i, j;
   long curr_pos = 0;
   long next_pos = 0;
   long n_l_elements = 0;
   long n_r_elements = n_elements;
-  double last_el = NUM2DBL(rb_ary_entry(sorted_f, n_elements - 1));
-  double curr_el = NUM2DBL(rb_ary_entry(sorted_f, 0));
+  double curr_el = f[o[0]];
+  double last_el = f[o[n_elements - 1]];
   double next_el;
   double l_impurity;
   double r_impurity;
   double gain;
-  VALUE l_sum_vec = create_zero_vector(n_dimensions);
-  VALUE r_sum_vec = create_zero_vector(n_dimensions);
+  VALUE l_sum_vec = create_zero_vector(n_outputs);
+  VALUE r_sum_vec = create_zero_vector(n_outputs);
   VALUE l_target_vecs = rb_ary_new();
   VALUE r_target_vecs = rb_ary_new();
   VALUE target;
-  VALUE opt_params = rb_ary_new2(4);
 
   /* Initialize optimal parameters. */
-  rb_ary_store(opt_params, 0, DBL2NUM(0));                /* left impurity */
-  rb_ary_store(opt_params, 1, DBL2NUM(w_impurity));       /* right impurity */
-  rb_ary_store(opt_params, 2, rb_ary_entry(sorted_f, 0)); /* threshold */
-  rb_ary_store(opt_params, 3, DBL2NUM(0));                /* gain */
+  params[0] = 0.0;        /* left impurity */
+  params[1] = w_impurity; /* right impurity */
+  params[2] = curr_el;    /* threshold */
+  params[3] = 0.0;        /* gain */
 
   /* Initialize child node variables. */
-  for (iter = 0; iter < n_elements; iter++) {
-    target = rb_ary_entry(sorted_y, iter);
+  for (i = 0; i < n_elements; i++) {
+    target = rb_ary_new2(n_outputs);
+    for (j = 0; j < n_outputs; j++) {
+      rb_ary_store(target, j, DBL2NUM(y[o[i] * n_outputs + j]));
+    }
     add_sum_vec(r_sum_vec, target);
     rb_ary_push(r_target_vecs, target);
   }
 
   /* Find optimal parameters. */
   while (curr_pos < n_elements && curr_el != last_el) {
-    next_el = NUM2DBL(rb_ary_entry(sorted_f, next_pos));
+    next_el = f[o[next_pos]];
     while (next_pos < n_elements && next_el == curr_el) {
-      target = rb_ary_entry(sorted_y, next_pos);
-      add_sum_vec(l_sum_vec, target);
+      target = rb_ary_shift(r_target_vecs);
+      n_r_elements--;
+      sub_sum_vec(r_sum_vec, target);
       rb_ary_push(l_target_vecs, target);
       n_l_elements++;
-      sub_sum_vec(r_sum_vec, target);
-      rb_ary_shift(r_target_vecs);
-      n_r_elements--;
-      next_el = NUM2DBL(rb_ary_entry(sorted_f, ++next_pos));
+      add_sum_vec(l_sum_vec, target);
+      next_pos++;
+      next_el = f[o[next_pos]];
     }
     /* Calculate gain of new split. */
     l_impurity = calc_impurity_reg(criterion, l_target_vecs, l_sum_vec);
     r_impurity = calc_impurity_reg(criterion, r_target_vecs, r_sum_vec);
     gain = w_impurity - (n_l_elements * l_impurity + n_r_elements * r_impurity) / n_elements;
     /* Update optimal parameters. */
-    if (gain > NUM2DBL(rb_ary_entry(opt_params, 3))) {
-      rb_ary_store(opt_params, 0, DBL2NUM(l_impurity));
-      rb_ary_store(opt_params, 1, DBL2NUM(r_impurity));
-      rb_ary_store(opt_params, 2, DBL2NUM(0.5 * (curr_el + next_el)));
-      rb_ary_store(opt_params, 3, DBL2NUM(gain));
+    if (gain > params[3]) {
+      params[0] = l_impurity;
+      params[1] = r_impurity;
+      params[2] = 0.5 * (curr_el + next_el);
+      params[3] = gain;
     }
     if (next_pos == n_elements) break;
     curr_pos = next_pos;
-    curr_el = NUM2DBL(rb_ary_entry(sorted_f, curr_pos));
+    curr_el = f[o[curr_pos]];
   }
-
-  return opt_params;
+}
+/**
+ * @!visibility private
+ * Find for split point with maximum information gain.
+ *
+ * @overload find_split_params(criterion, impurity, order, features, targets) -> Array<Float>
+ *
+ * @param criterion [String] The function to evaluate spliting point. Supported criteria are 'mae' and 'mse'.
+ * @param impurity [Float] The impurity of whole dataset.
+ * @param order [Numo::Int32] (shape: [n_samples]) The element indices sorted according to feature values in ascending order.
+ * @param features [Numo::DFloat] (shape: [n_samples]) The feature values.
+ * @param targets [Numo::DFloat] (shape: [n_samples, n_outputs]) The target values.
+ * @return [Array<Float>] The array consists of optimal parameters including impurities of child nodes, threshold, and gain.
+ */
+static VALUE
+find_split_params_reg(VALUE self, VALUE criterion, VALUE impurity, VALUE order, VALUE features, VALUE targets)
+{
+  ndfunc_arg_in_t ain[3] = { {numo_cInt32, 1}, {numo_cDFloat, 1}, {numo_cDFloat, 2} };
+  size_t out_shape[1] = { 4 };
+  ndfunc_arg_out_t aout[1] = { {numo_cDFloat, 1, out_shape} };
+  ndfunc_t ndf = { (na_iter_func_t)iter_find_split_params_reg, NO_LOOP, 3, 1, ain, aout };
+  split_opts_reg opts = { StringValuePtr(criterion), NUM2DBL(impurity) };
+  VALUE params = na_ndloop3(&ndf, &opts, 3, order, features, targets);
+  VALUE results = rb_ary_new2(4);
+  rb_ary_store(results, 0, DBL2NUM(((double*)na_get_pointer_for_read(params))[0]));
+  rb_ary_store(results, 1, DBL2NUM(((double*)na_get_pointer_for_read(params))[1]));
+  rb_ary_store(results, 2, DBL2NUM(((double*)na_get_pointer_for_read(params))[2]));
+  rb_ary_store(results, 3, DBL2NUM(((double*)na_get_pointer_for_read(params))[3]));
+  return results;
 }
 
 /**
@@ -487,7 +519,7 @@ node_impurity_cls(VALUE self, VALUE criterion, VALUE y_nary, VALUE n_elements_,
  * @overload node_impurity(criterion, y) -> Float
  *
  * @param criterion [String] The function to calculate impurity. Supported criteria are 'mae' and 'mse'.
- * @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The taget values.
+ * @param y [Array<Float>] (shape: [n_samples, n_outputs]) The taget values.
  * @return [Float] impurity
  */
 static VALUE
@@ -495,8 +527,8 @@ node_impurity_reg(VALUE self, VALUE criterion, VALUE y)
 {
   long i;
   const long n_elements = RARRAY_LEN(y);
-  const long n_dimensions = RARRAY_LEN(rb_ary_entry(y, 0));
-  VALUE sum_vec = create_zero_vector(n_dimensions);
+  const long n_outputs = RARRAY_LEN(rb_ary_entry(y, 0));
+  VALUE sum_vec = create_zero_vector(n_outputs);
   VALUE target_vecs = rb_ary_new();
   VALUE target;
 
@@ -506,7 +538,7 @@ node_impurity_reg(VALUE self, VALUE criterion, VALUE y)
     rb_ary_push(target_vecs, target);
   }
 
-  return DBL2NUM(calc_impurity_reg(criterion, target_vecs, sum_vec));
+  return DBL2NUM(calc_impurity_reg(StringValuePtr(criterion), target_vecs, sum_vec));
 }
 
 void Init_rumale(void)
@@ -536,7 +568,7 @@ void Init_rumale(void)
   VALUE mExtGTreeReg = rb_define_module_under(mTree, "ExtGradientTreeRegressor");
 
   rb_define_private_method(mExtDTreeCls, "find_split_params", find_split_params_cls, 6);
-  rb_define_private_method(mExtDTreeReg, "find_split_params", find_split_params_reg, 4);
+  rb_define_private_method(mExtDTreeReg, "find_split_params", find_split_params_reg, 5);
   rb_define_private_method(mExtGTreeReg, "find_split_params", find_split_params_grad_reg, 7);
   rb_define_private_method(mExtDTreeCls, "node_impurity", node_impurity_cls, 4);
   rb_define_private_method(mExtDTreeReg, "node_impurity", node_impurity_reg, 2);

data/lib/rumale.rb

@@ -57,6 +57,7 @@ require 'rumale/ensemble/random_forest_regressor'
 require 'rumale/ensemble/extra_trees_classifier'
 require 'rumale/ensemble/extra_trees_regressor'
 require 'rumale/clustering/k_means'
+require 'rumale/clustering/k_medoids'
 require 'rumale/clustering/gaussian_mixture'
 require 'rumale/clustering/dbscan'
 require 'rumale/clustering/power_iteration'

data/lib/rumale/clustering/k_medoids.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/cluster_analyzer'
+require 'rumale/pairwise_metric'
+
+module Rumale
+  module Clustering
+    # KMedoids is a class that implements K-Medoids cluster analysis.
+    #
+    # @example
+    #   analyzer = Rumale::Clustering::KMedoids.new(n_clusters: 10, max_iter: 50)
+    #   cluster_labels = analyzer.fit_predict(samples)
+    #
+    # *Reference*
+    # - D. Arthur and S. Vassilvitskii, "k-means++: the advantages of careful seeding," Proc. SODA'07, pp. 1027--1035, 2007.
+    class KMedoids
+      include Base::BaseEstimator
+      include Base::ClusterAnalyzer
+
+      # Return the indices of medoids.
+      # @return [Numo::Int32] (shape: [n_clusters])
+      attr_reader :medoid_ids
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new cluster analyzer with K-Medoids method.
+      #
+      # @param n_clusters [Integer] The number of clusters.
+      # @param metric [String] The metric to calculate the distances in original space.
+      #   If metric is 'euclidean', Euclidean distance is calculated for distance in original space.
+      #   If metric is 'precomputed', the fit and fit_transform methods expect to be given a distance matrix.
+      # @param init [String] The initialization method for centroids ('random' or 'k-means++').
+      # @param max_iter [Integer] The maximum number of iterations.
+      # @param tol [Float] The tolerance of termination criterion.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_clusters: 8, metric: 'euclidean', init: 'k-means++', max_iter: 50, tol: 1.0e-4, random_seed: nil)
+        check_params_integer(n_clusters: n_clusters, max_iter: max_iter)
+        check_params_float(tol: tol)
+        check_params_string(metric: metric, init: init)
+        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_positive(n_clusters: n_clusters, max_iter: max_iter)
+        @params = {}
+        @params[:n_clusters] = n_clusters
+        @params[:metric] = metric == 'precomputed' ? 'precomputed' : 'euclidean'
+        @params[:init] = init == 'random' ? 'random' : 'k-means++'
+        @params[:max_iter] = max_iter
+        @params[:tol] = tol
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
+        @medoid_ids = nil
+        @cluster_centers = nil
+        @rng = Random.new(@params[:random_seed])
+      end
+
+      # Analysis clusters with given training data.
+      #
+      # @overload fit(x) -> KMedoids
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
+      # @return [KMedoids] The learned cluster analyzer itself.
+      def fit(x, _not_used = nil)
+        check_sample_array(x)
+        raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+        # initialize some varibales.
+        distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
+        init_cluster_centers(distance_mat)
+        error = distance_mat[true, @medoid_ids].mean
+        @params[:max_iter].times do |_t|
+          cluster_labels = assign_cluster(distance_mat[true, @medoid_ids])
+          @params[:n_clusters].times do |n|
+            assigned_ids = cluster_labels.eq(n).where
+            @medoid_ids[n] = assigned_ids[distance_mat[assigned_ids, assigned_ids].sum(axis: 1).min_index]
+          end
+          new_error = distance_mat[true, @medoid_ids].mean
+          break if (error - new_error).abs <= @params[:tol]
+          error = new_error
+        end
+        @cluster_centers = x[@medoid_ids, true].dup if @params[:metric] == 'euclidean'
+        self
+      end
+
+      # Predict cluster labels for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the cluster label.
+      #   If the metric is 'precomputed', x must be distances between samples and medoids (shape: [n_samples, n_clusters]).
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
+      def predict(x)
+        check_sample_array(x)
+        distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x, @cluster_centers)
+        if @params[:metric] == 'precomputed' && distance_mat.shape[1] != @medoid_ids.size
+          raise ArgumentError, 'Expect the size input matrix to be n_samples-by-n_clusters.'
+        end
+        assign_cluster(distance_mat)
+      end
+
+      # Analysis clusters and assign samples to clusters.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
+      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
+      def fit_predict(x)
+        check_sample_array(x)
+        fit(x)
+        if @params[:metric] == 'precomputed'
+          predict(x[true, @medoid_ids])
+        else
+          predict(x)
+        end
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data.
+      def marshal_dump
+        { params: @params,
+          medoid_ids: @medoid_ids,
+          cluster_centers: @cluster_centers,
+          rng: @rng }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @medoid_ids = obj[:medoid_ids]
+        @cluster_centers = obj[:cluster_centers]
+        @rng = obj[:rng]
+        nil
+      end
+
+      private
+
+      def assign_cluster(distances_to_medoids)
+        distances_to_medoids.min_index(axis: 1) - Numo::Int32[*0.step(distances_to_medoids.size - 1, @params[:n_clusters])]
+      end
+
+      def init_cluster_centers(distance_mat)
+        # random initialize
+        n_samples = distance_mat.shape[0]
+        sub_rng = @rng.dup
+        @medoid_ids = Numo::Int32.asarray([*0...n_samples].sample(@params[:n_clusters], random: sub_rng))
+        return unless @params[:init] == 'k-means++'
+        # k-means++ initialize
+        (1...@params[:n_clusters]).each do |n|
+          distances = distance_mat[true, @medoid_ids[0...n]]
+          min_distances = distances.flatten[distances.min_index(axis: 1)]
+          probs = min_distances**2 / (min_distances**2).sum
+          cum_probs = probs.cumsum
+          @medoid_ids[n] = cum_probs.gt(sub_rng.rand).where.to_a.first
+        end
+      end
+    end
+  end
+end

data/lib/rumale/tree/decision_tree_regressor.rb

@@ -126,11 +126,8 @@ module Rumale
         node
       end
 
-      def best_split(features, y, whole_impurity)
-        order = features.sort_index
-        sorted_f = features[order].to_a
-        sorted_y = y[order, true].to_a
-        find_split_params(@params[:criterion], whole_impurity, sorted_f, sorted_y)
+      def best_split(f, y, impurity)
+        find_split_params(@params[:criterion], impurity, f.sort_index, f, y)
       end
 
       def impurity(y)

data/lib/rumale/version.rb

@@ -3,5 +3,5 @@
 # Rumale is a machine learning library in Ruby.
 module Rumale
   # The version of Rumale you are using.
-  VERSION = '0.12.8'
+  VERSION = '0.12.9'
 end

data/rumale.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
     Rumale currently supports Linear / Kernel Support Vector Machine,
     Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
     Naive Bayes, Decision Tree, AdaBoost, Gradient Tree Boosting, Random Forest, Extra-Trees, K-nearest neighbor algorithm,
-    K-Means, Gaussian Mixture Model, DBSCAN, Power Iteration Clustering,
+    K-Means, K-Medoids, Gaussian Mixture Model, DBSCAN, Power Iteration Clustering,
     Multidimensional Scaling, t-SNE, Principal Component Analysis, and Non-negative Matrix Factorization.
   MSG
   spec.homepage      = 'https://github.com/yoshoku/rumale'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.12.8
+  version: 0.12.9
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-15 00:00:00.000000000 Z
+date: 2019-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -114,7 +114,7 @@ description: |
   Rumale currently supports Linear / Kernel Support Vector Machine,
   Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
   Naive Bayes, Decision Tree, AdaBoost, Gradient Tree Boosting, Random Forest, Extra-Trees, K-nearest neighbor algorithm,
-  K-Means, Gaussian Mixture Model, DBSCAN, Power Iteration Clustering,
+  K-Means, K-Medoids, Gaussian Mixture Model, DBSCAN, Power Iteration Clustering,
   Multidimensional Scaling, t-SNE, Principal Component Analysis, and Non-negative Matrix Factorization.
 email:
 - yoshoku@outlook.com
@@ -150,6 +150,7 @@ files:
 - lib/rumale/clustering/dbscan.rb
 - lib/rumale/clustering/gaussian_mixture.rb
 - lib/rumale/clustering/k_means.rb
+- lib/rumale/clustering/k_medoids.rb
 - lib/rumale/clustering/power_iteration.rb
 - lib/rumale/dataset.rb
 - lib/rumale/decomposition/nmf.rb