rumale 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 939e53a9d8c52f86c1d112d1cfbca17802aa94d8
-  data.tar.gz: cc1454ad92767b7ea27f9ec8d27cc7e7bbf97441
+  metadata.gz: 50ce110d0d5ad24245b5b52347a7ae72c1a7c673
+  data.tar.gz: 52c1acc4ebe4c8da8120dc431be4e1a953317a63
 SHA512:
-  metadata.gz: bed2b567c09ec4e79e81181ca9978598cb89696463330c4ac6aa153375aaa7a86d2a6e0eb2af190037fd49d08aa720835af10ff3b021b851c285dc564607acaa
-  data.tar.gz: 6b9faf79edecfad12ce46d3572810fdaa2648a3c1df090b99964c2e0ccef2553dcecc1cca7d12e1a9dd9b69108b91ff9fe68d94f74738f1a8f57ccdb4436c69c
+  metadata.gz: f8774f51f6bde00ea9414de9bfbe2c31b1c3c09c6931bd29ae414117d2648ee8273fa4f8dc32e78573a9e9da96db2cba19ca67372e4ac56adbe2a68c9be5b92a
+  data.tar.gz: 7777ba4d627830877dea89b1c9573340fd03882ccdafac57700e261f1e0b621962cc9744129bdbf26ae1078995e7d16db9c36758ae9a327d93ef3e5c3f572b28

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 0.11.0
+- Introduce [Parallel gem](https://github.com/grosser/parallel) to improve execution speed for one-vs-the-rest and bagging methods.
+- Add the n_jobs parameter that specifies the number of jobs for parallel processing in some estimators belong to the Rumale::LinearModel, Rumale::PolynomialModel, and Rumale::Ensemble.
+- The n_jobs parameter is valid only when parallel gem is loaded.
+
+```ruby
+require 'rumale'
+require 'parallel'
+
+svc = Rumale::LinearModel::SVC.new(n_jobs: -1)
+```
+
 # 0.10.0
 - Add class for t-distributed Stochastic Neighborhood Embedding.
 - Fix bug of zero division on min-max scaling class.

data/README.md

@@ -6,7 +6,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/yoshoku/rumale/badge.svg?branch=master)](https://coveralls.io/github/yoshoku/rumale?branch=master)
 [![Gem Version](https://badge.fury.io/rb/rumale.svg)](https://badge.fury.io/rb/rumale)
 [![BSD 2-Clause License](https://img.shields.io/badge/License-BSD%202--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/master/LICENSE.txt)
-[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/rumale/0.10.0)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/rumale/0.11.0)
 
 Rumale (**Ru**by **ma**chine **le**arning) is a machine learning library in Ruby.
 Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.

data/lib/rumale/base/base_estimator.rb

@@ -8,6 +8,22 @@ module Rumale
       # Return parameters about an estimator.
       # @return [Hash]
       attr_reader :params
+
+      private
+
+      def enable_parallel?
+        return false if @params[:n_jobs].nil? || defined?(Parallel).nil?
+        true
+      end
+
+      def n_processes
+        return 1 unless enable_parallel?
+        @params[:n_jobs] <= 0 ? Parallel.processor_count : @params[:n_jobs]
+      end
+
+      def parallel_map(n_outputs, &block)
+        Parallel.map(Array.new(n_outputs) { |v| v }, in_processes: n_processes, &block)
+      end
     end
   end
 end

data/lib/rumale/ensemble/extra_trees_classifier.rb

@@ -47,13 +47,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,
@@ -76,18 +80,19 @@ 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 trees.
-        @estimators = Array.new(@params[:n_estimators]) do
-          tree = Tree::ExtraTreeClassifier.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)
-          )
-          tree.fit(x, y)
-          @feature_importances += tree.feature_importances
-          tree
-        end
+        rng_seeds = Array.new(@params[:n_estimators]) { @rng.rand(Rumale::Values.int_max) }
+        @estimators = if enable_parallel?
+                        parallel_map(@params[:n_estimators]) { |n| plant_tree(rng_seeds[n]).fit(x, y) }
+                      else
+                        Array.new(@params[:n_estimators]) { |n| plant_tree(rng_seeds[n]).fit(x, y) }
+                      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
@@ -130,6 +135,16 @@ module Rumale
       def marshal_load(obj)
         super
       end
+
+      private
+
+      def plant_tree(rnd_seed)
+        Tree::ExtraTreeClassifier.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/ensemble/extra_trees_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,
@@ -71,18 +75,19 @@ module Rumale
         n_features = x.shape[1]
         @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)
         # Construct forest.
-        @estimators = Array.new(@params[:n_estimators]) do
-          tree = Tree::ExtraTreeRegressor.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)
-          )
-          tree.fit(x, y)
-          @feature_importances += tree.feature_importances
-          tree
-        end
+        rng_seeds = Array.new(@params[:n_estimators]) { @rng.rand(Rumale::Values.int_max) }
+        @estimators = if enable_parallel?
+                        parallel_map(@params[:n_estimators]) { |n| plant_tree(rng_seeds[n]).fit(x, y) }
+                      else
+                        Array.new(@params[:n_estimators]) { |n| plant_tree(rng_seeds[n]).fit(x, y) }
+                      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
@@ -116,6 +121,16 @@ module Rumale
       def marshal_load(obj)
         super
       end
+
+      private
+
+      def plant_tree(rnd_seed)
+        Tree::ExtraTreeRegressor.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/ensemble/gradient_boosting_classifier.rb

@@ -56,19 +56,22 @@ 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: 100, learning_rate: 0.1, reg_lambda: 0.0, subsample: 1.0,
                      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_float(learning_rate: learning_rate, reg_lambda: reg_lambda, subsample: subsample)
-        check_params_positive(n_estimators: n_estimators,
-                              learning_rate: learning_rate, reg_lambda: reg_lambda, subsample: subsample,
-                              max_depth: max_depth, max_leaf_nodes: max_leaf_nodes, min_samples_leaf: min_samples_leaf,
-                              max_features: max_features)
+        check_params_positive(n_estimators: n_estimators, learning_rate: learning_rate, reg_lambda: reg_lambda,
+                              subsample: subsample, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                              min_samples_leaf: min_samples_leaf, max_features: max_features)
         @params = {}
         @params[:n_estimators] = n_estimators
         @params[:learning_rate] = learning_rate
@@ -78,6 +81,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
@@ -96,22 +100,16 @@ module Rumale
         check_sample_array(x)
         check_label_array(y)
         check_sample_label_size(x, y)
-
+        # initialize some variables.
         n_features = x.shape[1]
         @params[:max_features] = n_features if @params[:max_features].nil?
         @params[:max_features] = [[1, @params[:max_features]].max, n_features].min
-
-        # train estimator.
         @classes = Numo::Int32[*y.to_a.uniq.sort]
         n_classes = @classes.size
+        # train estimator.
         if n_classes > 2
-          @base_predictions = Numo::DFloat.zeros(n_classes)
-          @estimators = Array.new(n_classes) do |n|
-            bin_y = Numo::DFloat.cast(y.eq(@classes[n])) * 2 - 1
-            y_mean = bin_y.mean
-            @base_predictions[n] = 0.5 * Numo::NMath.log((1.0 + y_mean) / (1.0 - y_mean))
-            partial_fit(x, bin_y, @base_predictions[n])
-          end
+          @base_predictions = multiclass_base_predictions(y)
+          @estimators = multiclass_estimators(x, y)
         else
           negative_label = y.to_a.uniq.min
           bin_y = Numo::DFloat.cast(y.ne(negative_label)) * 2 - 1
@@ -119,17 +117,12 @@ module Rumale
           @base_predictions = 0.5 * Numo::NMath.log((1.0 + y_mean) / (1.0 - y_mean))
           @estimators = partial_fit(x, bin_y, @base_predictions)
         end
-
         # calculate feature importances.
-        @feature_importances = Numo::DFloat.zeros(n_features)
-        if n_classes > 2
-          n_classes.times do |n|
-            @estimators[n].each { |tree| @feature_importances += tree.feature_importances }
-          end
-        else
-          @estimators.each { |tree| @feature_importances += tree.feature_importances }
-        end
-
+        @feature_importances = if n_classes > 2
+                                 multiclass_feature_importances
+                               else
+                                 @estimators.map(&:feature_importances).reduce(&:+)
+                               end
         self
       end
 
@@ -139,18 +132,12 @@ module Rumale
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
       def decision_function(x)
         check_sample_array(x)
-        n_samples = x.shape[0]
         n_classes = @classes.size
         if n_classes > 2
-          scores = Numo::DFloat.ones(n_samples, n_classes) * @base_predictions
-          n_classes.times do |n|
-            @estimators[n].each { |tree| scores[true, n] += tree.predict(x) }
-          end
+          multiclass_scores(x)
         else
-          scores = Numo::DFloat.ones(n_samples) * @base_predictions
-          @estimators.each { |tree| scores += tree.predict(x) }
+          @estimators.map { |tree| tree.predict(x) }.reduce(&:+) + @base_predictions
         end
-        scores
       end
 
       # Predict class labels for samples.
@@ -273,6 +260,68 @@ module Rumale
           max_features: @params[:max_features], random_seed: @rng.rand(Rumale::Values.int_max)
         )
       end
+
+      def multiclass_base_predictions(y)
+        n_classes = @classes.size
+        b = if enable_parallel?
+              # :nocov:
+              parallel_map(n_classes) do |n|
+                bin_y = Numo::DFloat.cast(y.eq(@classes[n])) * 2 - 1
+                y_mean = bin_y.mean
+                0.5 * Math.log((1.0 + y_mean) / (1.0 - y_mean))
+              end
+              # :nocov:
+            else
+              Array.new(n_classes) do |n|
+                bin_y = Numo::DFloat.cast(y.eq(@classes[n])) * 2 - 1
+                y_mean = bin_y.mean
+                0.5 * Math.log((1.0 + y_mean) / (1.0 - y_mean))
+              end
+            end
+        Numo::DFloat.asarray(b)
+      end
+
+      def multiclass_estimators(x, y)
+        n_classes = @classes.size
+        if enable_parallel?
+          # :nocov:
+          parallel_map(n_classes) do |n|
+            bin_y = Numo::DFloat.cast(y.eq(@classes[n])) * 2 - 1
+            partial_fit(x, bin_y, @base_predictions[n])
+          end
+          # :nocov:
+        else
+          Array.new(n_classes) do |n|
+            bin_y = Numo::DFloat.cast(y.eq(@classes[n])) * 2 - 1
+            partial_fit(x, bin_y, @base_predictions[n])
+          end
+        end
+      end
+
+      def multiclass_feature_importances
+        n_classes = @classes.size
+        if enable_parallel?
+          parallel_map(n_classes) { |n| @estimators[n].map(&:feature_importances).reduce(&:+) }.reduce(&:+)
+        else
+          Array.new(n_classes) { |n| @estimators[n].map(&:feature_importances).reduce(&:+) }.reduce(&:+)
+        end
+      end
+
+      def multiclass_scores(x)
+        n_classes = @classes.size
+        s = if enable_parallel?
+              # :nocov:
+              parallel_map(n_classes) do |n|
+                @estimators[n].map { |tree| tree.predict(x) }.reduce(&:+)
+              end
+              # :nocov:
+            else
+              Array.new(n_classes) do |n|
+                @estimators[n].map { |tree| tree.predict(x) }.reduce(&:+)
+              end
+            end
+        Numo::DFloat.asarray(s).transpose + @base_predictions
+      end
     end
   end
 end

data/lib/rumale/ensemble/gradient_boosting_regressor.rb

@@ -51,19 +51,22 @@ 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: 100, learning_rate: 0.1, reg_lambda: 0.0, subsample: 1.0,
                      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_float(learning_rate: learning_rate, reg_lambda: reg_lambda, subsample: subsample)
-        check_params_positive(n_estimators: n_estimators,
-                              learning_rate: learning_rate, reg_lambda: reg_lambda, subsample: subsample,
-                              max_depth: max_depth, max_leaf_nodes: max_leaf_nodes, min_samples_leaf: min_samples_leaf,
-                              max_features: max_features)
+        check_params_positive(n_estimators: n_estimators, learning_rate: learning_rate, reg_lambda: reg_lambda,
+                              subsample: subsample, max_depth: max_depth, max_leaf_nodes: max_leaf_nodes,
+                              min_samples_leaf: min_samples_leaf, max_features: max_features)
         @params = {}
         @params[:n_estimators] = n_estimators
         @params[:learning_rate] = learning_rate
@@ -73,6 +76,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
@@ -90,32 +94,24 @@ module Rumale
         check_sample_array(x)
         check_tvalue_array(y)
         check_sample_tvalue_size(x, y)
-
+        # initialize some variables.
         n_features = x.shape[1]
         @params[:max_features] = n_features if @params[:max_features].nil?
         @params[:max_features] = [[1, @params[:max_features]].max, n_features].min
-
-        # train regressor.
         n_outputs = y.shape[1].nil? ? 1 : y.shape[1]
+        # train regressor.
         @base_predictions = n_outputs > 1 ? y.mean(0) : y.mean
         @estimators = if n_outputs > 1
-                        Array.new(n_outputs) do |n|
-                          partial_fit(x, y[true, n], @base_predictions[n])
-                        end
+                        multivar_estimators(x, y)
                       else
                         partial_fit(x, y, @base_predictions)
                       end
-
         # calculate feature importances.
-        @feature_importances = Numo::DFloat.zeros(n_features)
-        if n_outputs > 1
-          n_outputs.times do |n|
-            @estimators[n].each { |tree| @feature_importances += tree.feature_importances }
-          end
-        else
-          @estimators.each { |tree| @feature_importances += tree.feature_importances }
-        end
-
+        @feature_importances = if n_outputs > 1
+                                 multivar_feature_importances
+                               else
+                                 @estimators.map(&:feature_importances).reduce(&:+)
+                               end
         self
       end
 
@@ -125,18 +121,16 @@ module Rumale
       # @return [Numo::DFloat] (shape: [n_samples]) Predicted values per sample.
       def predict(x)
         check_sample_array(x)
-        n_samples = x.shape[0]
         n_outputs = @estimators.first.is_a?(Array) ? @estimators.size : 1
         if n_outputs > 1
-          predicted = Numo::DFloat.ones(n_samples, n_outputs) * @base_predictions
-          n_outputs.times do |n|
-            @estimators[n].each { |tree| predicted[true, n] += tree.predict(x) }
-          end
+          multivar_predict(x)
         else
-          predicted = Numo::DFloat.ones(n_samples) * @base_predictions
-          @estimators.each { |tree| predicted += tree.predict(x) }
+          if enable_parallel?
+            parallel_map(@params[:n_estimators]) { |n| @estimators[n].predict(x) }.reduce(&:+) + @base_predictions
+          else
+            @estimators.map { |tree| tree.predict(x) }.reduce(&:+) + @base_predictions
+          end
         end
-        predicted
       end
 
       # Return the index of the leaf that each sample reached.
@@ -225,6 +219,40 @@ module Rumale
           max_features: @params[:max_features], random_seed: @rng.rand(Rumale::Values.int_max)
         )
       end
+
+      def multivar_estimators(x, y)
+        n_outputs = y.shape[1]
+        if enable_parallel?
+          parallel_map(n_outputs) { |n| partial_fit(x, y[true, n], @base_predictions[n]) }
+        else
+          Array.new(n_outputs) { |n| partial_fit(x, y[true, n], @base_predictions[n]) }
+        end
+      end
+
+      def multivar_feature_importances
+        n_outputs = @estimators.size
+        if enable_parallel?
+          parallel_map(n_outputs) { |n| @estimators[n].map(&:feature_importances).reduce(&:+) }.reduce(&:+)
+        else
+          Array.new(n_outputs) { |n| @estimators[n].map(&:feature_importances).reduce(&:+) }.reduce(&:+)
+        end
+      end
+
+      def multivar_predict(x)
+        n_outputs = @estimators.size
+        p = if enable_parallel?
+              # :nocov:
+              parallel_map(n_outputs) do |n|
+                @estimators[n].map { |tree| tree.predict(x) }.reduce(&:+)
+              end
+              # :nocov:
+            else
+              Array.new(n_outputs) do |n|
+                @estimators[n].map { |tree| tree.predict(x) }.reduce(&:+)
+              end
+            end
+        Numo::DFloat.asarray(p).transpose + @base_predictions
+      end
     end
   end
 end