rumale 0.19.0 → 0.20.1

data/lib/rumale/feature_extraction/tfidf_transformer.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+require 'rumale/preprocessing/l1_normalizer'
+require 'rumale/preprocessing/l2_normalizer'
+
+module Rumale
+  module FeatureExtraction
+    # Transform sample matrix with term frequecy (tf) to a normalized tf-idf (inverse document frequency) reprensentation.
+    #
+    # @example
+    #   encoder = Rumale::FeatureExtraction::HashVectorizer.new
+    #   x = encoder.fit_transform([
+    #     { foo: 1, bar: 2 },
+    #     { foo: 3, baz: 1 }
+    #   ])
+    #
+    #   # > pp x
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[2, 0, 1],
+    #   #  [0, 1, 3]]
+    #
+    #   transformer = Rumale::FeatureExtraction::TfidfTransformer.new
+    #   x_tfidf = transformer.fit_transform(x)
+    #
+    #   # > pp x_tfidf
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[0.959056, 0, 0.283217],
+    #   #  [0, 0.491506, 0.870874]]
+    #
+    # *Reference*
+    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
+    class TfidfTransformer
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Return the vector consists of inverse document frequency.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :idf
+
+      # Create a new transfomer for converting tf vectors to tf-idf vectors.
+      #
+      # @param norm [String] The normalization method to be used ('l1', 'l2' and 'none').
+      # @param use_idf [Boolean] The flag indicating whether to use inverse document frequency weighting.
+      # @param smooth_idf [Boolean] The flag indicating whether to apply idf smoothing by log((n_samples + 1) / (df + 1)) + 1.
+      # @param sublinear_tf [Boolean] The flag indicating whether to perform subliner tf scaling by 1 + log(tf).
+      def initialize(norm: 'l2', use_idf: true, smooth_idf: false, sublinear_tf: false)
+        check_params_string(norm: norm)
+        check_params_boolean(use_idf: use_idf, smooth_idf: smooth_idf, sublinear_tf: sublinear_tf)
+        @params = {}
+        @params[:norm] = norm
+        @params[:use_idf] = use_idf
+        @params[:smooth_idf] = smooth_idf
+        @params[:sublinear_tf] = sublinear_tf
+        @idf = nil
+      end
+
+      # Calculate the inverse document frequency for weighting.
+      #
+      # @overload fit(x) -> TfidfTransformer
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the idf values.
+      # @return [TfidfTransformer]
+      def fit(x, _y = nil)
+        return self unless @params[:use_idf]
+
+        x = check_convert_sample_array(x)
+
+        n_samples = x.shape[0]
+        df = x.class.cast(x.gt(0.0).count(0))
+
+        if @params[:smooth_idf]
+          df += 1
+          n_samples += 1
+        end
+
+        @idf = Numo::NMath.log(n_samples / df) + 1
+
+        self
+      end
+
+      # Calculate the idf values, and then transfrom samples to the tf-idf representation.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate idf and be transformed to tf-idf representation.
+      # @return [Numo::DFloat] The transformed samples.
+      def fit_transform(x, _y = nil)
+        fit(x).transform(x)
+      end
+
+      # Perform transforming the given samples to the tf-idf representation.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be transformed.
+      # @return [Numo::DFloat] The transformed samples.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        z = x.dup
+
+        z[z.ne(0)] = Numo::NMath.log(z[z.ne(0)]) + 1 if @params[:sublinear_tf]
+        z *= @idf if @params[:use_idf]
+        case @params[:norm]
+        when 'l2'
+          z = Rumale::Preprocessing::L2Normalizer.new.fit_transform(z)
+        when 'l1'
+          z = Rumale::Preprocessing::L1Normalizer.new.fit_transform(z)
+        end
+        z
+      end
+    end
+  end
+end

data/lib/rumale/kernel_approximation/nystroem.rb

@@ -69,7 +69,7 @@ module Rumale
         n_components = [1, [@params[:n_components], n_samples].min].max
 
         # random sampling.
-        @component_indices = Numo::Int32.cast([*0...n_samples].shuffle(random: sub_rng)[0...n_components])
+        @component_indices = Numo::Int32.cast(Array(0...n_samples).shuffle(random: sub_rng)[0...n_components])
         @components = x[@component_indices, true]
 
         # calculate normalizing factor.

data/lib/rumale/kernel_machine/kernel_svc.rb

@@ -172,7 +172,7 @@ module Rumale
         # Start optimization.
         @params[:max_iter].times do |t|
           # random sampling
-          rand_ids = [*0...n_training_samples].shuffle(random: sub_rng) if rand_ids.empty?
+          rand_ids = Array(0...n_training_samples).shuffle(random: sub_rng) if rand_ids.empty?
           target_id = rand_ids.shift
           # update the weight vector
           func = (weight_vec * bin_y).dot(x[target_id, true].transpose).to_f

data/lib/rumale/linear_model/base_sgd.rb

@@ -209,7 +209,7 @@ module Rumale
         l1_penalty = LinearModel::Penalty::L1Penalty.new(reg_param: l1_reg_param) if apply_l1_penalty?
         # Optimization.
         @params[:max_iter].times do |t|
-          sample_ids = [*0...n_samples]
+          sample_ids = Array(0...n_samples)
           sample_ids.shuffle!(random: sub_rng)
           until (subset_ids = sample_ids.shift(@params[:batch_size])).empty?
             # sampling

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/cross_validation.rb

@@ -69,10 +69,11 @@ module Rumale
       #     the return_train_score is false.
       def perform(x, y)
         x = check_convert_sample_array(x)
-        if @estimator.is_a?(Rumale::Base::Classifier)
+        case @estimator
+        when Rumale::Base::Classifier
           y = check_convert_label_array(y)
           check_sample_label_size(x, y)
-        elsif @estimator.is_a?(Rumale::Base::Regressor)
+        when Rumale::Base::Regressor
           y = check_convert_tvalue_array(y)
           check_sample_tvalue_size(x, y)
         else

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/k_fold.rb

@@ -62,7 +62,7 @@ module Rumale
         end
         sub_rng = @rng.dup
         # Splits dataset ids to each fold.
-        dataset_ids = [*0...n_samples]
+        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

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,
@@ -74,7 +74,7 @@ module Rumale
         end
         sub_rng = @rng.dup
         # Returns array consisting of the training and testing ids for each fold.
-        dataset_ids = [*0...n_samples]
+        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?

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