rumale 0.13.8 → 0.14.0

data/lib/rumale/ensemble/random_forest_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,
@@ -80,8 +80,8 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.
       # @return [RandomForestRegressor] 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_samples, n_features = x.shape
@@ -122,7 +122,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)
         if enable_parallel?
           parallel_map(@params[:n_estimators]) { |n| @estimators[n].predict(x) }.reduce(&:+) / @params[:n_estimators]
         else
@@ -135,7 +135,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)
         Numo::Int32[*Array.new(@params[:n_estimators]) { |n| @estimators[n].apply(x) }].transpose
       end
 

data/lib/rumale/evaluation_measure/accuracy.rb

@@ -19,8 +19,8 @@ module Rumale
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
       # @return [Float] Mean accuracy
       def score(y_true, y_pred)
-        check_label_array(y_true)
-        check_label_array(y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_label_array(y_pred)
 
         (y_true.to_a.map.with_index { |label, n| label == y_pred[n] ? 1 : 0 }).inject(:+) / y_true.size.to_f
       end

data/lib/rumale/evaluation_measure/adjusted_rand_score.rb

@@ -21,8 +21,8 @@ module Rumale
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted cluster labels.
       # @return [Float] Adjusted rand index.
       def score(y_true, y_pred)
-        check_label_array(y_true)
-        check_label_array(y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_label_array(y_pred)
 
         # initiazlie some variables.
         n_samples = y_pred.size

data/lib/rumale/evaluation_measure/calinski_harabasz_score.rb

@@ -21,8 +21,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The predicted labels for each sample.
       # @return [Float] The Calinski and Harabasz score.
       def score(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)
 
         labels = y.to_a.uniq.sort

data/lib/rumale/evaluation_measure/davies_bouldin_score.rb

@@ -22,8 +22,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The predicted labels for each sample.
       # @return [Float] The Davies-Bouldin score.
       def score(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)
 
         labels = y.to_a.uniq.sort

data/lib/rumale/evaluation_measure/explained_variance_score.rb

@@ -18,8 +18,8 @@ module Rumale
       # @param y_pred [Numo::DFloat] (shape: [n_samples, n_outputs]) Estimated target values.
       # @return [Float] Explained variance score.
       def score(y_true, y_pred)
-        check_tvalue_array(y_true)
-        check_tvalue_array(y_pred)
+        y_true = check_convert_tvalue_array(y_true)
+        y_pred = check_convert_tvalue_array(y_pred)
         raise ArgumentError, 'Expect to have the same size both y_true and y_pred.' unless y_true.shape == y_pred.shape
 
         diff = y_true - y_pred

data/lib/rumale/evaluation_measure/f_score.rb

@@ -33,8 +33,8 @@ module Rumale
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
       # @return [Float] Average F1-score
       def score(y_true, y_pred)
-        check_label_array(y_true)
-        check_label_array(y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_label_array(y_pred)
 
         case @average
         when 'binary'

data/lib/rumale/evaluation_measure/log_loss.rb

@@ -22,8 +22,8 @@ module Rumale
       # @param eps [Float] A small value close to zero to avoid outputting infinity in logarithmic calcuation.
       # @return [Float] mean logarithmic loss
       def score(y_true, y_pred, eps = 1e-15)
-        check_params_type(Numo::Int32, y_true: y_true)
-        check_params_type(Numo::DFloat, y_pred: y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_tvalue_array(y_pred)
 
         n_samples, n_classes = y_pred.shape
         clipped_p = y_pred.clip(eps, 1 - eps)

data/lib/rumale/evaluation_measure/mean_absolute_error.rb

@@ -18,8 +18,8 @@ module Rumale
       # @param y_pred [Numo::DFloat] (shape: [n_samples, n_outputs]) Estimated target values.
       # @return [Float] Mean absolute error
       def score(y_true, y_pred)
-        check_tvalue_array(y_true)
-        check_tvalue_array(y_pred)
+        y_true = check_convert_tvalue_array(y_true)
+        y_pred = check_convert_tvalue_array(y_pred)
         raise ArgumentError, 'Expect to have the same size both y_true and y_pred.' unless y_true.shape == y_pred.shape
 
         (y_true - y_pred).abs.mean

data/lib/rumale/evaluation_measure/mean_squared_error.rb

@@ -18,8 +18,8 @@ module Rumale
       # @param y_pred [Numo::DFloat] (shape: [n_samples, n_outputs]) Estimated target values.
       # @return [Float] Mean squared error
       def score(y_true, y_pred)
-        check_tvalue_array(y_true)
-        check_tvalue_array(y_pred)
+        y_true = check_convert_tvalue_array(y_true)
+        y_pred = check_convert_tvalue_array(y_pred)
         raise ArgumentError, 'Expect to have the same size both y_true and y_pred.' unless y_true.shape == y_pred.shape
 
         ((y_true - y_pred)**2).mean

data/lib/rumale/evaluation_measure/mean_squared_log_error.rb

@@ -18,8 +18,8 @@ module Rumale
       # @param y_pred [Numo::DFloat] (shape: [n_samples, n_outputs]) Estimated target values.
       # @return [Float] Mean squared logarithmic error.
       def score(y_true, y_pred)
-        check_tvalue_array(y_true)
-        check_tvalue_array(y_pred)
+        y_true = check_convert_tvalue_array(y_true)
+        y_pred = check_convert_tvalue_array(y_pred)
         raise ArgumentError, 'Expect to have the same size both y_true and y_pred.' unless y_true.shape == y_pred.shape
 
         ((Numo::NMath.log(y_true + 1) - Numo::NMath.log(y_pred + 1))**2).mean

data/lib/rumale/evaluation_measure/median_absolute_error.rb

@@ -18,8 +18,8 @@ module Rumale
       # @param y_pred [Numo::DFloat] (shape: [n_samples]) Estimated target values.
       # @return [Float] Median absolute error.
       def score(y_true, y_pred)
-        check_tvalue_array(y_true)
-        check_tvalue_array(y_pred)
+        y_true = check_convert_tvalue_array(y_true)
+        y_pred = check_convert_tvalue_array(y_pred)
         raise ArgumentError, 'Expect to have the same size both y_true and y_pred.' unless y_true.shape == y_pred.shape
         raise ArgumentError, 'Expect target values to be 1-D arrray' if [y_true.shape.size, y_pred.shape.size].max > 1
 

data/lib/rumale/evaluation_measure/mutual_information.rb

@@ -21,8 +21,8 @@ module Rumale
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted cluster labels.
       # @return [Float] Mutual information.
       def score(y_true, y_pred)
-        check_label_array(y_true)
-        check_label_array(y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_label_array(y_pred)
         # initiazlie some variables.
         mutual_information = 0.0
         n_samples = y_pred.size

data/lib/rumale/evaluation_measure/normalized_mutual_information.rb

@@ -23,8 +23,8 @@ module Rumale
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted cluster labels.
       # @return [Float] Normalized mutual information
       def score(y_true, y_pred)
-        check_label_array(y_true)
-        check_label_array(y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_label_array(y_pred)
         # calculate entropies.
         class_entropy = entropy(y_true)
         return 0.0 if class_entropy.zero?

data/lib/rumale/evaluation_measure/precision.rb

@@ -33,8 +33,8 @@ module Rumale
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
       # @return [Float] Average precision
       def score(y_true, y_pred)
-        check_label_array(y_true)
-        check_label_array(y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_label_array(y_pred)
 
         case @average
         when 'binary'

data/lib/rumale/evaluation_measure/purity.rb

@@ -21,8 +21,8 @@ module Rumale
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted cluster labels.
       # @return [Float] Purity
       def score(y_true, y_pred)
-        check_label_array(y_true)
-        check_label_array(y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_label_array(y_pred)
         # initiazlie some variables.
         purity = 0
         n_samples = y_pred.size

data/lib/rumale/evaluation_measure/r2_score.rb

@@ -22,8 +22,8 @@ module Rumale
       # @param y_pred [Numo::DFloat] (shape: [n_samples, n_outputs]) Estimated taget values.
       # @return [Float] Coefficient of determination
       def score(y_true, y_pred)
-        check_tvalue_array(y_true)
-        check_tvalue_array(y_pred)
+        y_true = check_convert_tvalue_array(y_true)
+        y_pred = check_convert_tvalue_array(y_pred)
         raise ArgumentError, 'Expect to have the same size both y_true and y_pred.' unless y_true.shape == y_pred.shape
 
         n_samples, n_outputs = y_true.shape

data/lib/rumale/evaluation_measure/recall.rb

@@ -33,8 +33,8 @@ module Rumale
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
       # @return [Float] Average recall
       def score(y_true, y_pred)
-        check_label_array(y_true)
-        check_label_array(y_pred)
+        y_true = check_convert_label_array(y_true)
+        y_pred = check_convert_label_array(y_pred)
 
         case @average
         when 'binary'

data/lib/rumale/evaluation_measure/roc_auc.rb

@@ -33,7 +33,8 @@ module Rumale
       #   Predicted class probabilities or confidence scores.
       # @return [Float] (macro-averaged) ROC AUC.
       def score(y_true, y_score)
-        check_params_type(Numo::NArray, y_true: y_true, y_score: y_score)
+        y_true = Numo::Int32.cast(y_true) unless y_true.is_a?(Numo::Int32)
+        y_score = Numo::DFloat.cast(y_score) unless y_score.is_a?(Numo::DFloat)
         raise ArgumentError, 'Expect to have the same shape for y_true and y_score.' unless y_true.shape == y_score.shape
 
         n_classes = y_score.shape[1]
@@ -59,7 +60,8 @@ module Rumale
       # @return [Array] fpr (Numo::DFloat): false positive rates. tpr (Numo::DFloat): true positive rates.
       #   thresholds (Numo::DFloat): thresholds on the decision function used to calculate fpr and tpr.
       def roc_curve(y_true, y_score, pos_label = nil)
-        check_params_type(Numo::NArray, y_true: y_true, y_score: y_score)
+        y_true = Numo::Int32.cast(y_true) unless y_true.is_a?(Numo::Int32)
+        y_score = Numo::DFloat.cast(y_score) unless y_score.is_a?(Numo::DFloat)
         raise ArgumentError, 'Expect y_true to be 1-D arrray.' unless y_true.shape[1].nil?
         raise ArgumentError, 'Expect y_score to be 1-D arrray.' unless y_score.shape[1].nil?
         labels = y_true.to_a.uniq
@@ -90,7 +92,8 @@ module Rumale
       # @param y [Numo::Int32/Numo::DFloat] (shape: [n_elements]) y coordinates.
       # @return [Float] area under the curve.
       def auc(x, y)
-        check_params_type(Numo::NArray, x: x, y: y)
+        x = Numo::NArray.asarray(x) unless x.is_a?(Numo::NArray)
+        y = Numo::NArray.asarray(y) unless y.is_a?(Numo::NArray)
         raise ArgumentError, 'Expect x to be 1-D arrray.' unless x.shape[1].nil?
         raise ArgumentError, 'Expect y to be 1-D arrray.' unless y.shape[1].nil?
         n_samples = [x.shape[0], y.shape[0]].min

data/lib/rumale/evaluation_measure/silhouette_score.rb

@@ -32,8 +32,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The predicted labels for each sample.
       # @return [Float] The mean of silhouette coefficient.
       def score(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)
 
         dist_mat = @metric == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)

data/lib/rumale/kernel_approximation/rbf.rb

@@ -38,9 +38,8 @@ module Rumale
       # @param n_components [Integer] The number of dimensions of the RBF kernel feature space.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(gamma: 1.0, n_components: 128, random_seed: nil)
-        check_params_float(gamma: gamma)
-        check_params_integer(n_components: n_components)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_numeric(gamma: gamma, n_components: n_components)
+        check_params_numeric_or_nil(random_seed: random_seed)
         check_params_positive(gamma: gamma, n_components: n_components)
         @params = {}
         @params[:gamma] = gamma
@@ -60,7 +59,7 @@ module Rumale
       #   This method uses only the number of features of the data.
       # @return [RBF] The learned transformer itself.
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
 
         n_features = x.shape[1]
         sub_rng = @rng.dup
@@ -80,7 +79,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
@@ -92,7 +91,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)
 
         n_samples, = x.shape
         projection = x.dot(@random_mat) + @random_vec.tile(n_samples, 1)

data/lib/rumale/kernel_machine/kernel_pca.rb

@@ -35,7 +35,7 @@ module Rumale
       #
       # @param n_components [Integer] The number of components.
       def initialize(n_components: 2)
-        check_params_integer(n_components: n_components)
+        check_params_numeric(n_components: n_components)
         @params = {}
         @params[:n_components] = n_components
         @alphas = nil
@@ -52,7 +52,7 @@ module Rumale
       #     The kernel matrix of the training data to be used for fitting the model.
       # @return [KernelPCA] The learned transformer itself.
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the kernel matrix of training data to be square.' unless x.shape[0] == x.shape[1]
         raise 'KernelPCA#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
 
@@ -74,7 +74,7 @@ module Rumale
       #     The kernel matrix of the training data to be used for fitting the model and transformed.
       # @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
 
@@ -84,7 +84,7 @@ module Rumale
       #   The kernel matrix between testing samples and training samples to be transformed.
       # @return [Numo::DFloat] (shape: [n_testing_samples, n_components]) The transformed data.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         col_mean = x.sum(1) / @row_mean.shape[0]
         centered_kernel_mat = x - col_mean.expand_dims(1) - @row_mean + @all_mean
         transform_mat = @alphas.dot((1.0 / Numo::NMath.sqrt(@lambdas)).diag)

data/lib/rumale/kernel_machine/kernel_ridge.rb

@@ -42,8 +42,8 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The taget values to be used for fitting the model.
       # @return [KernelRidge] 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)
         raise ArgumentError, 'Expect the kernel matrix of training data to be square.' unless x.shape[0] == x.shape[1]
         raise 'KernelRidge#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
@@ -72,7 +72,7 @@ module Rumale
       #     The kernel matrix between testing samples and training samples to predict values.
       # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted values per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         x.dot(@weight_vec)
       end
 

data/lib/rumale/kernel_machine/kernel_svc.rb

@@ -52,10 +52,9 @@ module Rumale
       #   This parameter is ignored if the Parallel gem is not loaded.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(reg_param: 1.0, max_iter: 1000, probability: false, n_jobs: nil, random_seed: nil)
-        check_params_float(reg_param: reg_param)
-        check_params_integer(max_iter: max_iter)
+        check_params_numeric(reg_param: reg_param, max_iter: max_iter)
         check_params_boolean(probability: probability)
-        check_params_type_or_nil(Integer, n_jobs: n_jobs, random_seed: random_seed)
+        check_params_numeric_or_nil(n_jobs: n_jobs, random_seed: random_seed)
         check_params_positive(reg_param: reg_param, max_iter: max_iter)
         @params = {}
         @params[:reg_param] = reg_param
@@ -77,8 +76,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_training_samples]) The labels to be used for fitting the model.
       # @return [KernelSVC] 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)
 
         @classes = Numo::Int32[*y.to_a.uniq.sort]
@@ -117,7 +116,7 @@ module Rumale
       #     The kernel matrix between testing samples and training samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_testing_samples, n_classes]) Confidence score per sample.
       def decision_function(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
 
         x.dot(@weight_vec.transpose)
       end
@@ -128,7 +127,7 @@ module Rumale
       #     The kernel matrix between testing samples and training samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_testing_samples]) Predicted class label per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
 
         return Numo::Int32.cast(decision_function(x).ge(0.0)) * 2 - 1 if @classes.size <= 2
 
@@ -148,7 +147,7 @@ module Rumale
       #     The kernel matrix between testing samples and training samples to predict the labels.
       # @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)
 
         if @classes.size > 2
           probs = 1.0 / (Numo::NMath.exp(@prob_param[true, 0] * decision_function(x) + @prob_param[true, 1]) + 1.0)

data/lib/rumale/linear_model/lasso.rb

@@ -48,10 +48,9 @@ module Rumale
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(reg_param: 1.0, fit_bias: false, bias_scale: 1.0, max_iter: 1000, batch_size: 10, optimizer: nil,
                      n_jobs: nil, random_seed: nil)
-        check_params_float(reg_param: reg_param, bias_scale: bias_scale)
-        check_params_integer(max_iter: max_iter, batch_size: batch_size)
+        check_params_numeric(reg_param: reg_param, bias_scale: bias_scale, max_iter: max_iter, batch_size: batch_size)
         check_params_boolean(fit_bias: fit_bias)
-        check_params_type_or_nil(Integer, n_jobs: n_jobs, random_seed: random_seed)
+        check_params_numeric_or_nil(n_jobs: n_jobs, random_seed: random_seed)
         check_params_positive(reg_param: reg_param, max_iter: max_iter, batch_size: batch_size)
         super
       end
@@ -62,8 +61,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.
       # @return [Lasso] 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)
 
         n_outputs = y.shape[1].nil? ? 1 : y.shape[1]
@@ -89,7 +88,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 values per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         x.dot(@weight_vec.transpose) + @bias_term
       end