rumale 0.23.3 → 0.24.0

data/lib/rumale/preprocessing/l1_normalizer.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Preprocessing
-    # Normalize samples to unit L1-norm.
-    #
-    # @example
-    #   normalizer = Rumale::Preprocessing::L1Normalizer.new
-    #   new_samples = normalizer.fit_transform(samples)
-    class L1Normalizer
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the vector consists of L1-norm for each sample.
-      # @return [Numo::DFloat] (shape: [n_samples])
-      attr_reader :norm_vec # :nodoc:
-
-      # Create a new normalizer for normaliing to L1-norm.
-      def initialize
-        @params = {}
-        @norm_vec = nil
-      end
-
-      # Calculate L1-norms of each sample.
-      #
-      # @overload fit(x) -> L1Normalizer
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L1-norms.
-      # @return [L1Normalizer]
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-        @norm_vec = x.abs.sum(1)
-        @norm_vec[@norm_vec.eq(0)] = 1
-        self
-      end
-
-      # Calculate L1-norms of each sample, and then normalize samples to L1-norm.
-      #
-      # @overload fit_transform(x) -> Numo::DFloat
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L1-norms.
-      # @return [Numo::DFloat] The normalized samples.
-      def fit_transform(x, _y = nil)
-        x = check_convert_sample_array(x)
-        fit(x)
-        x / @norm_vec.expand_dims(1)
-      end
-
-      # Calculate L1-norms of each sample, and then normalize samples to L1-norm.
-      # 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 L1-norms.
-      # @return [Numo::DFloat] The normalized samples.
-      def transform(x)
-        fit_transform(x)
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/l2_normalizer.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  # This module consists of the classes that perform preprocessings.
-  module Preprocessing
-    # Normalize samples to unit L2-norm.
-    #
-    # @example
-    #   normalizer = Rumale::Preprocessing::L2Normalizer.new
-    #   new_samples = normalizer.fit_transform(samples)
-    class L2Normalizer
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the vector consists of L2-norm for each sample.
-      # @return [Numo::DFloat] (shape: [n_samples])
-      attr_reader :norm_vec # :nodoc:
-
-      # Create a new normalizer for normaliing to unit L2-norm.
-      def initialize
-        @params = {}
-        @norm_vec = nil
-      end
-
-      # Calculate L2-norms of each sample.
-      #
-      # @overload fit(x) -> L2Normalizer
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
-      # @return [L2Normalizer]
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-        @norm_vec = Numo::NMath.sqrt((x**2).sum(1))
-        @norm_vec[@norm_vec.eq(0)] = 1
-        self
-      end
-
-      # Calculate L2-norms of each sample, and then normalize samples to unit L2-norm.
-      #
-      # @overload fit_transform(x) -> Numo::DFloat
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
-      # @return [Numo::DFloat] The normalized samples.
-      def fit_transform(x, _y = nil)
-        x = check_convert_sample_array(x)
-        fit(x)
-        x / @norm_vec.expand_dims(1)
-      end
-
-      # Calculate L2-norms of each sample, and then normalize samples to unit L2-norm.
-      # 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 L2-norms.
-      # @return [Numo::DFloat] The normalized samples.
-      def transform(x)
-        fit_transform(x)
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/label_binarizer.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Preprocessing
-    # Encode labels to binary labels with one-vs-all scheme.
-    #
-    # @example
-    #   encoder = Rumale::Preprocessing::LabelBinarizer.new
-    #   label = [0, -1, 3, 3, 1, 1]
-    #   p encoder.fit_transform(label)
-    #   # Numo::Int32#shape=[6,4]
-    #   # [[0, 1, 0, 0],
-    #   #  [1, 0, 0, 0],
-    #   #  [0, 0, 0, 1],
-    #   #  [0, 0, 0, 1],
-    #   #  [0, 0, 1, 0],
-    #   #  [0, 0, 1, 0]]
-    class LabelBinarizer
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the class labels.
-      # @return [Array] (size: [n_classes])
-      attr_reader :classes
-
-      # Create a new encoder for binarizing labels with one-vs-all scheme.
-      #
-      # @param neg_label [Integer] The value represents negative label.
-      # @param pos_label [Integer] The value represents positive label.
-      def initialize(neg_label: 0, pos_label: 1)
-        check_params_numeric(neg_label: neg_label, pos_label: pos_label)
-        @params = {}
-        @params[:neg_label] = neg_label
-        @params[:pos_label] = pos_label
-        @classes = nil
-      end
-
-      # Fit encoder to labels.
-      #
-      # @overload fit(y) -> LabelBinarizer
-      #   @param y [Numo::NArray/Array] (shape: [n_samples]) The labels to fit encoder.
-      # @return [LabelBinarizer]
-      def fit(y, _not_used = nil)
-        y = y.to_a if y.is_a?(Numo::NArray)
-        check_params_type(Array, y: y)
-        @classes = y.uniq.sort
-        self
-      end
-
-      # Fit encoder to labels, then return binarized labels.
-      #
-      # @overload fit_transform(y) -> Numo::DFloat
-      #   @param y [Numo::NArray/Array] (shape: [n_samples]) The labels to fit encoder.
-      # @return [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels.
-      def fit_transform(y, _not_used = nil)
-        y = y.to_a if y.is_a?(Numo::NArray)
-        check_params_type(Array, y: y)
-        fit(y).transform(y)
-      end
-
-      # Encode labels.
-      #
-      # @param y [Array] (shape: [n_samples]) The labels to be encoded.
-      # @return [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels.
-      def transform(y)
-        y = y.to_a if y.is_a?(Numo::NArray)
-        check_params_type(Array, y: y)
-        n_classes = @classes.size
-        n_samples = y.size
-        codes = Numo::Int32.zeros(n_samples, n_classes) + @params[:neg_label]
-        n_samples.times { |n| codes[n, @classes.index(y[n])] = @params[:pos_label] }
-        codes
-      end
-
-      # Decode binarized labels.
-      #
-      # @param x [Numo::Int32] (shape: [n_samples, n_classes]) The binarized labels to be decoded.
-      # @return [Array] (shape: [n_samples]) The decoded labels.
-      def inverse_transform(x)
-        x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
-        n_samples = x.shape[0]
-        Array.new(n_samples) { |n| @classes[x[n, true].ne(@params[:neg_label]).where[0]] }
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/label_encoder.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Preprocessing
-    # Encode labels to values between 0 and n_classes - 1.
-    #
-    # @example
-    #   encoder = Rumale::Preprocessing::LabelEncoder.new
-    #   labels = Numo::Int32[1, 8, 8, 15, 0]
-    #   encoded_labels = encoder.fit_transform(labels)
-    #   # > pp encoded_labels
-    #   # Numo::Int32#shape=[5]
-    #   # [1, 2, 2, 3, 0]
-    #   decoded_labels = encoder.inverse_transform(encoded_labels)
-    #   # > pp decoded_labels
-    #   # [1, 8, 8, 15, 0]
-    class LabelEncoder
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the class labels.
-      # @return [Array] (size: [n_classes])
-      attr_reader :classes
-
-      # Create a new encoder for encoding labels to values between 0 and n_classes - 1.
-      def initialize
-        @params = {}
-        @classes = nil
-      end
-
-      # Fit label-encoder to labels.
-      #
-      # @overload fit(x) -> LabelEncoder
-      #
-      # @param x [Array] (shape: [n_samples]) The labels to fit label-encoder.
-      # @return [LabelEncoder]
-      def fit(x, _y = nil)
-        x = x.to_a if x.is_a?(Numo::NArray)
-        check_params_type(Array, x: x)
-        @classes = x.sort.uniq
-        self
-      end
-
-      # Fit label-encoder to labels, then return encoded labels.
-      #
-      # @overload fit_transform(x) -> Numo::DFloat
-      #
-      # @param x [Array] (shape: [n_samples]) The labels to fit label-encoder.
-      # @return [Numo::Int32] The encoded labels.
-      def fit_transform(x, _y = nil)
-        x = x.to_a if x.is_a?(Numo::NArray)
-        check_params_type(Array, x: x)
-        fit(x).transform(x)
-      end
-
-      # Encode labels.
-      #
-      # @param x [Array] (shape: [n_samples]) The labels to be encoded.
-      # @return [Numo::Int32] The encoded labels.
-      def transform(x)
-        x = x.to_a if x.is_a?(Numo::NArray)
-        check_params_type(Array, x: x)
-        Numo::Int32[*(x.map { |v| @classes.index(v) })]
-      end
-
-      # Decode encoded labels.
-      #
-      # @param x [Numo::Int32] (shape: [n_samples]) The labels to be decoded.
-      # @return [Array] The decoded labels.
-      def inverse_transform(x)
-        x = check_convert_label_array(x)
-        x.to_a.map { |n| @classes[n] }
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/max_abs_scaler.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Preprocessing
-    # Normalize samples by scaling each feature with its maximum absolute value.
-    #
-    # @example
-    #   normalizer = Rumale::Preprocessing::MaxAbsScaler.new
-    #   new_training_samples = normalizer.fit_transform(training_samples)
-    #   new_testing_samples = normalizer.transform(testing_samples)
-    class MaxAbsScaler
-      include Base::BaseEstimator
-      include 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
-        @params = {}
-        @max_abs_vec = nil
-      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 = 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 = 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 = check_convert_sample_array(x)
-        x / @max_abs_vec
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/max_normalizer.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Preprocessing
-    # Normalize samples with the maximum of the absolute values.
-    #
-    # @example
-    #   normalizer = Rumale::Preprocessing::MaxNormalizer.new
-    #   new_samples = normalizer.fit_transform(samples)
-    class MaxNormalizer
-      include Base::BaseEstimator
-      include 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
-        @params = {}
-        @norm_vec = nil
-      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 = 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 = 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)
-        fit_transform(x)
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/min_max_scaler.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  # This module consists of the classes that perform preprocessings.
-  module Preprocessing
-    # Normalize samples by scaling each feature to a given range.
-    #
-    # @example
-    #   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
-      include Base::BaseEstimator
-      include 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])
-        check_params_type(Array, feature_range: feature_range)
-        @params = {}
-        @params[:feature_range] = feature_range
-        @min_vec = nil
-        @max_vec = nil
-      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 = 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 = 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 = 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

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Preprocessing
-    # Encode categorical integer features to one-hot-vectors.
-    #
-    # @example
-    #   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
-      include Base::BaseEstimator
-      include 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
-        @params = {}
-        @n_values = nil
-        @active_features = nil
-        @feature_indices = nil
-      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)
-        x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
-        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(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)
-        x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
-        raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
-        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)
-        x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
-        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