rumale 0.13.8 → 0.14.0

data/lib/rumale/polynomial_model/factorization_machine_classifier.rb

@@ -61,10 +61,10 @@ module Rumale
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_factors: 2, loss: 'hinge', reg_param_linear: 1.0, reg_param_factor: 1.0,
                      max_iter: 1000, batch_size: 10, optimizer: nil, n_jobs: nil, random_seed: nil)
-        check_params_float(reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor)
-        check_params_integer(n_factors: n_factors, max_iter: max_iter, batch_size: batch_size)
+        check_params_numeric(reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
+                             n_factors: n_factors, max_iter: max_iter, batch_size: batch_size)
         check_params_string(loss: loss)
-        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(n_factors: n_factors,
                               reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
                               max_iter: max_iter, batch_size: batch_size)
@@ -78,15 +78,15 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [FactorizationMachineClassifier] 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_samples, n_features = x.shape
 
-        if n_classes > 2
+        if multiclass_problem?
+          n_classes = @classes.size
+          n_features = x.shape[1]
           @factor_mat = Numo::DFloat.zeros(n_classes, @params[:n_factors], n_features)
           @weight_vec = Numo::DFloat.zeros(n_classes, n_features)
           @bias_term = Numo::DFloat.zeros(n_classes)
@@ -105,7 +105,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
           @factor_mat, @weight_vec, @bias_term = partial_fit(x, bin_y)
         end
@@ -118,12 +118,12 @@ 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)
         linear_term = @bias_term + x.dot(@weight_vec.transpose)
-        factor_term = if @classes.size <= 2
-                        0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(0)
-                      else
+        factor_term = if multiclass_problem?
                         0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(1).transpose
+                      else
+                        0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(0)
                       end
         linear_term + factor_term
       end
@@ -133,15 +133,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
+        x = check_convert_sample_array(x)
 
         n_samples = x.shape[0]
-        decision_values = decision_function(x)
-        predicted = if enable_parallel?
-                      parallel_map(n_samples) { |n| @classes[decision_values[n, true].max_index] }
+        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
@@ -151,9 +155,9 @@ 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)
@@ -211,6 +215,10 @@ module Rumale
           logistic_loss_gradient(x, ex_x, y, factor, weight)
         end
       end
+
+      def multiclass_problem?
+        @classes.size > 2
+      end
     end
   end
 end

data/lib/rumale/polynomial_model/factorization_machine_regressor.rb

@@ -54,9 +54,9 @@ module Rumale
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_factors: 2, reg_param_linear: 1.0, reg_param_factor: 1.0,
                      max_iter: 1000, batch_size: 10, optimizer: nil, n_jobs: nil, random_seed: nil)
-        check_params_float(reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor)
-        check_params_integer(n_factors: n_factors, max_iter: max_iter, batch_size: batch_size)
-        check_params_type_or_nil(Integer, n_jobs: n_jobs, random_seed: random_seed)
+        check_params_numeric(reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
+                             n_factors: n_factors, max_iter: max_iter, batch_size: batch_size)
+        check_params_numeric_or_nil(n_jobs: n_jobs, random_seed: random_seed)
         check_params_positive(n_factors: n_factors, reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
                               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(loss: nil)
@@ -69,8 +69,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.
       # @return [FactorizationMachineRegressor] 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 +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 values per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         linear_term = @bias_term + x.dot(@weight_vec.transpose)
         factor_term = if @weight_vec.shape[1].nil?
                         0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(0)

data/lib/rumale/preprocessing/bin_discretizer.rb

@@ -50,7 +50,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the feature ranges.
       # @return [BinDiscretizer]
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_features = x.shape[1]
         max_vals = x.max(0)
         min_vals = x.min(0)
@@ -67,7 +67,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be discretized.
       # @return [Numo::DFloat] The discretized samples.
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         fit(x).transform(x)
       end
 
@@ -76,7 +76,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be discretized.
       # @return [Numo::DFloat] The discretized samples.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_samples, n_features = x.shape
         transformed = Numo::DFloat.zeros(n_samples, n_features)
         n_features.times do |n|

data/lib/rumale/preprocessing/l2_normalizer.rb

@@ -32,7 +32,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
       # @return [L2Normalizer]
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @norm_vec = Numo::NMath.sqrt((x**2).sum(1))
         self
       end
@@ -44,7 +44,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
       # @return [Numo::DFloat] The normalized samples.
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         fit(x)
         x / @norm_vec.tile(x.shape[1], 1).transpose
       end

data/lib/rumale/preprocessing/label_binarizer.rb

@@ -31,7 +31,7 @@ module Rumale
       # @param neg_label [Integer] The value represents negative label.
       # @param pos_label [Integer] The value represents positive label.
       def initialize(neg_label: 0, pos_label: 1)
-        check_params_integer(neg_label: neg_label, pos_label: pos_label)
+        check_params_numeric(neg_label: neg_label, pos_label: pos_label)
         @params = {}
         @params[:neg_label] = neg_label
         @params[:pos_label] = pos_label
@@ -80,7 +80,7 @@ module Rumale
       # @param x [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels to be decoded.
       # @return [Array] (shape: [n_samples]) The decoded labels.
       def inverse_transform(x)
-        check_params_type(Numo::Int32, x: x)
+        x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         n_samples = x.shape[0]
         Array.new(n_samples) { |n| @classes[x[n, true].ne(@params[:neg_label]).where[0]] }
       end

data/lib/rumale/preprocessing/label_encoder.rb

@@ -71,7 +71,7 @@ module Rumale
       # @param x [Numo::Int32] (shape: [n_samples]) The labels to be decoded.
       # @return [Array] The decoded labels.
       def inverse_transform(x)
-        check_label_array(x)
+        x = check_convert_label_array(x)
         x.to_a.map { |n| @classes[n] }
       end
 

data/lib/rumale/preprocessing/max_abs_scaler.rb

@@ -32,7 +32,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate maximum absolute value for each feature.
       # @return [MaxAbsScaler]
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @max_abs_vec = x.abs.max(0)
         self
       end
@@ -44,7 +44,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate maximum absolute value for each feature.
       # @return [Numo::DFloat] The scaled samples.
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         fit(x).transform(x)
       end
 
@@ -53,7 +53,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be scaled.
       # @return [Numo::DFloat] The scaled samples.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         x / @max_abs_vec
       end
 

data/lib/rumale/preprocessing/min_max_scaler.rb

@@ -42,7 +42,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
       # @return [MinMaxScaler]
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @min_vec = x.min(0)
         @max_vec = x.max(0)
         self
@@ -55,7 +55,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
       # @return [Numo::DFloat] The scaled samples.
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         fit(x).transform(x)
       end
 
@@ -64,7 +64,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be scaled.
       # @return [Numo::DFloat] The scaled samples.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_samples, = x.shape
         dif_vec = @max_vec - @min_vec
         dif_vec[dif_vec.eq(0)] = 1.0

data/lib/rumale/preprocessing/one_hot_encoder.rb

@@ -49,7 +49,7 @@ module Rumale
       #   @param x [Numo::Int32] (shape: [n_samples, n_features]) The samples to fit one-hot-encoder.
       # @return [OneHotEncoder]
       def fit(x, _y = nil)
-        check_params_type(Numo::Int32, x: x)
+        x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
         @n_values = x.max(0) + 1
         @feature_indices = Numo::Int32.hstack([[0], @n_values]).cumsum
@@ -64,7 +64,8 @@ module Rumale
       # @param x [Numo::Int32] (shape: [n_samples, n_features]) The samples to encode into one-hot-vectors.
       # @return [Numo::DFloat] The one-hot-vectors.
       def fit_transform(x, _y = nil)
-        check_params_type(Numo::Int32, x: x)
+        x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
+        raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
         fit(x).transform(x)
       end
@@ -74,7 +75,7 @@ module Rumale
       # @param x [Numo::Int32] (shape: [n_samples, n_features]) The samples to encode into one-hot-vectors.
       # @return [Numo::DFloat] The one-hot-vectors.
       def transform(x)
-        check_params_type(Numo::Int32, x: x)
+        x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
         codes = encode(x, @feature_indices)
         codes[true, @active_features].dup

data/lib/rumale/preprocessing/ordinal_encoder.rb

@@ -91,7 +91,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples consisting of values transformed from categorical features.
       # @return [Numo::NArray] The decoded features.
       def inverse_transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
 
         n_features = x.shape[1]
         raise ArgumentError, 'Expect the number of features and the number of categories to be equal' if n_features != @categories.size

data/lib/rumale/preprocessing/standard_scaler.rb

@@ -39,7 +39,7 @@ module Rumale
       #   The samples to calculate the mean values and standard deviations.
       # @return [StandardScaler]
       def fit(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @mean_vec = x.mean(0)
         @std_vec = x.stddev(0)
         self
@@ -53,7 +53,7 @@ module Rumale
       #   The samples to calculate the mean values and standard deviations.
       # @return [Numo::DFloat] The scaled samples.
       def fit_transform(x, _y = nil)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         fit(x).transform(x)
       end
 
@@ -62,7 +62,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be scaled.
       # @return [Numo::DFloat] The scaled samples.
       def transform(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         n_samples, = x.shape
         (x - @mean_vec.tile(n_samples, 1)) / @std_vec.tile(n_samples, 1)
       end

data/lib/rumale/tree/base_decision_tree.rb

@@ -43,7 +43,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples]) Leaf index for sample.
       def apply(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         Numo::Int32[*(Array.new(x.shape[0]) { |n| apply_at_node(@tree, x[n, true]) })]
       end
 

data/lib/rumale/tree/decision_tree_classifier.rb

@@ -53,9 +53,9 @@ module Rumale
       #   It is used to randomly determine the order of features when deciding spliting point.
       def initialize(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(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(min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
                               min_samples_leaf: min_samples_leaf, max_features: max_features)
@@ -69,8 +69,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [DecisionTreeClassifier] 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)
         n_samples, n_features = x.shape
         @params[:max_features] = n_features if @params[:max_features].nil?
@@ -91,7 +91,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)
         @leaf_labels[apply(x)].dup
       end
 
@@ -100,7 +100,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)
         Numo::DFloat[*(Array.new(x.shape[0]) { |n| predict_proba_at_node(@tree, x[n, true]) })]
       end
 

data/lib/rumale/tree/decision_tree_regressor.rb

@@ -49,9 +49,9 @@ module Rumale
       #   It is used to randomly determine the order of features when deciding spliting point.
       def initialize(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(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(min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
                               min_samples_leaf: min_samples_leaf, max_features: max_features)
@@ -65,8 +65,8 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The taget values to be used for fitting the model.
       # @return [DecisionTreeRegressor] 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_samples, n_features = x.shape
         @params[:max_features] = n_features if @params[:max_features].nil?
@@ -86,7 +86,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)
         @leaf_values.shape[1].nil? ? @leaf_values[apply(x)].dup : @leaf_values[apply(x), true].dup
       end
 

data/lib/rumale/tree/extra_tree_classifier.rb

@@ -50,9 +50,9 @@ module Rumale
       #   It is used to randomly determine the order of features when deciding spliting point.
       def initialize(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(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(min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
                               min_samples_leaf: min_samples_leaf, max_features: max_features)
@@ -65,8 +65,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [ExtraTreeClassifier] 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)
         super
       end
@@ -76,7 +76,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
 
@@ -85,7 +85,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