rumale 0.23.3 → 0.24.0

data/lib/rumale/model_selection/group_shuffle_split.rb

@@ -1,115 +0,0 @@
-# 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/k_fold.rb

@@ -1,81 +0,0 @@
-# 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
-    #   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 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)
-        check_params_numeric(n_splits: n_splits)
-        check_params_boolean(shuffle: shuffle)
-        check_params_numeric_or_nil(random_seed: random_seed)
-        check_params_positive(n_splits: n_splits)
-        @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)
-        x = check_convert_sample_array(x)
-        # 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

@@ -1,90 +0,0 @@
-# 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
-    #   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 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)
-        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 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)
-        x = check_convert_sample_array(x)
-        # 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

@@ -1,99 +0,0 @@
-# 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
-    #   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 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)
-        check_params_numeric(n_splits: n_splits)
-        check_params_boolean(shuffle: shuffle)
-        check_params_numeric_or_nil(random_seed: random_seed)
-        check_params_positive(n_splits: n_splits)
-        @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.
-      #
-      # @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)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(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

@@ -1,118 +0,0 @@
-# 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
-    #   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 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)
-        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 data indices for stratified random permutation cross validation.
-      #
-      # @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)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(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
-        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
-        # 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

@@ -1,91 +0,0 @@
-# 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
-    #   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 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)
-        check_params_numeric(n_splits: n_splits)
-        check_params_numeric_or_nil(max_train_size: max_train_size)
-        @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)
-        x = check_convert_sample_array(x)
-
-        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/multiclass/one_vs_rest_classifier.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/classifier'
-
-module Rumale
-  # This module consists of the classes that implement multi-class classification strategy.
-  module Multiclass
-    # @note
-    #   All classifier in Rumale support multi-class classifiction since version 0.2.7.
-    #   There is no need to explicitly use this class for multiclass classifiction.
-    #
-    # OneVsRestClassifier is a class that implements One-vs-Rest (OvR) strategy for multi-class classification.
-    #
-    # @example
-    #   base_estimator = Rumale::LinearModel::LogisticRegression.new
-    #   estimator = Rumale::Multiclass::OneVsRestClassifier.new(estimator: base_estimator)
-    #   estimator.fit(training_samples, training_labels)
-    #   results = estimator.predict(testing_samples)
-    class OneVsRestClassifier
-      include Base::BaseEstimator
-      include Base::Classifier
-
-      # Return the set of estimators.
-      # @return [Array<Classifier>]
-      attr_reader :estimators
-
-      # Return the class labels.
-      # @return [Numo::Int32] (shape: [n_classes])
-      attr_reader :classes
-
-      # Create a new multi-class classifier with the one-vs-rest startegy.
-      #
-      # @param estimator [Classifier] The (binary) classifier for construction a multi-class classifier.
-      def initialize(estimator: nil)
-        check_params_type(Rumale::Base::BaseEstimator, estimator: estimator)
-        @params = {}
-        @params[:estimator] = estimator
-        @estimators = nil
-        @classes = nil
-      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 [OneVsRestClassifier] 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)
-        y_arr = y.to_a
-        @classes = Numo::Int32.asarray(y_arr.uniq.sort)
-        @estimators = @classes.to_a.map do |label|
-          bin_y = Numo::Int32.asarray(y_arr.map { |l| l == label ? 1 : -1 })
-          @params[:estimator].dup.fit(x, bin_y)
-        end
-        self
-      end
-
-      # Calculate confidence scores for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
-      def decision_function(x)
-        x = check_convert_sample_array(x)
-        n_classes = @classes.size
-        Numo::DFloat.asarray(Array.new(n_classes) { |m| @estimators[m].decision_function(x).to_a }).transpose
-      end
-
-      # Predict class labels for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
-      # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
-      def predict(x)
-        x = check_convert_sample_array(x)
-        n_samples, = x.shape
-        decision_values = decision_function(x)
-        Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
-      end
-    end
-  end
-end