svmkit 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46878b59860b61bae7b522fb02af984208609f56
-  data.tar.gz: 6e889c6ad8382c654455a242d2f7f27de41de2d5
+  metadata.gz: bbc648db53b4285bd15ae00e2464c4376d027893
+  data.tar.gz: 28d9db47ae3053031f1643329cf02cd4e7d9c135
 SHA512:
-  metadata.gz: cddb239bf0768e6d983ce942ed6a7bdda8b827fa2e73e51c1b4591e8af3c641339377417f844358159c3a2bdff51d2f5678ef07fe21fe86e51136289e69ea38c
-  data.tar.gz: 64c2029c729de580765ad9ee89fd57821a40773721eac291201cb9b9f4c72697f5945c8f5259ed8d6a879f0b35dac841bcdd6d5322014c9cc78b9a42046dc310
+  metadata.gz: c504f010a70fc7a31afa4471096092adac9ff44de979d42d7277c63d737d517981e2ac6d7481ad42dc1c864f2a7756d39cd1d7697d2d4b1bca150d0a4eca3b8e
+  data.tar.gz: 8d89dc525ed37626a2d97e6fe3bebdacd4ec2945df285d8275cd0bd5df62c5ebc897dca67b91157df0bfc460fa987ed4098654ce6d164cb05ec46de4c6fe27af

data/HISTORY.md

@@ -1,3 +1,8 @@
+# 0.2.8
+- Fixed bug on gradient calculation of Logistic Regression.
+- Fixed to change accessor of params of estimators to read only.
+- Added parameter validation.
+
 # 0.2.7
 - Fixed to support multiclass classifiction into LinearSVC, LogisticRegression, KernelSVC, and FactorizationMachineClassifier
 

data/lib/svmkit/base/base_estimator.rb

@@ -7,7 +7,7 @@ module SVMKit
     module BaseEstimator
       # Return parameters about an estimator.
       # @return [Hash]
-      attr_accessor :params
+      attr_reader :params
     end
   end
 end

data/lib/svmkit/base/classifier.rb

@@ -20,6 +20,8 @@ module SVMKit
       # @param y [Numo::Int32] (shape: [n_samples]) True labels for testing data.
       # @return [Float] Mean accuracy
       def score(x, y)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         evaluator = SVMKit::EvaluationMeasure::Accuracy.new
         evaluator.score(y, predict(x))
       end

data/lib/svmkit/ensemble/random_forest_classifier.rb

@@ -50,6 +50,11 @@ module SVMKit
       #   It is used to randomly determine the order of features when deciding spliting point.
       def initialize(n_estimators: 10, criterion: 'gini', max_depth: nil, max_leaf_nodes: nil, min_samples_leaf: 1,
                      max_features: nil, random_seed: nil)
+        SVMKit::Validation.check_params_type_or_nil(Integer, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                                    max_features: max_features, random_seed: random_seed)
+        SVMKit::Validation.check_params_integer(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
+        SVMKit::Validation.check_params_string(criterion: criterion)
+
         @params = {}
         @params[:n_estimators] = n_estimators
         @params[:criterion] = criterion
@@ -59,10 +64,10 @@ module SVMKit
         @params[:max_features] = max_features
         @params[:random_seed] = random_seed
         @params[:random_seed] ||= srand
-        @rng = Random.new(@params[:random_seed])
         @estimators = nil
         @classes = nil
         @feature_importances = nil
+        @rng = Random.new(@params[:random_seed])
       end
 
       # Fit the model with given training data.
@@ -71,6 +76,8 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         # Initialize some variables.
         n_samples, n_features = x.shape
         @params[:max_features] = n_features unless @params[:max_features].is_a?(Integer)
@@ -98,6 +105,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         n_samples, = x.shape
         n_classes = @classes.size
         classes_arr = @classes.to_a
@@ -117,6 +125,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         n_samples, = x.shape
         n_classes = @classes.size
         classes_arr = @classes.to_a
@@ -136,6 +145,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         Numo::Int32[*Array.new(@params[:n_estimators]) { |n| @estimators[n].apply(x) }].transpose
       end
 

data/lib/svmkit/evaluation_measure/accuracy.rb

@@ -19,6 +19,9 @@ module SVMKit
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
       # @return [Float] Mean accuracy
       def score(y_true, y_pred)
+        SVMKit::Validation.check_label_array(y_true)
+        SVMKit::Validation.check_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
     end

data/lib/svmkit/evaluation_measure/f_score.rb

@@ -23,6 +23,7 @@ module SVMKit
       #
       # @param average [String] The average type ('binary', 'micro', 'macro')
       def initialize(average: 'binary')
+        SVMKit::Validation.check_params_string(average: average)
         @average = average
       end
 
@@ -32,6 +33,9 @@ module SVMKit
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
       # @return [Float] Average F1-score
       def score(y_true, y_pred)
+        SVMKit::Validation.check_label_array(y_true)
+        SVMKit::Validation.check_label_array(y_pred)
+
         case @average
         when 'binary'
           f_score_each_class(y_true, y_pred).last

data/lib/svmkit/evaluation_measure/precision.rb

@@ -23,6 +23,7 @@ module SVMKit
       #
       # @param average [String] The average type ('binary', 'micro', 'macro')
       def initialize(average: 'binary')
+        SVMKit::Validation.check_params_string(average: average)
         @average = average
       end
 
@@ -32,6 +33,9 @@ module SVMKit
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
       # @return [Float] Average precision
       def score(y_true, y_pred)
+        SVMKit::Validation.check_label_array(y_true)
+        SVMKit::Validation.check_label_array(y_pred)
+
         case @average
         when 'binary'
           precision_each_class(y_true, y_pred).last

data/lib/svmkit/evaluation_measure/recall.rb

@@ -23,6 +23,7 @@ module SVMKit
       #
       # @param average [String] The average type ('binary', 'micro', 'macro')
       def initialize(average: 'binary')
+        SVMKit::Validation.check_params_string(average: average)
         @average = average
       end
 
@@ -32,6 +33,9 @@ module SVMKit
       # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
       # @return [Float] Average recall
       def score(y_true, y_pred)
+        SVMKit::Validation.check_label_array(y_true)
+        SVMKit::Validation.check_label_array(y_pred)
+
         case @average
         when 'binary'
           recall_each_class(y_true, y_pred).last

data/lib/svmkit/kernel_approximation/rbf.rb

@@ -37,14 +37,18 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_params_float(gamma: gamma)
+        SVMKit::Validation.check_params_integer(n_components: n_components)
+        SVMKit::Validation.check_params_type_or_nil(Integer, random_seed: random_seed)
+
         @params = {}
         @params[:gamma] = gamma
         @params[:n_components] = n_components
         @params[:random_seed] = random_seed
         @params[:random_seed] ||= srand
-        @rng = Random.new(@params[:random_seed])
         @random_mat = nil
         @random_vec = nil
+        @rng = Random.new(@params[:random_seed])
       end
 
       # Fit the model with given training data.
@@ -55,6 +59,8 @@ module SVMKit
       #   This method uses only the number of features of the data.
       # @return [RBF] The learned transformer itself.
       def fit(x, _y = nil)
+        SVMKit::Validation.check_sample_array(x)
+
         n_features = x.shape[1]
         @params[:n_components] = 2 * n_features if @params[:n_components] <= 0
         @random_mat = rand_normal([n_features, @params[:n_components]]) * (2.0 * @params[:gamma])**0.5
@@ -72,6 +78,8 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+
         fit(x).transform(x)
       end
 
@@ -82,6 +90,8 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+
         n_samples, = x.shape
         projection = x.dot(@random_mat) + @random_vec.tile(n_samples, 1)
         Numo::NMath.sin(projection) * ((2.0 / @params[:n_components])**0.5)

data/lib/svmkit/kernel_machine/kernel_svc.rb

@@ -42,13 +42,17 @@ module SVMKit
       # @param max_iter [Integer] The maximum number of iterations.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(reg_param: 1.0, max_iter: 1000, random_seed: nil)
+        SVMKit::Validation.check_params_float(reg_param: reg_param)
+        SVMKit::Validation.check_params_integer(max_iter: max_iter)
+        SVMKit::Validation.check_params_type_or_nil(Integer, random_seed: random_seed)
+
         @params = {}
         @params[:reg_param] = reg_param
         @params[:max_iter] = max_iter
         @params[:random_seed] = random_seed
         @params[:random_seed] ||= srand
         @weight_vec = nil
-        @classes
+        @classes = nil
         @rng = Random.new(@params[:random_seed])
       end
 
@@ -59,6 +63,9 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
+
         @classes = Numo::Int32[*y.to_a.uniq.sort]
         n_classes = @classes.size
         _n_samples, n_features = x.shape
@@ -84,6 +91,8 @@ module SVMKit
       #     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)
+        SVMKit::Validation.check_sample_array(x)
+
         x.dot(@weight_vec.transpose)
       end
 
@@ -93,6 +102,8 @@ module SVMKit
       #     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)
+        SVMKit::Validation.check_sample_array(x)
+
         return Numo::Int32.cast(decision_function(x).ge(0.0)) * 2 - 1 if @classes.size <= 2
 
         n_samples, = x.shape
@@ -100,16 +111,6 @@ module SVMKit
         Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
       end
 
-      # Claculate the mean accuracy of the given testing data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_training_samples])
-      #     The kernel matrix between testing samples and training samples.
-      # @param y [Numo::Int32] (shape: [n_testing_samples]) True labels for testing data.
-      # @return [Float] Mean accuracy
-      def score(x, y)
-        super
-      end
-
       # Dump marshal data.
       # @return [Hash] The marshal data about KernelSVC.
       def marshal_dump

data/lib/svmkit/linear_model/logistic_regression.rb

@@ -50,6 +50,11 @@ module SVMKit
       # @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: 100, batch_size: 50, normalize: true, random_seed: nil)
+        SVMKit::Validation.check_params_float(reg_param: reg_param, bias_scale: bias_scale)
+        SVMKit::Validation.check_params_integer(max_iter: max_iter, batch_size: batch_size)
+        SVMKit::Validation.check_params_boolean(fit_bias: fit_bias, normalize: normalize)
+        SVMKit::Validation.check_params_type_or_nil(Integer, random_seed: random_seed)
+
         @params = {}
         @params[:reg_param] = reg_param
         @params[:fit_bias] = fit_bias
@@ -71,6 +76,9 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
+
         @classes = Numo::Int32[*y.to_a.uniq.sort]
         n_classes = @classes.size
         _n_samples, n_features = x.shape
@@ -79,14 +87,14 @@ module SVMKit
           @weight_vec = Numo::DFloat.zeros(n_classes, n_features)
           @bias_term = Numo::DFloat.zeros(n_classes)
           n_classes.times do |n|
-            bin_y = Numo::Int32.cast(y.eq(@classes[n]))
+            bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
             weight, bias = binary_fit(x, bin_y)
             @weight_vec[n, true] = weight
             @bias_term[n] = bias
           end
         else
           negative_label = y.to_a.uniq.sort.first
-          bin_y = Numo::Int32.cast(y.ne(negative_label))
+          bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
           @weight_vec, @bias_term = binary_fit(x, bin_y)
         end
 
@@ -98,6 +106,8 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+
         x.dot(@weight_vec.transpose) + @bias_term
       end
 
@@ -106,10 +116,12 @@ module SVMKit
       # @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)
-        return Numo::Int32.cast(decision_function(x).ge(0.5)) * 2 - 1 if @classes.size <= 2
+        SVMKit::Validation.check_sample_array(x)
+
+        return Numo::Int32.cast(predict_proba(x)[true, 1].ge(0.5)) * 2 - 1 if @classes.size <= 2
 
         n_samples, = x.shape
-        decision_values = decision_function(x)
+        decision_values = predict_proba(x)
         Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
       end
 
@@ -118,6 +130,8 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_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
 
@@ -165,9 +179,9 @@ module SVMKit
           rand_ids.concat(subset_ids)
           # update the weight vector.
           df = samples[subset_ids, true].dot(weight_vec.transpose)
-          coef = bin_y[subset_ids] / (Numo::NMath.exp(-bin_y[subset_ids] * df) + 1.0)
+          coef = bin_y[subset_ids] / (Numo::NMath.exp(-bin_y[subset_ids] * df) + 1.0) - bin_y[subset_ids]
           mean_vec = samples[subset_ids, true].transpose.dot(coef) / @params[:batch_size]
-          weight_vec -= learning_rate(t) * (@params[:reg_param] * weight_vec - mean_vec)
+          weight_vec -= learning_rate(t) * (@params[:reg_param] * weight_vec + mean_vec)
           # scale the weight vector.
           normalize_weight_vec(weight_vec) if @params[:normalize]
         end

data/lib/svmkit/linear_model/svc.rb

@@ -49,6 +49,11 @@ module SVMKit
       # @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: 100, batch_size: 50, normalize: true, random_seed: nil)
+        SVMKit::Validation.check_params_float(reg_param: reg_param, bias_scale: bias_scale)
+        SVMKit::Validation.check_params_integer(max_iter: max_iter, batch_size: batch_size)
+        SVMKit::Validation.check_params_boolean(fit_bias: fit_bias, normalize: normalize)
+        SVMKit::Validation.check_params_type_or_nil(Integer, random_seed: random_seed)
+
         @params = {}
         @params[:reg_param] = reg_param
         @params[:fit_bias] = fit_bias
@@ -70,6 +75,9 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
+
         @classes = Numo::Int32[*y.to_a.uniq.sort]
         n_classes = @classes.size
         _n_samples, n_features = x.shape
@@ -97,6 +105,8 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+
         x.dot(@weight_vec.transpose) + @bias_term
       end
 
@@ -105,6 +115,8 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+
         return Numo::Int32.cast(decision_function(x).ge(0.0)) * 2 - 1 if @classes.size <= 2
 
         n_samples, = x.shape

data/lib/svmkit/model_selection/cross_validation.rb

@@ -38,6 +38,10 @@ module SVMKit
       # @param evaluator [Evaluator] The evaluator that calculates score of estimator results.
       # @param return_train_score [Boolean] The flag indicating whether to calculate the score of training dataset.
       def initialize(estimator: nil, splitter: nil, evaluator: nil, return_train_score: false)
+        SVMKit::Validation.check_params_type(SVMKit::Base::BaseEstimator, estimator: estimator)
+        SVMKit::Validation.check_params_type(SVMKit::Base::Splitter, splitter: splitter)
+        SVMKit::Validation.check_params_type_or_nil(SVMKit::Base::Evaluator, evaluator: evaluator)
+        SVMKit::Validation.check_params_boolean(return_train_score: return_train_score)
         @estimator = estimator
         @splitter = splitter
         @evaluator = evaluator
@@ -56,6 +60,8 @@ module SVMKit
       #   * :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)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         # Initialize the report of cross validation.
         report = { test_score: [], train_score: nil, fit_time: [] }
         report[:train_score] = [] if @return_train_score

data/lib/svmkit/model_selection/k_fold.rb

@@ -32,6 +32,10 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_params_integer(n_splits: n_splits)
+        SVMKit::Validation.check_params_boolean(shuffle: shuffle)
+        SVMKit::Validation.check_params_type_or_nil(Integer, random_seed: random_seed)
+
         @n_splits = n_splits
         @shuffle = shuffle
         @random_seed = random_seed
@@ -43,11 +47,9 @@ module SVMKit
       #
       # @param x [Numo::DFloat] (shape: [n_samples, n_features])
       #   The dataset to be used to generate data indices for K-fold cross validation.
-      # @param y [Numo::Int32] (shape: [n_samples])
-      #   The labels to be used to generate data indices for stratified K-fold cross validation.
-      #   This argument exists to unify the interface between the K-fold methods, it is not used in the method.
       # @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
-      def split(x, y) # rubocop:disable Lint/UnusedMethodArgument
+      def split(x, _y = nil)
+        SVMKit::Validation.check_sample_array(x)
         # Initialize and check some variables.
         n_samples, = x.shape
         unless @n_splits.between?(2, n_samples)

data/lib/svmkit/model_selection/stratified_k_fold.rb

@@ -32,6 +32,10 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_params_integer(n_splits: n_splits)
+        SVMKit::Validation.check_params_boolean(shuffle: shuffle)
+        SVMKit::Validation.check_params_type_or_nil(Integer, random_seed: random_seed)
+
         @n_splits = n_splits
         @shuffle = shuffle
         @random_seed = random_seed
@@ -48,6 +52,8 @@ module SVMKit
       #   The labels to be used to generate data indices for stratified 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) # rubocop:disable Lint/UnusedMethodArgument
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         # Check the number of samples in each class.
         unless valid_n_splits?(y)
           raise ArgumentError,

data/lib/svmkit/multiclass/one_vs_rest_classifier.rb

@@ -33,6 +33,7 @@ module SVMKit
       #
       # @param estimator [Classifier] The (binary) classifier for construction a multi-class classifier.
       def initialize(estimator: nil)
+        SVMKit::Validation.check_params_type(SVMKit::Base::BaseEstimator, estimator: estimator)
         @params = {}
         @params[:estimator] = estimator
         @estimators = nil
@@ -45,6 +46,8 @@ module SVMKit
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [OneVsRestClassifier] The learned classifier itself.
       def fit(x, y)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         y_arr = y.to_a
         @classes = Numo::Int32.asarray(y_arr.uniq.sort)
         @estimators = @classes.to_a.map do |label|
@@ -59,6 +62,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
       def decision_function(x)
+        SVMKit::Validation.check_sample_array(x)
         n_classes = @classes.size
         Numo::DFloat.asarray(Array.new(n_classes) { |m| @estimators[m].decision_function(x).to_a }).transpose
       end
@@ -68,6 +72,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         n_samples, = x.shape
         decision_values = decision_function(x)
         Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })

data/lib/svmkit/naive_bayes/naive_bayes.rb

@@ -16,6 +16,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         n_samples = x.shape.first
         decision_values = decision_function(x)
         Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
@@ -26,6 +27,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         n_samples, = x.shape
         log_likelihoods = decision_function(x)
         log_likelihoods - Numo::NMath.log(Numo::NMath.exp(log_likelihoods).sum(1)).reshape(n_samples, 1)
@@ -36,6 +38,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         Numo::NMath.exp(predict_log_proba(x)).abs
       end
     end
@@ -75,6 +78,8 @@ module SVMKit
       #   to be used for fitting the model.
       # @return [GaussianNB] The learned classifier itself.
       def fit(x, y)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         n_samples, = x.shape
         @classes = Numo::Int32[*y.to_a.uniq.sort]
         @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count / n_samples.to_f }]
@@ -88,6 +93,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
       def decision_function(x)
+        SVMKit::Validation.check_sample_array(x)
         n_classes = @classes.size
         log_likelihoods = Array.new(n_classes) do |l|
           Math.log(@class_priors[l]) - 0.5 * (
@@ -147,6 +153,7 @@ module SVMKit
       #
       # @param smoothing_param [Float] The Laplace smoothing parameter.
       def initialize(smoothing_param: 1.0)
+        SVMKit::Validation.check_params_float(smoothing_param: smoothing_param)
         @params = {}
         @params[:smoothing_param] = smoothing_param
       end
@@ -158,6 +165,8 @@ module SVMKit
       #   to be used for fitting the model.
       # @return [MultinomialNB] The learned classifier itself.
       def fit(x, y)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         n_samples, = x.shape
         @classes = Numo::Int32[*y.to_a.uniq.sort]
         @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count / n_samples.to_f }]
@@ -173,6 +182,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
       def decision_function(x)
+        SVMKit::Validation.check_sample_array(x)
         n_classes = @classes.size
         bin_x = x.gt(0)
         log_likelihoods = Array.new(n_classes) do |l|
@@ -230,6 +240,7 @@ module SVMKit
       # @param smoothing_param [Float] The Laplace smoothing parameter.
       # @param bin_threshold [Float] The threshold for binarizing of features.
       def initialize(smoothing_param: 1.0, bin_threshold: 0.0)
+        SVMKit::Validation.check_params_float(smoothing_param: smoothing_param, bin_threshold: bin_threshold)
         @params = {}
         @params[:smoothing_param] = smoothing_param
         @params[:bin_threshold] = bin_threshold
@@ -242,6 +253,8 @@ module SVMKit
       #   to be used for fitting the model.
       # @return [BernoulliNB] The learned classifier itself.
       def fit(x, y)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         n_samples, = x.shape
         bin_x = Numo::DFloat[*x.gt(@params[:bin_threshold])]
         @classes = Numo::Int32[*y.to_a.uniq.sort]
@@ -260,6 +273,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
       def decision_function(x)
+        SVMKit::Validation.check_sample_array(x)
         n_classes = @classes.size
         bin_x = Numo::DFloat[*x.gt(@params[:bin_threshold])]
         not_bin_x = Numo::DFloat[*x.le(@params[:bin_threshold])]

data/lib/svmkit/nearest_neighbors/k_neighbors_classifier.rb

@@ -35,6 +35,7 @@ module SVMKit
       #
       # @param n_neighbors [Integer] The number of neighbors.
       def initialize(n_neighbors: 5)
+        SVMKit::Validation.check_params_integer(n_neighbors: n_neighbors)
         @params = {}
         @params[:n_neighbors] = n_neighbors
         @prototypes = nil
@@ -48,6 +49,8 @@ module SVMKit
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [KNeighborsClassifier] The learned classifier itself.
       def fit(x, y)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         @prototypes = Numo::DFloat.asarray(x.to_a)
         @labels = Numo::Int32.asarray(y.to_a)
         @classes = Numo::Int32.asarray(y.to_a.uniq.sort)
@@ -59,6 +62,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
       def decision_function(x)
+        SVMKit::Validation.check_sample_array(x)
         distance_matrix = PairwiseMetric.euclidean_distance(x, @prototypes)
         n_samples, n_prototypes = distance_matrix.shape
         n_classes = @classes.size
@@ -76,6 +80,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         n_samples = x.shape.first
         decision_values = decision_function(x)
         Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })

data/lib/svmkit/pairwise_metric.rb

@@ -11,6 +11,8 @@ module SVMKit
       # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
       def euclidean_distance(x, y = nil)
         y = x if y.nil?
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_sample_array(y)
         sum_x_vec = (x**2).sum(1)
         sum_y_vec = (y**2).sum(1)
         dot_xy_mat = x.dot(y.transpose)
@@ -29,6 +31,9 @@ module SVMKit
       def rbf_kernel(x, y = nil, gamma = nil)
         y = x if y.nil?
         gamma ||= 1.0 / x.shape[1]
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_sample_array(y)
+        SVMKit::Validation.check_params_float(gamma: gamma)
         distance_matrix = euclidean_distance(x, y)
         Numo::NMath.exp((distance_matrix**2) * -gamma)
       end
@@ -40,6 +45,8 @@ module SVMKit
       # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
       def linear_kernel(x, y = nil)
         y = x if y.nil?
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_sample_array(y)
         x.dot(y.transpose)
       end
 
@@ -54,6 +61,10 @@ module SVMKit
       def polynomial_kernel(x, y = nil, degree = 3, gamma = nil, coef = 1)
         y = x if y.nil?
         gamma ||= 1.0 / x.shape[1]
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_sample_array(y)
+        SVMKit::Validation.check_params_float(gamma: gamma)
+        SVMKit::Validation.check_params_integer(degree: degree, coef: coef)
         (x.dot(y.transpose) * gamma + coef)**degree
       end
 
@@ -67,6 +78,10 @@ module SVMKit
       def sigmoid_kernel(x, y = nil, gamma = nil, coef = 1)
         y = x if y.nil?
         gamma ||= 1.0 / x.shape[1]
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_sample_array(y)
+        SVMKit::Validation.check_params_float(gamma: gamma)
+        SVMKit::Validation.check_params_integer(coef: coef)
         Numo::NMath.tanh(x.dot(y.transpose) * gamma + coef)
       end
     end

data/lib/svmkit/polynomial_model/factorization_machine_classifier.rb

@@ -58,6 +58,12 @@ module SVMKit
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_factors: 2, loss: 'hinge', reg_param_bias: 1.0, reg_param_weight: 1.0, reg_param_factor: 1.0,
                      init_std: 0.1, max_iter: 1000, batch_size: 10, random_seed: nil)
+        SVMKit::Validation.check_params_float(reg_param_bias: reg_param_bias, reg_param_weight: reg_param_weight,
+                                              reg_param_factor: reg_param_factor, init_std: init_std)
+        SVMKit::Validation.check_params_integer(n_factors: n_factors, max_iter: max_iter, batch_size: batch_size)
+        SVMKit::Validation.check_params_string(loss: loss)
+        SVMKit::Validation.check_params_type_or_nil(Integer, random_seed: random_seed)
+
         @params = {}
         @params[:n_factors] = n_factors
         @params[:loss] = loss
@@ -82,6 +88,9 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
+
         @classes = Numo::Int32[*y.to_a.uniq.sort]
         n_classes = @classes.size
         _n_samples, n_features = x.shape
@@ -111,6 +120,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_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
@@ -125,6 +135,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         return Numo::Int32.cast(decision_function(x).ge(0.0)) * 2 - 1 if @classes.size <= 2
 
         n_samples, = x.shape
@@ -137,6 +148,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_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
 

data/lib/svmkit/preprocessing/l2_normalizer.rb

@@ -32,6 +32,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
       # @return [L2Normalizer]
       def fit(x, _y = nil)
+        SVMKit::Validation.check_sample_array(x)
         @norm_vec = Numo::NMath.sqrt((x**2).sum(1))
         self
       end
@@ -43,6 +44,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         fit(x)
         x / @norm_vec.tile(x.shape[1], 1).transpose
       end

data/lib/svmkit/preprocessing/min_max_scaler.rb

@@ -28,6 +28,7 @@ module SVMKit
       #
       # @param feature_range [Array<Float>] The desired range of samples.
       def initialize(feature_range: [0.0, 1.0])
+        SVMKit::Validation.check_params_type(Array, feature_range: feature_range)
         @params = {}
         @params[:feature_range] = feature_range
         @min_vec = nil
@@ -41,6 +42,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         @min_vec = x.min(0)
         @max_vec = x.max(0)
         self
@@ -53,6 +55,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         fit(x).transform(x)
       end
 
@@ -61,6 +64,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be scaled.
       # @return [Numo::DFloat] The scaled samples.
       def transform(x)
+        SVMKit::Validation.check_sample_array(x)
         n_samples, = x.shape
         dif_vec = @max_vec - @min_vec
         nx = (x - @min_vec.tile(n_samples, 1)) / dif_vec.tile(n_samples, 1)

data/lib/svmkit/preprocessing/standard_scaler.rb

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

data/lib/svmkit/tree/decision_tree_classifier.rb

@@ -54,6 +54,11 @@ module SVMKit
       #   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)
+        SVMKit::Validation.check_params_type_or_nil(Integer, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                                                    max_features: max_features, random_seed: random_seed)
+        SVMKit::Validation.check_params_integer(min_samples_leaf: min_samples_leaf)
+        SVMKit::Validation.check_params_string(criterion: criterion)
+
         @params = {}
         @params[:criterion] = criterion
         @params[:max_depth] = max_depth
@@ -62,12 +67,12 @@ module SVMKit
         @params[:max_features] = max_features
         @params[:random_seed] = random_seed
         @params[:random_seed] ||= srand
-        @rng = Random.new(@params[:random_seed])
         @tree = nil
         @classes = nil
         @feature_importances = nil
         @n_leaves = nil
         @leaf_labels = nil
+        @rng = Random.new(@params[:random_seed])
       end
 
       # Fit the model with given training data.
@@ -76,6 +81,8 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
+        SVMKit::Validation.check_label_array(y)
         n_samples, n_features = x.shape
         @params[:max_features] = n_features unless @params[:max_features].is_a?(Integer)
         @params[:max_features] = [[1, @params[:max_features]].max, n_features].min
@@ -90,6 +97,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         @leaf_labels[apply(x)]
       end
 
@@ -98,6 +106,7 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         probs = Numo::DFloat[*(Array.new(x.shape[0]) { |n| predict_at_node(@tree, x[n, true]) })]
         probs[true, @classes]
       end
@@ -107,14 +116,18 @@ module SVMKit
       # @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)
+        SVMKit::Validation.check_sample_array(x)
         Numo::Int32[*(Array.new(x.shape[0]) { |n| apply_at_node(@tree, x[n, true]) })]
       end
 
       # Dump marshal data.
       # @return [Hash] The marshal data about DecisionTreeClassifier
       def marshal_dump
-        { params: @params, classes: @classes, tree: @tree,
-          feature_importances: @feature_importances, leaf_labels: @leaf_labels,
+        { params: @params,
+          classes: @classes,
+          tree: @tree,
+          feature_importances: @feature_importances,
+          leaf_labels: @leaf_labels,
           rng: @rng }
       end
 

data/lib/svmkit/validation.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SVMKit
+  # @!visibility private
+  module Validation
+    module_function
+
+    # @!visibility private
+    def check_sample_array(x)
+      raise TypeError, 'Expect class of sample matrix to be Numo::DFloat' unless x.is_a?(Numo::DFloat)
+      raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+      nil
+    end
+
+    # @!visibility private
+    def check_label_array(y)
+      raise TypeError, 'Expect class of label vector to be Numo::Int32' unless y.is_a?(Numo::Int32)
+      raise ArgumentError, 'Expect label vector to be 1-D arrray' unless y.shape.size == 1
+      nil
+    end
+
+    # @!visibility private
+    def check_params_type(type, params = {})
+      params.each { |k, v| raise TypeError, "Expect class of #{k} to be #{type}" unless v.is_a?(type) }
+      nil
+    end
+
+    # @!visibility private
+    def check_params_type_or_nil(type, params = {})
+      params.each { |k, v| raise TypeError, "Expect class of #{k} to be #{type} or nil" unless v.is_a?(type) || v.is_a?(NilClass) }
+      nil
+    end
+
+    # @!visibility private
+    def check_params_float(params = {})
+      check_params_type(Float, params)
+    end
+
+    # @!visibility private
+    def check_params_integer(params = {})
+      check_params_type(Integer, params)
+    end
+
+    # @!visibility private
+    def check_params_string(params = {})
+      check_params_type(String, params)
+    end
+
+    # @!visibility private
+    def check_params_boolean(params = {})
+      params.each { |k, v| raise TypeError, "Expect class of #{k} to be Boolean" unless v.is_a?(FalseClass) || v.is_a?(TrueClass) }
+      nil
+    end
+  end
+end

data/lib/svmkit/version.rb

@@ -3,5 +3,5 @@
 # SVMKit is a machine learning library in Ruby.
 module SVMKit
   # @!visibility private
-  VERSION = '0.2.7'
+  VERSION = '0.2.8'
 end

data/lib/svmkit.rb

@@ -3,6 +3,7 @@
 require 'numo/narray'
 
 require 'svmkit/version'
+require 'svmkit/validation'
 require 'svmkit/pairwise_metric'
 require 'svmkit/dataset'
 require 'svmkit/base/base_estimator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: svmkit
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-01 00:00:00.000000000 Z
+date: 2018-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -135,6 +135,7 @@ files:
 - lib/svmkit/preprocessing/min_max_scaler.rb
 - lib/svmkit/preprocessing/standard_scaler.rb
 - lib/svmkit/tree/decision_tree_classifier.rb
+- lib/svmkit/validation.rb
 - lib/svmkit/version.rb
 - svmkit.gemspec
 homepage: https://github.com/yoshoku/svmkit