rumale 0.23.3 → 0.24.0

data/lib/rumale/feature_extraction/hash_vectorizer.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  # This module consists of the classes that extract features from raw data.
-  module FeatureExtraction
-    # Encode array of feature-value hash to vectors.
-    # This encoder turns array of mappings (Array<Hash>) with pairs of feature names and values into Numo::NArray.
-    #
-    # @example
-    #   encoder = Rumale::FeatureExtraction::HashVectorizer.new
-    #   x = encoder.fit_transform([
-    #     { foo: 1, bar: 2 },
-    #     { foo: 3, baz: 1 }
-    #   ])
-    #   # > pp x
-    #   # Numo::DFloat#shape=[2,3]
-    #   # [[2, 0, 1],
-    #   #  [0, 1, 3]]
-    #
-    #   x = encoder.fit_transform([
-    #     { city: 'Dubai',  temperature: 33 },
-    #     { city: 'London', temperature: 12 },
-    #     { city: 'San Francisco', temperature: 18 }
-    #   ])
-    #   # > pp x
-    #   # Numo::DFloat#shape=[3,4]
-    #   # [[1, 0, 0, 33],
-    #   #  [0, 1, 0, 12],
-    #   #  [0, 0, 1, 18]]
-    #   # > pp encoder.inverse_transform(x)
-    #   # [{:city=>"Dubai", :temperature=>33.0},
-    #   #  {:city=>"London", :temperature=>12.0},
-    #   #  {:city=>"San Francisco", :temperature=>18.0}]
-    class HashVectorizer
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the list of feature names.
-      # @return [Array] (size: [n_features])
-      attr_reader :feature_names
-
-      # Return the hash consisting of pairs of feature names and indices.
-      # @return [Hash] (size: [n_features])
-      attr_reader :vocabulary
-
-      # Create a new encoder for converting array of hash consisting of feature names and values to vectors.
-      #
-      # @param separator [String] The separator string used for constructing new feature names for categorical feature.
-      # @param sort [Boolean] The flag indicating whether to sort feature names.
-      def initialize(separator: '=', sort: true)
-        check_params_string(separator: separator)
-        check_params_boolean(sort: sort)
-        @params = {}
-        @params[:separator] = separator
-        @params[:sort] = sort
-      end
-
-      # Fit the encoder with given training data.
-      #
-      # @overload fit(x) -> HashVectorizer
-      #   @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
-      #   @return [HashVectorizer]
-      def fit(x, _y = nil)
-        @feature_names = []
-        @vocabulary = {}
-
-        x.each do |f|
-          f.each do |k, v|
-            k = "#{k}#{separator}#{v}".to_sym if v.is_a?(String)
-            next if @vocabulary.key?(k)
-
-            @feature_names.push(k)
-            @vocabulary[k] = @vocabulary.size
-          end
-        end
-
-        if sort_feature?
-          @feature_names.sort!
-          @feature_names.each_with_index { |k, i| @vocabulary[k] = i }
-        end
-
-        self
-      end
-
-      # Fit the encoder with given training data, then return encoded data.
-      #
-      # @overload fit_transform(x) -> Numo::DFloat
-      #   @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
-      #   @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
-      def fit_transform(x, _y = nil)
-        fit(x).transform(x)
-      end
-
-      # Encode given the array of feature-value hash.
-      #
-      # @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
-      # @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
-      def transform(x)
-        x = [x] unless x.is_a?(Array)
-        n_samples = x.size
-        n_features = @vocabulary.size
-        z = Numo::DFloat.zeros(n_samples, n_features)
-
-        x.each_with_index do |f, i|
-          f.each do |k, v|
-            if v.is_a?(String)
-              k = "#{k}#{separator}#{v}".to_sym
-              v = 1
-            end
-            z[i, @vocabulary[k]] = v if @vocabulary.key?(k)
-          end
-        end
-
-        z
-      end
-
-      # Decode sample matirx to the array of feature-value hash.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
-      # @return [Array<Hash>] The array of hash consisting of feature names and values.
-      def inverse_transform(x)
-        n_samples = x.shape[0]
-        reconst = []
-
-        n_samples.times do |i|
-          f = {}
-          x[i, true].each_with_index do |el, j|
-            feature_key_val(@feature_names[j], el).tap { |k, v| f[k.to_sym] = v } unless el.zero?
-          end
-          reconst.push(f)
-        end
-
-        reconst
-      end
-
-      private
-
-      def feature_key_val(fname, fval)
-        f = fname.to_s.split(separator)
-        f.size == 2 ? f : [fname, fval]
-      end
-
-      def separator
-        @params[:separator]
-      end
-
-      def sort_feature?
-        @params[:sort]
-      end
-    end
-  end
-end

data/lib/rumale/feature_extraction/tfidf_transformer.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-require 'rumale/preprocessing/l1_normalizer'
-require 'rumale/preprocessing/l2_normalizer'
-
-module Rumale
-  module FeatureExtraction
-    # Transform sample matrix with term frequecy (tf) to a normalized tf-idf (inverse document frequency) reprensentation.
-    #
-    # @example
-    #   encoder = Rumale::FeatureExtraction::HashVectorizer.new
-    #   x = encoder.fit_transform([
-    #     { foo: 1, bar: 2 },
-    #     { foo: 3, baz: 1 }
-    #   ])
-    #
-    #   # > pp x
-    #   # Numo::DFloat#shape=[2,3]
-    #   # [[2, 0, 1],
-    #   #  [0, 1, 3]]
-    #
-    #   transformer = Rumale::FeatureExtraction::TfidfTransformer.new
-    #   x_tfidf = transformer.fit_transform(x)
-    #
-    #   # > pp x_tfidf
-    #   # Numo::DFloat#shape=[2,3]
-    #   # [[0.959056, 0, 0.283217],
-    #   #  [0, 0.491506, 0.870874]]
-    #
-    # *Reference*
-    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
-    class TfidfTransformer
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the vector consists of inverse document frequency.
-      # @return [Numo::DFloat] (shape: [n_features])
-      attr_reader :idf
-
-      # Create a new transfomer for converting tf vectors to tf-idf vectors.
-      #
-      # @param norm [String] The normalization method to be used ('l1', 'l2' and 'none').
-      # @param use_idf [Boolean] The flag indicating whether to use inverse document frequency weighting.
-      # @param smooth_idf [Boolean] The flag indicating whether to apply idf smoothing by log((n_samples + 1) / (df + 1)) + 1.
-      # @param sublinear_tf [Boolean] The flag indicating whether to perform subliner tf scaling by 1 + log(tf).
-      def initialize(norm: 'l2', use_idf: true, smooth_idf: false, sublinear_tf: false)
-        check_params_string(norm: norm)
-        check_params_boolean(use_idf: use_idf, smooth_idf: smooth_idf, sublinear_tf: sublinear_tf)
-        @params = {}
-        @params[:norm] = norm
-        @params[:use_idf] = use_idf
-        @params[:smooth_idf] = smooth_idf
-        @params[:sublinear_tf] = sublinear_tf
-        @idf = nil
-      end
-
-      # Calculate the inverse document frequency for weighting.
-      #
-      # @overload fit(x) -> TfidfTransformer
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the idf values.
-      # @return [TfidfTransformer]
-      def fit(x, _y = nil)
-        return self unless @params[:use_idf]
-
-        x = check_convert_sample_array(x)
-
-        n_samples = x.shape[0]
-        df = x.class.cast(x.gt(0.0).count(0))
-
-        if @params[:smooth_idf]
-          df += 1
-          n_samples += 1
-        end
-
-        @idf = Numo::NMath.log(n_samples / df) + 1
-
-        self
-      end
-
-      # Calculate the idf values, and then transfrom samples to the tf-idf representation.
-      #
-      # @overload fit_transform(x) -> Numo::DFloat
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate idf and be transformed to tf-idf representation.
-      # @return [Numo::DFloat] The transformed samples.
-      def fit_transform(x, _y = nil)
-        fit(x).transform(x)
-      end
-
-      # Perform transforming the given samples to the tf-idf representation.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be transformed.
-      # @return [Numo::DFloat] The transformed samples.
-      def transform(x)
-        x = check_convert_sample_array(x)
-        z = x.dup
-
-        z[z.ne(0)] = Numo::NMath.log(z[z.ne(0)]) + 1 if @params[:sublinear_tf]
-        z *= @idf if @params[:use_idf]
-        case @params[:norm]
-        when 'l2'
-          z = Rumale::Preprocessing::L2Normalizer.new.fit_transform(z)
-        when 'l1'
-          z = Rumale::Preprocessing::L1Normalizer.new.fit_transform(z)
-        end
-        z
-      end
-    end
-  end
-end

data/lib/rumale/kernel_approximation/nystroem.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-require 'rumale/pairwise_metric'
-
-module Rumale
-  module KernelApproximation
-    # Nystroem is a class that implements feature mapping with Nystroem method.
-    #
-    # @example
-    #   require 'numo/linalg/autoloader'
-    #
-    #   transformer = Rumale::KernelApproximation::Nystroem.new(kernel: 'rbf', gamma: 1, n_components: 128, random_seed: 1)
-    #   new_training_samples = transformer.fit_transform(training_samples)
-    #   new_testing_samples = transformer.transform(testing_samples)
-    #
-    # *Reference*
-    # - Yang, T., Li, Y., Mahdavi, M., Jin, R., and Zhou, Z-H., "Nystrom Method vs Random Fourier Features: A Theoretical and Empirical Comparison," Advances in NIPS'12, Vol. 1, pp. 476--484, 2012.
-    class Nystroem
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Returns the randomly sampled training data for feature mapping.
-      # @return [Numo::DFloat] (shape: n_components, n_features])
-      attr_reader :components
-
-      # Returns the indices sampled training data.
-      # @return [Numo::Int32] (shape: [n_components])
-      attr_reader :component_indices
-
-      # Returns the normalizing factors.
-      # @return [Numo::DFloat] (shape: [n_components, n_components])
-      attr_reader :normalizer
-
-      # Return the random generator for transformation.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new transformer for mapping to kernel feature space with Nystrom method.
-      #
-      # @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.
-      # @param n_components [Integer] The number of dimensions of the kernel feature space.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(kernel: 'rbf', gamma: 1, degree: 3, coef: 1, n_components: 100, random_seed: nil)
-        check_params_string(kernel: kernel)
-        check_params_numeric(gamma: gamma, coef: coef, degree: degree, n_components: n_components)
-        check_params_numeric_or_nil(random_seed: random_seed)
-        @params = method(:initialize).parameters.map { |_t, arg| [arg, binding.local_variable_get(arg)] }.to_h
-        @params[:random_seed] ||= srand
-        @rng = Random.new(@params[:random_seed])
-        @component_indices = nil
-        @components = nil
-        @normalizer = nil
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> Nystroem
-      #   @param x [Numo::NArray] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @return [Nystroem] The learned transformer itself.
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-        raise 'Nystroem#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
-
-        # initialize some variables.
-        sub_rng = @rng.dup
-        n_samples = x.shape[0]
-        n_components = [1, [@params[:n_components], n_samples].min].max
-
-        # random sampling.
-        @component_indices = Numo::Int32.cast(Array(0...n_samples).shuffle(random: sub_rng)[0...n_components])
-        @components = x[@component_indices, true].dup
-
-        # calculate normalizing factor.
-        kernel_mat = kernel_mat(@components)
-        eig_vals, eig_vecs = Numo::Linalg.eigh(kernel_mat)
-        la = eig_vals.class.maximum(eig_vals.reverse, 1e-12)
-        u = eig_vecs.reverse(1)
-        @normalizer = u.dot((1.0 / Numo::NMath.sqrt(la)).diag)
-
-        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.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
-      def fit_transform(x, _y = nil)
-        x = check_convert_sample_array(x)
-        fit(x).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)
-        z = kernel_mat(x, @components)
-        z.dot(@normalizer)
-      end
-
-      private
-
-      def kernel_mat(x, y = nil)
-        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

data/lib/rumale/kernel_approximation/rbf.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/utils'
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  # Module for kernel approximation algorithms.
-  module KernelApproximation
-    # Class for RBF kernel feature mapping.
-    #
-    # @example
-    #   transformer = Rumale::KernelApproximation::RBF.new(gamma: 1.0, n_components: 128, random_seed: 1)
-    #   new_training_samples = transformer.fit_transform(training_samples)
-    #   new_testing_samples = transformer.transform(testing_samples)
-    #
-    # *Refernce*:
-    # - Rahimi, A., and Recht, B., "Random Features for Large-Scale Kernel Machines," Proc. NIPS'07, pp.1177--1184, 2007.
-    class RBF
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Return the random matrix for transformation.
-      # @return [Numo::DFloat] (shape: [n_features, n_components])
-      attr_reader :random_mat
-
-      # Return the random vector for transformation.
-      # @return [Numo::DFloat] (shape: [n_components])
-      attr_reader :random_vec
-
-      # Return the random generator for transformation.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new transformer for mapping to RBF kernel feature space.
-      #
-      # @param gamma [Float] The parameter of RBF kernel: exp(-gamma * x^2).
-      # @param n_components [Integer] The number of dimensions of the RBF kernel feature space.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(gamma: 1.0, n_components: 128, random_seed: nil)
-        check_params_numeric(gamma: gamma, n_components: n_components)
-        check_params_numeric_or_nil(random_seed: random_seed)
-        check_params_positive(gamma: gamma, n_components: n_components)
-        @params = {}
-        @params[:gamma] = gamma
-        @params[:n_components] = n_components
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @random_mat = nil
-        @random_vec = nil
-        @rng = Random.new(@params[:random_seed])
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> RBF
-      #
-      # @param x [Numo::NArray] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      #   This method uses only the number of features of the data.
-      # @return [RBF] The learned transformer itself.
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-
-        n_features = x.shape[1]
-        sub_rng = @rng.dup
-        @params[:n_components] = 2 * n_features if @params[:n_components] <= 0
-        @random_mat = Rumale::Utils.rand_normal([n_features, @params[:n_components]], sub_rng) * (2.0 * @params[:gamma])**0.5
-        n_half_components = @params[:n_components] / 2
-        @random_vec = Numo::DFloat.zeros(@params[:n_components] - n_half_components).concatenate(
-          Numo::DFloat.ones(n_half_components) * (0.5 * Math::PI)
-        )
-        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.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
-      def fit_transform(x, _y = nil)
-        x = check_convert_sample_array(x)
-
-        fit(x).transform(x)
-      end
-
-      # Transform the given data with the learned model.
-      #
-      # @overload transform(x) -> Numo::DFloat
-      #
-      # @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)
-
-        n_samples, = x.shape
-        projection = x.dot(@random_mat) + @random_vec.tile(n_samples, 1)
-        Numo::NMath.sin(projection) * ((2.0 / @params[:n_components])**0.5)
-      end
-    end
-  end
-end

data/lib/rumale/kernel_machine/kernel_fda.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module KernelMachine
-    # KernelFDA is a class that implements Kernel Fisher Discriminant Analysis.
-    #
-    # @example
-    #   require 'numo/linalg/autoloader'
-    #
-    #   kernel_mat_train = Rumale::PairwiseMetric::rbf_kernel(x_train)
-    #   kfda = Rumale::KernelMachine::KernelFDA.new
-    #   mapped_traininig_samples = kfda.fit_transform(kernel_mat_train, y)
-    #
-    #   kernel_mat_test = Rumale::PairwiseMetric::rbf_kernel(x_test, x_train)
-    #   mapped_test_samples = kfda.transform(kernel_mat_test)
-    #
-    # *Reference*
-    # - Baudat, G., and Anouar, F., "Generalized Discriminant Analysis using a Kernel Approach," Neural Computation, vol. 12, pp. 2385--2404, 2000.
-    class KernelFDA
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Returns the eigenvectors for embedding.
-      # @return [Numo::DFloat] (shape: [n_training_sampes, n_components])
-      attr_reader :alphas
-
-      # Create a new transformer with Kernel FDA.
-      #
-      # @param n_components [Integer] The number of components.
-      # @param reg_param [Float] The regularization parameter.
-      def initialize(n_components: nil, reg_param: 1e-8)
-        check_params_numeric_or_nil(n_components: n_components)
-        check_params_numeric(reg_param: reg_param)
-        @params = {}
-        @params[:n_components] = n_components
-        @params[:reg_param] = reg_param
-        @alphas = nil
-        @row_mean = nil
-        @all_mean = nil
-      end
-
-      # Fit the model with given training data.
-      # To execute this method, Numo::Linalg must be loaded.
-      #
-      # @param x [Numo::DFloat] (shape: [n_training_samples, n_training_samples])
-      #   The kernel matrix of 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 [KernelFDA] The learned transformer itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-        raise ArgumentError, 'Expect the kernel matrix of training data to be square.' unless x.shape[0] == x.shape[1]
-        raise 'KernelFDA#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
-
-        # initialize some variables.
-        n_samples = x.shape[0]
-        @classes = Numo::Int32[*y.to_a.uniq.sort]
-        n_classes = @classes.size
-        n_components = if @params[:n_components].nil?
-                         [n_samples, n_classes - 1].min
-                       else
-                         [n_samples, @params[:n_components]].min
-                       end
-
-        # centering
-        @row_mean = x.mean(0)
-        @all_mean = @row_mean.sum.fdiv(n_samples)
-        centered_kernel_mat = x - x.mean(1).expand_dims(1) - @row_mean + @all_mean
-
-        # calculate between and within scatter matrix.
-        class_mat = Numo::DFloat.zeros(n_samples, n_samples)
-        @classes.each do |label|
-          idx_vec = y.eq(label)
-          class_mat += Numo::DFloat.cast(idx_vec).outer(idx_vec) / idx_vec.count
-        end
-        between_mat = centered_kernel_mat.dot(class_mat).dot(centered_kernel_mat.transpose)
-        within_mat = centered_kernel_mat.dot(centered_kernel_mat.transpose) + @params[:reg_param] * Numo::DFloat.eye(n_samples)
-
-        # calculate projection matrix.
-        _, eig_vecs = Numo::Linalg.eigh(
-          between_mat, within_mat,
-          vals_range: (n_samples - n_components)...n_samples
-        )
-        @alphas = eig_vecs.reverse(1).dup
-        self
-      end
-
-      # Fit the model with training data, and then transform them with the learned model.
-      # To execute this method, Numo::Linalg must be loaded.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_samples])
-      #   The kernel matrix of the training data to be used for fitting the model and transformed.
-      # @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)
-        check_sample_label_size(x, y)
-        fit(x, y).transform(x)
-      end
-
-      # Transform the given data with the learned model.
-      #
-      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_training_samples])
-      #   The kernel matrix between testing samples and training samples to be transformed.
-      # @return [Numo::DFloat] (shape: [n_testing_samples, n_components]) The transformed data.
-      def transform(x)
-        x = check_convert_sample_array(x)
-        col_mean = x.sum(1) / @row_mean.shape[0]
-        centered_kernel_mat = x - col_mean.expand_dims(1) - @row_mean + @all_mean
-        transformed = centered_kernel_mat.dot(@alphas)
-        @params[:n_components] == 1 ? transformed[true, 0].dup : transformed
-      end
-    end
-  end
-end