rumale-ensemble 0.28.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ee0234ca988c60ca6ca08b57a985c5b135f371bd1150daf48b5549bfcda2e4a
-  data.tar.gz: cecfc6af3713696bc299f3835de2a9e84a6c21a59dbb0f0b9a56244fb38b6018
+  metadata.gz: 52f48f439afecd4e75af580c46392ae4c2975b808c91a49f3781c78d48e8a43c
+  data.tar.gz: b5deb1e9736674d6db4ee733679e90a5b71cc45ffcb9d4e13b2d5956d66a82e7
 SHA512:
-  metadata.gz: dab665e72aa587b613fa4dc551f015022648d69f2161bccef32cde6b27ba5891ef7f6c2d4a5ca2ba1f84bc6ea5940f097e8f50a90b8e4ddc6010bbca56555b55
-  data.tar.gz: 7c4cfd1950e0dd1fb7bf615a59eba6493a7e4b6b4d3ccb381ee49d6c72a362b6d9499479c267f0c3e0b5fb027d925eee1f920a9656e041715be5606e4da8c27d
+  metadata.gz: e21818a828be87993169c1eefded133a355a49b29c3a6d39ce6ce1c5e7d3b54af36f70650d8502fa2eb716436f44fa904f6c653fd46069ca4af5c7edb750d890
+  data.tar.gz: 5cd5ee453ef7f86a71b097c4f755a7e4faf90ef89787ad0e15b727e745d9e0d4c2eeebcfdd23616b189a65ee4a569c3eb16be39b4ccae956a9616e396a5531a1

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2022-2023 Atsushi Tatsuma
+Copyright (c) 2022-2024 Atsushi Tatsuma
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/lib/rumale/ensemble/version.rb

@@ -5,6 +5,6 @@ module Rumale
   # This module consists of the classes that implement ensemble-based methods.
   module Ensemble
     # @!visibility private
-    VERSION = '0.28.1'
+    VERSION = '1.0.0'
   end
 end

data/lib/rumale/ensemble/vr_trees_classifier.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'rumale/validation'
+require 'rumale/tree/vr_tree_classifier'
+require 'rumale/ensemble/random_forest_classifier'
+require 'rumale/ensemble/value'
+
+module Rumale
+  module Ensemble
+    # VRTreesClassifier is a class that implements variable-random (VR) trees for classification.
+    #
+    # @example
+    #   require 'rumale/ensemble/vr_trees_classifier'
+    #
+    #   estimator =
+    #     Rumale::Ensemble::VRTreesClassifier.new(
+    #       n_estimators: 10, criterion: 'gini', max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
+    #   estimator.fit(training_samples, traininig_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Liu, F. T., Ting, K. M., Yu, Y., and Zhou, Z. H., "Spectrum of Variable-Random Trees," Journal of Artificial Intelligence Research, vol. 32, pp. 355--384, 2008.
+    class VRTreesClassifier < RandomForestClassifier
+      # Return the set of estimators.
+      # @return [Array<VRTreeClassifier>]
+      attr_reader :estimators
+
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the importance for each feature.
+      # @return [Numo::DFloat] (size: n_features)
+      attr_reader :feature_importances
+
+      # Return the random generator for random selection of feature index.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new classifier with variable-random trees.
+      #
+      # @param n_estimators [Integer] The numeber of trees for contructing variable-random trees.
+      # @param criterion [String] The function to evalue spliting point. Supported criteria are 'gini' and 'entropy'.
+      # @param max_depth [Integer] The maximum depth of the tree.
+      #   If nil is given, variable-random tree grows without concern for depth.
+      # @param max_leaf_nodes [Integer] The maximum number of leaves on variable-random tree.
+      #   If nil is given, number of leaves is not limited.
+      # @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 'n_features' 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, n_jobs: nil, random_seed: nil)
+        super
+      end
+
+      # Fit the model with given training data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
+      # @return [VRTreesClassifier] The learned classifier itself.
+      def fit(x, y)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+        y = ::Rumale::Validation.check_convert_label_array(y)
+        ::Rumale::Validation.check_sample_size(x, y)
+
+        # Initialize some variables.
+        n_features = x.shape[1]
+        @params[:max_features] = n_features if @params[:max_features].nil?
+        @params[:max_features] = @params[:max_features].clamp(1, n_features)
+        @classes = Numo::Int32.asarray(y.to_a.uniq.sort)
+        sub_rng = @rng.dup
+        # Construct trees.
+        rng_seeds = Array.new(@params[:n_estimators]) { sub_rng.rand(::Rumale::Ensemble::Value::SEED_BASE) }
+        alpha_ratio = 0.5 / @params[:n_estimators]
+        alphas = Array.new(@params[:n_estimators]) { |v| v * alpha_ratio }
+        @estimators = if enable_parallel?
+                        parallel_map(@params[:n_estimators]) { |n| plant_tree(alphas[n], rng_seeds[n]).fit(x, y) }
+                      else
+                        Array.new(@params[:n_estimators]) { |n| plant_tree(alphas[n], rng_seeds[n]).fit(x, y) }
+                      end
+        @feature_importances =
+          if enable_parallel?
+            parallel_map(@params[:n_estimators]) { |n| @estimators[n].feature_importances }.sum
+          else
+            @estimators.sum(&:feature_importances)
+          end
+        @feature_importances /= @feature_importances.sum
+        self
+      end
+
+      # Predict class labels for samples.
+      #
+      # @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)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        super
+      end
+
+      # Predict probability for samples.
+      #
+      # @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)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        super
+      end
+
+      # Return the index of the leaf that each sample reached.
+      #
+      # @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)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        super
+      end
+
+      private
+
+      def plant_tree(alpha, rnd_seed)
+        ::Rumale::Tree::VRTreeClassifier.new(
+          criterion: @params[:criterion], alpha: alpha, 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/vr_trees_regressor.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'rumale/validation'
+require 'rumale/tree/vr_tree_regressor'
+require 'rumale/ensemble/random_forest_regressor'
+require 'rumale/ensemble/value'
+
+module Rumale
+  module Ensemble
+    # VRTreesRegressor is a class that implements variable-random (VR) trees for regression
+    #
+    # @example
+    #   @require 'rumale/ensemble/vr_trees_regressor'
+    #
+    #   estimator =
+    #     Rumale::Ensemble::VRTreesRegressor.new(
+    #       n_estimators: 10, criterion: 'mse', max_depth: 3, max_leaf_nodes: 10, min_samples_leaf: 5, random_seed: 1)
+    #   estimator.fit(training_samples, traininig_values)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Liu, F. T., Ting, K. M., Yu, Y., and Zhou, Z. H., "Spectrum of Variable-Random Trees," Journal of Artificial Intelligence Research, vol. 32, pp. 355--384, 2008.
+    class VRTreesRegressor < RandomForestRegressor
+      # Return the set of estimators.
+      # @return [Array<VRTreeRegressor>]
+      attr_reader :estimators
+
+      # Return the importance for each feature.
+      # @return [Numo::DFloat] (size: n_features)
+      attr_reader :feature_importances
+
+      # Return the random generator for random selection of feature index.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new regressor with variable-random trees.
+      #
+      # @param n_estimators [Integer] The numeber of trees for contructing variable-random trees.
+      # @param criterion [String] The function to evalue spliting point. Supported criteria are 'gini' and 'entropy'.
+      # @param max_depth [Integer] The maximum depth of the tree.
+      #   If nil is given, variable-random tree grows without concern for depth.
+      # @param max_leaf_nodes [Integer] The maximum number of leaves on variable-random tree.
+      #   If nil is given, number of leaves is not limited.
+      # @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 'n_features' 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, n_jobs: nil, random_seed: nil)
+        super
+      end
+
+      # Fit the model with given training data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [Numo::DFloat] (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.
+      # @return [VRTreesRegressor] The learned regressor itself.
+      def fit(x, y)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+        y = ::Rumale::Validation.check_convert_target_value_array(y)
+        ::Rumale::Validation.check_sample_size(x, y)
+
+        # Initialize some variables.
+        n_features = x.shape[1]
+        @params[:max_features] = n_features if @params[:max_features].nil?
+        @params[:max_features] = @params[:max_features].clamp(1, n_features)
+        sub_rng = @rng.dup
+        # Construct forest.
+        rng_seeds = Array.new(@params[:n_estimators]) { sub_rng.rand(::Rumale::Ensemble::Value::SEED_BASE) }
+        alpha_ratio = 0.5 / @params[:n_estimators]
+        alphas = Array.new(@params[:n_estimators]) { |v| v * alpha_ratio }
+        @estimators = if enable_parallel?
+                        parallel_map(@params[:n_estimators]) { |n| plant_tree(alphas[n], rng_seeds[n]).fit(x, y) }
+                      else
+                        Array.new(@params[:n_estimators]) { |n| plant_tree(alphas[n], rng_seeds[n]).fit(x, y) }
+                      end
+        @feature_importances =
+          if enable_parallel?
+            parallel_map(@params[:n_estimators]) { |n| @estimators[n].feature_importances }.sum
+          else
+            @estimators.sum(&:feature_importances)
+          end
+        @feature_importances /= @feature_importances.sum
+        self
+      end
+
+      # Predict values for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
+      # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted value per sample.
+      def predict(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        super
+      end
+
+      # Return the index of the leaf that each sample reached.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to assign each leaf.
+      # @return [Numo::Int32] (shape: [n_samples, n_estimators]) Leaf index for sample.
+      def apply(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        super
+      end
+
+      private
+
+      def plant_tree(alpha, rnd_seed)
+        ::Rumale::Tree::VRTreeRegressor.new(
+          criterion: @params[:criterion], alpha: alpha, 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.rb

@@ -18,3 +18,5 @@ require_relative 'ensemble/stacking_classifier'
 require_relative 'ensemble/stacking_regressor'
 require_relative 'ensemble/voting_classifier'
 require_relative 'ensemble/voting_regressor'
+require_relative 'ensemble/vr_trees_classifier'
+require_relative 'ensemble/vr_trees_regressor'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rumale-ensemble
 version: !ruby/object:Gem::Version
-  version: 0.28.1
+  version: 1.0.0
 platform: ruby
 authors:
 - yoshoku
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-24 00:00:00.000000000 Z
+date: 2025-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -30,70 +29,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rumale-linear_model
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rumale-model_selection
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rumale-preprocessing
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rumale-tree
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.1
+        version: 1.0.0
 description: |
   Rumale::Ensemble provides ensemble learning algorithms,
   such as AdaBoost, Gradient Tree Boosting, and Random Forest,
@@ -121,6 +120,8 @@ files:
 - lib/rumale/ensemble/version.rb
 - lib/rumale/ensemble/voting_classifier.rb
 - lib/rumale/ensemble/voting_regressor.rb
+- lib/rumale/ensemble/vr_trees_classifier.rb
+- lib/rumale/ensemble/vr_trees_regressor.rb
 homepage: https://github.com/yoshoku/rumale
 licenses:
 - BSD-3-Clause
@@ -130,7 +131,6 @@ metadata:
   changelog_uri: https://github.com/yoshoku/rumale/blob/main/CHANGELOG.md
   documentation_uri: https://yoshoku.github.io/rumale/doc/
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -145,8 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Rumale::Ensemble provides ensemble learning algorithms with Rumale interface.
 test_files: []