rumale 0.20.0 → 0.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 358515f8785eb3de2e6571a957ca76cece6b774bb022c1a0951c92d44ab422b4
-  data.tar.gz: '0289b7eb382cd3300845412af0fd43626f4f827bb719083c879b574e3ab37eb0'
+  metadata.gz: 0f361026cd2922a2d36846a817eee855bf0c000156ed6c756bca29d2e42d67a2
+  data.tar.gz: 016fa40aa2546824cacbc32353263cbfc9427f0ceabb7e703f99854914bb9a2e
 SHA512:
-  metadata.gz: f03fc0f27f99ed4acea3fb7d7bf34017c1dbf923b20dabc9a78d6d44f0b151bc9dc78ba24d122f81607a43fd1852e398a603b75b87656a2f79109f87c0db0d98
-  data.tar.gz: 69f6b8892f6bfb4c43706513245c3fba687dcb6a347c1c5185a70d5e45a024b2848a019bfae48726e1f49212878e8d6d67c811ec5f4a990fdbb3a2841efdfe9b
+  metadata.gz: 7a53a958db7ec8b56236018505370b9908ae81a9afc9d7c8ff0b16d83971539c1ad729b5ab350eb49ae9b90ada43a8912ed2404a37eef97a4d34dad90b1d3e9f
+  data.tar.gz: 2f2b3d48625c7120464179bc7759c01ba7de85cb0d54720665eaf1e4822f24c1870474ebc24a47cff123e44a8626b0e0fac6a7e81216c057286071770ea5ba79

data/.rubocop.yml

@@ -3,6 +3,7 @@ require:
   - rubocop-rspec
 
 AllCops:
+  NewCops: enable
   TargetRubyVersion: 2.5
   DisplayCopNames: true
   DisplayStyleGuide: true
@@ -15,34 +16,13 @@ AllCops:
 Style/Documentation:
   Enabled: false
 
-Style/HashEachMethods:
-  Enabled: true
-
-Style/HashTransformKeys:
-  Enabled: true
-
-Style/HashTransformValues:
-  Enabled: true
-
-Lint/DeprecatedOpenSSLConstant:
-  Enabled: true
-
-Lint/DuplicateElsifCondition:
-  Enabled: true
-
-Lint/MixedRegexpCaptureTypes:
-  Enabled: true
-
-Lint/RaiseException:
-  Enabled: true
-
-Lint/StructNewOverride:
-  Enabled: true
-
 Layout/LineLength:
   Max: 145
   IgnoredPatterns: ['(\A|\s)#']
 
+Lint/MissingSuper:
+  Enabled: false
+
 Metrics/ModuleLength:
   Max: 200
 
@@ -78,83 +58,14 @@ Naming/MethodParameterName:
 Naming/ConstantName:
   Enabled: false
 
-Style/AccessorGrouping:
-  Enabled: true
-
-Style/ArrayCoercion:
-  Enabled: true
-
-Style/BisectedAttrAccessor:
-  Enabled: true
-
-Style/CaseLikeIf:
-  Enabled: true
-
-Style/ExponentialNotation:
-  Enabled: true
-
 Style/FormatStringToken:
   Enabled: false
 
-Style/HashAsLastArrayItem:
-  Enabled: true
-
-Style/HashLikeCase:
-  Enabled: true
-
 Style/NumericLiterals:
   Enabled: false
 
-Style/RedundantAssignment:
-  Enabled: true
-
-Style/RedundantFetchBlock:
-  Enabled: true
-
-Style/RedundantFileExtensionInRequire:
-  Enabled: true
-
-Style/RedundantRegexpCharacterClass:
-  Enabled: true
-
-Style/RedundantRegexpEscape:
-  Enabled: true
-
-Style/SlicingWithRange:
-  Enabled: true
-
-Layout/EmptyLineAfterGuardClause:
-  Enabled: true
-
-Layout/EmptyLinesAroundAttributeAccessor:
-  Enabled: true
-
-Layout/SpaceAroundMethodCallOperator:
-  Enabled: true
-
-Performance/AncestorsInclude:
-  Enabled: true
-
-Performance/BigDecimalWithNumericArgument:
-  Enabled: true
-
-Performance/RedundantSortBlock:
-  Enabled: true
-
-Performance/RedundantStringChars:
-  Enabled: true
-
-Performance/ReverseFirst:
-  Enabled: true
-
-Performance/SortReverse:
-  Enabled: true
-
-Performance/Squeeze:
-  Enabled: true
-
-Performance/StringInclude:
-  Enabled: true
+Style/StringConcatenation:
+  Enabled: false
 
 RSpec/MultipleExpectations:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 0.20.1
+- Add cross-validator classes that split data according group labels.
+  - [GroupKFold](https://yoshoku.github.io/rumale/doc/Rumale/ModelSelection/GroupKFold.html)
+  - [GroupShuffleSplit](https://yoshoku.github.io/rumale/doc/Rumale/ModelSelection/GroupShuffleSplit.html)
+- Fix fraction treating of the number of samples on shuffle split cross-validator classes.
+  - [ShuffleSplit](https://yoshoku.github.io/rumale/doc/Rumale/ModelSelection/ShuffleSplit.html)
+  - [StratifiedShuffleSplit](https://yoshoku.github.io/rumale/doc/Rumale/ModelSelection/StratifiedShuffleSplit.html)
+- Refactor some codes with Rubocop.
+
 # 0.20.0
 ## Breaking changes
 - Delete deprecated estimators such as PolynomialModel, Optimizer, and BaseLinearModel.

data/lib/rumale.rb

@@ -98,8 +98,10 @@ require 'rumale/preprocessing/ordinal_encoder'
 require 'rumale/preprocessing/binarizer'
 require 'rumale/preprocessing/polynomial_features'
 require 'rumale/model_selection/k_fold'
+require 'rumale/model_selection/group_k_fold'
 require 'rumale/model_selection/stratified_k_fold'
 require 'rumale/model_selection/shuffle_split'
+require 'rumale/model_selection/group_shuffle_split'
 require 'rumale/model_selection/stratified_shuffle_split'
 require 'rumale/model_selection/cross_validation'
 require 'rumale/model_selection/grid_search_cv'

data/lib/rumale/clustering/hdbscan.rb

@@ -136,7 +136,7 @@ module Rumale
         res
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def condense_tree(hierarchy, min_cluster_size)
         n_edges = hierarchy.size
         root = 2 * n_edges
@@ -265,7 +265,7 @@ module Rumale
         end
         res
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rumale/dataset.rb

@@ -225,7 +225,7 @@ module Rumale
         line = dump_label(label, label_type.to_s)
         ftvec.to_a.each_with_index do |val, n|
           idx = n + (zero_based == false ? 1 : 0)
-          line += format(" %d:#{value_type}", idx, val) if val != 0.0
+          line += format(" %d:#{value_type}", idx, val) if val != 0
         end
         line
       end

data/lib/rumale/decomposition/nmf.rb

@@ -77,7 +77,7 @@ module Rumale
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
       def transform(x)
         x = check_convert_sample_array(x)
-        partial_fit(x, false)
+        partial_fit(x, update_comps: false)
       end
 
       # Inverse transform the given transformed data with the learned model.
@@ -91,7 +91,7 @@ module Rumale
 
       private
 
-      def partial_fit(x, update_comps = true)
+      def partial_fit(x, update_comps: true)
         # initialize some variables.
         n_samples, n_features = x.shape
         scale = Math.sqrt(x.mean / @params[:n_components])

data/lib/rumale/ensemble/random_forest_classifier.rb

@@ -85,7 +85,7 @@ module Rumale
       # @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 [RandomForestClassifier] The learned classifier itself.
-      def fit(x, y)
+      def fit(x, y) # rubocop:disable Metrics/AbcSize
         x = check_convert_sample_array(x)
         y = check_convert_label_array(y)
         check_sample_label_size(x, y)

data/lib/rumale/ensemble/random_forest_regressor.rb

@@ -79,7 +79,7 @@ module Rumale
       # @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 [RandomForestRegressor] The learned regressor itself.
-      def fit(x, y)
+      def fit(x, y) # rubocop:disable Metrics/AbcSize
         x = check_convert_sample_array(x)
         y = check_convert_tvalue_array(y)
         check_sample_tvalue_size(x, y)

data/lib/rumale/feature_extraction/feature_hasher.rb

@@ -67,7 +67,7 @@ module Rumale
       def transform(x)
         raise 'FeatureHasher#transform requires Mmh3 but that is not loaded.' unless enable_mmh3?
 
-        x = [x] unless x.is_a?(Array)
+        x = [x] unless x.is_a?(Array) # rubocop:disable Style/ArrayCoercion
         n_samples = x.size
 
         z = Numo::DFloat.zeros(n_samples, n_features)

data/lib/rumale/feature_extraction/hash_vectorizer.rb

@@ -99,7 +99,7 @@ module Rumale
       # @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
       # @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
       def transform(x)
-        x = [x] unless x.is_a?(Array)
+        x = [x] unless x.is_a?(Array) # rubocop:disable Style/ArrayCoercion
         n_samples = x.size
         n_features = @vocabulary.size
         z = Numo::DFloat.zeros(n_samples, n_features)

data/lib/rumale/manifold/tsne.rb

@@ -102,7 +102,7 @@ module Rumale
           break if terminate?(hi_prob_mat, lo_prob_mat)
 
           a = hi_prob_mat * lo_prob_mat
-          b = lo_prob_mat * lo_prob_mat
+          b = lo_prob_mat**2
           y = (b.dot(one_vec) * y + (a - b).dot(y)) / a.dot(one_vec)
           lo_prob_mat = t_distributed_probability_matrix(y)
           @n_iter = t + 1

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
+    #   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 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)
+        check_params_numeric(n_splits: n_splits)
+        @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)
+        x = check_convert_sample_array(x)
+        groups = check_convert_label_array(groups)
+        check_sample_label_size(x, groups)
+
+        encoder = Rumale::Preprocessing::LabelEncoder.new
+        groups = encoder.fit_transform(groups)
+        n_groups = encoder.classes.size
+
+        raise ArgumentError, 'The number of groups should be greater than or equal to the number of splits.' if n_groups < @n_splits
+
+        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,115 @@
+# 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
+    #   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 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)
+        check_params_numeric(n_splits: n_splits, test_size: test_size)
+        check_params_numeric_or_nil(train_size: train_size, random_seed: random_seed)
+        check_params_positive(n_splits: n_splits)
+        check_params_positive(test_size: test_size)
+        check_params_positive(train_size: train_size) unless train_size.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)
+        x = check_convert_sample_array(x)
+        groups = check_convert_label_array(groups)
+        check_sample_label_size(x, 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/shuffle_split.rb

@@ -54,19 +54,19 @@ module Rumale
         x = check_convert_sample_array(x)
         # Initialize and check some variables.
         n_samples = x.shape[0]
-        n_test_samples = (@test_size * n_samples).to_i
-        n_train_samples = @train_size.nil? ? n_samples - n_test_samples : (@train_size * n_samples).to_i
+        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 sample in test split must be not less than 1 and not more than the number of samples.'
+                '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 sample in train split must be not less than 1 and not more than the number of samples.'
+                '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,

data/lib/rumale/model_selection/stratified_k_fold.rb

@@ -30,7 +30,7 @@ module Rumale
       # @return [Random]
       attr_reader :rng
 
-      # Create a new data splitter for K-fold cross validation.
+      # 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.

data/lib/rumale/model_selection/stratified_shuffle_split.rb

@@ -66,15 +66,15 @@ module Rumale
           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
-        unless enough_data_size_each_class?(y, @test_size)
+        unless enough_data_size_each_class?(y, @test_size, 'test')
           raise RangeError,
-                'The number of sample in test split must be not less than 1 and not more than the number of samples in each class.'
+                '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)
+        unless enough_data_size_each_class?(y, train_sz, 'train')
           raise RangeError,
-                'The number of sample in train split must be not less than 1 and not more than the number of samples in each class.'
+                '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)
+        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
@@ -85,12 +85,12 @@ module Rumale
           test_ids = []
           sample_ids_each_class.each do |sample_ids|
             n_samples = sample_ids.size
-            n_test_samples = (@test_size * n_samples).to_i
-            n_train_samples = (train_sz * n_samples).to_i
+            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
@@ -104,9 +104,13 @@ module Rumale
         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)
+      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|
-          (data_size * n_samples).to_i.between?(1, 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

data/lib/rumale/probabilistic_output.rb

@@ -98,7 +98,7 @@ module Rumale
 
       def hessian_matrix(probs, df, sigma)
         sub = probs * (1 - probs)
-        h11 = (df * df * sub).sum + sigma
+        h11 = (df**2 * sub).sum + sigma
         h22 = sub.sum + sigma
         h21 = (df * sub).sum
         Numo::DFloat[[h11, h21], [h21, h22]]

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.20.0'
+  VERSION = '0.20.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.20.1
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-01 00:00:00.000000000 Z
+date: 2020-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -135,6 +135,8 @@ files:
 - 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