rumale 0.10.0 → 0.11.0

data/lib/rumale/ensemble/random_forest_classifier.rb

@@ -48,13 +48,17 @@ module Rumale
       # @param min_samples_leaf [Integer] The minimum number of samples at a leaf node.
       # @param max_features [Integer] The number of features to consider when searching optimal split point.
       #   If nil is given, split process considers all features.
+      # @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.
       #   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)
+                     max_features: nil, n_jobs: 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)
+                                          max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
         check_params_integer(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(n_estimators: n_estimators, max_depth: max_depth,
@@ -67,6 +71,7 @@ module Rumale
         @params[:max_leaf_nodes] = max_leaf_nodes
         @params[:min_samples_leaf] = min_samples_leaf
         @params[:max_features] = max_features
+        @params[:n_jobs] = n_jobs
         @params[:random_seed] = random_seed
         @params[:random_seed] ||= srand
         @estimators = nil
@@ -89,19 +94,28 @@ module Rumale
         @params[:max_features] = Math.sqrt(n_features).to_i unless @params[:max_features].is_a?(Integer)
         @params[:max_features] = [[1, @params[:max_features]].max, n_features].min
         @classes = Numo::Int32.asarray(y.to_a.uniq.sort)
-        @feature_importances = Numo::DFloat.zeros(n_features)
         # Construct forest.
-        @estimators = Array.new(@params[:n_estimators]) do
-          tree = Tree::DecisionTreeClassifier.new(
-            criterion: @params[:criterion], max_depth: @params[:max_depth],
-            max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
-            max_features: @params[:max_features], random_seed: @rng.rand(Rumale::Values.int_max)
-          )
-          bootstrap_ids = Array.new(n_samples) { @rng.rand(0...n_samples) }
-          tree.fit(x[bootstrap_ids, true], y[bootstrap_ids])
-          @feature_importances += tree.feature_importances
-          tree
-        end
+        @estimators =
+          if enable_parallel?
+            rngs = Array.new(@params[:n_estimators]) { Random.new(@rng.rand(Rumale::Values.int_max)) }
+            # :nocov:
+            parallel_map(@params[:n_estimators]) do |n|
+              bootstrap_ids = Array.new(n_samples) { rngs[n].rand(0...n_samples) }
+              plant_tree(rngs[n].rand(Rumale::Values.int_max)).fit(x[bootstrap_ids, true], y[bootstrap_ids])
+            end
+            # :nocov:
+          else
+            Array.new(@params[:n_estimators]) do
+              bootstrap_ids = Array.new(n_samples) { @rng.rand(0...n_samples) }
+              plant_tree(@rng.rand(Rumale::Values.int_max)).fit(x[bootstrap_ids, true], y[bootstrap_ids])
+            end
+          end
+        @feature_importances =
+          if enable_parallel?
+            parallel_map(@params[:n_estimators]) { |n| @estimators[n].feature_importances }.reduce(&:+)
+          else
+            @estimators.map(&:feature_importances).reduce(&:+)
+          end
         @feature_importances /= @feature_importances.sum
         self
       end
@@ -112,18 +126,16 @@ module Rumale
       # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
       def predict(x)
         check_sample_array(x)
-        n_samples, = x.shape
-        n_classes = @classes.size
-        classes_arr = @classes.to_a
-        ballot_box = Numo::DFloat.zeros(n_samples, n_classes)
-        @estimators.each do |tree|
-          predicted = tree.predict(x)
-          n_samples.times do |n|
-            class_id = classes_arr.index(predicted[n])
-            ballot_box[n, class_id] += 1.0 unless class_id.nil?
-          end
-        end
-        Numo::Int32[*Array.new(n_samples) { |n| @classes[ballot_box[n, true].max_index] }]
+        n_samples = x.shape[0]
+        n_estimators = @estimators.size
+        predicted = if enable_parallel?
+                      predict_set = parallel_map(n_estimators) { |n| @estimators[n].predict(x).to_a }.transpose
+                      parallel_map(n_samples) { |n| predict_set[n].group_by { |v| v }.max_by { |_k, v| v.size }.first }
+                    else
+                      predict_set = @estimators.map { |tree| tree.predict(x).to_a }.transpose
+                      Array.new(n_samples) { |n| predict_set[n].group_by { |v| v }.max_by { |_k, v| v.size }.first }
+                    end
+        Numo::Int32.asarray(predicted)
       end
 
       # Predict probability for samples.
@@ -132,18 +144,12 @@ module Rumale
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
         check_sample_array(x)
-        n_samples, = x.shape
-        n_classes = @classes.size
-        classes_arr = @classes.to_a
-        ballot_box = Numo::DFloat.zeros(n_samples, n_classes)
-        @estimators.each do |tree|
-          probs = tree.predict_proba(x)
-          tree.classes.size.times do |n|
-            class_id = classes_arr.index(tree.classes[n])
-            ballot_box[true, class_id] += probs[true, n] unless class_id.nil?
-          end
+        n_estimators = @estimators.size
+        if enable_parallel?
+          parallel_map(n_estimators) { |n| predict_proba_tree(@estimators[n], x) }.reduce(&:+) / n_estimators
+        else
+          @estimators.map { |tree| predict_proba_tree(tree, x) }.reduce(&:+) / n_estimators
         end
-        (ballot_box.transpose / ballot_box.sum(axis: 1)).transpose
       end
 
       # Return the index of the leaf that each sample reached.
@@ -175,6 +181,29 @@ module Rumale
         @rng = obj[:rng]
         nil
       end
+
+      private
+
+      def plant_tree(rnd_seed)
+        Tree::DecisionTreeClassifier.new(
+          criterion: @params[:criterion], max_depth: @params[:max_depth],
+          max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
+          max_features: @params[:max_features], random_seed: rnd_seed
+        )
+      end
+
+      def predict_proba_tree(tree, x)
+        # initialize some variables.
+        n_samples = x.shape[0]
+        base_classes = @classes.to_a
+        n_classes = base_classes.size
+        class_ids = tree.classes.map { |c| base_classes.index(c) }
+        # predict probabilities.
+        probs = Numo::DFloat.zeros(n_samples, n_classes)
+        tree_probs = tree.predict_proba(x)
+        class_ids.each_with_index { |i, j| probs[true, i] = tree_probs[true, j] }
+        probs
+      end
     end
   end
 end

data/lib/rumale/ensemble/random_forest_regressor.rb

@@ -43,13 +43,17 @@ module Rumale
       # @param min_samples_leaf [Integer] The minimum number of samples at a leaf node.
       # @param max_features [Integer] The number of features to consider when searching optimal split point.
       #   If nil is given, split process considers all features.
+      # @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.
       #   It is used to randomly determine the order of features when deciding spliting point.
       def initialize(n_estimators: 10,
                      criterion: 'mse', max_depth: nil, max_leaf_nodes: nil, min_samples_leaf: 1,
-                     max_features: nil, random_seed: nil)
+                     max_features: nil, n_jobs: 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)
+                                          max_features: max_features, n_jobs: n_jobs, random_seed: random_seed)
         check_params_integer(n_estimators: n_estimators, min_samples_leaf: min_samples_leaf)
         check_params_string(criterion: criterion)
         check_params_positive(n_estimators: n_estimators, max_depth: max_depth,
@@ -62,6 +66,7 @@ module Rumale
         @params[:max_leaf_nodes] = max_leaf_nodes
         @params[:min_samples_leaf] = min_samples_leaf
         @params[:max_features] = max_features
+        @params[:n_jobs] = n_jobs
         @params[:random_seed] = random_seed
         @params[:random_seed] ||= srand
         @estimators = nil
@@ -82,20 +87,31 @@ module Rumale
         n_samples, n_features = x.shape
         @params[:max_features] = Math.sqrt(n_features).to_i unless @params[:max_features].is_a?(Integer)
         @params[:max_features] = [[1, @params[:max_features]].max, n_features].min
-        @feature_importances = Numo::DFloat.zeros(n_features)
         single_target = y.shape[1].nil?
         # Construct forest.
-        @estimators = Array.new(@params[:n_estimators]) do
-          tree = Tree::DecisionTreeRegressor.new(
-            criterion: @params[:criterion], max_depth: @params[:max_depth],
-            max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
-            max_features: @params[:max_features], random_seed: @rng.rand(Rumale::Values.int_max)
-          )
-          bootstrap_ids = Array.new(n_samples) { @rng.rand(0...n_samples) }
-          tree.fit(x[bootstrap_ids, true], single_target ? y[bootstrap_ids] : y[bootstrap_ids, true])
-          @feature_importances += tree.feature_importances
-          tree
-        end
+        @estimators =
+          if enable_parallel?
+            rngs = Array.new(@params[:n_estimators]) { Random.new(@rng.rand(Rumale::Values.int_max)) }
+            # :nocov:
+            parallel_map(@params[:n_estimators]) do |n|
+              bootstrap_ids = Array.new(n_samples) { rngs[n].rand(0...n_samples) }
+              tree = plant_tree(rngs[n].rand(Rumale::Values.int_max))
+              tree.fit(x[bootstrap_ids, true], single_target ? y[bootstrap_ids] : y[bootstrap_ids, true])
+            end
+            # :nocov:
+          else
+            Array.new(@params[:n_estimators]) do
+              bootstrap_ids = Array.new(n_samples) { @rng.rand(0...n_samples) }
+              tree = plant_tree(@rng.rand(Rumale::Values.int_max))
+              tree.fit(x[bootstrap_ids, true], single_target ? y[bootstrap_ids] : y[bootstrap_ids, true])
+            end
+          end
+        @feature_importances =
+          if enable_parallel?
+            parallel_map(@params[:n_estimators]) { |n| @estimators[n].feature_importances }.reduce(&:+)
+          else
+            @estimators.map(&:feature_importances).reduce(&:+)
+          end
         @feature_importances /= @feature_importances.sum
         self
       end
@@ -106,7 +122,11 @@ module Rumale
       # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted value per sample.
       def predict(x)
         check_sample_array(x)
-        @estimators.map { |est| est.predict(x) }.reduce(&:+) / @params[:n_estimators]
+        if enable_parallel?
+          parallel_map(@params[:n_estimators]) { |n| @estimators[n].predict(x) }.reduce(&:+) / @params[:n_estimators]
+        else
+          @estimators.map { |tree| tree.predict(x) }.reduce(&:+) / @params[:n_estimators]
+        end
       end
 
       # Return the index of the leaf that each sample reached.
@@ -136,6 +156,16 @@ module Rumale
         @rng = obj[:rng]
         nil
       end
+
+      private
+
+      def plant_tree(rnd_seed)
+        Tree::DecisionTreeRegressor.new(
+          criterion: @params[:criterion], max_depth: @params[:max_depth],
+          max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
+          max_features: @params[:max_features], random_seed: rnd_seed
+        )
+      end
     end
   end
 end

data/lib/rumale/kernel_machine/kernel_svc.rb

@@ -42,17 +42,22 @@ module Rumale
       # @param reg_param [Float] The regularization parameter.
       # @param max_iter [Integer] The maximum number of iterations.
       # @param probability [Boolean] The flag indicating whether to perform probability estimation.
+      # @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, max_iter: 1000, probability: false, random_seed: nil)
+      def initialize(reg_param: 1.0, max_iter: 1000, probability: false, n_jobs: nil, random_seed: nil)
         check_params_float(reg_param: reg_param)
         check_params_integer(max_iter: max_iter)
         check_params_boolean(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, max_iter: max_iter)
         @params = {}
         @params[:reg_param] = reg_param
         @params[:max_iter] = max_iter
         @params[:probability] = probability
+        @params[:n_jobs] = n_jobs
         @params[:random_seed] = random_seed
         @params[:random_seed] ||= srand
         @weight_vec = nil
@@ -79,14 +84,30 @@ module Rumale
         if n_classes > 2
           @weight_vec = Numo::DFloat.zeros(n_classes, n_features)
           @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] = binary_fit(x, bin_y)
-            @prob_param[n, true] = if @params[:probability]
-                                     Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec[n, true].transpose), bin_y)
-                                   else
-                                     Numo::DFloat[1, 0]
-                                   end
+          if enable_parallel?
+            # :nocov:
+            models = parallel_map(n_classes) do |n|
+              bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
+              w = binary_fit(x, bin_y)
+              p = if @params[:probability]
+                    Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(w), bin_y)
+                  else
+                    Numo::DFloat[1, 0]
+                  end
+              [w, p]
+            end
+            # :nocov:
+            n_classes.times { |n| @weight_vec[n, true], @prob_param[n, true] = models[n] }
+          else
+            n_classes.times do |n|
+              bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
+              @weight_vec[n, true] = binary_fit(x, bin_y)
+              @prob_param[n, true] = if @params[:probability]
+                                       Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec[n, true].transpose), bin_y)
+                                     else
+                                       Numo::DFloat[1, 0]
+                                     end
+            end
           end
         else
           negative_label = y.to_a.uniq.min
@@ -125,7 +146,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.

data/lib/rumale/linear_model/base_linear_model.rb

@@ -20,9 +20,12 @@ 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.
       # @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)
+                     max_iter: 1000, batch_size: 10, optimizer: nil, n_jobs: nil, random_seed: nil)
         @params = {}
         @params[:reg_param] = reg_param
         @params[:fit_bias] = fit_bias
@@ -31,6 +34,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
         @weight_vec = nil

data/lib/rumale/linear_model/lasso.rb

@@ -41,12 +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, 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
@@ -67,11 +72,15 @@ 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
-
         self
       end
 

data/lib/rumale/linear_model/linear_regression.rb

@@ -37,12 +37,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(fit_bias: false, bias_scale: 1.0, max_iter: 1000, batch_size: 10, optimizer: nil, random_seed: nil)
+      def initialize(fit_bias: false, bias_scale: 1.0, max_iter: 1000, batch_size: 10, optimizer: nil,
+                     n_jobs: nil, random_seed: nil)
         check_params_float(bias_scale: bias_scale)
         check_params_integer(max_iter: max_iter, batch_size: batch_size)
         check_params_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(max_iter: max_iter, batch_size: batch_size)
         keywd_args = method(:initialize).parameters.map { |_t, arg| [arg, binding.local_variable_get(arg)] }.to_h.merge(reg_param: 0.0)
         super(keywd_args)
@@ -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/logistic_regression.rb

@@ -46,13 +46,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(reg_param: 1.0, fit_bias: false, bias_scale: 1.0,
-                     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)
         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, max_iter: max_iter, batch_size: batch_size)
         super
         @classes = nil
@@ -75,9 +79,19 @@ module Rumale
         if n_classes > 2
           @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
-            @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| @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
+              @weight_vec[n, true], @bias_term[n] = partial_fit(x, bin_y)
+            end
           end
         else
           negative_label = y.to_a.uniq.min
@@ -108,7 +122,12 @@ module Rumale
 
         n_samples, = x.shape
         decision_values = predict_proba(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.