rumale 0.12.1 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e069b026a9236e69924051af75689ba292632b50
-  data.tar.gz: b98e3260e947f66936a7149a8b09eb24bb5219fe
+  metadata.gz: 59005b59f6a6a195fbe200260e0c74008fa532fe
+  data.tar.gz: 00e40ea656556bd5a42bf7d96674e9b758ec7460
 SHA512:
-  metadata.gz: 2ff9dac0d7d633064fc3f4b5127a639a4617357c219fc20ad38c79048981c555fdddebc3f8d16047798bdfc658292e98cbc04d1f26733bcebf4a6412ca84f3ab
-  data.tar.gz: 9ad31638ea47d527a0af109a8cda2dcb44d0296ce31a88509833e4f8a116f49601dbf6353606fca080ed378425f5ce759c440791e8eccd90743ed65b14b1ef86
+  metadata.gz: 59ef5edcd1b435260e79792ed592d3b044a17c83ed23705c5f065cd46d916bb761cc8b4e1759c76cf86febf8839925ba53322ede8b29f57bdb7e7d656f92104b
+  data.tar.gz: 2ef45761c87c14882532c27e957d83adc2e40719df03a8cb497da09429713ddf946d1e6ba8bdcb73536cf6daed49c098c851b3bae2a7d828dd3efad42a712360

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.12.2
+- Add class for cluster analysis with Gaussian Mixture Model.
+- Add encoder class for categorical features.
+
 # 0.12.1
 - Refactor kernel support vector classifier.
 - Refactor random sampling on tree estimators.

data/README.md

@@ -6,7 +6,7 @@
 [![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.1)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/rumale/0.12.2)
 
 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.

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/gaussian_mixture'
 require 'rumale/clustering/dbscan'
 require 'rumale/decomposition/pca'
 require 'rumale/decomposition/nmf'
@@ -68,6 +69,7 @@ require 'rumale/preprocessing/standard_scaler'
 require 'rumale/preprocessing/bin_discretizer'
 require 'rumale/preprocessing/label_encoder'
 require 'rumale/preprocessing/one_hot_encoder'
+require 'rumale/preprocessing/ordinal_encoder'
 require 'rumale/model_selection/k_fold'
 require 'rumale/model_selection/stratified_k_fold'
 require 'rumale/model_selection/shuffle_split'

data/lib/rumale/clustering/gaussian_mixture.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/cluster_analyzer'
+require 'rumale/pairwise_metric'
+
+module Rumale
+  module Clustering
+    # GaussianMixture is a class that implements cluster analysis with gaussian mixture model.
+    # The current implementation uses only the diagonal elements of covariance matrices to represent mixture parameters
+    # without using full elements.
+    #
+    # @example
+    #   analyzer = Rumale::Clustering::GaussianMixture.new(n_clusters: 10, max_iter: 50)
+    #   cluster_labels = analyzer.fit_predict(samples)
+    class GaussianMixture
+      include Base::BaseEstimator
+      include Base::ClusterAnalyzer
+
+      # Return the number of iterations to covergence.
+      # @return [Integer]
+      attr_reader :n_iter
+
+      # Return the weight of each cluster.
+      # @return [Numo::DFloat] (shape: [n_clusters])
+      attr_reader :weights
+
+      # Return the mean of each cluster.
+      # @return [Numo::DFloat] (shape: [n_clusters, n_features])
+      attr_reader :means
+
+      # Return the diagonal elements of covariance matrix of each cluster.
+      # @return [Numo::DFloat] (shape: [n_clusters, n_features])
+      attr_reader :covariances
+
+      # Create a new cluster analyzer with gaussian mixture model.
+      #
+      # @param n_clusters [Integer] The number of clusters.
+      # @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 reg_covar [Float] The non-negative regularization to the diagonal of covariance.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_clusters: 8, init: 'k-means++', max_iter: 50, tol: 1.0e-4, reg_covar: 1.0e-6, random_seed: nil)
+        check_params_integer(n_clusters: n_clusters, max_iter: max_iter)
+        check_params_float(tol: tol)
+        check_params_string(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[:init] = init == 'random' ? 'random' : 'k-means++'
+        @params[:max_iter] = max_iter
+        @params[:tol] = tol
+        @params[:reg_covar] = reg_covar
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
+        @n_iter = nil
+        @weights = nil
+        @means = nil
+        @covariances = nil
+      end
+
+      # Analysis clusters with given training data.
+      #
+      # @overload fit(x) -> GaussianMixture
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
+      # @return [GaussianMixture] The learned cluster analyzer itself.
+      def fit(x, _y = nil)
+        check_sample_array(x)
+        n_samples = x.shape[0]
+        memberships = init_memberships(x)
+        @params[:max_iter].times do |t|
+          @n_iter = t
+          @weights = calc_weights(n_samples, memberships)
+          @means = calc_means(x, memberships)
+          @covariances = calc_diag_covariances(x, @means, memberships) + @params[:reg_covar]
+          new_memberships = calc_memberships(x, @weights, @means, @covariances)
+          error = (memberships - new_memberships).abs.max
+          break if error <= @params[:tol]
+          memberships = new_memberships.dup
+        end
+        self
+      end
+
+      # Predict cluster labels for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the cluster label.
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
+      def predict(x)
+        check_sample_array(x)
+        memberships = calc_memberships(x, @weights, @means, @covariances)
+        assign_cluster(memberships)
+      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.
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
+      def fit_predict(x)
+        check_sample_array(x)
+        fit(x).predict(x)
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data.
+      def marshal_dump
+        { params: @params,
+          n_iter: @n_iter,
+          weights: @weights,
+          means: @means,
+          covariances: @covariances }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @n_iter = obj[:n_iter]
+        @weights = obj[:weights]
+        @means = obj[:means]
+        @covariances = obj[:covariances]
+        nil
+      end
+
+      private
+
+      def assign_cluster(memberships)
+        n_clusters = memberships.shape[1]
+        memberships.max_index(axis: 1) - Numo::Int32[*0.step(memberships.size - 1, n_clusters)]
+      end
+
+      def init_memberships(x)
+        kmeans = Rumale::Clustering::KMeans.new(
+          n_clusters: @params[:n_clusters], init: @params[:init], max_iter: 0, random_seed: @params[:random_seed]
+        )
+        cluster_ids = kmeans.fit_predict(x)
+        encoder = Rumale::Preprocessing::OneHotEncoder.new
+        encoder.fit_transform(cluster_ids)
+      end
+
+      def calc_memberships(x, weights, means, diag_cov)
+        n_samples = x.shape[0]
+        n_clusters = means.shape[0]
+        memberships = Numo::DFloat.zeros(n_samples, n_clusters)
+        n_clusters.times do |n|
+          centered = x - means[n, true]
+          inv_cov = 1.0 / diag_cov[n, true]
+          sqrt_det_cov = 1.0 / Math.sqrt(diag_cov[n, true].prod)
+          memberships[true, n] = weights[n] * sqrt_det_cov * Numo::NMath.exp(-0.5 * (centered * inv_cov * centered).sum(1))
+        end
+        memberships / memberships.sum(1).expand_dims(1)
+      end
+
+      def calc_weights(n_samples, memberships)
+        memberships.sum(0) / n_samples
+      end
+
+      def calc_means(x, memberships)
+        memberships.transpose.dot(x) / memberships.sum(0).expand_dims(1)
+      end
+
+      def calc_diag_covariances(x, means, memberships)
+        n_clusters = means.shape[0]
+        diag_cov = Array.new(n_clusters) do |n|
+          centered = x - means[n, true]
+          memberships[true, n].dot(centered**2) / memberships[true, n].sum
+        end
+        Numo::DFloat.asarray(diag_cov)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/ordinal_encoder.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Transfrom categorical features to integer values.
+    #
+    # @example
+    #   encoder = Rumale::Preprocessing::OrdinalEncoder.new
+    #   training_samples = [['left', 10], ['right', 15], ['right', 20]]
+    #   training_samples = Numo::NArray.asarray(training_samples)
+    #   encoder.fit(training_samples)
+    #   p encoder.categories
+    #   # [["left", "right"], [10, 15, 20]]
+    #   testing_samples = [['left', 20], ['right', 10]]
+    #   testing_samples = Numo::NArray.asarray(testing_samples)
+    #   encoded = encoder.transform(testing_samples)
+    #   p encoded
+    #   # Numo::DFloat#shape=[2,2]
+    #   # [[0, 2],
+    #   #  [1, 0]]
+    #   p encoder.inverse_transform(encoded)
+    #   # Numo::RObject#shape=[2,2]
+    #   # [["left", 20],
+    #   #  ["right", 10]]
+    class OrdinalEncoder
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Return the array consists of categorical value each feature.
+      # @return [Array] (size: n_features)
+      attr_reader :categories
+
+      # Create a new encoder that transform categorical features to integer values.
+      #
+      # @param categories [Nil/Array] The category list for each feature.
+      #   If nil is given, extracted categories from the training data by calling the fit method are used.
+      def initialize(categories: nil)
+        check_params_type_or_nil(Array, categories: categories)
+        @categories = categories
+      end
+
+      # Fit encoder by extracting the category for each feature.
+      #
+      # @overload fit(x) -> OrdinalEncoder
+      #
+      # @param x [Numo::NArray] (shape: [n_samples, n_features]) The samples consisting of categorical features.
+      # @return [LabelEncoder]
+      def fit(x, _y = nil)
+        raise TypeError, 'Expect class of sample matrix to be Numo::NArray' unless x.is_a?(Numo::NArray)
+        raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+        n_features = x.shape[1]
+        @categories = Array.new(n_features) { |n| x[true, n].to_a.uniq.sort }
+        self
+      end
+
+      # Fit encoder, then return encoded categorical features to integer values.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::NArray] (shape: [n_samples, n_features]) The samples consisting of categorical features.
+      # @return [Numo::DFloat] The encoded categorical features to integer values.
+      def fit_transform(x, _y = nil)
+        raise TypeError, 'Expect class of sample matrix to be Numo::NArray' unless x.is_a?(Numo::NArray)
+        raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+        fit(x).transform(x)
+      end
+
+      # Encode categorical features.
+      #
+      # @param x [Numo::NArray] (shape: [n_samples, n_features]) The samples consisting of categorical features.
+      # @return [Numo::DFloat] The encoded categorical features to integer values.
+      def transform(x)
+        raise TypeError, 'Expect class of sample matrix to be Numo::NArray' unless x.is_a?(Numo::NArray)
+        raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+
+        n_features = x.shape[1]
+        raise ArgumentError, 'Expect the number of features and the number of categories to be equal' if n_features != @categories.size
+
+        transformed = Array.new(n_features) do |n|
+          x[true, n].to_a.map { |v| @categories[n].index(v) }
+        end
+
+        Numo::DFloat.asarray(transformed.transpose)
+      end
+
+      # Decode values to categorical features.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples consisting of values transformed from categorical features.
+      # @return [Numo::NArray] The decoded features.
+      def inverse_transform(x)
+        check_sample_array(x)
+
+        n_features = x.shape[1]
+        raise ArgumentError, 'Expect the number of features and the number of categories to be equal' if n_features != @categories.size
+
+        inv_transformed = Array.new(n_features) do |n|
+          x[true, n].to_a.map { |i| @categories[n][i.to_i] }
+        end
+
+        Numo::NArray.asarray(inv_transformed.transpose)
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about OrdinalEncoder.
+      def marshal_dump
+        { categories: @categories }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @categories = obj[:categories]
+        nil
+      end
+    end
+  end
+end

data/lib/rumale/tree/base_decision_tree.rb

@@ -70,7 +70,7 @@ module Rumale
 
       def grow_node(depth, x, y, impurity)
         # intialize node.
-        n_samples, n_features = x.shape
+        n_samples = x.shape[0]
         node = Node.new(depth: depth, impurity: impurity, n_samples: n_samples)
 
         # terminate growing.

data/lib/rumale/tree/gradient_tree_regressor.rb

@@ -155,7 +155,7 @@ module Rumale
       def build_tree(x, y, g, h)
         @feature_ids = Array.new(x.shape[1]) { |v| v }
         @tree = grow_node(0, x, y, g, h)
-				@feature_ids = nil
+        @feature_ids = nil
         nil
       end
 
@@ -163,7 +163,7 @@ module Rumale
         # intialize some variables.
         sum_g = g.sum
         sum_h = h.sum
-        n_samples, n_features = x.shape
+        n_samples = x.shape[0]
         node = Node.new(depth: depth, n_samples: n_samples)
 
         # terminate growing.

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.1'
+  VERSION = '0.12.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.12.2
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-08 00:00:00.000000000 Z
+date: 2019-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -147,6 +147,7 @@ files:
 - lib/rumale/base/splitter.rb
 - lib/rumale/base/transformer.rb
 - lib/rumale/clustering/dbscan.rb
+- lib/rumale/clustering/gaussian_mixture.rb
 - lib/rumale/clustering/k_means.rb
 - lib/rumale/dataset.rb
 - lib/rumale/decomposition/nmf.rb
@@ -213,6 +214,7 @@ files:
 - lib/rumale/preprocessing/max_abs_scaler.rb
 - lib/rumale/preprocessing/min_max_scaler.rb
 - lib/rumale/preprocessing/one_hot_encoder.rb
+- lib/rumale/preprocessing/ordinal_encoder.rb
 - lib/rumale/preprocessing/standard_scaler.rb
 - lib/rumale/probabilistic_output.rb
 - lib/rumale/tree/base_decision_tree.rb