svmkit 0.7.3 → 0.8.1

data/lib/svmkit/polynomial_model/factorization_machine_regressor.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-require 'svmkit/validation'
-require 'svmkit/base/base_estimator'
-require 'svmkit/base/regressor'
-require 'svmkit/optimizer/nadam'
-
-module SVMKit
-  module PolynomialModel
-    # FactorizationMachineRegressor is a class that implements Factorization Machine
-    # with stochastic gradient descent (SGD) optimization.
-    #
-    # @example
-    #   estimator =
-    #     SVMKit::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
-      include Base::BaseEstimator
-      include Base::Regressor
-      include Validation
-
-      # 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)
-        @params = {}
-        @params[:n_factors] = n_factors
-        @params[:reg_param_linear] = reg_param_linear
-        @params[:reg_param_factor] = reg_param_factor
-        @params[:max_iter] = max_iter
-        @params[:batch_size] = batch_size
-        @params[:optimizer] = optimizer
-        @params[:optimizer] ||= Optimizer::Nadam.new
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @factor_mat = nil
-        @weight_vec = nil
-        @bias_term = nil
-        @rng = Random.new(@params[:random_seed])
-      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] = single_fit(x, y[true, n]) }
-        else
-          @factor_mat, @weight_vec, @bias_term = single_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 single_fit(x, y)
-        # Initialize some variables.
-        n_samples, n_features = x.shape
-        rand_ids = [*0...n_samples].shuffle(random: @rng)
-        weight_vec = Numo::DFloat.zeros(n_features + 1)
-        factor_mat = Numo::DFloat.zeros(@params[:n_factors], n_features)
-        weight_optimizer = @params[:optimizer].dup
-        factor_optimizers = Array.new(@params[:n_factors]) { @params[:optimizer].dup }
-        # Start optimization.
-        @params[:max_iter].times do |_t|
-          # Random sampling.
-          subset_ids = rand_ids.shift(@params[:batch_size])
-          rand_ids.concat(subset_ids)
-          data = x[subset_ids, true]
-          ex_data = expand_feature(data)
-          values = y[subset_ids]
-          # Calculate gradients for loss function.
-          loss_grad = loss_gradient(data, ex_data, values, factor_mat, weight_vec)
-          next if loss_grad.ne(0.0).count.zero?
-          # Update each parameter.
-          weight_vec = weight_optimizer.call(weight_vec, weight_gradient(loss_grad, ex_data, weight_vec))
-          @params[:n_factors].times do |n|
-            factor_mat[n, true] = factor_optimizers[n].call(factor_mat[n, true],
-                                                            factor_gradient(loss_grad, data, factor_mat[n, true]))
-          end
-        end
-        [factor_mat, *split_weight_vec_bias(weight_vec)]
-      end
-
-      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
-
-      def weight_gradient(loss_grad, data, weight)
-        (loss_grad.expand_dims(1) * data).mean(0) + @params[:reg_param_linear] * weight
-      end
-
-      def factor_gradient(loss_grad, data, factor)
-        (loss_grad.expand_dims(1) * (data * data.dot(factor).expand_dims(1) - factor * (data**2))).mean(0) + @params[:reg_param_factor] * factor
-      end
-
-      def expand_feature(x)
-        Numo::NArray.hstack([x, Numo::DFloat.ones([x.shape[0], 1])])
-      end
-
-      def split_weight_vec_bias(weight_vec)
-        weights = weight_vec[0...-1].dup
-        bias = weight_vec[-1]
-        [weights, bias]
-      end
-    end
-  end
-end

data/lib/svmkit/preprocessing/l2_normalizer.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'svmkit/validation'
-require 'svmkit/base/base_estimator'
-require 'svmkit/base/transformer'
-
-module SVMKit
-  # This module consists of the classes that perform preprocessings.
-  module Preprocessing
-    # Normalize samples to unit L2-norm.
-    #
-    # @example
-    #   normalizer = SVMKit::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)
-        SVMKit::Validation.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)
-        SVMKit::Validation.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/svmkit/preprocessing/label_encoder.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require 'svmkit/validation'
-require 'svmkit/base/base_estimator'
-require 'svmkit/base/transformer'
-
-module SVMKit
-  module Preprocessing
-    # Encode labels to values between 0 and n_classes - 1.
-    #
-    # @example
-    #   encoder = SVMKit::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)
-        SVMKit::Validation.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)
-        SVMKit::Validation.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)
-        SVMKit::Validation.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)
-        SVMKit::Validation.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/svmkit/preprocessing/min_max_scaler.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'svmkit/validation'
-require 'svmkit/base/base_estimator'
-require 'svmkit/base/transformer'
-
-module SVMKit
-  # This module consists of the classes that perform preprocessings.
-  module Preprocessing
-    # Normalize samples by scaling each feature to a given range.
-    #
-    # @example
-    #   normalizer = SVMKit::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])
-        SVMKit::Validation.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)
-        SVMKit::Validation.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)
-        SVMKit::Validation.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)
-        SVMKit::Validation.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/svmkit/preprocessing/one_hot_encoder.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require 'svmkit/validation'
-require 'svmkit/base/base_estimator'
-require 'svmkit/base/transformer'
-
-module SVMKit
-  module Preprocessing
-    # Encode categorical integer features to one-hot-vectors.
-    #
-    # @example
-    #   encoder = SVMKit::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)
-        SVMKit::Validation.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)
-        SVMKit::Validation.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)
-        SVMKit::Validation.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