rumale 0.22.2 → 0.23.1

data/lib/rumale/model_selection/grid_search_cv.rb

@@ -160,15 +160,15 @@ module Rumale
         grid = [grid] if grid.is_a?(Hash)
         grid.each do |h|
           raise TypeError, 'Expect class of elements in param_grid to be Hash' unless h.is_a?(Hash)
-          raise TypeError, 'Expect class of parameter values in param_grid to be Array' unless h.values.all? { |v| v.is_a?(Array) }
+          raise TypeError, 'Expect class of parameter values in param_grid to be Array' unless h.values.all?(Array)
         end
         grid
       end
 
       def param_combinations
         @param_combinations ||= @params[:param_grid].map do |prm|
-          x = Hash[prm.sort].map { |k, v| [k].product(v) }
-          x[0].product(*x[1...x.size]).map { |v| Hash[v] }
+          x = prm.sort.to_h.map { |k, v| [k].product(v) }
+          x[0].product(*x[1...x.size]).map(&:to_h)
         end
       end
 

data/lib/rumale/naive_bayes/bernoulli_nb.rb

@@ -75,7 +75,7 @@ module Rumale
             (Numo::DFloat[*bin_x] * Numo::NMath.log(@feature_probs[l, true])).sum(1)
             (Numo::DFloat[*not_bin_x] * Numo::NMath.log(1.0 - @feature_probs[l, true])).sum(1))
         end
-        Numo::DFloat[*log_likelihoods].transpose
+        Numo::DFloat[*log_likelihoods].transpose.dup
       end
     end
   end

data/lib/rumale/naive_bayes/gaussian_nb.rb

@@ -62,7 +62,7 @@ module Rumale
             Numo::NMath.log(2.0 * Math::PI * @variances[l, true]) +
             ((x - @means[l, true])**2 / @variances[l, true])).sum(1)
         end
-        Numo::DFloat[*log_likelihoods].transpose
+        Numo::DFloat[*log_likelihoods].transpose.dup
       end
     end
   end

data/lib/rumale/naive_bayes/multinomial_nb.rb

@@ -67,7 +67,7 @@ module Rumale
         log_likelihoods = Array.new(n_classes) do |l|
           Math.log(@class_priors[l]) + (Numo::DFloat[*bin_x] * Numo::NMath.log(@feature_probs[l, true])).sum(1)
         end
-        Numo::DFloat[*log_likelihoods].transpose
+        Numo::DFloat[*log_likelihoods].transpose.dup
       end
     end
   end

data/lib/rumale/preprocessing/kernel_calculator.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+require 'rumale/pairwise_metric'
+
+module Rumale
+  module Preprocessing
+    # KernelCalculator is a class that calculates the kernel matrix with training data.
+    #
+    # @example
+    #   transformer = Rumale::Preprocessing::KernelCalculator.new(kernel: 'rbf', gamma: 0.5)
+    #   regressor = Rumale::KernelMachine::KernelRidge.new
+    #   pipeline = Rumale::Pipeline::Pipeline.new(
+    #     steps: { trs: transfomer, est: regressor }
+    #   )
+    #   pipeline.fit(x_train, y_train)
+    #   results = pipeline.predict(x_test)
+    class KernelCalculator
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Returns the training data for calculating kernel matrix.
+      # @return [Numo::DFloat] (shape: n_components, n_features)
+      attr_reader :components
+
+      # Create a new transformer that transforms feature vectors into a kernel matrix.
+      #
+      # @param kernel [String] The type of kernel function ('rbf', 'linear', 'poly', and 'sigmoid').
+      # @param gamma [Float] The gamma parameter in rbf/poly/sigmoid kernel function.
+      # @param degree [Integer] The degree parameter in polynomial kernel function.
+      # @param coef [Float] The coefficient in poly/sigmoid kernel function.
+      def initialize(kernel: 'rbf', gamma: 1, degree: 3, coef: 1)
+        check_params_string(kernel: kernel)
+        check_params_numeric(gamma: gamma, coef: coef, degree: degree)
+        @params = {}
+        @params[:kernel] = kernel
+        @params[:gamma] = gamma
+        @params[:degree] = degree
+        @params[:coef] = coef
+        @components = nil
+      end
+
+      # Fit the model with given training data.
+      #
+      # @overload fit(x) -> KernelCalculator
+      #   @param x [Numo::NArray] (shape: [n_samples, n_features]) The training data to be used for calculating kernel matrix.
+      # @return [KernelCalculator] The learned transformer itself.
+      def fit(x, _y = nil)
+        x = check_convert_sample_array(x)
+        @components = x.dup
+        self
+      end
+
+      # Fit the model with training data, and then transform them with the learned model.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for calculating kernel matrix.
+      # @return [Numo::DFloat] (shape: [n_samples, n_samples]) The calculated kernel matrix.
+      def fit_transform(x, y = nil)
+        x = check_convert_sample_array(x)
+        fit(x, y).transform(x)
+      end
+
+      # Transform the given data with the learned model.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be used for calculating kernel matrix with the training data.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The calculated kernel matrix.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        kernel_mat(x, @components)
+      end
+
+      private
+
+      def kernel_mat(x, y)
+        case @params[:kernel]
+        when 'rbf'
+          Rumale::PairwiseMetric.rbf_kernel(x, y, @params[:gamma])
+        when 'poly'
+          Rumale::PairwiseMetric.polynomial_kernel(x, y, @params[:degree], @params[:gamma], @params[:coef])
+        when 'sigmoid'
+          Rumale::PairwiseMetric.sigmoid_kernel(x, y, @params[:gamma], @params[:coef])
+        when 'linear'
+          Rumale::PairwiseMetric.linear_kernel(x, y)
+        else
+          raise ArgumentError, "Expect kernel parameter to be given 'rbf', 'linear', 'poly', or 'sigmoid'."
+        end
+      end
+    end
+  end
+end

data/lib/rumale/tree/base_decision_tree.rb

@@ -2,6 +2,7 @@
 
 require 'rumale/base/base_estimator'
 require 'rumale/tree/node'
+require 'rumale/rumaleext'
 
 module Rumale
   # This module consists of the classes that implement tree models.
@@ -44,21 +45,25 @@ module Rumale
       # @return [Numo::Int32] (shape: [n_samples]) Leaf index for sample.
       def apply(x)
         x = check_convert_sample_array(x)
-        Numo::Int32[*(Array.new(x.shape[0]) { |n| apply_at_node(@tree, x[n, true]) })]
+        Numo::Int32[*(Array.new(x.shape[0]) { |n| partial_apply(@tree, x[n, true]) })]
       end
 
       private
 
-      def apply_at_node(node, sample)
-        return node.leaf_id if node.leaf
-        return apply_at_node(node.left, sample) if node.right.nil?
-        return apply_at_node(node.right, sample) if node.left.nil?
-
-        if sample[node.feature_id] <= node.threshold
-          apply_at_node(node.left, sample)
-        else
-          apply_at_node(node.right, sample)
+      def partial_apply(tree, sample)
+        node = tree
+        until node.leaf
+          # :nocov:
+          node = if node.right.nil?
+                   node.left
+                 elsif node.left.nil?
+                   node.right
+                   # :nocov:
+                 else
+                   sample[node.feature_id] <= node.threshold ? node.left : node.right
+                 end
         end
+        node.leaf_id
       end
 
       def build_tree(x, y)

data/lib/rumale/tree/decision_tree_classifier.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'rumale/rumale'
 require 'rumale/tree/base_decision_tree'
 require 'rumale/base/classifier'
 
@@ -101,21 +100,25 @@ module Rumale
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
         x = check_convert_sample_array(x)
-        Numo::DFloat[*(Array.new(x.shape[0]) { |n| predict_proba_at_node(@tree, x[n, true]) })]
+        Numo::DFloat[*(Array.new(x.shape[0]) { |n| partial_predict_proba(@tree, x[n, true]) })]
       end
 
       private
 
-      def predict_proba_at_node(node, sample)
-        return node.probs if node.leaf
-        return predict_proba_at_node(node.left, sample) if node.right.nil?
-        return predict_proba_at_node(node.right, sample) if node.left.nil?
-
-        if sample[node.feature_id] <= node.threshold
-          predict_proba_at_node(node.left, sample)
-        else
-          predict_proba_at_node(node.right, sample)
+      def partial_predict_proba(tree, sample)
+        node = tree
+        until node.leaf
+          # :nocov:
+          node = if node.right.nil?
+                   node.left
+                 elsif node.left.nil?
+                   node.right
+                   # :nocov:
+                 else
+                   sample[node.feature_id] <= node.threshold ? node.left : node.right
+                 end
         end
+        node.probs
       end
 
       def stop_growing?(y)

data/lib/rumale/tree/decision_tree_regressor.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'rumale/rumale'
 require 'rumale/tree/base_decision_tree'
 require 'rumale/base/regressor'
 

data/lib/rumale/tree/gradient_tree_regressor.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'rumale/rumale'
 require 'rumale/base/base_estimator'
 require 'rumale/base/regressor'
+require 'rumale/rumaleext'
 require 'rumale/tree/node'
 
 module Rumale
@@ -114,21 +114,25 @@ module Rumale
       # @return [Numo::Int32] (shape: [n_samples]) Leaf index for sample.
       def apply(x)
         x = check_convert_sample_array(x)
-        Numo::Int32[*(Array.new(x.shape[0]) { |n| apply_at_node(@tree, x[n, true]) })]
+        Numo::Int32[*(Array.new(x.shape[0]) { |n| partial_apply(@tree, x[n, true]) })]
       end
 
       private
 
-      def apply_at_node(node, sample)
-        return node.leaf_id if node.leaf
-        return apply_at_node(node.left, sample) if node.right.nil?
-        return apply_at_node(node.right, sample) if node.left.nil?
-
-        if sample[node.feature_id] <= node.threshold
-          apply_at_node(node.left, sample)
-        else
-          apply_at_node(node.right, sample)
+      def partial_apply(tree, sample)
+        node = tree
+        until node.leaf
+          # :nocov:
+          node = if node.right.nil?
+                   node.left
+                 elsif node.left.nil?
+                   node.right
+                   # :nocov:
+                 else
+                   sample[node.feature_id] <= node.threshold ? node.left : node.right
+                 end
         end
+        node.leaf_id
       end
 
       def build_tree(x, y, g, h)

data/lib/rumale/validation.rb

@@ -27,6 +27,7 @@ module Rumale
       y
     end
 
+    # @deprecated Use check_convert_sample_array instead of this method.
     # @!visibility private
     def check_sample_array(x)
       raise TypeError, 'Expect class of sample matrix to be Numo::DFloat' unless x.is_a?(Numo::DFloat)
@@ -35,6 +36,7 @@ module Rumale
       nil
     end
 
+    # @deprecated Use check_convert_label_array instead of this method.
     # @!visibility private
     def check_label_array(y)
       raise TypeError, 'Expect class of label vector to be Numo::Int32' unless y.is_a?(Numo::Int32)
@@ -43,6 +45,7 @@ module Rumale
       nil
     end
 
+    # @deprecated Use check_convert_tvalue_array instead of this method.
     # @!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)
@@ -64,49 +67,58 @@ module Rumale
       nil
     end
 
+    # TODO: Better to replace with RBS in the future.
     # @!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
 
+    # TODO: Better to replace with RBS in the future.
     # @!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
 
+    # TODO: Better to replace with RBS in the future.
     # @!visibility private
     def check_params_numeric(params = {})
       check_params_type(Numeric, params)
     end
 
+    # TODO: Better to replace with RBS in the future.
     # @!visibility private
     def check_params_numeric_or_nil(params = {})
       check_params_type_or_nil(Numeric, params)
     end
 
+    # @deprecated Use check_params_numeric instead of this method.
     # @!visibility private
     def check_params_float(params = {})
       check_params_type(Float, params)
     end
 
+    # @deprecated Use check_params_numeric instead of this method.
     # @!visibility private
     def check_params_integer(params = {})
       check_params_type(Integer, params)
     end
 
+    # TODO: Better to replace with RBS in the future.
     # @!visibility private
     def check_params_string(params = {})
       check_params_type(String, params)
     end
 
+    # TODO: Better to replace with RBS in the future.
     # @!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
 
+    # TODO: Better to replace with RBS in the future.
     # @!visibility private
     def check_params_positive(params = {})
       params.compact.each { |k, v| raise ArgumentError, "Expect #{k} to be positive value" if v.negative? }

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.22.2'
+  VERSION = '0.23.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.22.2
+  version: 0.23.1
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-10 00:00:00.000000000 Z
+date: 2021-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -57,11 +57,13 @@ extensions:
 - ext/rumale/extconf.rb
 extra_rdoc_files: []
 files:
+- ".clang-format"
+- ".coveralls.yml"
 - ".github/workflows/build.yml"
+- ".github/workflows/coverage.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -69,8 +71,8 @@ files:
 - README.md
 - Rakefile
 - ext/rumale/extconf.rb
-- ext/rumale/rumale.c
-- ext/rumale/rumale.h
+- ext/rumale/rumaleext.c
+- ext/rumale/rumaleext.h
 - ext/rumale/tree.c
 - ext/rumale/tree.h
 - lib/rumale.rb
@@ -106,6 +108,8 @@ files:
 - lib/rumale/ensemble/random_forest_regressor.rb
 - lib/rumale/ensemble/stacking_classifier.rb
 - lib/rumale/ensemble/stacking_regressor.rb
+- lib/rumale/ensemble/voting_classifier.rb
+- lib/rumale/ensemble/voting_regressor.rb
 - lib/rumale/evaluation_measure/accuracy.rb
 - lib/rumale/evaluation_measure/adjusted_rand_score.rb
 - lib/rumale/evaluation_measure/calinski_harabasz_score.rb
@@ -135,12 +139,14 @@ files:
 - lib/rumale/kernel_machine/kernel_fda.rb
 - lib/rumale/kernel_machine/kernel_pca.rb
 - lib/rumale/kernel_machine/kernel_ridge.rb
+- lib/rumale/kernel_machine/kernel_ridge_classifier.rb
 - lib/rumale/kernel_machine/kernel_svc.rb
 - lib/rumale/linear_model/base_sgd.rb
 - lib/rumale/linear_model/elastic_net.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/nnls.rb
 - lib/rumale/linear_model/ridge.rb
 - lib/rumale/linear_model/svc.rb
 - lib/rumale/linear_model/svr.rb
@@ -178,6 +184,7 @@ files:
 - lib/rumale/pipeline/pipeline.rb
 - lib/rumale/preprocessing/bin_discretizer.rb
 - lib/rumale/preprocessing/binarizer.rb
+- lib/rumale/preprocessing/kernel_calculator.rb
 - lib/rumale/preprocessing/l1_normalizer.rb
 - lib/rumale/preprocessing/l2_normalizer.rb
 - lib/rumale/preprocessing/label_binarizer.rb
@@ -226,7 +233,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Rumale is a machine learning library in Ruby. Rumale provides machine learning