rumale 0.13.8 → 0.14.0

data/lib/rumale/decomposition/factor_analysis.rb

@@ -46,8 +46,8 @@ module Rumale
       # @param tol [Float/Nil] The tolerance of termination criterion for EM algorithm.
       #   If nil is given, iterate EM steps up to the maximum number of iterations.
       def initialize(n_components: 2, max_iter: 100, tol: 1e-8)
-        check_params_integer(n_components: n_components, max_iter: max_iter)
-        check_params_type_or_nil(Float, tol: tol)
+        check_params_numeric(n_components: n_components, max_iter: max_iter)
+        check_params_numeric_or_nil(tol: tol)
         check_params_positive(n_components: n_components, max_iter: max_iter)
         @params = {}
         @params[:n_components] = n_components
@@ -107,7 +107,7 @@ module Rumale
       #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         raise 'FactorAnalysis#fit_transform requires Numo::Linalg but that is not loaded.' unless enable_linalg?
 
         fit(x).transform(x)
@@ -118,7 +118,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned model.
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         raise 'FactorAnalysis#transform requires Numo::Linalg but that is not loaded.' unless enable_linalg?
 
         factors = @params[:n_components] == 1 ? @components.expand_dims(0) : @components

data/lib/rumale/decomposition/fast_ica.rb

@@ -47,11 +47,10 @@ module Rumale
       # @param tol [Float] The tolerance of termination criterion.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_components: 2, whiten: true, fun: 'logcosh', alpha: 1.0, max_iter: 200, tol: 1e-4, random_seed: nil)
-        check_params_integer(n_components: n_components, max_iter: max_iter)
+        check_params_numeric(n_components: n_components, max_iter: max_iter, alpha: alpha, tol: tol)
         check_params_boolean(whiten: whiten)
         check_params_string(fun: fun)
-        check_params_float(alpha: alpha, tol: tol)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_numeric_or_nil(random_seed: random_seed)
         check_params_positive(n_components: n_components, max_iter: max_iter, tol: tol)
         @params = {}
         @params[:n_components] = n_components
@@ -75,7 +74,7 @@ module Rumale
       #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
       # @return [FastICA] The learned transformer itself.
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         raise 'FastICA#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
 
         @mean, whiten_mat = whitening(x, @params[:n_components]) if @params[:whiten]
@@ -96,7 +95,7 @@ module Rumale
       #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         raise 'FastICA#fit_transform requires Numo::Linalg but that is not loaded.' unless enable_linalg?
 
         fit(x).transform(x)
@@ -107,7 +106,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned model.
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         cx = @params[:whiten] ? (x - @mean) : x
         cx.dot(@components.transpose)
       end
@@ -117,7 +116,7 @@ module Rumale
       # @param z [Numo::DFloat] (shape: [n_samples, n_components]) The source data reconstructed to the mixed data.
       # @return [Numo::DFloat] (shape: [n_samples, n_featuress]) The mixed data.
       def inverse_transform(z)
-        check_sample_array(z)
+        z = check_convert_sample_array(z)
         m = @mixing.shape[1].nil? ? @mixing.expand_dims(0).transpose : @mixing
         x = z.dot(m.transpose)
         x += @mean if @params[:whiten]

data/lib/rumale/decomposition/nmf.rb

@@ -34,9 +34,8 @@ module Rumale
       # @param eps [Float] A small value close to zero to avoid zero division error.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_components: 2, max_iter: 500, tol: 1.0e-4, eps: 1.0e-16, random_seed: nil)
-        check_params_integer(n_components: n_components, max_iter: max_iter)
-        check_params_float(tol: tol, eps: eps)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_numeric(n_components: n_components, max_iter: max_iter, tol: tol, eps: eps)
+        check_params_numeric_or_nil(random_seed: random_seed)
         check_params_positive(n_components: n_components, max_iter: max_iter, tol: tol, eps: eps)
         @params = {}
         @params[:n_components] = n_components
@@ -56,7 +55,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
       # @return [NMF] The learned transformer itself.
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         partial_fit(x)
         self
       end
@@ -68,7 +67,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         partial_fit(x)
       end
 
@@ -77,7 +76,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned model.
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         partial_fit(x, false)
       end
 
@@ -86,7 +85,7 @@ module Rumale
       # @param z [Numo::DFloat] (shape: [n_samples, n_components]) The data to be restored into original space with the learned model.
       # @return [Numo::DFloat] (shape: [n_samples, n_featuress]) The restored data.
       def inverse_transform(z)
-        check_sample_array(z)
+        z = check_convert_sample_array(z)
         z.dot(@components)
       end
 

data/lib/rumale/decomposition/pca.rb

@@ -44,10 +44,9 @@ module Rumale
       # @param tol [Float] The tolerance of termination criterion. If solver = 'evd', this parameter is ignored.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_components: 2, solver: 'fpt', max_iter: 100, tol: 1.0e-4, random_seed: nil)
-        check_params_integer(n_components: n_components, max_iter: max_iter)
+        check_params_numeric(n_components: n_components, max_iter: max_iter, tol: tol)
         check_params_string(solver: solver)
-        check_params_float(tol: tol)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_numeric_or_nil(random_seed: random_seed)
         check_params_positive(n_components: n_components, max_iter: max_iter, tol: tol)
         @params = {}
         @params[:solver] = solver != 'evd' ? 'fpt' : 'evd'
@@ -68,7 +67,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
       # @return [PCA] The learned transformer itself.
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         # initialize some variables.
         @components = nil
         n_samples, n_features = x.shape
@@ -103,7 +102,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         fit(x).transform(x)
       end
 
@@ -112,7 +111,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned model.
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         (x - @mean).dot(@components.transpose)
       end
 
@@ -121,7 +120,7 @@ module Rumale
       # @param z [Numo::DFloat] (shape: [n_samples, n_components]) The data to be restored into original space with the learned model.
       # @return [Numo::DFloat] (shape: [n_samples, n_featuress]) The restored data.
       def inverse_transform(z)
-        check_sample_array(z)
+        z = check_convert_sample_array(z)
         c = @components.shape[1].nil? ? @components.expand_dims(0) : @components
         z.dot(c) + @mean
       end

data/lib/rumale/ensemble/ada_boost_classifier.rb

@@ -56,9 +56,9 @@ module Rumale
       def initialize(n_estimators: 50,
                      criterion: 'gini', 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(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
+        check_params_numeric_or_nil(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                    max_features: max_features, random_seed: random_seed)
+        check_params_numeric(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(n_estimators: n_estimators, max_depth: max_depth,
                               max_leaf_nodes: max_leaf_nodes, min_samples_leaf: min_samples_leaf,
@@ -84,8 +84,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [AdaBoostClassifier] The learned classifier itself.
       def fit(x, y) # rubocop:disable Metrics/AbcSize
-        check_sample_array(x)
-        check_label_array(y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
         check_sample_label_size(x, y)
         ## Initialize some variables.
         n_samples, n_features = x.shape
@@ -137,7 +137,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
       def decision_function(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_samples, = x.shape
         n_classes = @classes.size
         sum_probs = Numo::DFloat.zeros(n_samples, n_classes)
@@ -153,7 +153,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_samples, = x.shape
         probs = decision_function(x)
         Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[probs[n, true].max_index] })
@@ -164,7 +164,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_classes = @classes.size
         probs = Numo::NMath.exp(1.fdiv(n_classes - 1) * decision_function(x))
         sum_probs = probs.sum(1)

data/lib/rumale/ensemble/ada_boost_regressor.rb

@@ -58,10 +58,10 @@ module Rumale
       def initialize(n_estimators: 10, threshold: 0.2, exponent: 1.0,
                      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(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
-        check_params_float(threshold: threshold, exponent: exponent)
+        check_params_numeric_or_nil(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                    max_features: max_features, random_seed: random_seed)
+        check_params_numeric(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf,
+                             threshold: threshold, exponent: exponent)
         check_params_string(criterion: criterion)
         check_params_positive(n_estimators: n_estimators, threshold: threshold, exponent: exponent,
                               max_depth: max_depth,
@@ -89,8 +89,8 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
       # @return [AdaBoostRegressor] The learned regressor itself.
       def fit(x, y) # rubocop:disable Metrics/AbcSize
-        check_sample_array(x)
-        check_tvalue_array(y)
+        x = check_convert_sample_array(x)
+        y = check_convert_tvalue_array(y)
         check_sample_tvalue_size(x, y)
         # Check target values
         raise ArgumentError, 'Expect target value vector to be 1-D arrray' unless y.shape.size == 1
@@ -144,7 +144,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
       # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted value per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_samples, = x.shape
         predictions = Numo::DFloat.zeros(n_samples)
         @estimators.size.times do |t|

data/lib/rumale/ensemble/extra_trees_classifier.rb

@@ -56,9 +56,9 @@ module Rumale
       def initialize(n_estimators: 10,
                      criterion: 'gini', max_depth: nil, max_leaf_nodes: nil, min_samples_leaf: 1,
                      max_features: nil, n_jobs: nil, random_seed: nil)
-        check_params_type_or_nil(Integer, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
-                                          max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
-        check_params_integer(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
+        check_params_numeric_or_nil(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                    max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
+        check_params_numeric(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(n_estimators: n_estimators, max_depth: max_depth,
                               max_leaf_nodes: max_leaf_nodes, min_samples_leaf: min_samples_leaf,
@@ -72,8 +72,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [ExtraTreesClassifier] The learned classifier itself.
       def fit(x, y)
-        check_sample_array(x)
-        check_label_array(y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
         check_sample_label_size(x, y)
         # Initialize some variables.
         n_features = x.shape[1]
@@ -103,7 +103,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         super
       end
 
@@ -112,7 +112,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         super
       end
 
@@ -121,7 +121,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples, n_estimators]) Leaf index for sample.
       def apply(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         super
       end
 

data/lib/rumale/ensemble/extra_trees_regressor.rb

@@ -52,9 +52,9 @@ module Rumale
       def initialize(n_estimators: 10,
                      criterion: 'mse', max_depth: nil, max_leaf_nodes: nil, min_samples_leaf: 1,
                      max_features: nil, n_jobs: nil, random_seed: nil)
-        check_params_type_or_nil(Integer, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
-                                          max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
-        check_params_integer(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
+        check_params_numeric_or_nil(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                    max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
+        check_params_numeric(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(n_estimators: n_estimators, max_depth: max_depth,
                               max_leaf_nodes: max_leaf_nodes, min_samples_leaf: min_samples_leaf,
@@ -68,8 +68,8 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.
       # @return [ExtraTreesRegressor] The learned regressor itself.
       def fit(x, y)
-        check_sample_array(x)
-        check_tvalue_array(y)
+        x = check_convert_sample_array(x)
+        y = check_convert_tvalue_array(y)
         check_sample_tvalue_size(x, y)
         # Initialize some variables.
         n_features = x.shape[1]
@@ -98,7 +98,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
       # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted value per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         super
       end
 
@@ -107,7 +107,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to assign each leaf.
       # @return [Numo::Int32] (shape: [n_samples, n_estimators]) Leaf index for sample.
       def apply(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         super
       end
 

data/lib/rumale/ensemble/gradient_boosting_classifier.rb

@@ -67,8 +67,8 @@ module Rumale
                      max_features: nil, n_jobs: nil, random_seed: nil)
         check_params_type_or_nil(Integer, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
                                           max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
-        check_params_integer(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
-        check_params_float(learning_rate: learning_rate, reg_lambda: reg_lambda, subsample: subsample)
+        check_params_numeric(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf,
+                             learning_rate: learning_rate, reg_lambda: reg_lambda, subsample: subsample)
         check_params_positive(n_estimators: n_estimators, learning_rate: learning_rate, reg_lambda: reg_lambda,
                               subsample: subsample, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
                               min_samples_leaf: min_samples_leaf, max_features: max_features)
@@ -97,8 +97,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [GradientBoostingClassifier] The learned classifier itself.
       def fit(x, y)
-        check_sample_array(x)
-        check_label_array(y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
         check_sample_label_size(x, y)
         # initialize some variables.
         n_features = x.shape[1]
@@ -131,7 +131,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
       def decision_function(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_classes = @classes.size
         if n_classes > 2
           multiclass_scores(x)
@@ -145,7 +145,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_samples = x.shape[0]
         probs = predict_proba(x)
         Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[probs[n, true].max_index] })
@@ -156,7 +156,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
 
         proba = 1.0 / (Numo::NMath.exp(-decision_function(x)) + 1.0)
 
@@ -174,7 +174,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples, n_estimators, n_classes]) Leaf index for sample.
       def apply(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_classes = @classes.size
         leaf_ids = if n_classes > 2
                      Array.new(n_classes) { |n| @estimators[n].map { |tree| tree.apply(x) } }

data/lib/rumale/ensemble/gradient_boosting_regressor.rb

@@ -60,10 +60,10 @@ module Rumale
       def initialize(n_estimators: 100, learning_rate: 0.1, reg_lambda: 0.0, subsample: 1.0,
                      max_depth: nil, max_leaf_nodes: nil, min_samples_leaf: 1,
                      max_features: nil, n_jobs: nil, random_seed: nil)
-        check_params_type_or_nil(Integer, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
-                                          max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
-        check_params_integer(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
-        check_params_float(learning_rate: learning_rate, reg_lambda: reg_lambda, subsample: subsample)
+        check_params_numeric_or_nil(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                    max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
+        check_params_numeric(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf,
+                             learning_rate: learning_rate, reg_lambda: reg_lambda, subsample: subsample)
         check_params_positive(n_estimators: n_estimators, learning_rate: learning_rate, reg_lambda: reg_lambda,
                               subsample: subsample, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
                               min_samples_leaf: min_samples_leaf, max_features: max_features)
@@ -91,8 +91,8 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
       # @return [GradientBoostingRegressor] The learned regressor itself.
       def fit(x, y)
-        check_sample_array(x)
-        check_tvalue_array(y)
+        x = check_convert_sample_array(x)
+        y = check_convert_tvalue_array(y)
         check_sample_tvalue_size(x, y)
         # initialize some variables.
         n_features = x.shape[1]
@@ -120,7 +120,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
       # @return [Numo::DFloat] (shape: [n_samples]) Predicted values per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_outputs = @estimators.first.is_a?(Array) ? @estimators.size : 1
         if n_outputs > 1
           multivar_predict(x)
@@ -138,7 +138,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
       # @return [Numo::Int32] (shape: [n_samples, n_estimators]) Leaf index for sample.
       def apply(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_outputs = @estimators.first.is_a?(Array) ? @estimators.size : 1
         leaf_ids = if n_outputs > 1
                      Array.new(n_outputs) { |n| @estimators[n].map { |tree| tree.apply(x) } }

data/lib/rumale/ensemble/random_forest_classifier.rb

@@ -57,9 +57,9 @@ module Rumale
       def initialize(n_estimators: 10,
                      criterion: 'gini', max_depth: nil, max_leaf_nodes: nil, min_samples_leaf: 1,
                      max_features: nil, n_jobs: nil, random_seed: nil)
-        check_params_type_or_nil(Integer, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
-                                          max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
-        check_params_integer(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
+        check_params_numeric_or_nil(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                    max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
+        check_params_numeric(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(n_estimators: n_estimators, max_depth: max_depth,
                               max_leaf_nodes: max_leaf_nodes, min_samples_leaf: min_samples_leaf,
@@ -86,8 +86,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [RandomForestClassifier] The learned classifier itself.
       def fit(x, y)
-        check_sample_array(x)
-        check_label_array(y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
         check_sample_label_size(x, y)
         # Initialize some variables.
         n_samples, n_features = x.shape
@@ -126,7 +126,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_samples = x.shape[0]
         n_estimators = @estimators.size
         predicted = if enable_parallel?
@@ -144,7 +144,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_estimators = @estimators.size
         if enable_parallel?
           parallel_map(n_estimators) { |n| predict_proba_tree(@estimators[n], x) }.reduce(&:+) / n_estimators
@@ -158,7 +158,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples, n_estimators]) Leaf index for sample.
       def apply(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         Numo::Int32[*Array.new(@params[:n_estimators]) { |n| @estimators[n].apply(x) }].transpose
       end