rumale 0.13.8 → 0.14.0

data/lib/rumale/linear_model/linear_regression.rb

@@ -55,11 +55,10 @@ module Rumale
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(fit_bias: false, bias_scale: 1.0, max_iter: 1000, batch_size: 10, optimizer: nil,
                      solver: 'sgd', n_jobs: nil, random_seed: nil)
-        check_params_float(bias_scale: bias_scale)
-        check_params_integer(max_iter: max_iter, batch_size: batch_size)
+        check_params_numeric(bias_scale: bias_scale, max_iter: max_iter, batch_size: batch_size)
         check_params_boolean(fit_bias: fit_bias)
         check_params_string(solver: solver)
-        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(max_iter: max_iter, batch_size: batch_size)
         keywd_args = method(:initialize).parameters.map { |_t, arg| [arg, binding.local_variable_get(arg)] }.to_h.merge(reg_param: 0.0)
         keywd_args.delete(:solver)
@@ -73,8 +72,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.
       # @return [LinearRegression] 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)
 
         if @params[:solver] == 'svd' && enable_linalg?
@@ -91,7 +90,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
 

data/lib/rumale/linear_model/logistic_regression.rb

@@ -57,10 +57,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: 20, 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, bias_scale: bias_scale, max_iter: max_iter, batch_size: batch_size)
         super
         @classes = nil
@@ -72,15 +71,15 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [LogisticRegression] 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]
-        n_classes = @classes.size
-        n_features = x.shape[1]
 
-        if n_classes > 2
+        if multiclass_problem?
+          n_classes = @classes.size
+          n_features = x.shape[1]
           @weight_vec = Numo::DFloat.zeros(n_classes, n_features)
           @bias_term = Numo::DFloat.zeros(n_classes)
           if enable_parallel?
@@ -98,7 +97,7 @@ module Rumale
             end
           end
         else
-          negative_label = y.to_a.uniq.min
+          negative_label = @classes[0]
           bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
           @weight_vec, @bias_term = partial_fit(x, bin_y)
         end
@@ -111,7 +110,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)
         x.dot(@weight_vec.transpose) + @bias_term
       end
 
@@ -120,9 +119,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)
-
-        return Numo::Int32.cast(predict_proba(x)[true, 1].ge(0.5)) * 2 - 1 if @classes.size <= 2
+        x = check_convert_sample_array(x)
 
         n_samples, = x.shape
         decision_values = predict_proba(x)
@@ -139,10 +136,10 @@ 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)
-        return (proba.transpose / proba.sum(axis: 1)).transpose if @classes.size > 2
+        return (proba.transpose / proba.sum(axis: 1)).transpose.dup if multiclass_problem?
 
         n_samples, = x.shape
         probs = Numo::DFloat.zeros(n_samples, 2)
@@ -177,6 +174,10 @@ module Rumale
       def calc_loss_gradient(x, y, weight)
         y / (Numo::NMath.exp(-y * x.dot(weight)) + 1.0) - y
       end
+
+      def multiclass_problem?
+        @classes.size > 2
+      end
     end
   end
 end

data/lib/rumale/linear_model/ridge.rb

@@ -56,11 +56,10 @@ 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,
                      solver: 'sgd', 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_string(solver: solver)
-        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)
         keywd_args = method(:initialize).parameters.map { |_t, arg| [arg, binding.local_variable_get(arg)] }.to_h
         keywd_args.delete(:solver)
@@ -74,8 +73,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.
       # @return [Ridge] 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)
 
         if @params[:solver] == 'svd' && enable_linalg?
@@ -92,7 +91,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
 

data/lib/rumale/linear_model/svc.rb

@@ -59,10 +59,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: 20, probability: false, 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, 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, bias_scale: bias_scale, max_iter: max_iter, batch_size: batch_size)
         keywd_args = method(:initialize).parameters.map { |_t, arg| [arg, binding.local_variable_get(arg)] }.to_h
         keywd_args.delete(:probability)
@@ -78,15 +77,15 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [SVC] 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]
-        n_classes = @classes.size
-        n_features = x.shape[1]
 
-        if n_classes > 2
+        if multiclass_problem?
+          n_classes = @classes.size
+          n_features = x.shape[1]
           # initialize model.
           @weight_vec = Numo::DFloat.zeros(n_classes, n_features)
           @bias_term = Numo::DFloat.zeros(n_classes)
@@ -108,7 +107,7 @@ module Rumale
           # store model.
           models.each_with_index { |model, n| @weight_vec[n, true], @bias_term[n], @prob_param[n, true] = model }
         else
-          negative_label = y.to_a.uniq.min
+          negative_label = @classes[0]
           bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
           @weight_vec, @bias_term, @prob_param = partial_fit(x, bin_y)
         end
@@ -121,7 +120,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)
         x.dot(@weight_vec.transpose) + @bias_term
       end
 
@@ -130,16 +129,19 @@ 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)
-
-        return Numo::Int32.cast(decision_function(x).ge(0.0)) * 2 - 1 if @classes.size <= 2
-
-        n_samples, = x.shape
-        decision_values = decision_function(x)
-        predicted = if enable_parallel?
-                      parallel_map(n_samples) { |n| @classes[decision_values[n, true].max_index] }
+        x = check_convert_sample_array(x)
+
+        n_samples = x.shape[0]
+        predicted = if multiclass_problem?
+                      decision_values = decision_function(x)
+                      if enable_parallel?
+                        parallel_map(n_samples) { |n| @classes[decision_values[n, true].max_index] }
+                      else
+                        Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] }
+                      end
                     else
-                      Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] }
+                      decision_values = decision_function(x).ge(0.0).to_a
+                      Array.new(n_samples) { |n| @classes[decision_values[n]] }
                     end
         Numo::Int32.asarray(predicted)
       end
@@ -149,18 +151,18 @@ 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)
 
-        if @classes.size > 2
+        if multiclass_problem?
           probs = 1.0 / (Numo::NMath.exp(@prob_param[true, 0] * decision_function(x) + @prob_param[true, 1]) + 1.0)
-          return (probs.transpose / probs.sum(axis: 1)).transpose
+          (probs.transpose / probs.sum(axis: 1)).transpose.dup
+        else
+          n_samples, = x.shape
+          probs = Numo::DFloat.zeros(n_samples, 2)
+          probs[true, 1] = 1.0 / (Numo::NMath.exp(@prob_param[0] * decision_function(x) + @prob_param[1]) + 1.0)
+          probs[true, 0] = 1.0 - probs[true, 1]
+          probs
         end
-
-        n_samples, = x.shape
-        probs = Numo::DFloat.zeros(n_samples, 2)
-        probs[true, 1] = 1.0 / (Numo::NMath.exp(@prob_param[0] * decision_function(x) + @prob_param[1]) + 1.0)
-        probs[true, 0] = 1.0 - probs[true, 1]
-        probs
       end
 
       # Dump marshal data.
@@ -204,6 +206,10 @@ module Rumale
         grad[target_ids] = -y[target_ids]
         grad
       end
+
+      def multiclass_problem?
+        @classes.size > 2
+      end
     end
   end
 end

data/lib/rumale/linear_model/svr.rb

@@ -52,10 +52,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, epsilon: 0.1,
                      max_iter: 1000, batch_size: 20, optimizer: nil, n_jobs: nil, random_seed: nil)
-        check_params_float(reg_param: reg_param, bias_scale: bias_scale, epsilon: epsilon)
-        check_params_integer(max_iter: max_iter, batch_size: batch_size)
+        check_params_numeric(reg_param: reg_param, bias_scale: bias_scale, epsilon: epsilon, 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, bias_scale: bias_scale, epsilon: epsilon,
                               max_iter: max_iter, batch_size: batch_size)
         keywd_args = method(:initialize).parameters.map { |_t, arg| [arg, binding.local_variable_get(arg)] }.to_h
@@ -70,8 +69,8 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.
       # @return [SVR] 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]
@@ -98,7 +97,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
 

data/lib/rumale/manifold/mds.rb

@@ -53,11 +53,10 @@ module Rumale
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_components: 2, metric: 'euclidean', init: 'random',
                      max_iter: 300, tol: nil, verbose: false, 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)
         check_params_string(metric: metric, init: init)
         check_params_boolean(verbose: verbose)
-        check_params_type_or_nil(Float, tol: tol)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_numeric_or_nil(tol: tol, random_seed: random_seed)
         check_params_positive(n_components: n_components, max_iter: max_iter)
         @params = {}
         @params[:n_components] = n_components
@@ -82,7 +81,7 @@ module Rumale
       #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
       # @return [MDS] The learned transformer itself.
       def fit(x, _not_used = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
         # initialize some varibales.
         n_samples = x.shape[0]

data/lib/rumale/manifold/tsne.rb

@@ -58,12 +58,10 @@ module Rumale
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_components: 2, perplexity: 30.0, metric: 'euclidean', init: 'random',
                      max_iter: 500, tol: nil, verbose: false, random_seed: nil)
-        check_params_integer(n_components: n_components, max_iter: max_iter)
-        check_params_float(perplexity: perplexity)
+        check_params_numeric(n_components: n_components, max_iter: max_iter, perplexity: perplexity)
         check_params_string(metric: metric, init: init)
         check_params_boolean(verbose: verbose)
-        check_params_type_or_nil(Float, tol: tol)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_numeric_or_nil(tol: tol, random_seed: random_seed)
         check_params_positive(n_components: n_components, perplexity: perplexity, max_iter: max_iter)
         @params = {}
         @params[:n_components] = n_components
@@ -89,7 +87,7 @@ module Rumale
       #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
       # @return [TSNE] The learned transformer itself.
       def fit(x, _not_used = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
         # initialize some varibales.
         @n_iter = 0

data/lib/rumale/model_selection/cross_validation.rb

@@ -68,14 +68,15 @@ module Rumale
       #   * :train_score (Array<Float>) The scores of training dataset for each split. This option is nil if
       #     the return_train_score is false.
       def perform(x, y)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         if @estimator.is_a?(Rumale::Base::Classifier)
-          check_label_array(y)
+          y = check_convert_label_array(y)
           check_sample_label_size(x, y)
-        end
-        if @estimator.is_a?(Rumale::Base::Regressor)
-          check_tvalue_array(y)
+        elsif @estimator.is_a?(Rumale::Base::Regressor)
+          y = check_convert_tvalue_array(y)
           check_sample_tvalue_size(x, y)
+        else
+          y = Numo::NArray.asarray(y)
         end
         # Initialize the report of cross validation.
         report = { test_score: [], train_score: nil, fit_time: [] }

data/lib/rumale/model_selection/grid_search_cv.rb

@@ -88,7 +88,7 @@ module Rumale
       # @param y [Numo::NArray] (shape: [n_samples, n_outputs]) The target values or labels to be used for fitting the model.
       # @return [GridSearchCV] The learned estimator with grid search.
       def fit(x, y)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
 
         init_attrs
 
@@ -111,7 +111,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples]) Confidence score per sample.
       def decision_function(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @best_estimator.decision_function(x)
       end
 
@@ -120,7 +120,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to obtain prediction result.
       # @return [Numo::NArray] Predicted results.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @best_estimator.predict(x)
       end
 
@@ -129,7 +129,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the log-probailities.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted log-probability of each class per sample.
       def predict_log_proba(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @best_estimator.predict_log_proba(x)
       end
 
@@ -138,7 +138,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)
         @best_estimator.predict_proba(x)
       end
 
@@ -148,7 +148,7 @@ module Rumale
       # @param y [Numo::NArray] (shape: [n_samples, n_outputs]) True target values or labels for testing data.
       # @return [Float] The score of estimator.
       def score(x, y)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @best_estimator.score(x, y)
       end
 

data/lib/rumale/model_selection/k_fold.rb

@@ -36,9 +36,9 @@ module Rumale
       # @param shuffle [Boolean] The flag indicating whether to shuffle the dataset.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_splits: 3, shuffle: false, random_seed: nil)
-        check_params_integer(n_splits: n_splits)
+        check_params_numeric(n_splits: n_splits)
         check_params_boolean(shuffle: shuffle)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_numeric_or_nil(random_seed: random_seed)
         check_params_positive(n_splits: n_splits)
         @n_splits = n_splits
         @shuffle = shuffle
@@ -53,7 +53,7 @@ module Rumale
       #   The dataset to be used to generate data indices for K-fold cross validation.
       # @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
       def split(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         # Initialize and check some variables.
         n_samples, = x.shape
         unless @n_splits.between?(2, n_samples)

data/lib/rumale/model_selection/shuffle_split.rb

@@ -32,10 +32,8 @@ module Rumale
       # @param train_size [Float] The ratio of number of samples for train data.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_splits: 3, test_size: 0.1, train_size: nil, random_seed: nil)
-        check_params_integer(n_splits: n_splits)
-        check_params_float(test_size: test_size)
-        check_params_type_or_nil(Float, train_size: train_size)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_numeric(n_splits: n_splits, test_size: test_size)
+        check_params_numeric_or_nil(train_size: train_size, random_seed: random_seed)
         check_params_positive(n_splits: n_splits)
         check_params_positive(test_size: test_size)
         check_params_positive(train_size: train_size) unless train_size.nil?
@@ -53,7 +51,7 @@ module Rumale
       #   The dataset to be used to generate data indices for random permutation cross validation.
       # @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
       def split(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         # Initialize and check some variables.
         n_samples = x.shape[0]
         n_test_samples = (@test_size * n_samples).to_i