rumale 0.22.1 → 0.22.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 475798da3815141b5337bc7803eca26978bbc98c36a2be4d681bc63f778f5840
-  data.tar.gz: 71841127edccbeea2b30c4bd8a744735933c1fcf8c7d6afa507cd2d361c8b5c8
+  metadata.gz: 703a6895f4218ca45c5d5ae5e86559b077cf1be213d4939eb1e9ab94eac4621d
+  data.tar.gz: 5862466e565d1e6030c35494b5028ae980a47d373e90050c62266055fcecd374
 SHA512:
-  metadata.gz: 8c90eaffa3847e3cc4f31c58e3d74f66a86e2cf0bd1c6e5aa386f9519de3984ac1c605187119e0ec01585c82cf8c06e4f4aa2f19c7b40883b784e834e2e801d8
-  data.tar.gz: 336b1afcc35e52e1c13ced74f527d54c994ff66509cf9b8b2f81dce62692078964a453df790a5bcaf8ea2bd156277d719a33958de2f57aa64d97beeafdc48d01
+  metadata.gz: 988d55c681a102e0c65b9133c6aeafc049e33755955f959d6e6046f5601dd192af881424355a2b373ed2e7a5a16b74236698aef5372e09584b10fe28d1b7bc21
+  data.tar.gz: adc58efa3b46d9fc1a87ddb2a4df32472507d61f21a3a0eb07026068cc5e41af166fb0a0f8ae23f1b23aec649b22835a50edbed79d35255e8cc231b82b31eb8c

data/.github/workflows/build.yml

@@ -1,6 +1,6 @@
 name: build
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:

data/.rubocop.yml

@@ -1,5 +1,6 @@
 require:
   - rubocop-performance
+  - rubocop-rake
   - rubocop-rspec
 
 AllCops:

data/CHANGELOG.md

@@ -1,5 +1,11 @@
+# 0.22.2
+- Add classifier and regressor classes for stacking method.
+  - [StackingClassifier](https://yoshoku.github.io/rumale/doc/Rumale/Ensemble/StackingClassifier.html)
+  - [StackingRegressor](https://yoshoku.github.io/rumale/doc/Rumale/Ensemble/StackingRegressor.html)
+- Refactor some codes with Rubocop.
+
 # 0.22.1
-- Add transfomer class for MLKR, that implements Metric Learning for Kernel Regression.
+- Add transfomer class for [MLKR](https://yoshoku.github.io/rumale/doc/Rumale/MetricLearning/MLKR.html), that implements Metric Learning for Kernel Regression.
 - Refactor NeighbourhoodComponentAnalysis.
 - Update API documentation.
 

data/Gemfile

@@ -9,7 +9,8 @@ gem 'parallel', '>= 1.17.0'
 gem 'rake', '~> 12.0'
 gem 'rake-compiler', '~> 1.0'
 gem 'rspec', '~> 3.0'
-gem 'rubocop', '~> 0.91'
+gem 'rubocop', '~> 1.0'
 gem 'rubocop-performance', '~> 1.8'
-gem 'rubocop-rspec', '~> 1.43'
+gem 'rubocop-rake', '~> 0.5'
+gem 'rubocop-rspec', '~> 2.0'
 gem 'simplecov', '~> 0.19'

data/README.md

@@ -4,7 +4,7 @@
 
 [![Build Status](https://github.com/yoshoku/rumale/workflows/build/badge.svg)](https://github.com/yoshoku/rumale/actions?query=workflow%3Abuild)
 [![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)
+[![BSD 2-Clause License](https://img.shields.io/badge/License-BSD%202--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/main/LICENSE.txt)
 [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/rumale/doc/)
 
 Rumale (**Ru**by **ma**chine **le**arning) is a machine learning library in Ruby.
@@ -244,4 +244,4 @@ The gem is available as open source under the terms of the [BSD 2-clause License
 ## Code of Conduct
 
 Everyone interacting in the Rumale project’s codebases, issue trackers,
-chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/yoshoku/Rumale/blob/master/CODE_OF_CONDUCT.md).
+chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/yoshoku/Rumale/blob/main/CODE_OF_CONDUCT.md).

data/lib/rumale.rb

@@ -59,6 +59,8 @@ require 'rumale/ensemble/random_forest_classifier'
 require 'rumale/ensemble/random_forest_regressor'
 require 'rumale/ensemble/extra_trees_classifier'
 require 'rumale/ensemble/extra_trees_regressor'
+require 'rumale/ensemble/stacking_classifier'
+require 'rumale/ensemble/stacking_regressor'
 require 'rumale/clustering/k_means'
 require 'rumale/clustering/mini_batch_k_means'
 require 'rumale/clustering/k_medoids'

data/lib/rumale/decomposition/pca.rb

@@ -59,7 +59,7 @@ module Rumale
         @params[:solver] = if solver == 'auto'
                              load_linalg? ? 'evd' : 'fpt'
                            else
-                             solver != 'evd' ? 'fpt' : 'evd'
+                             solver != 'evd' ? 'fpt' : 'evd' # rubocop:disable Style/NegatedIfElseCondition
                            end
         @params[:n_components] = n_components
         @params[:max_iter] = max_iter

data/lib/rumale/ensemble/stacking_classifier.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/classifier'
+
+module Rumale
+  module Ensemble
+    # StackingClassifier is a class that implements classifier with stacking method.
+    #
+    # @example
+    #   estimators = {
+    #     lgr: Rumale::LinearModel::LogisticRegression.new(reg_param: 1e-2, random_seed: 1),
+    #     mlp: Rumele::NeuralNetwork::MLPClassifier.new(hidden_units: [256], random_seed: 1),
+    #     rnd: Rumale::Ensemble::RandomForestClassifier.new(random_seed: 1)
+    #   }
+    #   meta_estimator = Rumale::LinearModel::LogisticRegression.new(random_seed: 1)
+    #   classifier = Rumale::Ensemble::StackedClassifier.new(
+    #     estimators: estimators, meta_estimator: meta_estimator, random_seed: 1
+    #   )
+    #   classifier.fit(training_samples, traininig_labels)
+    #   results = classifier.predict(testing_samples)
+    #
+    # *Reference*
+    # - Zhou, Z-H., "Ensemble Mehotds - Foundations and Algorithms," CRC Press Taylor and Francis Group, Chapman and Hall/CRC, 2012.
+    class StackingClassifier
+      include Base::BaseEstimator
+      include Base::Classifier
+
+      # Return the base classifiers.
+      # @return [Hash<Symbol,Classifier>]
+      attr_reader :estimators
+
+      # Return the meta classifier.
+      # @return [Classifier]
+      attr_reader :meta_estimator
+
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the method used by each base classifier.
+      # @return [Hash<Symbol,Symbol>]
+      attr_reader :stack_method
+
+      # Create a new classifier with stacking method.
+      #
+      # @param estimators [Hash<Symbol,Classifier>] The base classifiers for extracting meta features.
+      # @param meta_estimator [Classifier/Nil] The meta classifier that predicts class label.
+      #   If nil is given, LogisticRegression is used.
+      # @param n_splits [Integer] The number of folds for cross validation with stratified k-fold on meta feature extraction in training phase.
+      # @param shuffle [Boolean] The flag indicating whether to shuffle the dataset on cross validation.
+      # @param stack_method [String] The method name of base classifier for using meta feature extraction.
+      #   If 'auto' is given, it searches the callable method in the order 'predict_proba', 'decision_function', and 'predict'
+      #   on each classifier.
+      # @param passthrough [Boolean] The flag indicating whether to concatenate the original features and meta features when training the meta classifier.
+      # @param random_seed [Integer/Nil] The seed value using to initialize the random generator on cross validation.
+      def initialize(estimators:, meta_estimator: nil, n_splits: 5, shuffle: true, stack_method: 'auto', passthrough: false, random_seed: nil)
+        check_params_type(Hash, estimators: estimators)
+        check_params_numeric(n_splits: n_splits)
+        check_params_string(stack_method: stack_method)
+        check_params_boolean(shuffle: shuffle, passthrough: passthrough)
+        check_params_numeric_or_nil(random_seed: random_seed)
+        @estimators = estimators
+        @meta_estimator = meta_estimator || Rumale::LinearModel::LogisticRegression.new
+        @classes = nil
+        @stack_method = nil
+        @output_size = nil
+        @params = {}
+        @params[:n_splits] = n_splits
+        @params[:shuffle] = shuffle
+        @params[:stack_method] = stack_method
+        @params[:passthrough] = passthrough
+        @params[:random_seed] = random_seed || srand
+      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::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
+      # @return [StackedClassifier] The learned classifier itself.
+      def fit(x, y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
+        check_sample_label_size(x, y)
+
+        n_samples, n_features = x.shape
+
+        @encoder = Rumale::Preprocessing::LabelEncoder.new
+        y_encoded = @encoder.fit_transform(y)
+        @classes = Numo::NArray[*@encoder.classes]
+
+        # training base classifiers with all training data.
+        @estimators.each_key { |name| @estimators[name].fit(x, y_encoded) }
+
+        # detecting feature extraction method and its size of output for each base classifier.
+        @stack_method = detect_stack_method
+        @output_size = detect_output_size(n_features)
+
+        # extracting meta features with base classifiers.
+        n_components = @output_size.values.inject(:+)
+        z = Numo::DFloat.zeros(n_samples, n_components)
+
+        kf = Rumale::ModelSelection::StratifiedKFold.new(
+          n_splits: @params[:n_splits], shuffle: @params[:shuffle], random_seed: @params[:random_seed]
+        )
+
+        kf.split(x, y_encoded).each do |train_ids, valid_ids|
+          x_train = x[train_ids, true]
+          y_train = y_encoded[train_ids]
+          x_valid = x[valid_ids, true]
+          f_start = 0
+          @estimators.each_key do |name|
+            est_fold = Marshal.load(Marshal.dump(@estimators[name]))
+            f_last = f_start + @output_size[name]
+            f_position = @output_size[name] == 1 ? f_start : f_start...f_last
+            z[valid_ids, f_position] = est_fold.fit(x_train, y_train).public_send(@stack_method[name], x_valid)
+            f_start = f_last
+          end
+        end
+
+        # concatenating original features.
+        z = Numo::NArray.hstack([z, x]) if @params[:passthrough]
+
+        # training meta classifier.
+        @meta_estimator.fit(z, y_encoded)
+
+        self
+      end
+
+      # Calculate confidence scores for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) The confidence score per sample.
+      def decision_function(x)
+        x = check_convert_sample_array(x)
+        z = transform(x)
+        @meta_estimator.decision_function(z)
+      end
+
+      # Predict class labels for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
+      # @return [Numo::Int32] (shape: [n_samples]) The predicted class label per sample.
+      def predict(x)
+        x = check_convert_sample_array(x)
+        z = transform(x)
+        Numo::Int32.cast(@encoder.inverse_transform(@meta_estimator.predict(z)))
+      end
+
+      # Predict probability for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) The predicted probability of each class per sample.
+      def predict_proba(x)
+        x = check_convert_sample_array(x)
+        z = transform(x)
+        @meta_estimator.predict_proba(z)
+      end
+
+      # Transform the given data with the learned model.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be transformed with the learned model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The meta features for samples.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        n_samples = x.shape[0]
+        n_components = @output_size.values.inject(:+)
+        z = Numo::DFloat.zeros(n_samples, n_components)
+        f_start = 0
+        @estimators.each_key do |name|
+          f_last = f_start + @output_size[name]
+          f_position = @output_size[name] == 1 ? f_start : f_start...f_last
+          z[true, f_position] = @estimators[name].public_send(@stack_method[name], x)
+          f_start = f_last
+        end
+        z = Numo::NArray.hstack([z, x]) if @params[:passthrough]
+        z
+      end
+
+      # Fit the model with training data, and then transform them with the learned model.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The meta features for training data.
+      def fit_transform(x, y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
+        fit(x, y).transform(x)
+      end
+
+      private
+
+      STACK_METHODS = %i[predict_proba decision_function predict].freeze
+
+      private_constant :STACK_METHODS
+
+      def detect_stack_method
+        if @params[:stack_method] == 'auto'
+          @estimators.each_key.with_object({}) { |name, obj| obj[name] = STACK_METHODS.detect { |m| @estimators[name].respond_to?(m) } }
+        else
+          @estimators.each_key.with_object({}) { |name, obj| obj[name] = @params[:stack_method].to_sym }
+        end
+      end
+
+      def detect_output_size(n_features)
+        x_dummy = Numo::DFloat.new(2, n_features).rand
+        @estimators.each_key.with_object({}) do |name, obj|
+          output_dummy = @estimators[name].public_send(@stack_method[name], x_dummy)
+          obj[name] = output_dummy.ndim == 1 ? 1 : output_dummy.shape[1]
+        end
+      end
+    end
+  end
+end

data/lib/rumale/ensemble/stacking_regressor.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/regressor'
+
+module Rumale
+  module Ensemble
+    # StackingRegressor is a class that implements regressor with stacking method.
+    #
+    # @example
+    #   estimators = {
+    #     las: Rumale::LinearModel::Lasso.new(reg_param: 1e-2, random_seed: 1),
+    #     mlp: Rumele::NeuralNetwork::MLPRegressor.new(hidden_units: [256], random_seed: 1),
+    #     rnd: Rumale::Ensemble::RandomForestRegressor.new(random_seed: 1)
+    #   }
+    #   meta_estimator = Rumale::LinearModel::Ridge.new(random_seed: 1)
+    #   regressor = Rumale::Ensemble::StackedRegressor.new(
+    #     estimators: estimators, meta_estimator: meta_estimator, random_seed: 1
+    #   )
+    #   regressor.fit(training_samples, traininig_values)
+    #   results = regressor.predict(testing_samples)
+    #
+    # *Reference*
+    # - Zhou, Z-H., "Ensemble Mehotds - Foundations and Algorithms," CRC Press Taylor and Francis Group, Chapman and Hall/CRC, 2012.
+    class StackingRegressor
+      include Base::BaseEstimator
+      include Base::Regressor
+
+      # Return the base regressors.
+      # @return [Hash<Symbol,Regressor>]
+      attr_reader :estimators
+
+      # Return the meta regressor.
+      # @return [Regressor]
+      attr_reader :meta_estimator
+
+      # Create a new regressor with stacking method.
+      #
+      # @param estimators [Hash<Symbol,Regressor>] The base regressors for extracting meta features.
+      # @param meta_estimator [Regressor/Nil] The meta regressor that predicts values.
+      #   If nil is given, Ridge is used.
+      # @param n_splits [Integer] The number of folds for cross validation with k-fold on meta feature extraction in training phase.
+      # @param shuffle [Boolean] The flag indicating whether to shuffle the dataset on cross validation.
+      # @param passthrough [Boolean] The flag indicating whether to concatenate the original features and meta features when training the meta regressor.
+      # @param random_seed [Integer/Nil] The seed value using to initialize the random generator on cross validation.
+      def initialize(estimators:, meta_estimator: nil, n_splits: 5, shuffle: true, passthrough: false, random_seed: nil)
+        check_params_type(Hash, estimators: estimators)
+        check_params_numeric(n_splits: n_splits)
+        check_params_boolean(shuffle: shuffle, passthrough: passthrough)
+        check_params_numeric_or_nil(random_seed: random_seed)
+        @estimators = estimators
+        @meta_estimator = meta_estimator || Rumale::LinearModel::Ridge.new
+        @output_size = nil
+        @params = {}
+        @params[:n_splits] = n_splits
+        @params[:shuffle] = shuffle
+        @params[:passthrough] = passthrough
+        @params[:random_seed] = random_seed || srand
+      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 target variables to be used for fitting the model.
+      # @return [StackedRegressor] The learned regressor itself.
+      def fit(x, y)
+        x = check_convert_sample_array(x)
+        y = check_convert_tvalue_array(y)
+        check_sample_tvalue_size(x, y)
+
+        n_samples, n_features = x.shape
+        n_outputs = y.ndim == 1 ? 1 : y.shape[1]
+
+        # training base regressors with all training data.
+        @estimators.each_key { |name| @estimators[name].fit(x, y) }
+
+        # detecting size of output for each base regressor.
+        @output_size = detect_output_size(n_features)
+
+        # extracting meta features with base regressors.
+        n_components = @output_size.values.inject(:+)
+        z = Numo::DFloat.zeros(n_samples, n_components)
+
+        kf = Rumale::ModelSelection::KFold.new(
+          n_splits: @params[:n_splits], shuffle: @params[:shuffle], random_seed: @params[:random_seed]
+        )
+
+        kf.split(x, y).each do |train_ids, valid_ids|
+          x_train = x[train_ids, true]
+          y_train = n_outputs == 1 ? y[train_ids] : y[train_ids, true]
+          x_valid = x[valid_ids, true]
+          f_start = 0
+          @estimators.each_key do |name|
+            est_fold = Marshal.load(Marshal.dump(@estimators[name]))
+            f_last = f_start + @output_size[name]
+            f_position = @output_size[name] == 1 ? f_start : f_start...f_last
+            z[valid_ids, f_position] = est_fold.fit(x_train, y_train).predict(x_valid)
+            f_start = f_last
+          end
+        end
+
+        # concatenating original features.
+        z = Numo::NArray.hstack([z, x]) if @params[:passthrough]
+
+        # training meta regressor.
+        @meta_estimator.fit(z, y)
+
+        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]) The predicted values per sample.
+      def predict(x)
+        x = check_convert_sample_array(x)
+        z = transform(x)
+        @meta_estimator.predict(z)
+      end
+
+      # Transform the given data with the learned model.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be transformed with the learned model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The meta features for samples.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        n_samples = x.shape[0]
+        n_components = @output_size.values.inject(:+)
+        z = Numo::DFloat.zeros(n_samples, n_components)
+        f_start = 0
+        @estimators.each_key do |name|
+          f_last = f_start + @output_size[name]
+          f_position = @output_size[name] == 1 ? f_start : f_start...f_last
+          z[true, f_position] = @estimators[name].predict(x)
+          f_start = f_last
+        end
+        z = Numo::NArray.hstack([z, x]) if @params[:passthrough]
+        z
+      end
+
+      # Fit the model with training data, and then transform them with the learned model.
+      #
+      # @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 target variables to be used for fitting the model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The meta features for training data.
+      def fit_transform(x, y)
+        x = check_convert_sample_array(x)
+        y = check_convert_tvalue_array(y)
+        fit(x, y).transform(x)
+      end
+
+      private
+
+      def detect_output_size(n_features)
+        x_dummy = Numo::DFloat.new(2, n_features).rand
+        @estimators.each_key.with_object({}) do |name, obj|
+          output_dummy = @estimators[name].predict(x_dummy)
+          obj[name] = output_dummy.ndim == 1 ? 1 : output_dummy.shape[1]
+        end
+      end
+    end
+  end
+end

data/lib/rumale/feature_extraction/feature_hasher.rb

@@ -67,7 +67,7 @@ module Rumale
       def transform(x)
         raise 'FeatureHasher#transform requires Mmh3 but that is not loaded.' unless enable_mmh3?
 
-        x = [x] unless x.is_a?(Array) # rubocop:disable Style/ArrayCoercion
+        x = [x] unless x.is_a?(Array)
         n_samples = x.size
 
         z = Numo::DFloat.zeros(n_samples, n_features)

data/lib/rumale/feature_extraction/hash_vectorizer.rb

@@ -99,7 +99,7 @@ module Rumale
       # @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
       # @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
       def transform(x)
-        x = [x] unless x.is_a?(Array) # rubocop:disable Style/ArrayCoercion
+        x = [x] unless x.is_a?(Array)
         n_samples = x.size
         n_features = @vocabulary.size
         z = Numo::DFloat.zeros(n_samples, n_features)

data/lib/rumale/linear_model/linear_regression.rb

@@ -82,7 +82,7 @@ module Rumale
         @params[:solver] = if solver == 'auto'
                              load_linalg? ? 'svd' : 'sgd'
                            else
-                             solver != 'svd' ? 'sgd' : 'svd'
+                             solver != 'svd' ? 'sgd' : 'svd' # rubocop:disable Style/NegatedIfElseCondition
                            end
         @params[:decay] ||= @params[:learning_rate]
         @params[:random_seed] ||= srand

data/lib/rumale/linear_model/logistic_regression.rb

@@ -181,7 +181,7 @@ module Rumale
         @classes.size > 2
       end
 
-      def fit_lbfgs(base_x, base_y)
+      def fit_lbfgs(base_x, base_y) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         if multiclass_problem?
           fnc = proc do |w, x, y, a|
             n_features = x.shape[1]

data/lib/rumale/linear_model/ridge.rb

@@ -85,7 +85,7 @@ module Rumale
         @params[:solver] = if solver == 'auto'
                              load_linalg? ? 'svd' : 'sgd'
                            else
-                             solver != 'svd' ? 'sgd' : 'svd'
+                             solver != 'svd' ? 'sgd' : 'svd' # rubocop:disable Style/NegatedIfElseCondition
                            end
         @params[:decay] ||= @params[:reg_param] * @params[:learning_rate]
         @params[:random_seed] ||= srand

data/lib/rumale/pairwise_metric.rb

@@ -123,7 +123,7 @@ module Rumale
       # @param gamma [Float] The parameter of polynomial kernel, if nil it is 1 / n_features.
       # @param coef [Integer] The parameter of polynomial kernel.
       # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def polynomial_kernel(x, y = nil, degree = 3, gamma = nil, coef = 1)
+      def polynomial_kernel(x, y = nil, degree = 3, gamma = nil, coef = 1) # rubocop:disable Metrics/ParameterLists
         y = x if y.nil?
         gamma ||= 1.0 / x.shape[1]
         x = Rumale::Validation.check_convert_sample_array(x)

data/lib/rumale/validation.rb

@@ -109,7 +109,7 @@ module Rumale
 
     # @!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? }
+      params.compact.each { |k, v| raise ArgumentError, "Expect #{k} to be positive value" if v.negative? }
       nil
     end
   end

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

data/rumale.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata      = {
     'homepage_uri' => 'https://github.com/yoshoku/rumale',
-    'changelog_uri' => 'https://github.com/yoshoku/rumale/blob/master/CHANGELOG.md',
+    'changelog_uri' => 'https://github.com/yoshoku/rumale/blob/main/CHANGELOG.md',
     'source_code_uri' => 'https://github.com/yoshoku/rumale',
     'documentation_uri' => 'https://yoshoku.github.io/rumale/doc/',
     'bug_tracker_uri' => 'https://github.com/yoshoku/rumale/issues'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.22.1
+  version: 0.22.2
 platform: ruby
 authors:
 - yoshoku
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-05 00:00:00.000000000 Z
+date: 2021-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -104,6 +104,8 @@ files:
 - lib/rumale/ensemble/gradient_boosting_regressor.rb
 - lib/rumale/ensemble/random_forest_classifier.rb
 - lib/rumale/ensemble/random_forest_regressor.rb
+- lib/rumale/ensemble/stacking_classifier.rb
+- lib/rumale/ensemble/stacking_regressor.rb
 - lib/rumale/evaluation_measure/accuracy.rb
 - lib/rumale/evaluation_measure/adjusted_rand_score.rb
 - lib/rumale/evaluation_measure/calinski_harabasz_score.rb
@@ -205,11 +207,11 @@ licenses:
 - BSD-2-Clause
 metadata:
   homepage_uri: https://github.com/yoshoku/rumale
-  changelog_uri: https://github.com/yoshoku/rumale/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/yoshoku/rumale/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/yoshoku/rumale
   documentation_uri: https://yoshoku.github.io/rumale/doc/
   bug_tracker_uri: https://github.com/yoshoku/rumale/issues
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -225,7 +227,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.4
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Rumale is a machine learning library in Ruby. Rumale provides machine learning
   algorithms with interfaces similar to Scikit-Learn in Python.