rumale 0.13.8 → 0.14.0

data/lib/rumale/tree/extra_tree_regressor.rb

@@ -46,9 +46,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)
@@ -61,8 +61,8 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The taget values to be used for fitting the model.
       # @return [ExtraTreeRegressor] 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)
         super
       end
@@ -72,7 +72,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)
         super
       end
 

data/lib/rumale/tree/gradient_tree_regressor.rb

@@ -52,10 +52,9 @@ module Rumale
       #   It is used to randomly determine the order of features when deciding spliting point.
       def initialize(reg_lambda: 0.0, shrinkage_rate: 1.0,
                      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_float(reg_lambda: reg_lambda, shrinkage_rate: shrinkage_rate)
-        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(reg_lambda: reg_lambda, shrinkage_rate: shrinkage_rate, min_samples_leaf: min_samples_leaf)
         check_params_positive(reg_lambda: reg_lambda, shrinkage_rate: shrinkage_rate,
                               max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
                               min_samples_leaf: min_samples_leaf, max_features: max_features)
@@ -83,10 +82,11 @@ module Rumale
       # @param h [Numo::DFloat] (shape: [n_samples]) The hessian of loss function.
       # @return [GradientTreeRegressor] The learned regressor itself.
       def fit(x, y, g, h)
-        check_sample_array(x)
-        check_tvalue_array(y)
+        x = check_convert_sample_array(x)
+        y = check_convert_tvalue_array(y)
+        g = check_convert_tvalue_array(g)
+        h = check_convert_tvalue_array(h)
         check_sample_tvalue_size(x, y)
-        check_params_type(Numo::DFloat, g: g, h: g)
         # Initialize some variables.
         n_features = x.shape[1]
         @params[:max_features] ||= n_features
@@ -105,7 +105,7 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
       # @return [Numo::DFloat] (size: n_samples) Predicted values per sample.
       def predict(x)
-        check_sample_array(x)
+        x = check_convert_sample_array(x)
         @leaf_weights[apply(x)].dup
       end
 
@@ -114,7 +114,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/validation.rb

@@ -5,17 +5,37 @@ module Rumale
   module Validation
     module_function
 
+    # @!visibility private
+    def check_convert_sample_array(x)
+      x = Numo::DFloat.cast(x) unless x.is_a?(Numo::DFloat)
+      raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.ndim == 2
+      x
+    end
+
+    # @!visibility private
+    def check_convert_label_array(y)
+      y = Numo::Int32.cast(y) unless y.is_a?(Numo::Int32)
+      raise ArgumentError, 'Expect label vector to be 1-D arrray' unless y.ndim == 1
+      y
+    end
+
+    # @!visibility private
+    def check_convert_tvalue_array(y)
+      y = Numo::DFloat.cast(y) unless y.is_a?(Numo::DFloat)
+      y
+    end
+
     # @!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
+      raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.ndim == 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
+      raise ArgumentError, 'Expect label vector to be 1-D arrray' unless y.ndim == 1
       nil
     end
 
@@ -49,6 +69,16 @@ module Rumale
       nil
     end
 
+    # @!visibility private
+    def check_params_numeric(params = {})
+      check_params_type(Numeric, params)
+    end
+
+    # @!visibility private
+    def check_params_numeric_or_nil(params = {})
+      check_params_type_or_nil(Numeric, params)
+    end
+
     # @!visibility private
     def check_params_float(params = {})
       check_params_type(Float, params)

data/lib/rumale/version.rb

@@ -3,5 +3,5 @@
 # Rumale is a machine learning library in Ruby.
 module Rumale
   # The version of Rumale you are using.
-  VERSION = '0.13.8'
+  VERSION = '0.14.0'
 end

data/rumale.gemspec

@@ -1,4 +1,3 @@
-
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rumale/version'
@@ -13,14 +12,15 @@ Gem::Specification.new do |spec|
     Rumale is a machine learning library in Ruby.
     Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
   MSG
-  spec.description   = <<~MSG
+  spec.description = <<~MSG
     Rumale is a machine learning library in Ruby.
     Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
-    Rumale currently supports Linear / Kernel Support Vector Machine,
-    Logistic Regression, Linear Regression, Ridge, Lasso, Kernel Ridge, Factorization Machine,
-    Naive Bayes, Decision Tree, AdaBoost, Gradient Tree Boosting, Random Forest, Extra-Trees, K-nearest neighbor algorithm,
-    K-Means, K-Medoids, Gaussian Mixture Model, DBSCAN, HDBSCAN, SNN, Spectral Clustering, Power Iteration Clustering,
-    Multidimensional Scaling, t-SNE, Principal Component Analysis, Kernel PCA, and Non-negative Matrix Factorization.
+    Rumale supports Support Vector Machine,
+    Logistic Regression, Ridge, Lasso, Factorization Machine,
+    Multi-layer Perceptron,
+    Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest,
+    K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering,
+    Mutidimensional Scaling, t-SNE, Principal Component Analysis, and Non-negative Matrix Factorization.
   MSG
   spec.homepage      = 'https://github.com/yoshoku/rumale'
   spec.license       = 'BSD-2-Clause'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.13.8
+  version: 0.14.0
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-08 00:00:00.000000000 Z
+date: 2019-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -125,11 +125,12 @@ dependencies:
 description: |
   Rumale is a machine learning library in Ruby.
   Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
-  Rumale currently supports Linear / Kernel Support Vector Machine,
-  Logistic Regression, Linear Regression, Ridge, Lasso, Kernel Ridge, Factorization Machine,
-  Naive Bayes, Decision Tree, AdaBoost, Gradient Tree Boosting, Random Forest, Extra-Trees, K-nearest neighbor algorithm,
-  K-Means, K-Medoids, Gaussian Mixture Model, DBSCAN, HDBSCAN, SNN, Spectral Clustering, Power Iteration Clustering,
-  Multidimensional Scaling, t-SNE, Principal Component Analysis, Kernel PCA, and Non-negative Matrix Factorization.
+  Rumale supports Support Vector Machine,
+  Logistic Regression, Ridge, Lasso, Factorization Machine,
+  Multi-layer Perceptron,
+  Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest,
+  K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering,
+  Mutidimensional Scaling, t-SNE, Principal Component Analysis, and Non-negative Matrix Factorization.
 email:
 - yoshoku@outlook.com
 executables: []
@@ -226,6 +227,9 @@ files:
 - lib/rumale/naive_bayes/naive_bayes.rb
 - lib/rumale/nearest_neighbors/k_neighbors_classifier.rb
 - lib/rumale/nearest_neighbors/k_neighbors_regressor.rb
+- lib/rumale/neural_network/base_mlp.rb
+- lib/rumale/neural_network/mlp_classifier.rb
+- lib/rumale/neural_network/mlp_regressor.rb
 - lib/rumale/optimizer/ada_grad.rb
 - lib/rumale/optimizer/adam.rb
 - lib/rumale/optimizer/nadam.rb