rumale 0.23.3 → 0.24.0

data/lib/rumale/manifold/mds.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-require 'rumale/utils'
-require 'rumale/pairwise_metric'
-require 'rumale/decomposition/pca'
-
-module Rumale
-  module Manifold
-    # MDS is a class that implements Metric Multidimensional Scaling (MDS)
-    # with Scaling by MAjorizing a COmplicated Function (SMACOF) algorithm.
-    #
-    # @example
-    #   mds = Rumale::Manifold::MDS.new(init: 'pca', max_iter: 500, random_seed: 1)
-    #   representations = mds.fit_transform(samples)
-    #
-    # *Reference*
-    # - Groenen, P J. F.  and van de Velden, M., "Multidimensional Scaling by Majorization: A Review," J. of Statistical Software, Vol. 73 (8), 2016.
-    class MDS
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the data in representation space.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components])
-      attr_reader :embedding
-
-      # Return the stress function value after optimization.
-      # @return [Float]
-      attr_reader :stress
-
-      # Return the number of iterations run for optimization
-      # @return [Integer]
-      attr_reader :n_iter
-
-      # Return the random generator.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new transformer with MDS.
-      #
-      # @param n_components [Integer] The number of dimensions on representation space.
-      # @param metric [String] The metric to calculate the distances in original space.
-      #   If metric is 'euclidean', Euclidean distance is calculated for distance in original space.
-      #   If metric is 'precomputed', the fit and fit_transform methods expect to be given a distance matrix.
-      # @param init [String] The init is a method to initialize the representaion space.
-      #   If init is 'random', the representaion space is initialized with normal random variables.
-      #   If init is 'pca', the result of principal component analysis as the initial value of the representation space.
-      # @param max_iter [Integer] The maximum number of iterations.
-      # @param tol [Float] The tolerance of stress value for terminating optimization.
-      #   If tol is nil,  it does not use stress value as a criterion for terminating the optimization.
-      # @param verbose [Boolean] The flag indicating whether to output stress value during iteration.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_components: 2, metric: 'euclidean', init: 'random',
-                     max_iter: 300, tol: nil, verbose: false, random_seed: nil)
-        check_params_numeric(n_components: n_components, max_iter: max_iter)
-        check_params_string(metric: metric, init: init)
-        check_params_boolean(verbose: verbose)
-        check_params_numeric_or_nil(tol: tol, random_seed: random_seed)
-        check_params_positive(n_components: n_components, max_iter: max_iter)
-        @params = {}
-        @params[:n_components] = n_components
-        @params[:max_iter] = max_iter
-        @params[:tol] = tol
-        @params[:metric] = metric
-        @params[:init] = init
-        @params[:verbose] = verbose
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @rng = Random.new(@params[:random_seed])
-        @embedding = nil
-        @stress = nil
-        @n_iter = nil
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> MDS
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
-      # @return [MDS] The learned transformer itself.
-      def fit(x, _not_used = nil)
-        x = check_convert_sample_array(x)
-        raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
-
-        # initialize some varibales.
-        n_samples = x.shape[0]
-        hi_distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
-        @embedding = init_embedding(x)
-        lo_distance_mat = Rumale::PairwiseMetric.euclidean_distance(@embedding)
-        @stress = calc_stress(hi_distance_mat, lo_distance_mat)
-        @n_iter = 0
-        # perform optimization.
-        @params[:max_iter].times do |t|
-          # guttman tarnsform.
-          ratio = hi_distance_mat / lo_distance_mat
-          ratio[ratio.diag_indices] = 0.0
-          ratio[lo_distance_mat.eq(0)] = 0.0
-          tmp_mat = -ratio
-          tmp_mat[tmp_mat.diag_indices] += ratio.sum(axis: 1)
-          @embedding = 1.fdiv(n_samples) * tmp_mat.dot(@embedding)
-          lo_distance_mat = Rumale::PairwiseMetric.euclidean_distance(@embedding)
-          # check convergence.
-          new_stress = calc_stress(hi_distance_mat, lo_distance_mat)
-          if terminate?(@stress, new_stress)
-            @stress = new_stress
-            break
-          end
-          # next step.
-          @n_iter = t + 1
-          @stress = new_stress
-          puts "[MDS] stress function after #{@n_iter} iterations: #{@stress}" if @params[:verbose] && (@n_iter % 100).zero?
-        end
-        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 fitting the model.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
-      def fit_transform(x, _not_used = nil)
-        fit(x)
-        @embedding.dup
-      end
-
-      private
-
-      def init_embedding(x)
-        if @params[:init] == 'pca' && @params[:metric] == 'euclidean'
-          pca = Rumale::Decomposition::PCA.new(n_components: @params[:n_components], random_seed: @params[:random_seed])
-          pca.fit_transform(x)
-        else
-          n_samples = x.shape[0]
-          sub_rng = @rng.dup
-          Rumale::Utils.rand_uniform([n_samples, @params[:n_components]], sub_rng) - 0.5
-        end
-      end
-
-      def terminate?(old_stress, new_stress)
-        return false if @params[:tol].nil?
-        return false if old_stress.nil?
-
-        (old_stress - new_stress).abs <= @params[:tol]
-      end
-
-      def calc_stress(hi_distance_mat, lo_distance_mat)
-        ((hi_distance_mat - lo_distance_mat)**2).sum.fdiv(2)
-      end
-    end
-  end
-end

data/lib/rumale/manifold/tsne.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-require 'rumale/utils'
-require 'rumale/pairwise_metric'
-require 'rumale/decomposition/pca'
-
-module Rumale
-  # Module for data embedding algorithms.
-  module Manifold
-    # TSNE is a class that implements t-Distributed Stochastic Neighbor Embedding (t-SNE)
-    # with fixed-point optimization algorithm.
-    # Fixed-point algorithm usually converges faster than gradient descent method and
-    # do not need the learning parameters such as the learning rate and momentum.
-    #
-    # @example
-    #   tsne = Rumale::Manifold::TSNE.new(perplexity: 40.0, init: 'pca', max_iter: 500, random_seed: 1)
-    #   representations = tsne.fit_transform(samples)
-    #
-    # *Reference*
-    # - van der Maaten, L., and Hinton, G., "Visualizing data using t-SNE," J. of Machine Learning Research, vol. 9, pp. 2579--2605, 2008.
-    # - Yang, Z., King, I., Xu, Z., and Oja, E., "Heavy-Tailed Symmetric Stochastic Neighbor Embedding," Proc. NIPS'09, pp. 2169--2177, 2009.
-    class TSNE
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the data in representation space.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components])
-      attr_reader :embedding
-
-      # Return the Kullback-Leibler divergence after optimization.
-      # @return [Float]
-      attr_reader :kl_divergence
-
-      # Return the number of iterations run for optimization
-      # @return [Integer]
-      attr_reader :n_iter
-
-      # Return the random generator.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new transformer with t-SNE.
-      #
-      # @param n_components [Integer] The number of dimensions on representation space.
-      # @param perplexity [Float] The effective number of neighbors for each point. Perplexity are typically set from 5 to 50.
-      # @param metric [String] The metric to calculate the distances in original space.
-      #   If metric is 'euclidean', Euclidean distance is calculated for distance in original space.
-      #   If metric is 'precomputed', the fit and fit_transform methods expect to be given a distance matrix.
-      # @param init [String] The init is a method to initialize the representaion space.
-      #   If init is 'random', the representaion space is initialized with normal random variables.
-      #   If init is 'pca', the result of principal component analysis as the initial value of the representation space.
-      # @param max_iter [Integer] The maximum number of iterations.
-      # @param tol [Float] The tolerance of KL-divergence for terminating optimization.
-      #   If tol is nil,  it does not use KL divergence as a criterion for terminating the optimization.
-      # @param verbose [Boolean] The flag indicating whether to output KL divergence during iteration.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_components: 2, perplexity: 30.0, metric: 'euclidean', init: 'random',
-                     max_iter: 500, tol: nil, verbose: false, random_seed: nil)
-        check_params_numeric(n_components: n_components, max_iter: max_iter, perplexity: perplexity)
-        check_params_string(metric: metric, init: init)
-        check_params_boolean(verbose: verbose)
-        check_params_numeric_or_nil(tol: tol, random_seed: random_seed)
-        check_params_positive(n_components: n_components, perplexity: perplexity, max_iter: max_iter)
-        @params = {}
-        @params[:n_components] = n_components
-        @params[:perplexity] = perplexity
-        @params[:max_iter] = max_iter
-        @params[:tol] = tol
-        @params[:metric] = metric
-        @params[:init] = init
-        @params[:verbose] = verbose
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @rng = Random.new(@params[:random_seed])
-        @embedding = nil
-        @kl_divergence = nil
-        @n_iter = nil
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> TSNE
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
-      # @return [TSNE] The learned transformer itself.
-      def fit(x, _not_used = nil)
-        x = check_convert_sample_array(x)
-        raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
-
-        # initialize some varibales.
-        @n_iter = 0
-        distance_mat = @params[:metric] == 'precomputed' ? x**2 : Rumale::PairwiseMetric.squared_error(x)
-        hi_prob_mat = gaussian_distributed_probability_matrix(distance_mat)
-        y = init_embedding(x)
-        lo_prob_mat = t_distributed_probability_matrix(y)
-        # perform fixed-point optimization.
-        one_vec = Numo::DFloat.ones(x.shape[0]).expand_dims(1)
-        @params[:max_iter].times do |t|
-          break if terminate?(hi_prob_mat, lo_prob_mat)
-
-          a = hi_prob_mat * lo_prob_mat
-          b = lo_prob_mat**2
-          y = (b.dot(one_vec) * y + (a - b).dot(y)) / a.dot(one_vec)
-          lo_prob_mat = t_distributed_probability_matrix(y)
-          @n_iter = t + 1
-          if @params[:verbose] && (@n_iter % 100).zero?
-            puts "[t-SNE] KL divergence after #{@n_iter} iterations: #{cost(hi_prob_mat, lo_prob_mat)}"
-          end
-        end
-        # store results.
-        @embedding = y
-        @kl_divergence = cost(hi_prob_mat, lo_prob_mat)
-        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 fitting the model.
-      #   If the metric is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
-      def fit_transform(x, _not_used = nil)
-        fit(x)
-        @embedding.dup
-      end
-
-      private
-
-      def init_embedding(x)
-        if @params[:init] == 'pca' && @params[:metric] == 'euclidean'
-          pca = Rumale::Decomposition::PCA.new(n_components: @params[:n_components], random_seed: @params[:random_seed])
-          pca.fit_transform(x)
-        else
-          n_samples = x.shape[0]
-          sub_rng = @rng.dup
-          Rumale::Utils.rand_normal([n_samples, @params[:n_components]], sub_rng, 0, 0.0001)
-        end
-      end
-
-      def gaussian_distributed_probability_matrix(distance_mat)
-        # initialize some variables.
-        n_samples = distance_mat.shape[0]
-        prob_mat = Numo::DFloat.zeros(n_samples, n_samples)
-        sum_beta = 0.0
-        # calculate conditional probabilities.
-        n_samples.times do |n|
-          beta, probs = optimal_probabilities(n, distance_mat[n, true])
-          prob_mat[n, true] = probs
-          sum_beta += beta
-          puts "[t-SNE] Computed conditional probabilities for sample #{n + 1} / #{n_samples}" if @params[:verbose] && ((n + 1) % 1000).zero?
-        end
-        puts "[t-SNE] Mean sigma: #{Math.sqrt(n_samples.fdiv(sum_beta))}" if @params[:verbose]
-        # symmetrize and normalize probability matrix.
-        prob_mat[prob_mat.diag_indices(0)] = 0.0
-        prob_mat = 0.5 * (prob_mat + prob_mat.transpose)
-        prob_mat / prob_mat.sum
-      end
-
-      def optimal_probabilities(sample_id, distance_vec, max_iter = 100)
-        # initialize some variables.
-        probs = nil
-        beta = 1.0
-        betamin = Float::MIN
-        betamax = Float::MAX
-        init_entropy = Math.log(@params[:perplexity])
-        # calculate optimal beta and conditional probabilities with binary search.
-        max_iter.times do
-          entropy, probs = gaussian_distributed_probability_vector(sample_id, distance_vec, beta)
-          diff_entropy = entropy - init_entropy
-          break if diff_entropy.abs <= 1e-5
-
-          if diff_entropy.positive?
-            betamin = beta
-            if betamax == Float::MAX
-              beta *= 2.0
-            else
-              beta = 0.5 * (beta + betamax)
-            end
-          else
-            betamax = beta
-            if betamin == Float::MIN
-              beta /= 2.0
-            else
-              beta = 0.5 * (beta + betamin)
-            end
-          end
-        end
-        [beta, probs]
-      end
-
-      def gaussian_distributed_probability_vector(n, distance_vec, beta)
-        probs = Numo::NMath.exp(-beta * distance_vec)
-        probs[n] = 0.0
-        sum_probs = probs.sum
-        probs /= sum_probs
-        entropy = Math.log(sum_probs) + beta * (distance_vec * probs).sum
-        [entropy, probs]
-      end
-
-      def t_distributed_probability_matrix(y)
-        distance_mat = Rumale::PairwiseMetric.squared_error(y)
-        prob_mat = 1.0 / (1.0 + distance_mat)
-        prob_mat[prob_mat.diag_indices(0)] = 0.0
-        prob_mat / prob_mat.sum
-      end
-
-      def cost(p, q)
-        (p * Numo::NMath.log(Numo::DFloat.maximum(1e-20, p) / Numo::DFloat.maximum(1e-20, q))).sum
-      end
-
-      def terminate?(p, q)
-        return false if @params[:tol].nil?
-
-        cost(p, q) <= @params[:tol]
-      end
-    end
-  end
-end

data/lib/rumale/metric_learning/fisher_discriminant_analysis.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  # Module for metric learning algorithms.
-  module MetricLearning
-    # FisherDiscriminantAnalysis is a class that implements Fisher Discriminant Analysis.
-    #
-    # @example
-    #   transformer = Rumale::MetricLearning::FisherDiscriminantAnalysis.new
-    #   transformer.fit(training_samples, traininig_labels)
-    #   low_samples = transformer.transform(testing_samples)
-    #
-    # *Reference*
-    # - Fisher, R. A., "The use of multiple measurements in taxonomic problems," Annals of Eugenics, vol. 7, pp. 179--188, 1936.
-    # - Sugiyama, M., "Local Fisher Discriminant Analysis for Supervised Dimensionality Reduction," Proc. ICML'06, pp. 905--912, 2006.
-    class FisherDiscriminantAnalysis
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Returns the transform matrix.
-      # @return [Numo::DFloat] (shape: [n_components, n_features])
-      attr_reader :components
-
-      # Returns the mean vector.
-      # @return [Numo::DFloat] (shape: [n_features])
-      attr_reader :mean
-
-      # Returns the class mean vectors.
-      # @return [Numo::DFloat] (shape: [n_classes, n_features])
-      attr_reader :class_means
-
-      # Return the class labels.
-      # @return [Numo::Int32] (shape: [n_classes])
-      attr_reader :classes
-
-      # Create a new transformer with FisherDiscriminantAnalysis.
-      #
-      # @param n_components [Integer] The number of components.
-      #   If nil is given, the number of components will be set to [n_features, n_classes - 1].min
-      def initialize(n_components: nil)
-        check_params_numeric_or_nil(n_components: n_components)
-        @params = {}
-        @params[:n_components] = n_components
-      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]) The labels to be used for fitting the model.
-      # @return [FisherDiscriminantAnalysis] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        raise 'FisherDiscriminatAnalysis#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
-
-        # initialize some variables.
-        n_features = x.shape[1]
-        @classes = Numo::Int32[*y.to_a.uniq.sort]
-        n_classes = @classes.size
-        n_components = if @params[:n_components].nil?
-                         [n_features, n_classes - 1].min
-                       else
-                         [n_features, @params[:n_components]].min
-                       end
-
-        # calculate within and between scatter matricies.
-        within_mat = Numo::DFloat.zeros(n_features, n_features)
-        between_mat = Numo::DFloat.zeros(n_features, n_features)
-        @class_means = Numo::DFloat.zeros(n_classes, n_features)
-        @mean = x.mean(0)
-        @classes.each_with_index do |label, i|
-          mask_vec = y.eq(label)
-          sz_class = mask_vec.count
-          class_samples = x[mask_vec, true]
-          class_mean = class_samples.mean(0)
-          within_mat += (class_samples - class_mean).transpose.dot(class_samples - class_mean)
-          between_mat += sz_class * (class_mean - @mean).expand_dims(1) * (class_mean - @mean)
-          @class_means[i, true] = class_mean
-        end
-
-        # calculate components.
-        _, evecs = Numo::Linalg.eigh(between_mat, within_mat, vals_range: (n_features - n_components)...n_features)
-        comps = evecs.reverse(1).transpose.dup
-        @components = n_components == 1 ? comps[0, true].dup : comps.dup
-        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 model.
-      # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
-      def fit_transform(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        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 model.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
-      def transform(x)
-        x = check_convert_sample_array(x)
-        x.dot(@components.transpose)
-      end
-    end
-  end
-end

data/lib/rumale/metric_learning/mlkr.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-require 'rumale/decomposition/pca'
-require 'rumale/pairwise_metric'
-require 'rumale/utils'
-require 'lbfgsb'
-
-module Rumale
-  module MetricLearning
-    # MLKR is a class that implements Metric Learning for Kernel Regression.
-    #
-    # @example
-    #   transformer = Rumale::MetricLearning::MLKR.new
-    #   transformer.fit(training_samples, traininig_target_values)
-    #   low_samples = transformer.transform(testing_samples)
-    #
-    # *Reference*
-    # - Weinberger, K. Q. and Tesauro, G., "Metric Learning for Kernel Regression," Proc. AISTATS'07, pp. 612--629, 2007.
-    class MLKR
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Returns the metric components.
-      # @return [Numo::DFloat] (shape: [n_components, n_features])
-      attr_reader :components
-
-      # Return the number of iterations run for optimization
-      # @return [Integer]
-      attr_reader :n_iter
-
-      # Return the random generator.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new transformer with MLKR.
-      #
-      # @param n_components [Integer] The number of components.
-      # @param init [String] The initialization method for components ('random' or 'pca').
-      # @param max_iter [Integer] The maximum number of iterations.
-      # @param tol [Float] The tolerance of termination criterion.
-      #   This value is given as tol / Lbfgsb::DBL_EPSILON to the factr argument of Lbfgsb.minimize method.
-      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
-      #   If true is given, 'iterate.dat' file is generated by lbfgsb.rb.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_components: nil, init: 'random', max_iter: 100, tol: 1e-6, verbose: false, random_seed: nil)
-        check_params_numeric_or_nil(n_components: n_components, random_seed: random_seed)
-        check_params_numeric(max_iter: max_iter, tol: tol)
-        check_params_string(init: init)
-        check_params_boolean(verbose: verbose)
-        @params = {}
-        @params[:n_components] = n_components
-        @params[:init] = init
-        @params[:max_iter] = max_iter
-        @params[:tol] = tol
-        @params[:verbose] = verbose
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @components = nil
-        @n_iter = 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::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
-      # @return [MLKR] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_tvalue_array(y)
-        check_sample_tvalue_size(x, y)
-        n_features = x.shape[1]
-        n_components = if @params[:n_components].nil?
-                         n_features
-                       else
-                         [n_features, @params[:n_components]].min
-                       end
-        @components, @n_iter = optimize_components(x, y, n_features, n_components)
-        @prototypes = x.dot(@components.transpose)
-        @values = 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 model.
-      # @param y [Numo::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
-      def fit_transform(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_tvalue_array(y)
-        check_sample_tvalue_size(x, y)
-        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 model.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
-      def transform(x)
-        x = check_convert_sample_array(x)
-        x.dot(@components.transpose)
-      end
-
-      private
-
-      def init_components(x, n_features, n_components)
-        if @params[:init] == 'pca'
-          pca = Rumale::Decomposition::PCA.new(n_components: n_components)
-          pca.fit(x).components.flatten.dup
-        else
-          Rumale::Utils.rand_normal([n_features, n_components], @rng.dup).flatten.dup
-        end
-      end
-
-      def optimize_components(x, y, n_features, n_components)
-        # initialize components.
-        comp_init = init_components(x, n_features, n_components)
-        # initialize optimization results.
-        res = {}
-        res[:x] = comp_init
-        res[:n_iter] = 0
-        # perform optimization.
-        verbose = @params[:verbose] ? 1 : -1
-        res = Lbfgsb.minimize(
-          fnc: method(:mlkr_fnc), jcb: true, x_init: comp_init, args: [x, y],
-          maxiter: @params[:max_iter], factr: @params[:tol] / Lbfgsb::DBL_EPSILON, verbose: verbose
-        )
-        # return the results.
-        n_iter = res[:n_iter]
-        comps = n_components == 1 ? res[:x].dup : res[:x].reshape(n_components, n_features)
-        [comps, n_iter]
-      end
-
-      def mlkr_fnc(w, x, y)
-        # initialize some variables.
-        n_features = x.shape[1]
-        n_components = w.size / n_features
-        # projection.
-        w = w.reshape(n_components, n_features)
-        z = x.dot(w.transpose)
-        # predict values.
-        kernel_mat = Numo::NMath.exp(-Rumale::PairwiseMetric.squared_error(z))
-        kernel_mat[kernel_mat.diag_indices] = 0.0
-        norm = kernel_mat.sum(1)
-        norm[norm.eq(0)] = 1
-        y_pred = kernel_mat.dot(y) / norm
-        # calculate loss.
-        y_diff = y_pred - y
-        loss = (y_diff**2).sum
-        # calculate gradient.
-        weight_mat = y_diff * y_diff.expand_dims(1) * kernel_mat
-        weight_mat = weight_mat.sum(0).diag - weight_mat
-        gradient = 8 * z.transpose.dot(weight_mat).dot(x)
-        [loss, gradient.flatten.dup]
-      end
-    end
-  end
-end