rumale 0.8.0

data/lib/rumale/tree/decision_tree_regressor.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'rumale/tree/base_decision_tree'
+require 'rumale/base/regressor'
+
+module Rumale
+  module Tree
+    # DecisionTreeRegressor is a class that implements decision tree for regression.
+    #
+    # @example
+    #   estimator =
+    #     Rumale::Tree::DecisionTreeRegressor.new(
+    #       max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
+    #   estimator.fit(training_samples, traininig_values)
+    #   results = estimator.predict(testing_samples)
+    #
+    class DecisionTreeRegressor < BaseDecisionTree
+      include Base::Regressor
+
+      # Return the importance for each feature.
+      # @return [Numo::DFloat] (size: n_features)
+      attr_reader :feature_importances
+
+      # Return the learned tree.
+      # @return [Node]
+      attr_reader :tree
+
+      # Return the random generator for random selection of feature index.
+      # @return [Random]
+      attr_reader :rng
+
+      # Return the values assigned each leaf.
+      # @return [Numo::DFloat] (shape: [n_leafs, n_outputs])
+      attr_reader :leaf_values
+
+      # Create a new regressor with decision tree algorithm.
+      #
+      # @param criterion [String] The function to evalue spliting point. Supported criteria are 'mae' and 'mse'.
+      # @param max_depth [Integer] The maximum depth of the tree.
+      #   If nil is given, decision tree grows without concern for depth.
+      # @param max_leaf_nodes [Integer] The maximum number of leaves on decision tree.
+      #   If nil is given, number of leaves is not limited.
+      # @param min_samples_leaf [Integer] The minimum number of samples at a leaf node.
+      # @param max_features [Integer] The number of features to consider when searching optimal split point.
+      #   If nil is given, split process considers all features.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      #   It is used to randomly determine the order of features when deciding spliting point.
+      def initialize(criterion: 'mse', max_depth: nil, max_leaf_nodes: nil, min_samples_leaf: 1, max_features: nil,
+                     random_seed: nil)
+        check_params_type_or_nil(Integer, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                          max_features: max_features, random_seed: random_seed)
+        check_params_integer(min_samples_leaf: min_samples_leaf)
+        check_params_string(criterion: criterion)
+        check_params_positive(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                              min_samples_leaf: min_samples_leaf, max_features: max_features)
+        super
+        @leaf_values = nil
+      end
+
+      # Fit the model with given training data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The taget values to be used for fitting the model.
+      # @return [DecisionTreeRegressor] The learned regressor itself.
+      def fit(x, y)
+        check_sample_array(x)
+        check_tvalue_array(y)
+        check_sample_tvalue_size(x, y)
+        n_samples, n_features = x.shape
+        @params[:max_features] = n_features if @params[:max_features].nil?
+        @params[:max_features] = [@params[:max_features], n_features].min
+        @n_leaves = 0
+        @leaf_values = []
+        build_tree(x, y)
+        eval_importance(n_samples, n_features)
+        @leaf_values = Numo::DFloat.cast(@leaf_values)
+        @leaf_values = @leaf_values.flatten.dup if @leaf_values.shape[1] == 1
+        self
+      end
+
+      # Predict values for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
+      # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted values per sample.
+      def predict(x)
+        check_sample_array(x)
+        @leaf_values.shape[1].nil? ? @leaf_values[apply(x)] : @leaf_values[apply(x), true]
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about DecisionTreeRegressor
+      def marshal_dump
+        { params: @params,
+          tree: @tree,
+          feature_importances: @feature_importances,
+          leaf_values: @leaf_values,
+          rng: @rng }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @tree = obj[:tree]
+        @feature_importances = obj[:feature_importances]
+        @leaf_values = obj[:leaf_values]
+        @rng = obj[:rng]
+        nil
+      end
+
+      private
+
+      def stop_growing?(y)
+        (y - y.mean(0)).sum.abs.zero?
+      end
+
+      def put_leaf(node, y)
+        node.probs = nil
+        node.leaf = true
+        node.leaf_id = @n_leaves
+        @n_leaves += 1
+        @leaf_values.push(y.mean(0))
+        node
+      end
+
+      def impurity(values)
+        if @params[:criterion] == 'mae'
+          (values - values.mean(0)).abs.mean
+        else
+          ((values - values.mean(0))**2).mean
+        end
+      end
+    end
+  end
+end

data/lib/rumale/tree/node.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Rumale
+  module Tree
+    # Node is a class that implements node used for construction of decision tree.
+    # This class is used for internal data structures.
+    class Node
+      # @!visibility private
+      attr_accessor :depth, :impurity, :n_samples, :probs, :leaf, :leaf_id, :left, :right, :feature_id, :threshold
+
+      # Create a new node for decision tree.
+      #
+      # @param depth [Integer] The depth of the node in tree.
+      # @param impurity [Float] The impurity of the node.
+      # @param n_samples [Integer] The number of the samples in the node.
+      # @param probs [Float] The probability of the node.
+      # @param leaf [Boolean] The flag indicating whether the node is a leaf.
+      # @param leaf_id [Integer] The leaf index of the node.
+      # @param left [Node] The left node.
+      # @param right [Node] The right node.
+      # @param feature_id [Integer] The feature index used for evaluation.
+      # @param threshold [Float] The threshold value of the feature for splitting the node.
+      def initialize(depth: 0, impurity: 0.0, n_samples: 0, probs: 0.0,
+                     leaf: true, leaf_id: 0,
+                     left: nil, right: nil, feature_id: 0, threshold: 0.0)
+        @depth = depth
+        @impurity = impurity
+        @n_samples = n_samples
+        @probs = probs
+        @leaf = leaf
+        @leaf_id = leaf_id
+        @left = left
+        @right = right
+        @feature_id = feature_id
+        @threshold = threshold
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about Node
+      def marshal_dump
+        { depth: @depth,
+          impurity: @impurity,
+          n_samples: @n_samples,
+          probs: @probs,
+          leaf: @leaf,
+          leaf_id: @leaf_id,
+          left: @left,
+          right: @right,
+          feature_id: @feature_id,
+          threshold: @threshold }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @depth = obj[:depth]
+        @impurity = obj[:impurity]
+        @n_samples = obj[:n_samples]
+        @probs = obj[:probs]
+        @leaf = obj[:leaf]
+        @leaf_id = obj[:leaf_id]
+        @left = obj[:left]
+        @right = obj[:right]
+        @feature_id = obj[:feature_id]
+        @threshold = obj[:threshold]
+        nil
+      end
+    end
+  end
+end

data/lib/rumale/utils.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rumale
+  # @!visibility private
+  module Utils
+    module_function
+
+    # @!visibility private
+    def choice_ids(size, probs, rng = nil)
+      rng ||= Random.new
+      Array.new(size) do
+        target = rng.rand
+        chosen = 0
+        probs.each_with_index do |p, idx|
+          break (chosen = idx) if target <= p
+          target -= p
+        end
+        chosen
+      end
+    end
+
+    # @!visibility private
+    def rand_uniform(shape, rng = nil)
+      rng ||= Random.new
+      rnd_vals = Array.new(shape.inject(:*)) { rng.rand }
+      Numo::DFloat.asarray(rnd_vals).reshape(shape[0], shape[1])
+    end
+
+    # @!visibility private
+    def rand_normal(shape, rng = nil, mu = 0.0, sigma = 1.0)
+      rng ||= Random.new
+      a = rand_uniform(shape, rng)
+      b = rand_uniform(shape, rng)
+      (Numo::NMath.sqrt(Numo::NMath.log(a) * -2.0) * Numo::NMath.sin(b * 2.0 * Math::PI)) * sigma + mu
+    end
+  end
+end

data/lib/rumale/validation.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Rumale
+  # @!visibility private
+  module Validation
+    module_function
+
+    # @!visibility private
+    def check_sample_array(x)
+      raise TypeError, 'Expect class of sample matrix to be Numo::DFloat' unless x.is_a?(Numo::DFloat)
+      raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+      nil
+    end
+
+    # @!visibility private
+    def check_label_array(y)
+      raise TypeError, 'Expect class of label vector to be Numo::Int32' unless y.is_a?(Numo::Int32)
+      raise ArgumentError, 'Expect label vector to be 1-D arrray' unless y.shape.size == 1
+      nil
+    end
+
+    # @!visibility private
+    def check_tvalue_array(y)
+      raise TypeError, 'Expect class of target value vector to be Numo::DFloat' unless y.is_a?(Numo::DFloat)
+      nil
+    end
+
+    # @!visibility private
+    def check_sample_label_size(x, y)
+      raise ArgumentError, 'Expect to have the same number of samples for sample matrix and label vector' unless x.shape[0] == y.shape[0]
+      nil
+    end
+
+    # @!visibility private
+    def check_sample_tvalue_size(x, y)
+      raise ArgumentError, 'Expect to have the same number of samples for sample matrix and target value vector' unless x.shape[0] == y.shape[0]
+      nil
+    end
+
+    # @!visibility private
+    def check_params_type(type, params = {})
+      params.each { |k, v| raise TypeError, "Expect class of #{k} to be #{type}" unless v.is_a?(type) }
+      nil
+    end
+
+    # @!visibility private
+    def check_params_type_or_nil(type, params = {})
+      params.each { |k, v| raise TypeError, "Expect class of #{k} to be #{type} or nil" unless v.is_a?(type) || v.is_a?(NilClass) }
+      nil
+    end
+
+    # @!visibility private
+    def check_params_float(params = {})
+      check_params_type(Float, params)
+    end
+
+    # @!visibility private
+    def check_params_integer(params = {})
+      check_params_type(Integer, params)
+    end
+
+    # @!visibility private
+    def check_params_string(params = {})
+      check_params_type(String, params)
+    end
+
+    # @!visibility private
+    def check_params_boolean(params = {})
+      params.each { |k, v| raise TypeError, "Expect class of #{k} to be Boolean" unless v.is_a?(FalseClass) || v.is_a?(TrueClass) }
+      nil
+    end
+
+    # @!visibility private
+    def check_params_positive(params = {})
+      params.reject { |_, v| v.nil? }.each { |k, v| raise ArgumentError, "Expect #{k} to be positive value" if v.negative? }
+      nil
+    end
+  end
+end

data/lib/rumale/values.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rumale
+  # @!visibility private
+  module Values
+    module_function
+
+    # @!visibility private
+    def int_max
+      @int_max ||= 2**([42].pack('i').size * 16 - 2) - 1
+    end
+  end
+end

data/lib/rumale/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Rumale is a machine learning library in Ruby.
+module Rumale
+  VERSION = '0.8.0'
+end

data/rumale.gemspec

@@ -0,0 +1,41 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rumale/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rumale'
+  spec.version       = Rumale::VERSION
+  spec.authors       = ['yoshoku']
+  spec.email         = ['yoshoku@outlook.com']
+
+  spec.summary       = <<MSG
+Rumale is a machine learninig library in Ruby.
+Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
+MSG
+  spec.description   = <<MSG
+Rumale is a machine learninig library in Ruby.
+Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
+Rumale currently supports Linear / Kernel Support Vector Machine,
+Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
+Naive Bayes, Decision Tree, AdaBoost, Random Forest, K-nearest neighbor algorithm,
+K-Means, DBSCAN, Principal Component Analysis, and Non-negative Matrix Factorization.
+MSG
+  spec.homepage      = 'https://github.com/yoshoku/Rumale'
+  spec.license       = 'BSD-2-Clause'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_runtime_dependency 'numo-narray', '>= 0.9.1'
+
+  spec.add_development_dependency 'bundler', '>= 1.16'
+  spec.add_development_dependency 'coveralls', '~> 0.8'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: rumale
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- yoshoku
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |
+  Rumale is a machine learninig library in Ruby.
+  Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
+  Rumale currently supports Linear / Kernel Support Vector Machine,
+  Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
+  Naive Bayes, Decision Tree, AdaBoost, Random Forest, K-nearest neighbor algorithm,
+  K-Means, DBSCAN, Principal Component Analysis, and Non-negative Matrix Factorization.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rumale.rb
+- lib/rumale/base/base_estimator.rb
+- lib/rumale/base/classifier.rb
+- lib/rumale/base/cluster_analyzer.rb
+- lib/rumale/base/evaluator.rb
+- lib/rumale/base/regressor.rb
+- lib/rumale/base/splitter.rb
+- lib/rumale/base/transformer.rb
+- lib/rumale/clustering/dbscan.rb
+- lib/rumale/clustering/k_means.rb
+- lib/rumale/dataset.rb
+- lib/rumale/decomposition/nmf.rb
+- lib/rumale/decomposition/pca.rb
+- lib/rumale/ensemble/ada_boost_classifier.rb
+- lib/rumale/ensemble/ada_boost_regressor.rb
+- lib/rumale/ensemble/random_forest_classifier.rb
+- lib/rumale/ensemble/random_forest_regressor.rb
+- lib/rumale/evaluation_measure/accuracy.rb
+- lib/rumale/evaluation_measure/f_score.rb
+- lib/rumale/evaluation_measure/log_loss.rb
+- lib/rumale/evaluation_measure/mean_absolute_error.rb
+- lib/rumale/evaluation_measure/mean_squared_error.rb
+- lib/rumale/evaluation_measure/normalized_mutual_information.rb
+- lib/rumale/evaluation_measure/precision.rb
+- lib/rumale/evaluation_measure/precision_recall.rb
+- lib/rumale/evaluation_measure/purity.rb
+- lib/rumale/evaluation_measure/r2_score.rb
+- lib/rumale/evaluation_measure/recall.rb
+- lib/rumale/kernel_approximation/rbf.rb
+- lib/rumale/kernel_machine/kernel_svc.rb
+- lib/rumale/linear_model/base_linear_model.rb
+- lib/rumale/linear_model/lasso.rb
+- lib/rumale/linear_model/linear_regression.rb
+- lib/rumale/linear_model/logistic_regression.rb
+- lib/rumale/linear_model/ridge.rb
+- lib/rumale/linear_model/svc.rb
+- lib/rumale/linear_model/svr.rb
+- lib/rumale/model_selection/cross_validation.rb
+- lib/rumale/model_selection/grid_search_cv.rb
+- lib/rumale/model_selection/k_fold.rb
+- lib/rumale/model_selection/stratified_k_fold.rb
+- lib/rumale/multiclass/one_vs_rest_classifier.rb
+- lib/rumale/naive_bayes/naive_bayes.rb
+- lib/rumale/nearest_neighbors/k_neighbors_classifier.rb
+- lib/rumale/nearest_neighbors/k_neighbors_regressor.rb
+- lib/rumale/optimizer/nadam.rb
+- lib/rumale/optimizer/rmsprop.rb
+- lib/rumale/optimizer/sgd.rb
+- lib/rumale/optimizer/yellow_fin.rb
+- lib/rumale/pairwise_metric.rb
+- lib/rumale/pipeline/pipeline.rb
+- lib/rumale/polynomial_model/base_factorization_machine.rb
+- lib/rumale/polynomial_model/factorization_machine_classifier.rb
+- lib/rumale/polynomial_model/factorization_machine_regressor.rb
+- lib/rumale/preprocessing/l2_normalizer.rb
+- lib/rumale/preprocessing/label_encoder.rb
+- lib/rumale/preprocessing/min_max_scaler.rb
+- lib/rumale/preprocessing/one_hot_encoder.rb
+- lib/rumale/preprocessing/standard_scaler.rb
+- lib/rumale/probabilistic_output.rb
+- lib/rumale/tree/base_decision_tree.rb
+- lib/rumale/tree/decision_tree_classifier.rb
+- lib/rumale/tree/decision_tree_regressor.rb
+- lib/rumale/tree/node.rb
+- lib/rumale/utils.rb
+- lib/rumale/validation.rb
+- lib/rumale/values.rb
+- lib/rumale/version.rb
+- rumale.gemspec
+homepage: https://github.com/yoshoku/Rumale
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Rumale is a machine learninig library in Ruby. Rumale provides machine learning
+  algorithms with interfaces similar to Scikit-Learn in Python.
+test_files: []