rumale 0.10.0 → 0.11.0

data/lib/rumale/linear_model/ridge.rb

@@ -38,12 +38,17 @@ module Rumale
       # @param batch_size [Integer] The size of the mini batches.
       # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
       #   If nil is given, Nadam is used.
+      # @param n_jobs [Integer] The number of jobs for running the fit method in parallel.
+      #   If nil is given, the method does not execute in parallel.
+      #   If zero or less is given, it becomes equal to the number of processors.
+      #   This parameter is ignored if the Parallel gem is not loaded.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(reg_param: 1.0, fit_bias: false, bias_scale: 1.0, max_iter: 1000, batch_size: 10, optimizer: nil, random_seed: nil)
+      def initialize(reg_param: 1.0, fit_bias: false, bias_scale: 1.0, max_iter: 1000, batch_size: 10, optimizer: nil,
+                     n_jobs: nil, random_seed: nil)
         check_params_float(reg_param: reg_param, bias_scale: bias_scale)
         check_params_integer(max_iter: max_iter, batch_size: batch_size)
         check_params_boolean(fit_bias: fit_bias)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_type_or_nil(Integer, n_jobs: n_jobs, random_seed: random_seed)
         check_params_positive(reg_param: reg_param, max_iter: max_iter, batch_size: batch_size)
         super
       end
@@ -64,7 +69,12 @@ module Rumale
         if n_outputs > 1
           @weight_vec = Numo::DFloat.zeros(n_outputs, n_features)
           @bias_term = Numo::DFloat.zeros(n_outputs)
-          n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
+          if enable_parallel?
+            models = parallel_map(n_outputs) { |n| partial_fit(x, y[true, n]) }
+            n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = models[n] }
+          else
+            n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
+          end
         else
           @weight_vec, @bias_term = partial_fit(x, y)
         end

data/lib/rumale/linear_model/svc.rb

@@ -48,13 +48,17 @@ module Rumale
       # @param probability [Boolean] The flag indicating whether to perform probability estimation.
       # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
       #   If nil is given, Nadam is used.
+      # @param n_jobs [Integer] The number of jobs for running the fit and predict methods in parallel.
+      #   If nil is given, the methods do not execute in parallel.
+      #   If zero or less is given, it becomes equal to the number of processors.
+      #   This parameter is ignored if the Parallel gem is not loaded.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(reg_param: 1.0, fit_bias: false, bias_scale: 1.0,
-                     max_iter: 1000, batch_size: 20, probability: false, optimizer: nil, random_seed: nil)
+                     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_boolean(fit_bias: fit_bias, probability: probability)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_type_or_nil(Integer, 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)
@@ -79,27 +83,30 @@ module Rumale
         n_features = x.shape[1]
 
         if n_classes > 2
+          # initialize model.
           @weight_vec = Numo::DFloat.zeros(n_classes, n_features)
           @bias_term = Numo::DFloat.zeros(n_classes)
           @prob_param = Numo::DFloat.zeros(n_classes, 2)
-          n_classes.times do |n|
-            bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
-            @weight_vec[n, true], @bias_term[n] = partial_fit(x, bin_y)
-            @prob_param[n, true] = if @params[:probability]
-                                     Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec[n, true].transpose) + @bias_term[n], bin_y)
-                                   else
-                                     Numo::DFloat[1, 0]
-                                   end
-          end
+          # fit model.
+          models = if enable_parallel?
+                     # :nocov:
+                     parallel_map(n_classes) do |n|
+                       bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
+                       partial_fit(x, bin_y)
+                     end
+                     # :nocov:
+                   else
+                     Array.new(n_classes) do |n|
+                       bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
+                       partial_fit(x, bin_y)
+                     end
+                   end
+          # 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
           bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
-          @weight_vec, @bias_term = partial_fit(x, bin_y)
-          @prob_param = if @params[:probability]
-                          Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec.transpose) + @bias_term, bin_y)
-                        else
-                          Numo::DFloat[1, 0]
-                        end
+          @weight_vec, @bias_term, @prob_param = partial_fit(x, bin_y)
         end
 
         self
@@ -125,7 +132,12 @@ module Rumale
 
         n_samples, = x.shape
         decision_values = decision_function(x)
-        Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
+        predicted = 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
+        Numo::Int32.asarray(predicted)
       end
 
       # Predict probability for samples.
@@ -172,6 +184,16 @@ module Rumale
 
       private
 
+      def partial_fit(x, bin_y)
+        w, b = super
+        p = if @params[:probability]
+              Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(w.transpose) + b, bin_y)
+            else
+              Numo::DFloat[1, 0]
+            end
+        [w, b, p]
+      end
+
       def calc_loss_gradient(x, y, weight)
         target_ids = (x.dot(weight) * y).lt(1.0).where
         grad = Numo::DFloat.zeros(@params[:batch_size])

data/lib/rumale/linear_model/svr.rb

@@ -41,13 +41,17 @@ module Rumale
       # @param batch_size [Integer] The size of the mini batches.
       # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
       #   If nil is given, Nadam is used.
+      # @param n_jobs [Integer] The number of jobs for running the fit method in parallel.
+      #   If nil is given, the method does not execute in parallel.
+      #   If zero or less is given, it becomes equal to the number of processors.
+      #   This parameter is ignored if the Parallel gem is not loaded.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(reg_param: 1.0, fit_bias: false, bias_scale: 1.0, epsilon: 0.1,
-                     max_iter: 1000, batch_size: 20, optimizer: nil, random_seed: nil)
+                     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_boolean(fit_bias: fit_bias)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_type_or_nil(Integer, 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
@@ -72,7 +76,12 @@ module Rumale
         if n_outputs > 1
           @weight_vec = Numo::DFloat.zeros(n_outputs, n_features)
           @bias_term = Numo::DFloat.zeros(n_outputs)
-          n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
+          if enable_parallel?
+            models = parallel_map(n_outputs) { |n| partial_fit(x, y[true, n]) }
+            n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = models[n] }
+          else
+            n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
+          end
         else
           @weight_vec, @bias_term = partial_fit(x, y)
         end

data/lib/rumale/polynomial_model/base_factorization_machine.rb

@@ -21,9 +21,13 @@ module Rumale
       # @param batch_size [Integer] The size of the mini batches.
       # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
       #   If nil is given, Nadam is used.
+      # @param n_jobs [Integer] The number of jobs for running the fit and predict methods in parallel.
+      #   If nil is given, the methods do not execute in parallel.
+      #   If zero or less is given, it becomes equal to the number of processors.
+      #   This parameter is ignored if the Parallel gem is not loaded.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_factors: 2, loss: nil, reg_param_linear: 1.0, reg_param_factor: 1.0,
-                     max_iter: 1000, batch_size: 10, optimizer: nil, random_seed: nil)
+                     max_iter: 1000, batch_size: 10, optimizer: nil, n_jobs: nil, random_seed: nil)
         @params = {}
         @params[:n_factors] = n_factors
         @params[:loss] = loss unless loss.nil?
@@ -33,6 +37,7 @@ module Rumale
         @params[:batch_size] = batch_size
         @params[:optimizer] = optimizer
         @params[:optimizer] ||= Optimizer::Nadam.new
+        @params[:n_jobs] = n_jobs
         @params[:random_seed] = random_seed
         @params[:random_seed] ||= srand
         @factor_mat = nil

data/lib/rumale/polynomial_model/factorization_machine_classifier.rb

@@ -54,13 +54,17 @@ module Rumale
       # @param batch_size [Integer] The size of the mini batches.
       # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
       #   If nil is given, Nadam is used.
+      # @param n_jobs [Integer] The number of jobs for running the fit and predict methods in parallel.
+      #   If nil is given, the methods do not execute in parallel.
+      #   If zero or less is given, it becomes equal to the number of processors.
+      #   This parameter is ignored if the Parallel gem is not loaded.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_factors: 2, loss: 'hinge', reg_param_linear: 1.0, reg_param_factor: 1.0,
-                     max_iter: 1000, batch_size: 10, optimizer: nil, random_seed: nil)
+                     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_string(loss: loss)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_type_or_nil(Integer, 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)
@@ -86,9 +90,19 @@ module Rumale
           @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)
-          n_classes.times do |n|
-            bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
-            @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = partial_fit(x, bin_y)
+          if enable_parallel?
+            # :nocov:
+            models = parallel_map(n_classes) do |n|
+              bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
+              partial_fit(x, bin_y)
+            end
+            # :nocov:
+            n_classes.times { |n| @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = models[n] }
+          else
+            n_classes.times do |n|
+              bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
+              @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = partial_fit(x, bin_y)
+            end
           end
         else
           negative_label = y.to_a.uniq.min
@@ -122,9 +136,14 @@ module Rumale
         check_sample_array(x)
         return Numo::Int32.cast(decision_function(x).ge(0.0)) * 2 - 1 if @classes.size <= 2
 
-        n_samples, = x.shape
+        n_samples = x.shape[0]
         decision_values = decision_function(x)
-        Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
+        predicted = 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
+        Numo::Int32.asarray(predicted)
       end
 
       # Predict probability for samples.

data/lib/rumale/polynomial_model/factorization_machine_regressor.rb

@@ -47,12 +47,16 @@ module Rumale
       # @param batch_size [Integer] The size of the mini batches.
       # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
       #   If nil is given, Nadam is used.
+      # @param n_jobs [Integer] The number of jobs for running the fit method in parallel.
+      #   If nil is given, the method does not execute in parallel.
+      #   If zero or less is given, it becomes equal to the number of processors.
+      #   This parameter is ignored if the Parallel gem is not loaded.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(n_factors: 2, reg_param_linear: 1.0, reg_param_factor: 1.0,
-                     max_iter: 1000, batch_size: 10, optimizer: nil, random_seed: nil)
+                     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, random_seed: random_seed)
+        check_params_type_or_nil(Integer, 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)
@@ -76,7 +80,12 @@ module Rumale
           @factor_mat = Numo::DFloat.zeros(n_outputs, @params[:n_factors], n_features)
           @weight_vec = Numo::DFloat.zeros(n_outputs, n_features)
           @bias_term = Numo::DFloat.zeros(n_outputs)
-          n_outputs.times { |n| @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
+          if enable_parallel?
+            models = parallel_map(n_outputs) { |n| partial_fit(x, y[true, n]) }
+            n_outputs.times { |n| @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = models[n] }
+          else
+            n_outputs.times { |n| @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
+          end
         else
           @factor_mat, @weight_vec, @bias_term = partial_fit(x, y)
         end

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.10.0'
+  VERSION = '0.11.0'
 end

data/rumale.gemspec

@@ -39,5 +39,6 @@ MSG
   spec.add_development_dependency 'coveralls', '~> 0.8'
   spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'parallel'
   spec.add_development_dependency 'rspec', '~> 3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-17 00:00:00.000000000 Z
+date: 2019-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement