rumale 0.17.3 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68b01301c9e7b9aa9d98f0a252e87fc0c5e5e888379e347660a76a63ae7f86a4
-  data.tar.gz: dd464110ff410705a20fa2446c884ed039b9f0ea3febfc4cd12ef8d6b542b736
+  metadata.gz: 7caefe8d0715984980daede523f1944460bcff7dd782c431b7e95d851ddfbf82
+  data.tar.gz: 05ba1863410dcaabd31dc281c921011a9625f75980c137ab8c88f302c33042b5
 SHA512:
-  metadata.gz: d95cf5140e5846431b812867a64927f51ede6f6a925ffdc3a43f3ae1add1ce33756ad6481ca7645edeed56084fe0f8d294f5032364ff664cae19e9edcdaac57e
-  data.tar.gz: 620bd2099ddd5ce14ff9525062938740835fe9714f1c42023f7782e963a96b423bba4921e35d134877aada0d05189d5213b90e5556b50799dadfebdeeaf59eba
+  metadata.gz: 06a95f1fda83e546954e235f06c5b487cc393a340c48b1316b9ef2d0fafbb5be4bb4de02681c6b7b013915695ecd06a04a8692c9df2ba9822e3ba4e01925c0df
+  data.tar.gz: 0e5e1ae19fbb420cba2914f251b8ba44de29f4eb9feed31d5bcdb0dc4003a9221053bedddc3214faf8803282965c9dbd51c1e3e81df94fe6bb4fa8c6afbfe277

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.18.0
+- Add transformer class for [FisherDiscriminantAnalysis](https://yoshoku.github.io/rumale/doc/Rumale/MetricLearning/FisherDiscriminantAnalysis.html).
+- Add transformer class for [NeighbourhoodComponentAnalysis](https://yoshoku.github.io/rumale/doc/Rumale/MetricLearning/NeighbourhoodComponentAnalysis.html).
+- Add [module function](https://yoshoku.github.io/rumale/doc/Rumale/ModelSelection.html#train_test_split-class_method) for hold-out validation.
+
 # 0.17.3
 - Add pipeline class for [FeatureUnion](https://yoshoku.github.io/rumale/doc/Rumale/Pipeline/FeatureUnion.html).
 - Fix to use mmh3 gem for generating hash value on [FeatureHasher](https://yoshoku.github.io/rumale/doc/Rumale/FeatureExtraction/FeatureHasher.html).

data/README.md

@@ -15,12 +15,11 @@ Logistic Regression, Ridge, Lasso, Factorization Machine,
 Multi-layer Perceptron,
 Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest,
 K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering,
-Mutidimensional Scaling, t-SNE, Principal Component Analysis, Non-negative Matrix Factorization,
+Mutidimensional Scaling, t-SNE,
+Fisher Discriminant Analysis, Neighbourhood Component Analysis,
+Principal Component Analysis, Non-negative Matrix Factorization,
 and many other algorithms.
 
-This project was formerly known as "SVMKit".
-If you are using SVMKit, please install Rumale and replace `SVMKit` constants with `Rumale`.
-
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/rumale.rb

@@ -78,6 +78,8 @@ require 'rumale/decomposition/factor_analysis'
 require 'rumale/decomposition/fast_ica'
 require 'rumale/manifold/tsne'
 require 'rumale/manifold/mds'
+require 'rumale/metric_learning/fisher_discriminant_analysis'
+require 'rumale/metric_learning/neighbourhood_component_analysis.rb'
 require 'rumale/neural_network/adam'
 require 'rumale/neural_network/base_mlp'
 require 'rumale/neural_network/mlp_regressor'
@@ -100,6 +102,7 @@ require 'rumale/model_selection/shuffle_split'
 require 'rumale/model_selection/stratified_shuffle_split'
 require 'rumale/model_selection/cross_validation'
 require 'rumale/model_selection/grid_search_cv'
+require 'rumale/model_selection/function'
 require 'rumale/evaluation_measure/accuracy'
 require 'rumale/evaluation_measure/precision'
 require 'rumale/evaluation_measure/recall'

data/lib/rumale/metric_learning/fisher_discriminant_analysis.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  # Module for metric learning algorithms.
+  module MetricLearning
+    # FisherDiscriminantAnalysis is a class that implements Fisher Discriminant Analysis.
+    #
+    # @example
+    #   transformer = Rumale::MetricLearning::FisherDiscriminantAnalysis.new
+    #   transformer.fit(training_samples, traininig_labels)
+    #   low_samples = transformer.transform(testing_samples)
+    #
+    # *Reference*
+    # - Fisher, R. A., "The use of multiple measurements in taxonomic problems," Annals of Eugenics, vol. 7, pp. 179--188, 1936.
+    # - Sugiyama, M., "Local Fisher Discriminant Analysis for Supervised Dimensionality Reduction," Proc. ICML'06, pp. 905--912, 2006.
+    class FisherDiscriminantAnalysis
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Returns the transform matrix.
+      # @return [Numo::DFloat] (shape: [n_components, n_features])
+      attr_reader :components
+
+      # Returns the mean vector.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :mean
+
+      # Returns the class mean vectors.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :class_means
+
+      # Return the class labels.
+      # @return [Numo::Int32] (shape: [n_classes])
+      attr_reader :classes
+
+      # Create a new transformer with FisherDiscriminantAnalysis.
+      #
+      # @param n_components [Integer] The number of components.
+      #   If nil is given, the number of components will be set to [n_features, n_classes - 1].min
+      def initialize(n_components: nil)
+        check_params_numeric_or_nil(n_components: n_components)
+        @params = {}
+        @params[:n_components] = n_components
+      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 [FisherDiscriminantAnalysis] The learned classifier itself.
+      def fit(x, y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
+        check_sample_label_size(x, y)
+        raise 'FisherDiscriminatAnalysis#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
+
+        # initialize some variables.
+        n_features = x.shape[1]
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        n_classes = @classes.size
+        n_components = if @params[:n_components].nil?
+                         [n_features, n_classes - 1].min
+                       else
+                         [n_features, @params[:n_components]].min
+                       end
+
+        # calculate within and between scatter matricies.
+        within_mat = Numo::DFloat.zeros(n_features, n_features)
+        between_mat = Numo::DFloat.zeros(n_features, n_features)
+        @class_means = Numo::DFloat.zeros(n_classes, n_features)
+        @mean = x.mean(0)
+        @classes.each_with_index do |label, i|
+          mask_vec = y.eq(label)
+          sz_class = mask_vec.count
+          class_samples = x[mask_vec, true]
+          class_mean = class_samples.mean(0)
+          within_mat += (class_samples - class_mean).transpose.dot(class_samples - class_mean)
+          between_mat += sz_class * (class_mean - @mean).expand_dims(1) * (class_mean - @mean)
+          @class_means[i, true] = class_mean
+        end
+
+        # calculate components.
+        _, evecs = Numo::Linalg.eigh(between_mat, within_mat, vals_range: (n_features - n_components)...n_features)
+        comps = evecs.reverse(1).transpose.dup
+        @components = n_components == 1 ? comps[0, true].dup : comps.dup
+        self
+      end
+
+      # Fit the model with training data, and then transform them with the learned model.
+      #
+      # @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 [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
+      def fit_transform(x, y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
+        fit(x, y).transform(x)
+      end
+
+      # Transform the given data with the learned model.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        x.dot(@components.transpose)
+      end
+    end
+  end
+end

data/lib/rumale/metric_learning/neighbourhood_component_analysis.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+require 'mopti/scaled_conjugate_gradient'
+
+module Rumale
+  module MetricLearning
+    # NeighbourhoodComponentAnalysis is a class that implements Neighbourhood Component Analysis.
+    #
+    # @example
+    #   transformer = Rumale::MetricLearning::NeighbourhoodComponentAnalysis.new
+    #   transformer.fit(training_samples, traininig_labels)
+    #   low_samples = transformer.transform(testing_samples)
+    #
+    # *Reference*
+    # - Goldberger, J., Roweis, S., Hinton, G., and Salakhutdinov, R., "Neighbourhood Component Analysis," Advances in NIPS'17, pp. 513--520, 2005.
+    class NeighbourhoodComponentAnalysis
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Returns the neighbourhood components.
+      # @return [Numo::DFloat] (shape: [n_components, n_features])
+      attr_reader :components
+
+      # Return the number of iterations run for optimization
+      # @return [Integer]
+      attr_reader :n_iter
+
+      # Return the random generator.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new transformer with NeighbourhoodComponentAnalysis.
+      #
+      # @param n_components [Integer] The number of components.
+      # @param init [String] The initialization method for components ('random' or 'pca').
+      # @param max_iter [Integer] The maximum number of iterations.
+      # @param tol [Float] The tolerance of termination criterion.
+      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_components: nil, init: 'random', max_iter: 100, tol: 1e-6, verbose: false, random_seed: nil)
+        check_params_numeric_or_nil(n_components: n_components, random_seed: random_seed)
+        check_params_numeric(max_iter: max_iter, tol: tol)
+        check_params_string(init: init)
+        check_params_boolean(verbose: verbose)
+        @params = {}
+        @params[:n_components] = n_components
+        @params[:init] = init
+        @params[:max_iter] = max_iter
+        @params[:tol] = tol
+        @params[:verbose] = verbose
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
+        @components = nil
+        @n_iter = nil
+        @rng = Random.new(@params[:random_seed])
+      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 [NeighbourhoodComponentAnalysis] The learned classifier itself.
+      def fit(x, y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
+        check_sample_label_size(x, y)
+        n_features = x.shape[1]
+        n_components = if @params[:n_components].nil?
+                         n_features
+                       else
+                         [n_features, @params[:n_components]].min
+                       end
+        @components, @n_iter = optimize_components(x, y, n_features, n_components)
+        self
+      end
+
+      # Fit the model with training data, and then transform them with the learned model.
+      #
+      # @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 [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
+      def fit_transform(x, y)
+        x = check_convert_sample_array(x)
+        y = check_convert_label_array(y)
+        fit(x, y).transform(x)
+      end
+
+      # Transform the given data with the learned model.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned model.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        x.dot(@components.transpose)
+      end
+
+      private
+
+      def init_components(x, n_features, n_components)
+        if @params[:init] == 'pca'
+          pca = Rumale::Decomposition::PCA.new(n_components: n_components, solver: 'evd')
+          pca.fit(x).components.flatten.dup
+        else
+          Rumale::Utils.rand_normal([n_features, n_components], @rng.dup).flatten.dup
+        end
+      end
+
+      def optimize_components(x, y, n_features, n_components)
+        # initialize components.
+        comp_init = init_components(x, n_features, n_components)
+        # initialize optimization results.
+        res = {}
+        res[:x] = comp_init
+        res[:n_iter] = 0
+        # perform optimization.
+        optimizer = Mopti::ScaledConjugateGradient.new(
+          fnc: method(:nca_loss), jcb: method(:nca_dloss),
+          x_init: comp_init, args: [x, y],
+          max_iter: @params[:max_iter], ftol: @params[:tol]
+        )
+        fold = 0.0
+        dold = 0.0
+        optimizer.each do |prm|
+          res = prm
+          puts "[NeighbourhoodComponentAnalysis] The value of objective function after #{res[:n_iter]} epochs: #{x.shape[0] - res[:fnc]}" if @params[:verbose]
+          break if (fold - res[:fnc]).abs <= @params[:tol] && (dold - res[:jcb]).abs <= @params[:tol]
+          fold = res[:fnc]
+          dold = res[:jcb]
+        end
+        # return the results.
+        n_iter = res[:n_iter]
+        comps = n_components == 1 ? res[:x].dup : res[:x].reshape(n_components, n_features)
+        [comps, n_iter]
+      end
+
+      def nca_loss(w, x, y)
+        # initialize some variables.
+        n_samples, n_features = x.shape
+        n_components = w.size / n_features
+        # projection.
+        w = w.reshape(n_components, n_features)
+        z = x.dot(w.transpose)
+        # calculate probability matrix.
+        prob_mat = probability_matrix(z)
+        # calculate loss.
+        # NOTE:
+        # NCA attempts to maximize its objective function.
+        # For the minization algorithm, the objective function value is subtracted from the maixmum value (n_samples).
+        mask_mat = y.expand_dims(1).eq(y)
+        masked_prob_mat = prob_mat * mask_mat
+        n_samples - masked_prob_mat.sum
+      end
+
+      def nca_dloss(w, x, y)
+        # initialize some variables.
+        n_features = x.shape[1]
+        n_components = w.size / n_features
+        # projection.
+        w = w.reshape(n_components, n_features)
+        z = x.dot(w.transpose)
+        # calculate probability matrix.
+        prob_mat = probability_matrix(z)
+        # calculate gradient.
+        mask_mat = y.expand_dims(1).eq(y)
+        masked_prob_mat = prob_mat * mask_mat
+        weighted_prob_mat = masked_prob_mat - prob_mat * masked_prob_mat.sum(1).expand_dims(1)
+        weighted_prob_mat += weighted_prob_mat.transpose
+        weighted_prob_mat[weighted_prob_mat.diag_indices] = -weighted_prob_mat.sum(0)
+        gradient = 2 * z.transpose.dot(weighted_prob_mat).dot(x)
+        -gradient.flatten.dup
+      end
+
+      def probability_matrix(z)
+        prob_mat = Numo::NMath.exp(-Rumale::PairwiseMetric.squared_error(z))
+        prob_mat[prob_mat.diag_indices] = 0.0
+        prob_mat /= prob_mat.sum(1).expand_dims(1)
+        prob_mat
+      end
+    end
+  end
+end

data/lib/rumale/model_selection/function.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'rumale/model_selection/shuffle_split'
+require 'rumale/model_selection/stratified_shuffle_split'
+
+module Rumale
+  module ModelSelection
+    module_function
+
+    # Split randomly data set into test and train data.
+    #
+    # @example
+    #   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/pairwise_metric.rb

@@ -42,15 +42,16 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
       # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
       def squared_error(x, y = nil)
-        y = x if y.nil?
+        y_not_given = y.nil?
+        y = x if y_not_given
         x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y)
-        n_features = x.shape[1]
-        one_vec = Numo::DFloat.ones(n_features).expand_dims(1)
-        sum_x_vec = (x**2).dot(one_vec)
-        sum_y_vec = (y**2).dot(one_vec).transpose
-        dot_xy_mat = x.dot(y.transpose)
-        dot_xy_mat * -2.0 + sum_x_vec + sum_y_vec
+        y = Rumale::Validation.check_convert_sample_array(y) unless y_not_given
+        sum_x_vec = (x**2).sum(1).expand_dims(1)
+        sum_y_vec = y_not_given ? sum_x_vec.transpose : (y**2).sum(1).expand_dims(1).transpose
+        err_mat = -2 * x.dot(y.transpose)
+        err_mat += sum_x_vec
+        err_mat += sum_y_vec
+        err_mat.class.maximum(err_mat, 0)
       end
 
       # Calculate the rbf kernel between x and y.

data/lib/rumale/version.rb

@@ -3,5 +3,5 @@
 # Rumale is a machine learning library in Ruby.
 module Rumale
   # The version of Rumale you are using.
-  VERSION = '0.17.3'
+  VERSION = '0.18.0'
 end

data/rumale.gemspec

@@ -20,7 +20,9 @@ Gem::Specification.new do |spec|
     Multi-layer Perceptron,
     Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest,
     K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering,
-    Mutidimensional Scaling, t-SNE, Principal Component Analysis, Non-negative Matrix Factorization,
+    Mutidimensional Scaling, t-SNE,
+    Fisher Discriminant Analysis, Neighbourhood Component Analysis,
+    Principal Component Analysis, Non-negative Matrix Factorization,
     and many other algorithms.
   MSG
   spec.homepage      = 'https://github.com/yoshoku/rumale'
@@ -45,13 +47,14 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.3'
 
   spec.add_runtime_dependency 'numo-narray', '>= 0.9.1'
+  spec.add_runtime_dependency 'mopti', '~> 0.1'
   spec.add_runtime_dependency 'mmh3', '~> 0.1'
 
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'coveralls', '~> 0.8'
   spec.add_development_dependency 'numo-linalg', '>= 0.1.4'
   spec.add_development_dependency 'parallel', '>= 1.17.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rake-compiler', '~> 1.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.17.3
+  version: 0.18.0
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-16 00:00:00.000000000 Z
+date: 2020-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: mopti
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: mmh3
   requirement: !ruby/object:Gem::Requirement
@@ -100,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -144,7 +158,9 @@ description: |
   Multi-layer Perceptron,
   Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest,
   K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering,
-  Mutidimensional Scaling, t-SNE, Principal Component Analysis, Non-negative Matrix Factorization,
+  Mutidimensional Scaling, t-SNE,
+  Fisher Discriminant Analysis, Neighbourhood Component Analysis,
+  Principal Component Analysis, Non-negative Matrix Factorization,
   and many other algorithms.
 email:
 - yoshoku@outlook.com
@@ -239,7 +255,10 @@ files:
 - lib/rumale/linear_model/svr.rb
 - lib/rumale/manifold/mds.rb
 - lib/rumale/manifold/tsne.rb
+- lib/rumale/metric_learning/fisher_discriminant_analysis.rb
+- lib/rumale/metric_learning/neighbourhood_component_analysis.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/k_fold.rb
 - lib/rumale/model_selection/shuffle_split.rb