rumale-model_selection 0.24.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 28fa6e0e0c5832366f7130aa8185283b9ae316220b4cebec64774acab7f5cfd6
+  data.tar.gz: c85aa131bbcc278f99f2aa91dc6d529c291a2274dbf46c96b468191fefc8015d
+SHA512:
+  metadata.gz: ad3df526ec16120843536a9f199ba3f0c5856f40ac5a9de545b34b43bb60a798ad17b1c75588e7cfc59caa34bb886c7f5f180aacb9f24e338d70ebd389bd58aa
+  data.tar.gz: 8214f4cec33f056f49d2a479d23f16bc264b92c1e457af695c20d6b5b5233f78c2ab735d6ed584c00ce5333ec9779a8966d6bfd5c96128b7984cda6269b88732

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2022 Atsushi Tatsuma
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,34 @@
+# Rumale::ModelSelection
+
+[![Gem Version](https://badge.fury.io/rb/rumale-model_selection.svg)](https://badge.fury.io/rb/rumale-model_selection)
+[![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/rumale/blob/main/rumale-model_selection/LICENSE.txt)
+[![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/rumale/doc/Rumale/ModelSelection.html)
+
+Rumale is a machine learning library in Ruby.
+Rumale::ModelSelection provides model validation techniques,
+such as k-fold cross-validation, time series cross-validation, and grid search,
+with Rumale interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rumale-model_selection'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rumale-model_selection
+
+## Documentation
+
+- [Rumale API Documentation - ModelSelection](https://yoshoku.github.io/rumale/doc/Rumale/ModelSelection.html)
+
+## License
+
+The gem is available as open source under the terms of the [BSD-3-Clause License](https://opensource.org/licenses/BSD-3-Clause).

data/lib/rumale/model_selection/cross_validation.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'rumale/evaluation_measure/log_loss'
+
+module Rumale
+  # This module consists of the classes for model validation techniques.
+  module ModelSelection
+    # CrossValidation is a class that evaluates a given classifier with cross-validation method.
+    #
+    # @example
+    #   require 'rumale/linear_model'
+    #   require 'rumale/model_selection/stratified_k_fold'
+    #   require 'rumale/model_selection/cross_validation'
+    #
+    #   svc = Rumale::LinearModel::SVC.new
+    #   kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5)
+    #   cv = Rumale::ModelSelection::CrossValidation.new(estimator: svc, splitter: kf)
+    #   report = cv.perform(samples, labels)
+    #   mean_test_score = report[:test_score].inject(:+) / kf.n_splits
+    #
+    class CrossValidation
+      # Return the classifier of which performance is evaluated.
+      # @return [Classifier]
+      attr_reader :estimator
+
+      # Return the splitter that divides dataset.
+      # @return [Splitter]
+      attr_reader :splitter
+
+      # Return the evaluator that calculates score.
+      # @return [Evaluator]
+      attr_reader :evaluator
+
+      # Return the flag indicating whether to caculate the score of training dataset.
+      # @return [Boolean]
+      attr_reader :return_train_score
+
+      # Create a new evaluator with cross-validation method.
+      #
+      # @param estimator [Classifier] The classifier of which performance is evaluated.
+      # @param splitter [Splitter] The splitter that divides dataset to training and testing dataset.
+      # @param evaluator [Evaluator] The evaluator that calculates score of estimator results.
+      # @param return_train_score [Boolean] The flag indicating whether to calculate the score of training dataset.
+      def initialize(estimator: nil, splitter: nil, evaluator: nil, return_train_score: false)
+        @estimator = estimator
+        @splitter = splitter
+        @evaluator = evaluator
+        @return_train_score = return_train_score
+      end
+
+      # Perform the evalution of given classifier with cross-validation method.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #   The dataset to be used to evaluate the estimator.
+      # @param y [Numo::Int32 / Numo::DFloat] (shape: [n_samples] / [n_samples, n_outputs])
+      #   The labels to be used to evaluate the classifier / The target values to be used to evaluate the regressor.
+      # @return [Hash] The report summarizing the results of cross-validation.
+      #   * :fit_time (Array<Float>) The calculation times of fitting the estimator for each split.
+      #   * :test_score (Array<Float>) The scores of testing dataset for each split.
+      #   * :train_score (Array<Float>) The scores of training dataset for each split. This option is nil if
+      #     the return_train_score is false.
+      def perform(x, y)
+        # Initialize the report of cross validation.
+        report = { test_score: [], train_score: nil, fit_time: [] }
+        report[:train_score] = [] if @return_train_score
+        # Evaluate the estimator on each split.
+        @splitter.split(x, y).each do |train_ids, test_ids|
+          # Split dataset into training and testing dataset.
+          feature_ids = !kernel_machine? || train_ids
+          train_x = x[train_ids, feature_ids]
+          train_y = y.shape[1].nil? ? y[train_ids] : y[train_ids, true]
+          test_x = x[test_ids, feature_ids]
+          test_y = y.shape[1].nil? ? y[test_ids] : y[test_ids, true]
+          # Fit the estimator.
+          start_time = Time.now.to_i
+          @estimator.fit(train_x, train_y)
+          # Calculate scores and prepare the report.
+          report[:fit_time].push(Time.now.to_i - start_time)
+          if @evaluator.nil?
+            report[:test_score].push(@estimator.score(test_x, test_y))
+            report[:train_score].push(@estimator.score(train_x, train_y)) if @return_train_score
+          elsif log_loss?
+            report[:test_score].push(@evaluator.score(test_y, @estimator.predict_proba(test_x)))
+            if @return_train_score
+              report[:train_score].push(@evaluator.score(train_y,
+                                                         @estimator.predict_proba(train_x)))
+            end
+          else
+            report[:test_score].push(@evaluator.score(test_y, @estimator.predict(test_x)))
+            report[:train_score].push(@evaluator.score(train_y, @estimator.predict(train_x))) if @return_train_score
+          end
+        end
+        report
+      end
+
+      private
+
+      def kernel_machine?
+        @estimator.class.name.include?('Rumale::KernelMachine')
+      end
+
+      def log_loss?
+        @evaluator.is_a?(::Rumale::EvaluationMeasure::LogLoss)
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/function.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require 'rumale/model_selection/shuffle_split'
+require 'rumale/model_selection/stratified_shuffle_split'
+
+module Rumale
+  # This module consists of the classes for model validation techniques.
+  module ModelSelection
+    module_function
+
+    # Split randomly data set into test and train data.
+    #
+    # @example
+    #   require 'rumale/model_selection/function'
+    #
+    #   x_train, x_test, y_train, y_test = Rumale::ModelSelection.train_test_split(x, y, test_size: 0.2, stratify: true, random_seed: 1)
+    #
+    # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The dataset to be used to generate data indices.
+    # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used to generate data indices for stratified random permutation.
+    #   If stratify = false, this parameter is ignored.
+    # @param test_size [Float] The ratio of number of samples for test data.
+    # @param train_size [Float] The ratio of number of samples for train data.
+    #   If nil is given, it sets to 1 - test_size.
+    # @param stratify [Boolean] The flag indicating whether to perform stratify split.
+    # @param random_seed [Integer] The seed value using to initialize the random generator.
+    # @return [Array<Numo::NArray>] The set of training and testing data.
+    def train_test_split(x, y = nil, test_size: 0.1, train_size: nil, stratify: false, random_seed: nil)
+      splitter = if stratify
+                   ::Rumale::ModelSelection::StratifiedShuffleSplit.new(
+                     n_splits: 1, test_size: test_size, train_size: train_size, random_seed: random_seed
+                   )
+                 else
+                   ::Rumale::ModelSelection::ShuffleSplit.new(
+                     n_splits: 1, test_size: test_size, train_size: train_size, random_seed: random_seed
+                   )
+                 end
+      train_ids, test_ids = splitter.split(x, y).first
+      x_train = x[train_ids, true].dup
+      y_train = y[train_ids].dup
+      x_test = x[test_ids, true].dup
+      y_test = y[test_ids].dup
+      [x_train, x_test, y_train, y_test]
+    end
+  end
+end

data/lib/rumale/model_selection/grid_search_cv.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/model_selection/cross_validation'
+
+module Rumale
+  module ModelSelection
+    # GridSearchCV is a class that performs hyperparameter optimization with grid search method.
+    #
+    # @example
+    #   require 'rumale/ensemble'
+    #   require 'rumale/model_selection/stratified_k_fold'
+    #   require 'rumale/model_selection/grid_search_cv'
+    #
+    #   rfc = Rumale::Ensemble::RandomForestClassifier.new(random_seed: 1)
+    #   pg = { n_estimators: [5, 10], max_depth: [3, 5], max_leaf_nodes: [15, 31] }
+    #   kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5)
+    #   gs = Rumale::ModelSelection::GridSearchCV.new(estimator: rfc, param_grid: pg, splitter: kf)
+    #   gs.fit(samples, labels)
+    #   p gs.cv_results
+    #   p gs.best_params
+    #
+    # @example
+    #   rbf = Rumale::KernelApproximation::RBF.new(random_seed: 1)
+    #   svc = Rumale::LinearModel::SVC.new(random_seed: 1)
+    #   pipe = Rumale::Pipeline::Pipeline.new(steps: { rbf: rbf, svc: svc })
+    #   pg = { rbf__gamma: [32.0, 1.0], rbf__n_components: [4, 128], svc__reg_param: [16.0, 0.1] }
+    #   kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 5)
+    #   gs = Rumale::ModelSelection::GridSearchCV.new(estimator: pipe, param_grid: pg, splitter: kf)
+    #   gs.fit(samples, labels)
+    #   p gs.cv_results
+    #   p gs.best_params
+    #
+    class GridSearchCV < ::Rumale::Base::Estimator
+      # Return the result of cross validation for each parameter.
+      # @return [Hash]
+      attr_reader :cv_results
+
+      # Return the score of the estimator learned with the best parameter.
+      # @return [Float]
+      attr_reader :best_score
+
+      # Return the best parameter set.
+      # @return [Hash]
+      attr_reader :best_params
+
+      # Return the index of the best parameter.
+      # @return [Integer]
+      attr_reader :best_index
+
+      # Return the estimator learned with the best parameter.
+      # @return [Estimator]
+      attr_reader :best_estimator
+
+      # Create a new grid search method.
+      #
+      # @param estimator [Classifier/Regresor] The estimator to be searched for optimal parameters with grid search method.
+      # @param param_grid [Array<Hash>] The parameter sets is represented with array of hash that
+      #   consists of parameter names as keys and array of parameter values as values.
+      # @param splitter [Splitter] The splitter that divides dataset to training and testing dataset on cross validation.
+      # @param evaluator [Evaluator] The evaluator that calculates score of estimator results on cross validation.
+      #   If nil is given, the score method of estimator is used to evaluation.
+      # @param greater_is_better [Boolean] The flag that indicates whether the estimator is better as
+      #   evaluation score is larger.
+      def initialize(estimator: nil, param_grid: nil, splitter: nil, evaluator: nil, greater_is_better: true)
+        super()
+        @params = {
+          param_grid: valid_param_grid(param_grid),
+          estimator: Marshal.load(Marshal.dump(estimator)),
+          splitter: Marshal.load(Marshal.dump(splitter)),
+          evaluator: Marshal.load(Marshal.dump(evaluator)),
+          greater_is_better: greater_is_better
+        }
+      end
+
+      # Fit the model with given training data and all sets of parameters.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [Numo::NArray] (shape: [n_samples, n_outputs]) The target values or labels to be used for fitting the model.
+      # @return [GridSearchCV] The learned estimator with grid search.
+      def fit(x, y)
+        init_attrs
+
+        param_combinations.each do |prm_set|
+          prm_set.each do |prms|
+            report = perform_cross_validation(x, y, prms)
+            store_cv_result(prms, report)
+          end
+        end
+
+        find_best_params
+
+        @best_estimator = configurated_estimator(@best_params)
+        @best_estimator.fit(x, y)
+        self
+      end
+
+      # Call the decision_function method of learned estimator with the best parameter.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples]) Confidence score per sample.
+      def decision_function(x)
+        @best_estimator.decision_function(x)
+      end
+
+      # Call the predict method of learned estimator with the best parameter.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to obtain prediction result.
+      # @return [Numo::NArray] Predicted results.
+      def predict(x)
+        @best_estimator.predict(x)
+      end
+
+      # Call the predict_log_proba method of learned estimator with the best parameter.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the log-probailities.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted log-probability of each class per sample.
+      def predict_log_proba(x)
+        @best_estimator.predict_log_proba(x)
+      end
+
+      # Call the predict_proba method of learned estimator with the best parameter.
+      #
+      # @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)
+        @best_estimator.predict_proba(x)
+      end
+
+      # Call the score method of learned estimator with the best parameter.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) Testing data.
+      # @param y [Numo::NArray] (shape: [n_samples, n_outputs]) True target values or labels for testing data.
+      # @return [Float] The score of estimator.
+      def score(x, y)
+        @best_estimator.score(x, y)
+      end
+
+      private
+
+      def valid_param_grid(grid)
+        raise TypeError, 'Expect class of param_grid to be Hash or Array' unless grid.is_a?(Hash) || grid.is_a?(Array)
+
+        grid = [grid] if grid.is_a?(Hash)
+        grid.each do |h|
+          raise TypeError, 'Expect class of elements in param_grid to be Hash' unless h.is_a?(Hash)
+          raise TypeError, 'Expect class of parameter values in param_grid to be Array' unless h.values.all?(Array)
+        end
+        grid
+      end
+
+      def param_combinations
+        @param_combinations ||= @params[:param_grid].map do |prm|
+          x = prm.sort.to_h.map { |k, v| [k].product(v) }
+          x[0].product(*x[1...x.size]).map(&:to_h)
+        end
+      end
+
+      def perform_cross_validation(x, y, prms)
+        est = configurated_estimator(prms)
+        cv = ::Rumale::ModelSelection::CrossValidation.new(estimator: est, splitter: @params[:splitter],
+                                                           evaluator: @params[:evaluator], return_train_score: true)
+        cv.perform(x, y)
+      end
+
+      def configurated_estimator(prms)
+        estimator = Marshal.load(Marshal.dump(@params[:estimator]))
+        if pipeline?
+          prms.each do |k, v|
+            est_name, prm_name = k.to_s.split('__')
+            estimator.steps[est_name.to_sym].params[prm_name.to_sym] = v
+          end
+        else
+          prms.each { |k, v| estimator.params[k] = v }
+        end
+        estimator
+      end
+
+      def init_attrs
+        @cv_results = %i[mean_test_score std_test_score
+                         mean_train_score std_train_score
+                         mean_fit_time std_fit_time params].to_h { |v| [v, []] }
+        @best_score = nil
+        @best_params = nil
+        @best_index = nil
+        @best_estimator = nil
+      end
+
+      def store_cv_result(prms, report)
+        test_scores = Numo::DFloat[*report[:test_score]]
+        train_scores = Numo::DFloat[*report[:train_score]]
+        fit_times = Numo::DFloat[*report[:fit_time]]
+        @cv_results[:mean_test_score].push(test_scores.mean)
+        @cv_results[:std_test_score].push(test_scores.stddev)
+        @cv_results[:mean_train_score].push(train_scores.mean)
+        @cv_results[:std_train_score].push(train_scores.stddev)
+        @cv_results[:mean_fit_time].push(fit_times.mean)
+        @cv_results[:std_fit_time].push(fit_times.stddev)
+        @cv_results[:params].push(prms)
+      end
+
+      def find_best_params
+        @best_score = @params[:greater_is_better] ? @cv_results[:mean_test_score].max : @cv_results[:mean_test_score].min
+        @best_index = @cv_results[:mean_test_score].index(@best_score)
+        @best_params = @cv_results[:params][@best_index]
+      end
+
+      def pipeline?
+        @params[:estimator].class.name.include?('Rumale::Pipeline')
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/group_k_fold.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'rumale/base/splitter'
+require 'rumale/preprocessing/label_encoder'
+
+module Rumale
+  module ModelSelection
+    # GroupKFold is a class that generates the set of data indices for K-fold cross-validation.
+    # The data points belonging to the same group do not be split into different folds.
+    # The number of groups should be greater than or equal to the number of splits.
+    #
+    # @example
+    #   require 'rumale/model_selection/group_k_fold'
+    #
+    #   cv = Rumale::ModelSelection::GroupKFold.new(n_splits: 3)
+    #   x = Numo::DFloat.new(8, 2).rand
+    #   groups = Numo::Int32[1, 1, 1, 2, 2, 3, 3, 3]
+    #   cv.split(x, nil, groups).each do |train_ids, test_ids|
+    #     puts '---'
+    #     pp train_ids
+    #     pp test_ids
+    #   end
+    #
+    #   # ---
+    #   # [0, 1, 2, 3, 4]
+    #   # [5, 6, 7]
+    #   # ---
+    #   # [3, 4, 5, 6, 7]
+    #   # [0, 1, 2]
+    #   # ---
+    #   # [0, 1, 2, 5, 6, 7]
+    #   # [3, 4]
+    #
+    class GroupKFold
+      include ::Rumale::Base::Splitter
+
+      # Return the number of folds.
+      # @return [Integer]
+      attr_reader :n_splits
+
+      # Create a new data splitter for grouped K-fold cross validation.
+      #
+      # @param n_splits [Integer] The number of folds.
+      def initialize(n_splits: 5)
+        @n_splits = n_splits
+      end
+
+      # Generate data indices for grouped K-fold cross validation.
+      #
+      # @overload split(x, y, groups) -> Array
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #     The dataset to be used to generate data indices for grouped K-fold cross validation.
+      #   @param y [Numo::Int32] (shape: [n_samples])
+      #     This argument exists to unify the interface between the K-fold methods, it is not used in the method.
+      #   @param groups [Numo::Int32] (shape: [n_samples])
+      #     The group labels to be used to generate data indices for grouped K-fold cross validation.
+      # @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
+      def split(x, _y, groups)
+        encoder = ::Rumale::Preprocessing::LabelEncoder.new
+        groups = encoder.fit_transform(groups)
+        n_groups = encoder.classes.size
+
+        if n_groups < @n_splits
+          raise ArgumentError,
+                'The number of groups should be greater than or equal to the number of splits.'
+        end
+
+        n_samples_per_group = groups.bincount
+        group_ids = n_samples_per_group.sort_index.reverse
+        n_samples_per_group = n_samples_per_group[group_ids]
+
+        n_samples_per_fold = Numo::Int32.zeros(@n_splits)
+        group_to_fold = Numo::Int32.zeros(n_groups)
+
+        n_samples_per_group.each_with_index do |weight, id|
+          min_sample_fold_id = n_samples_per_fold.min_index
+          n_samples_per_fold[min_sample_fold_id] += weight
+          group_to_fold[group_ids[id]] = min_sample_fold_id
+        end
+
+        n_samples = x.shape[0]
+        sample_ids = Array(0...n_samples)
+        fold_ids = group_to_fold[groups]
+
+        Array.new(@n_splits) do |fid|
+          test_ids = fold_ids.eq(fid).where.to_a
+          train_ids = sample_ids - test_ids
+          [train_ids, test_ids]
+        end
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/group_shuffle_split.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'rumale/base/splitter'
+
+module Rumale
+  module ModelSelection
+    # GroupShuffleSplit is a class that generates the set of data indices
+    # for random permutation cross-validation by randomly selecting group labels.
+    #
+    # @example
+    #   require 'rumale/model_selection/group_shuffle_split'
+    #
+    #   cv = Rumale::ModelSelection::GroupShuffleSplit.new(n_splits: 2, test_size: 0.2, random_seed: 1)
+    #   x = Numo::DFloat.new(8, 2).rand
+    #   groups = Numo::Int32[1, 1, 1, 2, 2, 3, 3, 3]
+    #   cv.split(x, nil, groups).each do |train_ids, test_ids|
+    #     puts '---'
+    #     pp train_ids
+    #     pp test_ids
+    #   end
+    #
+    #   # ---
+    #   # [0, 1, 2, 5, 6, 7]
+    #   # [3, 4]
+    #   # ---
+    #   # [3, 4, 5, 6, 7]
+    #   # [0, 1, 2]
+    #
+    class GroupShuffleSplit
+      include Rumale::Base::Splitter
+
+      # Return the number of folds.
+      # @return [Integer]
+      attr_reader :n_splits
+
+      # Return the random generator for shuffling the dataset.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new data splitter for random permutation cross validation with given group labels.
+      #
+      # @param n_splits [Integer] The number of folds.
+      # @param test_size [Float] The ratio of number of groups for test data.
+      # @param train_size [Float/Nil] The ratio of number of groups for train data.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_splits: 5, test_size: 0.2, train_size: nil, random_seed: nil)
+        @n_splits = n_splits
+        @test_size = test_size
+        @train_size = train_size
+        @random_seed = random_seed
+        @random_seed ||= srand
+        @rng = Random.new(@random_seed)
+      end
+
+      # Generate train and test data indices by randomly selecting group labels.
+      #
+      # @overload split(x, y, groups) -> Array
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #     The dataset to be used to generate data indices for random permutation cross validation.
+      #   @param y [Numo::Int32] (shape: [n_samples])
+      #     This argument exists to unify the interface between the K-fold methods, it is not used in the method.
+      #   @param groups [Numo::Int32] (shape: [n_samples])
+      #     The group labels to be used to generate data indices for random permutation cross validation.
+      # @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
+      def split(_x, _y, groups)
+        classes = groups.to_a.uniq.sort
+        n_groups = classes.size
+        n_test_groups = (@test_size * n_groups).ceil.to_i
+        n_train_groups = @train_size.nil? ? n_groups - n_test_groups : (@train_size * n_groups).floor.to_i
+
+        unless n_test_groups.between?(1, n_groups)
+          raise RangeError,
+                'The number of groups in test split must be not less than 1 and not more than the number of groups.'
+        end
+        unless n_train_groups.between?(1, n_groups)
+          raise RangeError,
+                'The number of groups in train split must be not less than 1 and not more than the number of groups.'
+        end
+        if (n_test_groups + n_train_groups) > n_groups
+          raise RangeError,
+                'The total number of groups in test split and train split must be not more than the number of groups.'
+        end
+
+        sub_rng = @rng.dup
+
+        Array.new(@n_splits) do
+          test_group_ids = classes.sample(n_test_groups, random: sub_rng)
+          train_group_ids = if @train_size.nil?
+                              classes - test_group_ids
+                            else
+                              (classes - test_group_ids).sample(n_train_groups, random: sub_rng)
+                            end
+          test_ids = in1d(groups, test_group_ids).where.to_a
+          train_ids = in1d(groups, train_group_ids).where.to_a
+          [train_ids, test_ids]
+        end
+      end
+
+      private
+
+      def in1d(a, b)
+        res = Numo::Bit.zeros(a.shape[0])
+        b.each { |v| res |= a.eq(v) }
+        res
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/k_fold.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'rumale/base/splitter'
+
+module Rumale
+  # This module consists of the classes for model validation techniques.
+  module ModelSelection
+    # KFold is a class that generates the set of data indices for K-fold cross-validation.
+    #
+    # @example
+    #   require 'rumale/model_selection/k_fold'
+    #
+    #   kf = Rumale::ModelSelection::KFold.new(n_splits: 3, shuffle: true, random_seed: 1)
+    #   kf.split(samples, labels).each do |train_ids, test_ids|
+    #     train_samples = samples[train_ids, true]
+    #     test_samples = samples[test_ids, true]
+    #     ...
+    #   end
+    #
+    class KFold
+      include ::Rumale::Base::Splitter
+
+      # Return the number of folds.
+      # @return [Integer]
+      attr_reader :n_splits
+
+      # Return the flag indicating whether to shuffle the dataset.
+      # @return [Boolean]
+      attr_reader :shuffle
+
+      # Return the random generator for shuffling the dataset.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new data splitter for K-fold cross validation.
+      #
+      # @param n_splits [Integer] The number of folds.
+      # @param shuffle [Boolean] The flag indicating whether to shuffle the dataset.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_splits: 3, shuffle: false, random_seed: nil)
+        @n_splits = n_splits
+        @shuffle = shuffle
+        @random_seed = random_seed
+        @random_seed ||= srand
+        @rng = Random.new(@random_seed)
+      end
+
+      # Generate data indices for K-fold cross validation.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #   The dataset to be used to generate data indices for K-fold cross validation.
+      # @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
+      def split(x, _y = nil)
+        # Initialize and check some variables.
+        n_samples, = x.shape
+        unless @n_splits.between?(2, n_samples)
+          raise ArgumentError,
+                'The value of n_splits must be not less than 2 and not more than the number of samples.'
+        end
+        sub_rng = @rng.dup
+        # Splits dataset ids to each fold.
+        dataset_ids = Array(0...n_samples)
+        dataset_ids.shuffle!(random: sub_rng) if @shuffle
+        fold_sets = Array.new(@n_splits) do |n|
+          n_fold_samples = n_samples / @n_splits
+          n_fold_samples += 1 if n < n_samples % @n_splits
+          dataset_ids.shift(n_fold_samples)
+        end
+        # Returns array consisting of the training and testing ids for each fold.
+        Array.new(@n_splits) do |n|
+          train_ids = fold_sets.select.with_index { |_, id| id != n }.flatten
+          test_ids = fold_sets[n]
+          [train_ids, test_ids]
+        end
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/shuffle_split.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'rumale/base/splitter'
+
+module Rumale
+  module ModelSelection
+    # ShuffleSplit is a class that generates the set of data indices for random permutation cross-validation.
+    #
+    # @example
+    #   require 'rumale/model_selection/shuffle_split'
+    #
+    #   ss = Rumale::ModelSelection::ShuffleSplit.new(n_splits: 3, test_size: 0.2, random_seed: 1)
+    #   ss.split(samples, labels).each do |train_ids, test_ids|
+    #     train_samples = samples[train_ids, true]
+    #     test_samples = samples[test_ids, true]
+    #     ...
+    #   end
+    #
+    class ShuffleSplit
+      include ::Rumale::Base::Splitter
+
+      # Return the number of folds.
+      # @return [Integer]
+      attr_reader :n_splits
+
+      # Return the random generator for shuffling the dataset.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new data splitter for random permutation cross validation.
+      #
+      # @param n_splits [Integer] The number of folds.
+      # @param test_size [Float] The ratio of number of samples for test data.
+      # @param train_size [Float] The ratio of number of samples for train data.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_splits: 3, test_size: 0.1, train_size: nil, random_seed: nil)
+        @n_splits = n_splits
+        @test_size = test_size
+        @train_size = train_size
+        @random_seed = random_seed
+        @random_seed ||= srand
+        @rng = Random.new(@random_seed)
+      end
+
+      # Generate data indices for random permutation cross validation.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #   The dataset to be used to generate data indices for random permutation cross validation.
+      # @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
+      def split(x, _y = nil)
+        # Initialize and check some variables.
+        n_samples = x.shape[0]
+        n_test_samples = (@test_size * n_samples).ceil.to_i
+        n_train_samples = @train_size.nil? ? n_samples - n_test_samples : (@train_size * n_samples).floor.to_i
+        unless @n_splits.between?(1, n_samples)
+          raise ArgumentError,
+                'The value of n_splits must be not less than 1 and not more than the number of samples.'
+        end
+        unless n_test_samples.between?(1, n_samples)
+          raise RangeError,
+                'The number of samples in test split must be not less than 1 and not more than the number of samples.'
+        end
+        unless n_train_samples.between?(1, n_samples)
+          raise RangeError,
+                'The number of samples in train split must be not less than 1 and not more than the number of samples.'
+        end
+        if (n_test_samples + n_train_samples) > n_samples
+          raise RangeError,
+                'The total number of samples in test split and train split must be not more than the number of samples.'
+        end
+        sub_rng = @rng.dup
+        # Returns array consisting of the training and testing ids for each fold.
+        dataset_ids = Array(0...n_samples)
+        Array.new(@n_splits) do
+          test_ids = dataset_ids.sample(n_test_samples, random: sub_rng)
+          train_ids = if @train_size.nil?
+                        dataset_ids - test_ids
+                      else
+                        (dataset_ids - test_ids).sample(n_train_samples, random: sub_rng)
+                      end
+          [train_ids, test_ids]
+        end
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/stratified_k_fold.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'rumale/base/splitter'
+
+module Rumale
+  module ModelSelection
+    # StratifiedKFold is a class that generates the set of data indices for K-fold cross-validation.
+    # The proportion of the number of samples in each class will be almost equal for each fold.
+    #
+    # @example
+    #   require 'rumale/model_selection/stratified_k_fold'
+    #
+    #   kf = Rumale::ModelSelection::StratifiedKFold.new(n_splits: 3, shuffle: true, random_seed: 1)
+    #   kf.split(samples, labels).each do |train_ids, test_ids|
+    #     train_samples = samples[train_ids, true]
+    #     test_samples = samples[test_ids, true]
+    #     ...
+    #   end
+    #
+    class StratifiedKFold
+      include ::Rumale::Base::Splitter
+
+      # Return the number of folds.
+      # @return [Integer]
+      attr_reader :n_splits
+
+      # Return the flag indicating whether to shuffle the dataset.
+      # @return [Boolean]
+      attr_reader :shuffle
+
+      # Return the random generator for shuffling the dataset.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new data splitter for stratified K-fold cross validation.
+      #
+      # @param n_splits [Integer] The number of folds.
+      # @param shuffle [Boolean] The flag indicating whether to shuffle the dataset.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_splits: 3, shuffle: false, random_seed: nil)
+        @n_splits = n_splits
+        @shuffle = shuffle
+        @random_seed = random_seed
+        @random_seed ||= srand
+        @rng = Random.new(@random_seed)
+      end
+
+      # Generate data indices for stratified K-fold cross validation.
+      #
+      # @overload split(x, y) -> Array
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #     The dataset to be used to generate data indices for stratified K-fold cross validation.
+      #     This argument exists to unify the interface between the K-fold methods, it is not used in the method.
+      #   @param y [Numo::Int32] (shape: [n_samples])
+      #     The labels to be used to generate data indices for stratified K-fold cross validation.
+      #   @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
+      def split(_x, y)
+        # Check the number of samples in each class.
+        unless valid_n_splits?(y)
+          raise ArgumentError,
+                'The value of n_splits must be not less than 2 and not more than the number of samples in each class.'
+        end
+        # Splits dataset ids of each class to each fold.
+        sub_rng = @rng.dup
+        fold_sets_each_class = y.to_a.uniq.map { |label| fold_sets(y, label, sub_rng) }
+        # Returns array consisting of the training and testing ids for each fold.
+        Array.new(@n_splits) { |fold_id| train_test_sets(fold_sets_each_class, fold_id) }
+      end
+
+      private
+
+      def valid_n_splits?(y)
+        y.to_a.uniq.map { |label| y.eq(label).where.size }.all? { |n_samples| @n_splits.between?(2, n_samples) }
+      end
+
+      def fold_sets(y, label, sub_rng)
+        sample_ids = y.eq(label).where.to_a
+        sample_ids.shuffle!(random: sub_rng) if @shuffle
+        n_samples = sample_ids.size
+        Array.new(@n_splits) do |n|
+          n_fold_samples = n_samples / @n_splits
+          n_fold_samples += 1 if n < n_samples % @n_splits
+          sample_ids.shift(n_fold_samples)
+        end
+      end
+
+      def train_test_sets(fold_sets_each_class, fold_id)
+        train_test_sets_each_class = fold_sets_each_class.map do |folds|
+          folds.partition.with_index { |_, id| id != fold_id }.map(&:flatten)
+        end
+        train_test_sets_each_class.transpose.map(&:flatten)
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/stratified_shuffle_split.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'rumale/base/splitter'
+
+module Rumale
+  module ModelSelection
+    # StratifiedShuffleSplit is a class that generates the set of data indices for random permutation cross-validation.
+    # The proportion of the number of samples in each class will be almost equal for each fold.
+    #
+    # @example
+    #   require 'rumale/model_selection/stratified_shuffle_split'
+    #
+    #   ss = Rumale::ModelSelection::StratifiedShuffleSplit.new(n_splits: 3, test_size: 0.2, random_seed: 1)
+    #   ss.split(samples, labels).each do |train_ids, test_ids|
+    #     train_samples = samples[train_ids, true]
+    #     test_samples = samples[test_ids, true]
+    #     ...
+    #   end
+    #
+    class StratifiedShuffleSplit
+      include ::Rumale::Base::Splitter
+
+      # Return the number of folds.
+      # @return [Integer]
+      attr_reader :n_splits
+
+      # Return the random generator for shuffling the dataset.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new data splitter for random permutation cross validation.
+      #
+      # @param n_splits [Integer] The number of folds.
+      # @param test_size [Float] The ratio of number of samples for test data.
+      # @param train_size [Float] The ratio of number of samples for train data.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_splits: 3, test_size: 0.1, train_size: nil, random_seed: nil)
+        @n_splits = n_splits
+        @test_size = test_size
+        @train_size = train_size
+        @random_seed = random_seed
+        @random_seed ||= srand
+        @rng = Random.new(@random_seed)
+      end
+
+      # Generate data indices for stratified random permutation cross validation.
+      #
+      # @overload split(x, y) -> Array
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #     The dataset to be used to generate data indices for stratified random permutation cross validation.
+      #     This argument exists to unify the interface between the K-fold methods, it is not used in the method.
+      #   @param y [Numo::Int32] (shape: [n_samples])
+      #     The labels to be used to generate data indices for stratified random permutation cross validation.
+      #   @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
+      def split(_x, y)
+        # Initialize and check some variables.
+        train_sz = @train_size.nil? ? 1.0 - @test_size : @train_size
+        sub_rng = @rng.dup
+        # Check the number of samples in each class.
+        unless valid_n_splits?(y)
+          raise ArgumentError,
+                'The value of n_splits must be not less than 1 and not more than the number of samples in each class.'
+        end
+        # rubocop:disable Layout/LineLength
+        unless enough_data_size_each_class?(y, @test_size, 'test')
+          raise RangeError,
+                'The number of samples in test split must be not less than 1 and not more than the number of samples in each class.'
+        end
+        unless enough_data_size_each_class?(y, train_sz, 'train')
+          raise RangeError,
+                'The number of samples in train split must be not less than 1 and not more than the number of samples in each class.'
+        end
+        unless enough_data_size_each_class?(y, train_sz + @test_size, 'train')
+          raise RangeError,
+                'The total number of samples in test split and train split must be not more than the number of samples in each class.'
+        end
+        # rubocop:enable Layout/LineLength
+        # Returns array consisting of the training and testing ids for each fold.
+        sample_ids_each_class = y.to_a.uniq.map { |label| y.eq(label).where.to_a }
+        Array.new(@n_splits) do
+          train_ids = []
+          test_ids = []
+          sample_ids_each_class.each do |sample_ids|
+            n_samples = sample_ids.size
+            n_test_samples = (@test_size * n_samples).ceil.to_i
+            test_ids += sample_ids.sample(n_test_samples, random: sub_rng)
+            train_ids += if @train_size.nil?
+                           sample_ids - test_ids
+                         else
+                           n_train_samples = (train_sz * n_samples).floor.to_i
+                           (sample_ids - test_ids).sample(n_train_samples, random: sub_rng)
+                         end
+          end
+          [train_ids, test_ids]
+        end
+      end
+
+      private
+
+      def valid_n_splits?(y)
+        y.to_a.uniq.map { |label| y.eq(label).where.size }.all? { |n_samples| @n_splits.between?(1, n_samples) }
+      end
+
+      def enough_data_size_each_class?(y, data_size, data_type)
+        y.to_a.uniq.map { |label| y.eq(label).where.size }.all? do |n_samples|
+          if data_type == 'test'
+            (data_size * n_samples).ceil.to_i.between?(1, n_samples)
+          else
+            (data_size * n_samples).floor.to_i.between?(1, n_samples)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/time_series_split.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'rumale/base/splitter'
+
+module Rumale
+  module ModelSelection
+    # TimeSeriesSplit is a class that generates the set of data indices for time series cross-validation.
+    # It is assumed that the dataset given are already ordered by time information.
+    #
+    # @example
+    #   require 'rumale/model_selection/time_series_split'
+    #
+    #   cv = Rumale::ModelSelection::TimeSeriesSplit.new(n_splits: 5)
+    #   x = Numo::DFloat.new(6, 2).rand
+    #   cv.split(x, nil).each do |train_ids, test_ids|
+    #     puts '---'
+    #     pp train_ids
+    #     pp test_ids
+    #   end
+    #
+    #   # ---
+    #   # [0]
+    #   # [1]
+    #   # ---
+    #   # [0, 1]
+    #   # [2]
+    #   # ---
+    #   # [0, 1, 2]
+    #   # [3]
+    #   # ---
+    #   # [0, 1, 2, 3]
+    #   # [4]
+    #   # ---
+    #   # [0, 1, 2, 3, 4]
+    #   # [5]
+    #
+    class TimeSeriesSplit
+      include ::Rumale::Base::Splitter
+
+      # Return the number of splits.
+      # @return [Integer]
+      attr_reader :n_splits
+
+      # Return the maximum number of training samples in a split.
+      # @return [Integer/Nil]
+      attr_reader :max_train_size
+
+      # Create a new data splitter for time series cross-validation.
+      #
+      # @param n_splits [Integer] The number of splits.
+      # @param max_train_size [Integer/Nil] The maximum number of training samples in a split.
+      def initialize(n_splits: 5, max_train_size: nil)
+        @n_splits = n_splits
+        @max_train_size = max_train_size
+      end
+
+      # Generate data indices for time series cross-validation.
+      #
+      # @overload split(x, y) -> Array
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #     The dataset to be used to generate data indices for time series cross-validation.
+      #     It is expected that the data will be ordered by time information.
+      #   @param y [Numo::Int32] (shape: [n_samples])
+      #     This argument exists to unify the interface between the K-fold methods, it is not used in the method.
+      # @return [Array] The set of data indices for constructing the training and testing dataset in each fold.
+      def split(x, _y)
+        n_samples = x.shape[0]
+        unless (@n_splits + 1).between?(2, n_samples)
+          raise ArgumentError,
+                'The number of folds (n_splits + 1) must be not less than 2 and not more than the number of samples.'
+        end
+
+        test_size = n_samples / (@n_splits + 1)
+        offset = test_size + n_samples % (@n_splits + 1)
+
+        Array.new(@n_splits) do |n|
+          start = offset * (n + 1)
+          train_ids = if !@max_train_size.nil? && @max_train_size < test_size
+                        Array((start - @max_train_size)...start)
+                      else
+                        Array(0...start)
+                      end
+          test_ids = Array(start...(start + test_size))
+          [train_ids, test_ids]
+        end
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rumale
+  module ModelSelection
+    # @!visibility private
+    VERSION = '0.24.0'
+  end
+end

data/lib/rumale/model_selection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require_relative 'model_selection/version'
+
+require_relative 'model_selection/cross_validation'
+require_relative 'model_selection/function'
+require_relative 'model_selection/grid_search_cv'
+require_relative 'model_selection/group_k_fold'
+require_relative 'model_selection/group_shuffle_split'
+require_relative 'model_selection/k_fold'
+require_relative 'model_selection/shuffle_split'
+require_relative 'model_selection/stratified_k_fold'
+require_relative 'model_selection/stratified_shuffle_split'
+require_relative 'model_selection/time_series_split'

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: rumale-model_selection
+version: !ruby/object:Gem::Version
+  version: 0.24.0
+platform: ruby
+authors:
+- yoshoku
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: rumale-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+- !ruby/object:Gem::Dependency
+  name: rumale-evaluation_measure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+- !ruby/object:Gem::Dependency
+  name: rumale-preprocessing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+description: |
+  Rumale::ModelSelection provides model validation techniques,
+  such as k-fold cross-validation, time series cross-validation, and grid search,
+  with Rumale interface.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/rumale/model_selection.rb
+- lib/rumale/model_selection/cross_validation.rb
+- lib/rumale/model_selection/function.rb
+- lib/rumale/model_selection/grid_search_cv.rb
+- lib/rumale/model_selection/group_k_fold.rb
+- lib/rumale/model_selection/group_shuffle_split.rb
+- lib/rumale/model_selection/k_fold.rb
+- lib/rumale/model_selection/shuffle_split.rb
+- lib/rumale/model_selection/stratified_k_fold.rb
+- lib/rumale/model_selection/stratified_shuffle_split.rb
+- lib/rumale/model_selection/time_series_split.rb
+- lib/rumale/model_selection/version.rb
+homepage: https://github.com/yoshoku/rumale
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://github.com/yoshoku/rumale
+  source_code_uri: https://github.com/yoshoku/rumale/tree/main/rumale-model_selection
+  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
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Rumale::ModelSelection provides model validation techniques with Rumale interface.
+test_files: []