rumale 0.23.3 → 0.24.0

data/lib/rumale/pairwise_metric.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-
-module Rumale
-  # Module for calculating pairwise distances, similarities, and kernels.
-  module PairwiseMetric
-    class << self
-      # Calculate the pairwise euclidean distances between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def euclidean_distance(x, y = nil)
-        y = x if y.nil?
-        x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y)
-        Numo::NMath.sqrt(squared_error(x, y).abs)
-      end
-
-      # Calculate the pairwise manhattan distances between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def manhattan_distance(x, y = nil)
-        y = x if y.nil?
-        x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y)
-        n_samples_x = x.shape[0]
-        n_samples_y = y.shape[0]
-        distance_mat = Numo::DFloat.zeros(n_samples_x, n_samples_y)
-        n_samples_x.times do |n|
-          distance_mat[n, true] = (y - x[n, true]).abs.sum(axis: 1)
-        end
-        distance_mat
-      end
-
-      # Calculate the pairwise squared errors between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def squared_error(x, y = nil)
-        y_not_given = y.nil?
-        y = x if y_not_given
-        x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y) unless y_not_given
-        sum_x_vec = (x**2).sum(1).expand_dims(1)
-        sum_y_vec = y_not_given ? sum_x_vec.transpose : (y**2).sum(1).expand_dims(1).transpose
-        err_mat = -2 * x.dot(y.transpose)
-        err_mat += sum_x_vec
-        err_mat += sum_y_vec
-        err_mat.class.maximum(err_mat, 0)
-      end
-
-      # Calculate the pairwise cosine simlarities between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def cosine_similarity(x, y = nil)
-        y_not_given = y.nil?
-        x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y) unless y_not_given
-        x_norm = Numo::NMath.sqrt((x**2).sum(1))
-        x_norm[x_norm.eq(0)] = 1
-        x /= x_norm.expand_dims(1)
-        if y_not_given
-          x.dot(x.transpose)
-        else
-          y_norm = Numo::NMath.sqrt((y**2).sum(1))
-          y_norm[y_norm.eq(0)] = 1
-          y /= y_norm.expand_dims(1)
-          x.dot(y.transpose)
-        end
-      end
-
-      # Calculate the pairwise cosine distances between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def cosine_distance(x, y = nil)
-        dist_mat = 1 - cosine_similarity(x, y)
-        dist_mat[dist_mat.diag_indices] = 0 if y.nil?
-        dist_mat.clip(0, 2)
-      end
-
-      # Calculate the rbf kernel between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @param gamma [Float] The parameter of rbf kernel, if nil it is 1 / n_features.
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def rbf_kernel(x, y = nil, gamma = nil)
-        y_not_given = y.nil?
-        y = x if y_not_given
-        x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y) unless y_not_given
-        gamma ||= 1.0 / x.shape[1]
-        Rumale::Validation.check_params_numeric(gamma: gamma)
-        Numo::NMath.exp(-gamma * squared_error(x, y))
-      end
-
-      # Calculate the linear kernel between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def linear_kernel(x, y = nil)
-        y = x if y.nil?
-        x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y)
-        x.dot(y.transpose)
-      end
-
-      # Calculate the polynomial kernel between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @param degree [Integer] The parameter of polynomial kernel.
-      # @param gamma [Float] The parameter of polynomial kernel, if nil it is 1 / n_features.
-      # @param coef [Integer] The parameter of polynomial kernel.
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def polynomial_kernel(x, y = nil, degree = 3, gamma = nil, coef = 1) # rubocop:disable Metrics/ParameterLists
-        y = x if y.nil?
-        gamma ||= 1.0 / x.shape[1]
-        x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y)
-        Rumale::Validation.check_params_numeric(gamma: gamma, degree: degree, coef: coef)
-        (x.dot(y.transpose) * gamma + coef)**degree
-      end
-
-      # Calculate the sigmoid kernel between x and y.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
-      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
-      # @param gamma [Float] The parameter of polynomial kernel, if nil it is 1 / n_features.
-      # @param coef [Integer] The parameter of polynomial kernel.
-      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
-      def sigmoid_kernel(x, y = nil, gamma = nil, coef = 1)
-        y = x if y.nil?
-        gamma ||= 1.0 / x.shape[1]
-        x = Rumale::Validation.check_convert_sample_array(x)
-        y = Rumale::Validation.check_convert_sample_array(y)
-        Rumale::Validation.check_params_numeric(gamma: gamma, coef: coef)
-        Numo::NMath.tanh(x.dot(y.transpose) * gamma + coef)
-      end
-    end
-  end
-end

data/lib/rumale/pipeline/feature_union.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/base/base_estimator'
-
-module Rumale
-  module Pipeline
-    # FeatureUnion is a class that implements the function concatenating the multi-transformer results.
-    #
-    # @example
-    #   fu = Rumale::Pipeline::FeatureUnion.new(
-    #     transformers: {
-    #       'rbf': Rumale::KernelApproximation::RBF.new(gamma: 1.0, n_components: 96, random_seed: 1),
-    #       'pca': Rumale::Decomposition::PCA.new(n_components: 32)
-    #     }
-    #   )
-    #   fu.fit(training_samples, traininig_labels)
-    #   results = fu.predict(testing_samples)
-    #
-    #   # > p results.shape[1]
-    #   # > 128
-    #
-    class FeatureUnion
-      include Base::BaseEstimator
-      include Validation
-
-      # Return the transformers
-      # @return [Hash]
-      attr_reader :transformers
-
-      # Create a new feature union.
-      #
-      # @param transformers [Hash] List of transformers.  The order of transforms follows the insertion order of hash keys.
-      def initialize(transformers:)
-        check_params_type(Hash, transformers: transformers)
-        @params = {}
-        @transformers = transformers
-      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 transformers.
-      # @param y [Numo::NArray/Nil] (shape: [n_samples, n_outputs]) The target values or labels to be used for fitting the transformers.
-      # @return [FeatureUnion] The learned feature union itself.
-      def fit(x, y = nil)
-        @transformers.each { |_k, t| t.fit(x, y) }
-        self
-      end
-
-      # Fit the model with training data, and then transform them with the learned model.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the transformers.
-      # @param y [Numo::NArray/Nil] (shape: [n_samples, n_outputs]) The target values or labels to be used for fitting the transformers.
-      # @return [Numo::DFloat] (shape: [n_samples, sum_n_components]) The transformed and concatenated data.
-      def fit_transform(x, y = nil)
-        fit(x, y).transform(x)
-      end
-
-      # Transform the given data with the learned model.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned transformers.
-      # @return [Numo::DFloat] (shape: [n_samples, sum_n_components]) The transformed and concatenated data.
-      def transform(x)
-        z = @transformers.values.map { |t| t.transform(x) }
-        Numo::NArray.hstack(z)
-      end
-    end
-  end
-end

data/lib/rumale/pipeline/pipeline.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/base/base_estimator'
-
-module Rumale
-  # Module implements utilities of pipeline that cosists of a chain of transfomers and estimators.
-  module Pipeline
-    # Pipeline is a class that implements the function to perform the transformers and estimators sequencially.
-    #
-    # @example
-    #   rbf = Rumale::KernelApproximation::RBF.new(gamma: 1.0, n_components: 128, random_seed: 1)
-    #   svc = Rumale::LinearModel::SVC.new(reg_param: 1.0, fit_bias: true, max_iter: 5000, random_seed: 1)
-    #   pipeline = Rumale::Pipeline::Pipeline.new(steps: { trs: rbf, est: svc })
-    #   pipeline.fit(training_samples, traininig_labels)
-    #   results = pipeline.predict(testing_samples)
-    #
-    class Pipeline
-      include Base::BaseEstimator
-      include Validation
-
-      # Return the steps.
-      # @return [Hash]
-      attr_reader :steps
-
-      # Create a new pipeline.
-      #
-      # @param steps [Hash] List of transformers and estimators. The order of transforms follows the insertion order of hash keys.
-      #   The last entry is considered an estimator.
-      def initialize(steps:)
-        check_params_type(Hash, steps: steps)
-        validate_steps(steps)
-        @params = {}
-        @steps = steps
-      end
-
-      # Fit the model with given training data.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be transformed and used for fitting the model.
-      # @param y [Numo::NArray] (shape: [n_samples, n_outputs]) The target values or labels to be used for fitting the model.
-      # @return [Pipeline] The learned pipeline itself.
-      def fit(x, y)
-        trans_x = apply_transforms(x, y, fit: true)
-        last_estimator&.fit(trans_x, y)
-        self
-      end
-
-      # Call the fit_predict method of last estimator after applying all transforms.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be transformed and used for fitting the model.
-      # @param y [Numo::NArray] (shape: [n_samples, n_outputs], default: nil) The target values or labels to be used for fitting the model.
-      # @return [Numo::NArray] The predicted results by last estimator.
-      def fit_predict(x, y = nil)
-        trans_x = apply_transforms(x, y, fit: true)
-        last_estimator.fit_predict(trans_x)
-      end
-
-      # Call the fit_transform method of last estimator after applying all transforms.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be transformed and used for fitting the model.
-      # @param y [Numo::NArray] (shape: [n_samples, n_outputs], default: nil) The target values or labels to be used for fitting the model.
-      # @return [Numo::NArray] The predicted results by last estimator.
-      def fit_transform(x, y = nil)
-        trans_x = apply_transforms(x, y, fit: true)
-        last_estimator.fit_transform(trans_x, y)
-      end
-
-      # Call the decision_function method of last estimator after applying all transforms.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
-      # @return [Numo::DFloat] (shape: [n_samples]) Confidence score per sample.
-      def decision_function(x)
-        trans_x = apply_transforms(x)
-        last_estimator.decision_function(trans_x)
-      end
-
-      # Call the predict method of last estimator after applying all transforms.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to obtain prediction result.
-      # @return [Numo::NArray] The predicted results by last estimator.
-      def predict(x)
-        trans_x = apply_transforms(x)
-        last_estimator.predict(trans_x)
-      end
-
-      # Call the predict_log_proba method of last estimator after applying all transforms.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the log-probailities.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted log-probability of each class per sample.
-      def predict_log_proba(x)
-        trans_x = apply_transforms(x)
-        last_estimator.predict_log_proba(trans_x)
-      end
-
-      # Call the predict_proba method of last estimator after applying all transforms.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
-      def predict_proba(x)
-        trans_x = apply_transforms(x)
-        last_estimator.predict_proba(trans_x)
-      end
-
-      # Call the transform method of last estimator after applying all transforms.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be transformed.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed samples.
-      def transform(x)
-        trans_x = apply_transforms(x)
-        last_estimator.nil? ? trans_x : last_estimator.transform(trans_x)
-      end
-
-      # Call the inverse_transform method in reverse order.
-      #
-      # @param z [Numo::DFloat] (shape: [n_samples, n_components]) The transformed samples to be restored into original space.
-      # @return [Numo::DFloat] (shape: [n_samples, n_featuress]) The restored samples.
-      def inverse_transform(z)
-        itrans_z = z
-        @steps.keys.reverse_each do |name|
-          transformer = @steps[name]
-          next if transformer.nil?
-
-          itrans_z = transformer.inverse_transform(itrans_z)
-        end
-        itrans_z
-      end
-
-      # Call the score method of last estimator after applying all transforms.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) Testing data.
-      # @param y [Numo::NArray] (shape: [n_samples, n_outputs]) True target values or labels for testing data.
-      # @return [Float] The score of last estimator
-      def score(x, y)
-        trans_x = apply_transforms(x)
-        last_estimator.score(trans_x, y)
-      end
-
-      private
-
-      def validate_steps(steps)
-        steps.keys[0...-1].each do |name|
-          transformer = steps[name]
-          next if transformer.nil? || (transformer.class.method_defined?(:fit) && transformer.class.method_defined?(:transform))
-
-          raise TypeError,
-                'Class of intermediate step in pipeline should be implemented fit and transform methods: ' \
-                "#{name} => #{transformer.class}"
-        end
-
-        estimator = steps[steps.keys.last]
-        unless estimator.nil? || estimator.class.method_defined?(:fit) # rubocop:disable Style/GuardClause
-          raise TypeError,
-                'Class of last step in pipeline should be implemented fit method: ' \
-                "#{steps.keys.last} => #{estimator.class}"
-        end
-      end
-
-      def apply_transforms(x, y = nil, fit: false)
-        trans_x = x
-        @steps.keys[0...-1].each do |name|
-          transformer = @steps[name]
-          next if transformer.nil?
-
-          transformer.fit(trans_x, y) if fit
-          trans_x = transformer.transform(trans_x)
-        end
-        trans_x
-      end
-
-      def last_estimator
-        @steps[@steps.keys.last]
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/bin_discretizer.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Preprocessing
-    # Discretizes features with a given number of bins.
-    # In some cases, discretizing features may accelerate decision tree training.
-    #
-    # @example
-    #   discretizer = Rumale::Preprocessing::BinDiscretizer.new(n_bins: 4)
-    #   samples = Numo::DFloat.new(5, 2).rand - 0.5
-    #   transformed = discretizer.fit_transform(samples)
-    #   # > pp samples
-    #   # Numo::DFloat#shape=[5,2]
-    #   # [[-0.438246, -0.126933],
-    #   #  [ 0.294815, -0.298958],
-    #   #  [-0.383959, -0.155968],
-    #   #  [ 0.039948,  0.237815],
-    #   #  [-0.334911, -0.449117]]
-    #   # > pp transformed
-    #   # Numo::DFloat#shape=[5,2]
-    #   # [[0, 1],
-    #   #  [3, 0],
-    #   #  [0, 1],
-    #   #  [2, 3],
-    #   #  [0, 0]]
-    class BinDiscretizer
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the feature steps to be used discretizing.
-      # @return [Array<Numo::DFloat>] (shape: [n_features, n_bins])
-      attr_reader :feature_steps
-
-      # Create a new discretizer for features with given number of bins.
-      #
-      # @param n_bins [Integer] The number of bins to be used disretizing feature values.
-      def initialize(n_bins: 32)
-        @params = {}
-        @params[:n_bins] = n_bins
-        @feature_steps = nil
-      end
-
-      # Fit feature ranges to be discretized.
-      #
-      # @overload fit(x) -> BinDiscretizer
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the feature ranges.
-      # @return [BinDiscretizer]
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-        n_features = x.shape[1]
-        max_vals = x.max(0)
-        min_vals = x.min(0)
-        @feature_steps = Array.new(n_features) do |n|
-          Numo::DFloat.linspace(min_vals[n], max_vals[n], @params[:n_bins] + 1)[0...@params[:n_bins]]
-        end
-        self
-      end
-
-      # Fit feature ranges to be discretized, then return discretized samples.
-      #
-      # @overload fit_transform(x) -> Numo::DFloat
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be discretized.
-      # @return [Numo::DFloat] The discretized samples.
-      def fit_transform(x, _y = nil)
-        x = check_convert_sample_array(x)
-        fit(x).transform(x)
-      end
-
-      # Peform discretizing the given samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be discretized.
-      # @return [Numo::DFloat] The discretized samples.
-      def transform(x)
-        x = check_convert_sample_array(x)
-        n_samples, n_features = x.shape
-        transformed = Numo::DFloat.zeros(n_samples, n_features)
-        n_features.times do |n|
-          steps = @feature_steps[n]
-          @params[:n_bins].times do |bin|
-            mask = x[true, n].ge(steps[bin]).where
-            transformed[mask, n] = bin
-          end
-        end
-        transformed
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/binarizer.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Preprocessing
-    # Binarize samples according to a threshold
-    #
-    # @example
-    #   binarizer = Rumale::Preprocessing::Binarizer.new
-    #   x = Numo::DFloat[[-1.2, 3.2], [2.4, -0.5], [4.5, 0.8]]
-    #   b = binarizer.transform(x)
-    #   p b
-    #
-    #   # Numo::DFloat#shape=[3, 2]
-    #   # [[0, 1],
-    #   #  [1, 0],
-    #   #  [1, 1]]
-    class Binarizer
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Create a new transformer for binarization.
-      # @param threshold [Float] The threshold value for binarization.
-      def initialize(threshold: 0.0)
-        check_params_numeric(threshold: threshold)
-        @params = { threshold: threshold }
-      end
-
-      # This method does nothing and returns the object itself.
-      # For compatibility with other transformer, this method exists.
-      #
-      # @overload fit() -> Binarizer
-      #
-      # @return [Binarizer]
-      def fit(_x = nil, _y = nil)
-        self
-      end
-
-      # Binarize each sample.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be binarized.
-      # @return [Numo::DFloat] The binarized samples.
-      def transform(x)
-        x = check_convert_sample_array(x)
-        x.class.cast(x.gt(@params[:threshold]))
-      end
-
-      # The output of this method is the same as that of the transform method.
-      # For compatibility with other transformer, this method exists.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be binarized.
-      # @return [Numo::DFloat] The binarized samples.
-      def fit_transform(x, _y = nil)
-        fit(x).transform(x)
-      end
-    end
-  end
-end

data/lib/rumale/preprocessing/kernel_calculator.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-require 'rumale/pairwise_metric'
-
-module Rumale
-  module Preprocessing
-    # KernelCalculator is a class that calculates the kernel matrix with training data.
-    #
-    # @example
-    #   transformer = Rumale::Preprocessing::KernelCalculator.new(kernel: 'rbf', gamma: 0.5)
-    #   regressor = Rumale::KernelMachine::KernelRidge.new
-    #   pipeline = Rumale::Pipeline::Pipeline.new(
-    #     steps: { trs: transfomer, est: regressor }
-    #   )
-    #   pipeline.fit(x_train, y_train)
-    #   results = pipeline.predict(x_test)
-    class KernelCalculator
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Returns the training data for calculating kernel matrix.
-      # @return [Numo::DFloat] (shape: n_components, n_features)
-      attr_reader :components
-
-      # Create a new transformer that transforms feature vectors into a kernel matrix.
-      #
-      # @param kernel [String] The type of kernel function ('rbf', 'linear', 'poly', and 'sigmoid').
-      # @param gamma [Float] The gamma parameter in rbf/poly/sigmoid kernel function.
-      # @param degree [Integer] The degree parameter in polynomial kernel function.
-      # @param coef [Float] The coefficient in poly/sigmoid kernel function.
-      def initialize(kernel: 'rbf', gamma: 1, degree: 3, coef: 1)
-        check_params_string(kernel: kernel)
-        check_params_numeric(gamma: gamma, coef: coef, degree: degree)
-        @params = {}
-        @params[:kernel] = kernel
-        @params[:gamma] = gamma
-        @params[:degree] = degree
-        @params[:coef] = coef
-        @components = nil
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> KernelCalculator
-      #   @param x [Numo::NArray] (shape: [n_samples, n_features]) The training data to be used for calculating kernel matrix.
-      # @return [KernelCalculator] The learned transformer itself.
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-        @components = x.dup
-        self
-      end
-
-      # Fit the model with training data, and then transform them with the learned model.
-      #
-      # @overload fit_transform(x) -> Numo::DFloat
-      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for calculating kernel matrix.
-      # @return [Numo::DFloat] (shape: [n_samples, n_samples]) The calculated kernel matrix.
-      def fit_transform(x, y = nil)
-        x = check_convert_sample_array(x)
-        fit(x, y).transform(x)
-      end
-
-      # Transform the given data with the learned model.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be used for calculating kernel matrix with the training data.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The calculated kernel matrix.
-      def transform(x)
-        x = check_convert_sample_array(x)
-        kernel_mat(x, @components)
-      end
-
-      private
-
-      def kernel_mat(x, y)
-        case @params[:kernel]
-        when 'rbf'
-          Rumale::PairwiseMetric.rbf_kernel(x, y, @params[:gamma])
-        when 'poly'
-          Rumale::PairwiseMetric.polynomial_kernel(x, y, @params[:degree], @params[:gamma], @params[:coef])
-        when 'sigmoid'
-          Rumale::PairwiseMetric.sigmoid_kernel(x, y, @params[:gamma], @params[:coef])
-        when 'linear'
-          Rumale::PairwiseMetric.linear_kernel(x, y)
-        else
-          raise ArgumentError, "Expect kernel parameter to be given 'rbf', 'linear', 'poly', or 'sigmoid'."
-        end
-      end
-    end
-  end
-end