rumale 0.8.0

data/lib/rumale/polynomial_model/factorization_machine_regressor.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'rumale/base/regressor'
+require 'rumale/polynomial_model/base_factorization_machine'
+
+module Rumale
+  module PolynomialModel
+    # FactorizationMachineRegressor is a class that implements Factorization Machine
+    # with stochastic gradient descent (SGD) optimization.
+    #
+    # @example
+    #   estimator =
+    #     Rumale::PolynomialModel::FactorizationMachineRegressor.new(
+    #      n_factors: 10, reg_param_linear: 0.1, reg_param_factor: 0.1,
+    #      max_iter: 5000, batch_size: 50, random_seed: 1)
+    #   estimator.fit(training_samples, traininig_values)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - S. Rendle, "Factorization Machines with libFM," ACM TIST, vol. 3 (3), pp. 57:1--57:22, 2012.
+    # - S. Rendle, "Factorization Machines," Proc. ICDM'10, pp. 995--1000, 2010.
+    class FactorizationMachineRegressor < BaseFactorizationMachine
+      include Base::Regressor
+
+      # Return the factor matrix for Factorization Machine.
+      # @return [Numo::DFloat] (shape: [n_outputs, n_factors, n_features])
+      attr_reader :factor_mat
+
+      # Return the weight vector for Factorization Machine.
+      # @return [Numo::DFloat] (shape: [n_outputs, n_features])
+      attr_reader :weight_vec
+
+      # Return the bias term for Factoriazation Machine.
+      # @return [Numo::DFloat] (shape: [n_outputs])
+      attr_reader :bias_term
+
+      # Return the random generator for random sampling.
+      # @return [Random]
+      attr_reader :rng
+
+      # Create a new regressor with Factorization Machine.
+      #
+      # @param n_factors [Integer] The maximum number of iterations.
+      # @param reg_param_linear [Float] The regularization parameter for linear model.
+      # @param reg_param_factor [Float] The regularization parameter for factor matrix.
+      # @param max_iter [Integer] The maximum number of iterations.
+      # @param batch_size [Integer] The size of the mini batches.
+      # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
+      #   If nil is given, Nadam is used.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(n_factors: 2, reg_param_linear: 1.0, reg_param_factor: 1.0,
+                     max_iter: 1000, batch_size: 10, optimizer: nil, random_seed: nil)
+        check_params_float(reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor)
+        check_params_integer(n_factors: n_factors, max_iter: max_iter, batch_size: batch_size)
+        check_params_type_or_nil(Integer, random_seed: random_seed)
+        check_params_positive(n_factors: n_factors, reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
+                              max_iter: max_iter, batch_size: batch_size)
+        keywd_args = method(:initialize).parameters.map { |_t, arg| [arg, binding.local_variable_get(arg)] }.to_h.merge(loss: nil)
+        super(keywd_args)
+      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, n_outputs]) The target values to be used for fitting the model.
+      # @return [FactorizationMachineRegressor] The learned regressor itself.
+      def fit(x, y)
+        check_sample_array(x)
+        check_tvalue_array(y)
+        check_sample_tvalue_size(x, y)
+
+        n_outputs = y.shape[1].nil? ? 1 : y.shape[1]
+        _n_samples, n_features = x.shape
+
+        if n_outputs > 1
+          @factor_mat = Numo::DFloat.zeros(n_outputs, @params[:n_factors], n_features)
+          @weight_vec = Numo::DFloat.zeros(n_outputs, n_features)
+          @bias_term = Numo::DFloat.zeros(n_outputs)
+          n_outputs.times { |n| @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
+        else
+          @factor_mat, @weight_vec, @bias_term = partial_fit(x, y)
+        end
+
+        self
+      end
+
+      # Predict values for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
+      # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted values per sample.
+      def predict(x)
+        check_sample_array(x)
+        linear_term = @bias_term + x.dot(@weight_vec.transpose)
+        factor_term = if @weight_vec.shape[1].nil?
+                        0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(0)
+                      else
+                        0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(1).transpose
+                      end
+        linear_term + factor_term
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about FactorizationMachineRegressor.
+      def marshal_dump
+        { params: @params,
+          factor_mat: @factor_mat,
+          weight_vec: @weight_vec,
+          bias_term: @bias_term,
+          rng: @rng }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @factor_mat = obj[:factor_mat]
+        @weight_vec = obj[:weight_vec]
+        @bias_term = obj[:bias_term]
+        @rng = obj[:rng]
+        nil
+      end
+
+      private
+
+      def loss_gradient(x, ex_x, y, factor, weight)
+        z = ex_x.dot(weight) + 0.5 * (factor.dot(x.transpose)**2 - (factor**2).dot(x.transpose**2)).sum(0)
+        2.0 * (z - y)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/l2_normalizer.rb

@@ -0,0 +1,62 @@
+# 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::StandardScaler.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)
+        check_sample_array(x)
+        @norm_vec = Numo::NMath.sqrt((x**2).sum(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)
+        check_sample_array(x)
+        fit(x)
+        x / @norm_vec.tile(x.shape[1], 1).transpose
+      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_encoder.rb

@@ -0,0 +1,94 @@
+# 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)
+        check_label_array(x)
+        x.to_a.map { |n| @classes[n] }
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about LabelEncoder
+      def marshal_dump
+        { params: @params,
+          classes: @classes }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @classes = obj[:classes]
+        nil
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/min_max_scaler.rb

@@ -0,0 +1,92 @@
+# 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)
+        check_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)
+        check_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)
+        check_sample_array(x)
+        n_samples, = x.shape
+        dif_vec = @max_vec - @min_vec
+        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
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about MinMaxScaler.
+      def marshal_dump
+        { params: @params,
+          min_vec: @min_vec,
+          max_vec: @max_vec }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @min_vec = obj[:min_vec]
+        @max_vec = obj[:max_vec]
+        nil
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/one_hot_encoder.rb

@@ -0,0 +1,98 @@
+# 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 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
+        @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)
+        check_params_type(Numo::Int32, x: x)
+        @n_values = x.max(0) + 1
+        @feature_indices = Numo::Int32.hstack([[0], @n_values]).cumsum
+        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)
+        check_params_type(Numo::Int32, x: x)
+        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)
+        check_params_type(Numo::Int32, x: x)
+        n_samples, n_features = x.shape
+        n_features = 1 if n_features.nil?
+        column_indices = (x + @feature_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, @feature_indices[-1])
+        row_indices.zip(column_indices).each { |r, c| codes[r, c] = 1.0 }
+        codes
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about OneHotEncoder.
+      def marshal_dump
+        { params: @params,
+          n_values: @n_values,
+          feature_indices: @feature_indices }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @n_values = obj[:n_values]
+        @feature_indices = obj[:feature_indices]
+        nil
+      end
+    end
+  end
+end