rumale-preprocessing 0.24.0

data/lib/rumale/preprocessing/max_abs_scaler.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  module Preprocessing
+    # Normalize samples by scaling each feature with its maximum absolute value.
+    #
+    # @example
+    #   require 'rumale/preprocessing/max_abs_scaler'
+    #
+    #   normalizer = Rumale::Preprocessing::MaxAbsScaler.new
+    #   new_training_samples = normalizer.fit_transform(training_samples)
+    #   new_testing_samples = normalizer.transform(testing_samples)
+    class MaxAbsScaler < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the vector consists of the maximum absolute value for each feature.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :max_abs_vec
+
+      # Creates a new normalizer for scaling each feature with its maximum absolute value.
+      def initialize # rubocop:disable Lint/UselessMethodDefinition
+        super()
+      end
+
+      # Calculate the minimum and maximum value of each feature for scaling.
+      #
+      # @overload fit(x) -> MaxAbsScaler
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate maximum absolute value for each feature.
+      # @return [MaxAbsScaler]
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @max_abs_vec = x.abs.max(0)
+        self
+      end
+
+      # Calculate the maximum absolute value for each feature, and then normalize samples.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate maximum absolute value for each feature.
+      # @return [Numo::DFloat] The scaled samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x).transform(x)
+      end
+
+      # Perform scaling the given samples with maximum absolute value for each feature.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be scaled.
+      # @return [Numo::DFloat] The scaled samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        x / @max_abs_vec
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/max_normalizer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  module Preprocessing
+    # Normalize samples with the maximum of the absolute values.
+    #
+    # @example
+    #   require 'rumale/preprocessing/max_normalizer'
+    #
+    #   normalizer = Rumale::Preprocessing::MaxNormalizer.new
+    #   new_samples = normalizer.fit_transform(samples)
+    class MaxNormalizer < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the vector consists of the maximum norm for each sample.
+      # @return [Numo::DFloat] (shape: [n_samples])
+      attr_reader :norm_vec # :nodoc:
+
+      # Create a new normalizer for normaliing to max-norm.
+      def initialize # rubocop:disable Lint/UselessMethodDefinition
+        super()
+      end
+
+      # Calculate the maximum norms of each sample.
+      #
+      # @overload fit(x) -> MaxNormalizer
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the maximum norms.
+      # @return [MaxNormalizer]
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @norm_vec = x.abs.max(1)
+        @norm_vec[@norm_vec.eq(0)] = 1
+        self
+      end
+
+      # Calculate the maximums norm of each sample, and then normalize samples with the norms.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate maximum norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x)
+        x / @norm_vec.expand_dims(1)
+      end
+
+      # Calculate the maximum norms of each sample, and then normalize samples with the norms.
+      # This method calls the fit_transform method. This method exists for the Pipeline class.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate maximum norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit_transform(x)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/min_max_scaler.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  # This module consists of the classes that perform preprocessings.
+  module Preprocessing
+    # Normalize samples by scaling each feature to a given range.
+    #
+    # @example
+    #   require 'rumale/preprocessing/min_max_scaler'
+    #
+    #   normalizer = Rumale::Preprocessing::MinMaxScaler.new(feature_range: [0.0, 1.0])
+    #   new_training_samples = normalizer.fit_transform(training_samples)
+    #   new_testing_samples = normalizer.transform(testing_samples)
+    class MinMaxScaler < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the vector consists of the minimum value for each feature.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :min_vec
+
+      # Return the vector consists of the maximum value for each feature.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :max_vec
+
+      # Creates a new normalizer for scaling each feature to a given range.
+      #
+      # @param feature_range [Array<Float>] The desired range of samples.
+      def initialize(feature_range: [0.0, 1.0])
+        super()
+        @params = { feature_range: feature_range }
+      end
+
+      # Calculate the minimum and maximum value of each feature for scaling.
+      #
+      # @overload fit(x) -> MinMaxScaler
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
+      # @return [MinMaxScaler]
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @min_vec = x.min(0)
+        @max_vec = x.max(0)
+        self
+      end
+
+      # Calculate the minimum and maximum values, and then normalize samples to feature_range.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
+      # @return [Numo::DFloat] The scaled samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x).transform(x)
+      end
+
+      # Perform scaling the given samples according to feature_range.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be scaled.
+      # @return [Numo::DFloat] The scaled samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_samples, = x.shape
+        dif_vec = @max_vec - @min_vec
+        dif_vec[dif_vec.eq(0)] = 1.0
+        nx = (x - @min_vec.tile(n_samples, 1)) / dif_vec.tile(n_samples, 1)
+        nx * (@params[:feature_range][1] - @params[:feature_range][0]) + @params[:feature_range][0]
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/one_hot_encoder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Encode categorical integer features to one-hot-vectors.
+    #
+    # @example
+    #   require 'rumale/preprocessing/one_hot_encoder'
+    #
+    #   encoder = Rumale::Preprocessing::OneHotEncoder.new
+    #   labels = Numo::Int32[0, 0, 2, 3, 2, 1]
+    #   one_hot_vectors = encoder.fit_transform(labels)
+    #   # > pp one_hot_vectors
+    #   # Numo::DFloat#shape[6, 4]
+    #   # [[1, 0, 0, 0],
+    #   #  [1, 0, 0, 0],
+    #   #  [0, 0, 1, 0],
+    #   #  [0, 0, 0, 1],
+    #   #  [0, 0, 1, 0],
+    #   #  [0, 1, 0, 0]]
+    class OneHotEncoder < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the maximum values for each feature.
+      # @return [Numo::Int32] (shape: [n_features])
+      attr_reader :n_values
+
+      # Return the indices for feature values that actually occur in the training set.
+      # @return [Nimo::Int32]
+      attr_reader :active_features
+
+      # Return the indices to feature ranges.
+      # @return [Numo::Int32] (shape: [n_features + 1])
+      attr_reader :feature_indices
+
+      # Create a new encoder for encoding categorical integer features to one-hot-vectors
+      def initialize # rubocop:disable Lint/UselessMethodDefinition
+        super()
+      end
+
+      # Fit one-hot-encoder to samples.
+      #
+      # @overload fit(x) -> OneHotEncoder
+      #   @param x [Numo::Int32] (shape: [n_samples, n_features]) The samples to fit one-hot-encoder.
+      # @return [OneHotEncoder]
+      def fit(x, _y = nil)
+        raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
+        @n_values = x.max(0) + 1
+        @feature_indices = Numo::Int32.hstack([[0], @n_values]).cumsum
+        @active_features = encode(x, @feature_indices).sum(axis: 0).ne(0).where
+        self
+      end
+
+      # Fit one-hot-encoder to samples, then encode samples into one-hot-vectors
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::Int32] (shape: [n_samples, n_features]) The samples to encode into one-hot-vectors.
+      # @return [Numo::DFloat] The one-hot-vectors.
+      def fit_transform(x, _y = nil)
+        raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
+        fit(x).transform(x)
+      end
+
+      # Encode samples into one-hot-vectors.
+      #
+      # @param x [Numo::Int32] (shape: [n_samples, n_features]) The samples to encode into one-hot-vectors.
+      # @return [Numo::DFloat] The one-hot-vectors.
+      def transform(x)
+        raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
+        codes = encode(x, @feature_indices)
+        codes[true, @active_features].dup
+      end
+
+      private
+
+      def encode(x, indices)
+        n_samples, n_features = x.shape
+        n_features = 1 if n_features.nil?
+        col_indices = (x + indices[0...-1]).flatten.to_a
+        row_indices = Numo::Int32.new(n_samples).seq.repeat(n_features).to_a
+        codes = Numo::DFloat.zeros(n_samples, indices[-1])
+        row_indices.zip(col_indices).each { |r, c| codes[r, c] = 1.0 }
+        codes
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/ordinal_encoder.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Transfrom categorical features to integer values.
+    #
+    # @example
+    #   require 'rumale/preprocessing/ordinal_encoder'
+    #
+    #   encoder = Rumale::Preprocessing::OrdinalEncoder.new
+    #   training_samples = [['left', 10], ['right', 15], ['right', 20]]
+    #   training_samples = Numo::NArray.asarray(training_samples)
+    #   encoder.fit(training_samples)
+    #   p encoder.categories
+    #   # [["left", "right"], [10, 15, 20]]
+    #   testing_samples = [['left', 20], ['right', 10]]
+    #   testing_samples = Numo::NArray.asarray(testing_samples)
+    #   encoded = encoder.transform(testing_samples)
+    #   p encoded
+    #   # Numo::DFloat#shape=[2,2]
+    #   # [[0, 2],
+    #   #  [1, 0]]
+    #   p encoder.inverse_transform(encoded)
+    #   # Numo::RObject#shape=[2,2]
+    #   # [["left", 20],
+    #   #  ["right", 10]]
+    class OrdinalEncoder < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the array consists of categorical value each feature.
+      # @return [Array] (size: n_features)
+      attr_reader :categories
+
+      # Create a new encoder that transform categorical features to integer values.
+      #
+      # @param categories [Nil/Array] The category list for each feature.
+      #   If nil is given, extracted categories from the training data by calling the fit method are used.
+      def initialize(categories: nil)
+        super()
+        @categories = categories
+      end
+
+      # Fit encoder by extracting the category for each feature.
+      #
+      # @overload fit(x) -> OrdinalEncoder
+      #
+      # @param x [Numo::NArray] (shape: [n_samples, n_features]) The samples consisting of categorical features.
+      # @return [LabelEncoder]
+      def fit(x, _y = nil)
+        raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+
+        n_features = x.shape[1]
+        @categories = Array.new(n_features) { |n| x[true, n].to_a.uniq.sort }
+        self
+      end
+
+      # Fit encoder, then return encoded categorical features to integer values.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::NArray] (shape: [n_samples, n_features]) The samples consisting of categorical features.
+      # @return [Numo::DFloat] The encoded categorical features to integer values.
+      def fit_transform(x, _y = nil)
+        raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+
+        fit(x).transform(x)
+      end
+
+      # Encode categorical features.
+      #
+      # @param x [Numo::NArray] (shape: [n_samples, n_features]) The samples consisting of categorical features.
+      # @return [Numo::DFloat] The encoded categorical features to integer values.
+      def transform(x)
+        raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+
+        n_features = x.shape[1]
+        if n_features != @categories.size
+          raise ArgumentError,
+                'Expect the number of features and the number of categories to be equal'
+        end
+
+        transformed = Array.new(n_features) do |n|
+          x[true, n].to_a.map { |v| @categories[n].index(v) }
+        end
+
+        Numo::DFloat.asarray(transformed.transpose)
+      end
+
+      # Decode values to categorical features.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples consisting of values transformed from categorical features.
+      # @return [Numo::NArray] The decoded features.
+      def inverse_transform(x)
+        n_features = x.shape[1]
+        if n_features != @categories.size
+          raise ArgumentError,
+                'Expect the number of features and the number of categories to be equal'
+        end
+
+        inv_transformed = Array.new(n_features) do |n|
+          x[true, n].to_a.map { |i| @categories[n][i.to_i] }
+        end
+
+        Numo::NArray.asarray(inv_transformed.transpose)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/polynomial_features.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  module Preprocessing
+    # Generating polynomial features from the given samples.
+    #
+    # @example
+    #   require 'rumale/preprocessing/polynomial_features'
+    #
+    #   transformer = Rumale::Preprocessing::PolynomialFeatures.new(degree: 2)
+    #   x = Numo::DFloat[[0, 1], [2, 3], [4, 5]]
+    #   z = transformer.fit_transform(x)
+    #   p z
+    #
+    #   # Numo::DFloat#shape=[3,6]
+    #   # [[1, 0, 1, 0, 0, 1],
+    #   #  [1, 2, 3, 4, 6, 9],
+    #   #  [1, 4, 5, 16, 20, 25]]
+    #
+    #   # If you want to perform polynomial regression, combine it with LinearRegression as follows:
+    #   require 'rumale/preprocessing/polynomial_features'
+    #   require 'rumale/linear_model/linear_regression'
+    #   require 'rumale/pipeline/pipeline'
+    #
+    #   ply = Rumale::Preprocessing::PolynomialFeatures.new(degree: 2)
+    #   reg = Rumale::LinearModel::LinearRegression.new(fit_bias: false, random_seed: 1)
+    #   pipeline = Rumale::Pipeline::Pipeline.new(steps: { trs: ply, est: reg })
+    #   pipeline.fit(training_samples, training_values)
+    #   results = pipeline.predict(testing_samples)
+    #
+    class PolynomialFeatures < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the number of polynomial features.
+      # @return [Integer]
+      attr_reader :n_output_features
+
+      # Create a transformer for generating polynomial features.
+      #
+      # @param degree [Integer] The degree of polynomial features.
+      def initialize(degree: 2)
+        raise ArgumentError, 'Expect the value of degree parameter greater than or eqaul to 1.' if degree < 1
+
+        super()
+        @params = { degree: degree }
+      end
+
+      # Calculate the number of output polynomial fetures.
+      #
+      # @overload fit(x) -> PolynomialFeatures
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the number of output polynomial fetures.
+      # @return [PolynomialFeatures]
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_features = x.shape[1]
+        @n_output_features = 1
+        @params[:degree].times do |t|
+          @n_output_features += Array.new(n_features) { |n| n }.repeated_combination(t + 1).size
+        end
+        self
+      end
+
+      # Calculate the number of polynomial features, and then transform samples to polynomial features.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the number of polynomial features
+      #     and be transformed.
+      # @return [Numo::DFloat] (shape: [n_samples, n_output_features]) The transformed samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x).transform(x)
+      end
+
+      # Transform the given samples to polynomial features.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be transformed.
+      # @return [Numo::DFloat] (shape: [n_samples, n_output_features]) The transformed samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        # initialize transformed features
+        n_samples, n_features = x.shape
+        z = Numo::DFloat.zeros(n_samples, n_output_features)
+        # bias
+        z[true, 0] = 1
+        curr_col = 1
+        # itself
+        z[true, 1..n_features] = x
+        curr_col += n_features
+        # high degree features
+        curr_feat_ids = Array.new(n_features + 1) { |n| n + 1 }
+        (1...@params[:degree]).each do
+          next_feat_ids = []
+          n_features.times do |d|
+            f_range = curr_feat_ids[d]...curr_feat_ids.last
+            next_col = curr_col + f_range.size
+            z[true, curr_col...next_col] = z[true, f_range] * x[true, d..d]
+            next_feat_ids.push(curr_col)
+            curr_col = next_col
+          end
+          next_feat_ids.push(curr_col)
+          curr_feat_ids = next_feat_ids
+        end
+        z
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/standard_scaler.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/transformer'
+require 'rumale/validation'
+
+module Rumale
+  # This module consists of the classes that perform preprocessings.
+  module Preprocessing
+    # Normalize samples by centering and scaling to unit variance.
+    #
+    # @example
+    #   require 'rumale/preprocessing/standard_scaler'
+    #
+    #   normalizer = Rumale::Preprocessing::StandardScaler.new
+    #   new_training_samples = normalizer.fit_transform(training_samples)
+    #   new_testing_samples = normalizer.transform(testing_samples)
+    class StandardScaler < ::Rumale::Base::Estimator
+      include ::Rumale::Base::Transformer
+
+      # Return the vector consists of the mean value for each feature.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :mean_vec
+
+      # Return the vector consists of the standard deviation for each feature.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :std_vec
+
+      # Create a new normalizer for centering and scaling to unit variance.
+      def initialize # rubocop:disable Lint/UselessMethodDefinition
+        super()
+      end
+
+      # Calculate the mean value and standard deviation of each feature for scaling.
+      #
+      # @overload fit(x) -> StandardScaler
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #   The samples to calculate the mean values and standard deviations.
+      # @return [StandardScaler]
+      def fit(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        @mean_vec = x.mean(0)
+        @std_vec = x.stddev(0)
+        self
+      end
+
+      # Calculate the mean values and standard deviations, and then normalize samples using them.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features])
+      #   The samples to calculate the mean values and standard deviations.
+      # @return [Numo::DFloat] The scaled samples.
+      def fit_transform(x, _y = nil)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        fit(x).transform(x)
+      end
+
+      # Perform standardization the given samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be scaled.
+      # @return [Numo::DFloat] The scaled samples.
+      def transform(x)
+        x = ::Rumale::Validation.check_convert_sample_array(x)
+
+        n_samples, = x.shape
+        (x - @mean_vec.tile(n_samples, 1)) / @std_vec.tile(n_samples, 1)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Rumale is a machine learning library in Ruby.
+module Rumale
+  # This module consists of the classes that perform preprocessings.
+  module Preprocessing
+    # @!visibility private
+    VERSION = '0.24.0'
+  end
+end

data/lib/rumale/preprocessing.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+
+require_relative 'preprocessing/bin_discretizer'
+require_relative 'preprocessing/binarizer'
+require_relative 'preprocessing/kernel_calculator'
+require_relative 'preprocessing/l1_normalizer'
+require_relative 'preprocessing/l2_normalizer'
+require_relative 'preprocessing/label_binarizer'
+require_relative 'preprocessing/label_encoder'
+require_relative 'preprocessing/max_abs_scaler'
+require_relative 'preprocessing/max_normalizer'
+require_relative 'preprocessing/min_max_scaler'
+require_relative 'preprocessing/one_hot_encoder'
+require_relative 'preprocessing/ordinal_encoder'
+require_relative 'preprocessing/polynomial_features'
+require_relative 'preprocessing/standard_scaler'
+require_relative 'preprocessing/version'