rumale 0.23.3 → 0.24.0

data/lib/rumale/dataset.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-
-require 'csv'
-require 'rumale/validation'
-require 'rumale/utils'
-require 'rumale/preprocessing/min_max_scaler'
-
-module Rumale
-  # Module for loading and saving a dataset file.
-  module Dataset
-    class << self
-      # Load a dataset with the libsvm file format into Numo::NArray.
-      #
-      # @param filename [String] A path to a dataset file.
-      # @param n_features [Integer/Nil] The number of features of data to load.
-      #   If nil is given, it will be detected automatically from given file.
-      # @param zero_based [Boolean] Whether the column index starts from 0 (true) or 1 (false).
-      # @param dtype [Numo::NArray] Data type of Numo::NArray for features to be loaded.
-      #
-      # @return [Array<Numo::NArray>]
-      #   Returns array containing the (n_samples x n_features) matrix for feature vectors
-      #   and (n_samples) vector for labels or target values.
-      def load_libsvm_file(filename, n_features: nil, zero_based: false, dtype: Numo::DFloat)
-        ftvecs = []
-        labels = []
-        n_features_detected = 0
-        CSV.foreach(filename, col_sep: "\s", headers: false) do |line|
-          label, ftvec, max_idx = parse_libsvm_line(line, zero_based)
-          labels.push(label)
-          ftvecs.push(ftvec)
-          n_features_detected = max_idx if n_features_detected < max_idx
-        end
-        n_features ||= n_features_detected
-        n_features = [n_features, n_features_detected].max
-        [convert_to_matrix(ftvecs, n_features, dtype), Numo::NArray.asarray(labels)]
-      end
-
-      # Dump the dataset with the libsvm file format.
-      #
-      # @param data [Numo::NArray] (shape: [n_samples, n_features]) matrix consisting of feature vectors.
-      # @param labels [Numo::NArray] (shape: [n_samples]) matrix consisting of labels or target values.
-      # @param filename [String] A path to the output libsvm file.
-      # @param zero_based [Boolean] Whether the column index starts from 0 (true) or 1 (false).
-      def dump_libsvm_file(data, labels, filename, zero_based: false)
-        n_samples = [data.shape[0], labels.shape[0]].min
-        single_label = labels.shape[1].nil?
-        label_type = detect_dtype(labels)
-        value_type = detect_dtype(data)
-        File.open(filename, 'w') do |file|
-          n_samples.times do |n|
-            label = single_label ? labels[n] : labels[n, true].to_a
-            file.puts(dump_libsvm_line(label, data[n, true],
-                                       label_type, value_type, zero_based))
-          end
-        end
-      end
-
-      # Generate a two-dimensional data set consisting of an inner circle and an outer circle.
-      #
-      # @param n_samples [Integer] The number of samples.
-      # @param shuffle [Boolean] The flag indicating whether to shuffle the dataset
-      # @param noise [Float] The standard deviaion of gaussian noise added to the data.
-      #   If nil is given, no noise is added.
-      # @param factor [Float] The scale factor between inner and outer circles. The interval of factor is (0, 1).
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def make_circles(n_samples, shuffle: true, noise: nil, factor: 0.8, random_seed: nil)
-        Rumale::Validation.check_params_numeric(n_samples: n_samples, factor: factor)
-        Rumale::Validation.check_params_boolean(shuffle: shuffle)
-        Rumale::Validation.check_params_numeric_or_nil(noise: noise, random_seed: random_seed)
-        raise ArgumentError, 'The number of samples must be more than 2.' if n_samples <= 1
-        raise RangeError, 'The interval of factor is (0, 1).' if factor <= 0 || factor >= 1
-
-        # initialize some variables.
-        rs = random_seed
-        rs ||= srand
-        rng = Random.new(rs)
-        n_samples_out = n_samples.fdiv(2).to_i
-        n_samples_in = n_samples - n_samples_out
-        # make two circles.
-        linsp_out = Numo::DFloat.linspace(0, 2 * Math::PI, n_samples_out)
-        linsp_in = Numo::DFloat.linspace(0, 2 * Math::PI, n_samples_in)
-        circle_out = Numo::DFloat[Numo::NMath.cos(linsp_out), Numo::NMath.sin(linsp_out)].transpose
-        circle_in = Numo::DFloat[Numo::NMath.cos(linsp_in), Numo::NMath.sin(linsp_in)].transpose
-        x = Numo::DFloat.vstack([circle_out, factor * circle_in])
-        y = Numo::Int32.hstack([Numo::Int32.zeros(n_samples_out), Numo::Int32.ones(n_samples_in)])
-        # shuffle data indices.
-        if shuffle
-          rand_ids = Array(0...n_samples).shuffle(random: rng.dup)
-          x = x[rand_ids, true].dup
-          y = y[rand_ids].dup
-        end
-        # add gaussian noise.
-        x += Rumale::Utils.rand_normal(x.shape, rng.dup, 0.0, noise) unless noise.nil?
-        [x, y]
-      end
-
-      # Generate a two-dimensional data set consisting of two half circles shifted.
-      #
-      # @param n_samples [Integer] The number of samples.
-      # @param shuffle [Boolean] The flag indicating whether to shuffle the dataset
-      # @param noise [Float] The standard deviaion of gaussian noise added to the data.
-      #   If nil is given, no noise is added.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def make_moons(n_samples, shuffle: true, noise: nil, random_seed: nil)
-        Rumale::Validation.check_params_numeric(n_samples: n_samples)
-        Rumale::Validation.check_params_boolean(shuffle: shuffle)
-        Rumale::Validation.check_params_numeric_or_nil(noise: noise, random_seed: random_seed)
-        raise ArgumentError, 'The number of samples must be more than 2.' if n_samples <= 1
-
-        # initialize some variables.
-        rs = random_seed
-        rs ||= srand
-        rng = Random.new(rs)
-        n_samples_out = n_samples.fdiv(2).to_i
-        n_samples_in = n_samples - n_samples_out
-        # make two half circles.
-        linsp_out = Numo::DFloat.linspace(0, Math::PI, n_samples_out)
-        linsp_in = Numo::DFloat.linspace(0, Math::PI, n_samples_in)
-        circle_out = Numo::DFloat[Numo::NMath.cos(linsp_out), Numo::NMath.sin(linsp_out)].transpose
-        circle_in = Numo::DFloat[1 - Numo::NMath.cos(linsp_in), 1 - Numo::NMath.sin(linsp_in) - 0.5].transpose
-        x = Numo::DFloat.vstack([circle_out, circle_in])
-        y = Numo::Int32.hstack([Numo::Int32.zeros(n_samples_out), Numo::Int32.ones(n_samples_in)])
-        # shuffle data indices.
-        if shuffle
-          rand_ids = Array(0...n_samples).shuffle(random: rng.dup)
-          x = x[rand_ids, true].dup
-          y = y[rand_ids].dup
-        end
-        # add gaussian noise.
-        x += Rumale::Utils.rand_normal(x.shape, rng.dup, 0.0, noise) unless noise.nil?
-        [x, y]
-      end
-
-      # Generate Gaussian blobs.
-      #
-      # @param n_samples [Integer] The total number of samples.
-      # @param n_features [Integer] The number of features.
-      #   If "centers" parameter is given as a Numo::DFloat array, this parameter is ignored.
-      # @param centers [Integer/Numo::DFloat/Nil] The number of cluster centroids or the fixed cluster centroids.
-      #   If nil is given, the number of cluster centroids is set to 3.
-      # @param cluster_std [Float] The standard deviation of the clusters.
-      # @param center_box [Array] The bounding box for each cluster centroids.
-      #   If "centers" parameter is given as a Numo::DFloat array, this parameter is ignored.
-      # @param shuffle [Boolean] The flag indicating whether to shuffle the dataset
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def make_blobs(n_samples = 1000, n_features = 2,
-                     centers: nil, cluster_std: 1.0, center_box: [-10, 10], shuffle: true, random_seed: nil)
-        Rumale::Validation.check_params_numeric(n_samples: n_samples, n_features: n_features, cluster_std: cluster_std)
-        Rumale::Validation.check_params_type(Array, center_box: center_box)
-        Rumale::Validation.check_params_boolean(shuffle: shuffle)
-        Rumale::Validation.check_params_numeric_or_nil(random_seed: random_seed)
-        # initialize rng.
-        rs = random_seed
-        rs ||= srand
-        rng = Random.new(rs)
-        # initialize centers.
-        if centers.is_a?(Numo::DFloat)
-          n_centers = centers.shape[0]
-          n_features = centers.shape[1]
-        else
-          n_centers = centers.is_a?(Integer) ? centers : 3
-          center_min = center_box.first
-          center_max = center_box.last
-          centers = Rumale::Utils.rand_uniform([n_centers, n_features], rng)
-          normalizer = Rumale::Preprocessing::MinMaxScaler.new(feature_range: [center_min, center_max])
-          centers = normalizer.fit_transform(centers)
-        end
-        # generate blobs.
-        sz_cluster = [n_samples / n_centers] * n_centers
-        (n_samples % n_centers).times { |n| sz_cluster[n] += 1 }
-        x = Rumale::Utils.rand_normal([sz_cluster[0], n_features], rng, 0.0, cluster_std) + centers[0, true]
-        y = Numo::Int32.zeros(sz_cluster[0])
-        (1...n_centers).each do |n|
-          c = Rumale::Utils.rand_normal([sz_cluster[n], n_features], rng, 0.0, cluster_std) + centers[n, true]
-          x = Numo::DFloat.vstack([x, c])
-          y = y.concatenate(Numo::Int32.zeros(sz_cluster[n]) + n)
-        end
-        # shuffle data.
-        if shuffle
-          rand_ids = Array(0...n_samples).shuffle(random: rng.dup)
-          x = x[rand_ids, true].dup
-          y = y[rand_ids].dup
-        end
-        [x, y]
-      end
-
-      private
-
-      def parse_libsvm_line(line, zero_based)
-        label = parse_label(line.shift)
-        adj_idx = zero_based == false ? 1 : 0
-        max_idx = -1
-        ftvec = []
-        while (el = line.shift)
-          idx, val = el.split(':')
-          idx = idx.to_i - adj_idx
-          val = val.to_i.to_s == val ? val.to_i : val.to_f
-          max_idx = idx if max_idx < idx
-          ftvec.push([idx, val])
-        end
-        [label, ftvec, max_idx]
-      end
-
-      def parse_label(label)
-        lbl_arr = label.split(',').map { |lbl| lbl.to_i.to_s == lbl ? lbl.to_i : lbl.to_f }
-        lbl_arr.size > 1 ? lbl_arr : lbl_arr[0]
-      end
-
-      def convert_to_matrix(data, n_features, dtype)
-        mat = []
-        data.each do |ft|
-          vec = Array.new(n_features) { 0 }
-          ft.each { |el| vec[el[0]] = el[1] }
-          mat.push(vec)
-        end
-        dtype.asarray(mat)
-      end
-
-      def detect_dtype(data)
-        arr_type_str = Numo::NArray.array_type(data).to_s
-        type = '%s'
-        type = '%d' if ['Numo::Int8', 'Numo::Int16', 'Numo::Int32', 'Numo::Int64'].include?(arr_type_str)
-        type = '%d' if ['Numo::UInt8', 'Numo::UInt16', 'Numo::UInt32', 'Numo::UInt64'].include?(arr_type_str)
-        type = '%.10g' if ['Numo::SFloat', 'Numo::DFloat'].include?(arr_type_str)
-        type
-      end
-
-      def dump_libsvm_line(label, ftvec, label_type, value_type, zero_based)
-        line = dump_label(label, label_type.to_s)
-        ftvec.to_a.each_with_index do |val, n|
-          idx = n + (zero_based == false ? 1 : 0)
-          line += format(" %d:#{value_type}", idx, val) if val != 0
-        end
-        line
-      end
-
-      def dump_label(label, label_type_str)
-        if label.is_a?(Array)
-          label.map { |lbl| format(label_type_str, lbl) }.join(',')
-        else
-          format(label_type_str, label)
-        end
-      end
-    end
-  end
-end

data/lib/rumale/decomposition/factor_analysis.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-require 'rumale/utils'
-
-module Rumale
-  module Decomposition
-    # FactorAnalysis is a class that implements fator analysis with EM algorithm.
-    #
-    # @example
-    #   require 'numo/linalg/autoloader'
-    #   decomposer = Rumale::Decomposition::FactorAnalysis.new(n_components: 2)
-    #   representaion = decomposer.fit_transform(samples)
-    #
-    # *Reference*
-    # - Barber, D., "Bayesian Reasoning and Machine Learning," Cambridge University Press, 2012.
-    class FactorAnalysis
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Returns the mean vector.
-      # @return [Numo::DFloat] (shape: [n_features])
-      attr_reader :mean
-
-      # Returns the estimated noise variance for each feature.
-      # @return [Numo::DFloat] (shape: [n_features])
-      attr_reader :noise_variance
-
-      # Returns the components with maximum variance.
-      # @return [Numo::DFloat] (shape: [n_components, n_features])
-      attr_reader :components
-
-      # Returns the log likelihood at each iteration.
-      # @return [Numo::DFloat] (shape: [n_iter])
-      attr_reader :loglike
-
-      # Return the number of iterations run for optimization
-      # @return [Integer]
-      attr_reader :n_iter
-
-      # Create a new transformer with factor analysis.
-      #
-      # @param n_components [Integer] The number of components (dimensionality of latent space).
-      # @param max_iter [Integer] The maximum number of iterations.
-      # @param tol [Float/Nil] The tolerance of termination criterion for EM algorithm.
-      #   If nil is given, iterate EM steps up to the maximum number of iterations.
-      def initialize(n_components: 2, max_iter: 100, tol: 1e-8)
-        check_params_numeric(n_components: n_components, max_iter: max_iter)
-        check_params_numeric_or_nil(tol: tol)
-        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
-        @mean = nil
-        @noise_variance = nil
-        @components = nil
-        @loglike = nil
-        @n_iter = nil
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> FactorAnalysis
-      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @return [FactorAnalysis] The learned transformer itself.
-      def fit(x, _y = nil)
-        raise 'FactorAnalysis#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
-
-        # initialize some variables.
-        n_samples, n_features = x.shape
-        @mean = x.mean(0)
-        centered_x = x - @mean
-        cov_mat = centered_x.transpose.dot(centered_x) / n_samples
-        sample_vars = x.var(0)
-        sqrt_n_samples = Math.sqrt(n_samples)
-        @noise_variance = Numo::DFloat.ones(n_features)
-
-        # run optimization.
-        old_loglike = 0.0
-        @n_iter = 0
-        @loglike = [] unless @params[:tol].nil?
-        @params[:max_iter].times do |t|
-          @n_iter = t + 1
-          sqrt_noise_variance = Numo::NMath.sqrt(@noise_variance)
-          scaled_x = centered_x / (sqrt_noise_variance * sqrt_n_samples + 1e-12)
-          s, u = truncate_svd(scaled_x, @params[:n_components])
-          scaler = Numo::NMath.sqrt(Numo::DFloat.maximum(s**2 - 1.0, 0.0))
-          @components = (sqrt_noise_variance.diag.dot(u) * scaler).transpose.dup
-          @noise_variance = Numo::DFloat.maximum(sample_vars - @components.transpose.dot(@components).diagonal, 1e-12)
-          next if @params[:tol].nil?
-
-          new_loglike = log_likelihood(cov_mat, @components, @noise_variance)
-          @loglike.push(new_loglike)
-          break if (old_loglike - new_loglike).abs <= @params[:tol]
-
-          old_loglike = new_loglike
-        end
-
-        @loglike = Numo::DFloat.cast(@loglike) unless @params[:tol].nil?
-        @components = @components[0, true].dup if @params[:n_components] == 1
-        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)
-        raise 'FactorAnalysis#fit_transform requires Numo::Linalg but that is not loaded.' unless enable_linalg?
-
-        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)
-        raise 'FactorAnalysis#transform requires Numo::Linalg but that is not loaded.' unless enable_linalg?
-
-        factors = @params[:n_components] == 1 ? @components.expand_dims(0) : @components
-        centered_x = x - @mean
-        beta = Numo::Linalg.inv(Numo::DFloat.eye(factors.shape[0]) + (factors / @noise_variance).dot(factors.transpose))
-        z = centered_x.dot((beta.dot(factors) / @noise_variance).transpose)
-        @params[:n_components] == 1 ? z[true, 0].dup : z
-      end
-
-      private
-
-      def log_likelihood(cov_mat, factors, noise_vars)
-        n_samples = noise_vars.size
-        fact_cov_mat = factors.transpose.dot(factors) + noise_vars.diag
-        n_samples.fdiv(2) * Math.log(Numo::Linalg.det(fact_cov_mat)) + Numo::Linalg.inv(fact_cov_mat).dot(cov_mat).trace
-      end
-
-      def truncate_svd(x, k)
-        m = x.shape[1]
-        eig_vals, eig_vecs = Numo::Linalg.eigh(x.transpose.dot(x), vals_range: (m - k)...m)
-        s = Numo::NMath.sqrt(eig_vals.reverse.dup)
-        u = eig_vecs.reverse(1).dup
-        [s, u]
-      end
-    end
-  end
-end

data/lib/rumale/decomposition/fast_ica.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module Decomposition
-    # FastICA is a class that implments Fast Independent Component Analaysis.
-    #
-    # @example
-    #   require 'numo/linalg/autoloader'
-    #
-    #   transformer = Rumale::Decomposition::FastICA.new(n_components: 2, random_seed: 1)
-    #   source_data = transformer.fit_transform(observed_data)
-    #
-    # *Reference*
-    # - Hyvarinen, A., "Fast and Robust Fixed-Point Algorithms for Independent Component Analysis," IEEE Trans. Neural Networks, Vol. 10 (3), pp. 626--634, 1999.
-    # - Hyvarinen, A., and Oja, E., "Independent Component Analysis: Algorithms and Applications," Neural Networks, Vol. 13 (4-5), pp. 411--430, 2000.
-    class FastICA
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Returns the unmixing matrix.
-      # @return [Numo::DFloat] (shape: [n_components, n_features])
-      attr_reader :components
-
-      # Returns the mixing matrix.
-      # @return [Numo::DFloat] (shape: [n_features, n_components])
-      attr_reader :mixing
-
-      # Returns the number of iterations when converged.
-      # @return [Integer]
-      attr_reader :n_iter
-
-      # Return the random generator.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new transformer with FastICA.
-      #
-      # @param n_components [Integer] The number of independent components.
-      # @param whiten [Boolean] The flag indicating whether to perform whitening.
-      # @param fun [String] The type of contrast function ('logcosh', 'exp', or 'cube').
-      # @param alpha [Float] The parameter of contrast function for 'logcosh' and 'exp'.
-      #   If fun = 'cube', this parameter is ignored.
-      # @param max_iter [Integer] The maximum number of iterations.
-      # @param tol [Float] The tolerance of termination criterion.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_components: 2, whiten: true, fun: 'logcosh', alpha: 1.0, max_iter: 200, tol: 1e-4, random_seed: nil)
-        check_params_numeric(n_components: n_components, max_iter: max_iter, alpha: alpha, tol: tol)
-        check_params_boolean(whiten: whiten)
-        check_params_string(fun: fun)
-        check_params_numeric_or_nil(random_seed: random_seed)
-        check_params_positive(n_components: n_components, max_iter: max_iter, tol: tol)
-        @params = {}
-        @params[:n_components] = n_components
-        @params[:whiten] = whiten
-        @params[:fun] = fun
-        @params[:alpha] = alpha
-        @params[:max_iter] = max_iter
-        @params[:tol] = tol
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @components = nil
-        @mixing = nil
-        @n_iter = nil
-        @mean = nil
-        @rng = Random.new(@params[:random_seed])
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> FastICA
-      #   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @return [FastICA] The learned transformer itself.
-      def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
-        raise 'FastICA#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
-
-        @mean, whiten_mat = whitening(x, @params[:n_components]) if @params[:whiten]
-        wx = @params[:whiten] ? (x - @mean).dot(whiten_mat.transpose) : x
-        unmixing, @n_iter = ica(wx, @params[:fun], @params[:max_iter], @params[:tol], @rng.dup)
-        @components = @params[:whiten] ? unmixing.dot(whiten_mat) : unmixing
-        @mixing = Numo::Linalg.pinv(@components).dup
-        if @params[:n_components] == 1
-          @components = @components.flatten.dup
-          @mixing = @mixing.flatten.dup
-        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.
-      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data
-      def fit_transform(x, _y = nil)
-        x = check_convert_sample_array(x)
-        raise 'FastICA#fit_transform requires Numo::Linalg but that is not loaded.' unless enable_linalg?
-
-        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)
-        cx = @params[:whiten] ? (x - @mean) : x
-        cx.dot(@components.transpose)
-      end
-
-      # Inverse transform the given transformed data with the learned model.
-      #
-      # @param z [Numo::DFloat] (shape: [n_samples, n_components]) The source data reconstructed to the mixed data.
-      # @return [Numo::DFloat] (shape: [n_samples, n_featuress]) The mixed data.
-      def inverse_transform(z)
-        z = check_convert_sample_array(z)
-        m = @mixing.shape[1].nil? ? @mixing.expand_dims(0).transpose : @mixing
-        x = z.dot(m.transpose)
-        x += @mean if @params[:whiten]
-        x
-      end
-
-      private
-
-      def whitening(x, n_components)
-        n_samples, n_features = x.shape
-        mean_vec = x.mean(0)
-        centered_x = x - mean_vec
-        covar_mat = centered_x.transpose.dot(centered_x) / n_samples
-        eig_vals, eig_vecs = Numo::Linalg.eigh(covar_mat, vals_range: (n_features - n_components)...n_features)
-        [mean_vec, (eig_vecs.reverse(1).dup * (1 / Numo::NMath.sqrt(eig_vals.reverse.dup))).transpose.dup]
-      end
-
-      def ica(x, fun, max_iter, tol, sub_rng)
-        n_samples, n_components = x.shape
-        w = decorrelation(Rumale::Utils.rand_normal([n_components, n_components], sub_rng))
-        n_iters = 0
-        max_iter.times do |t|
-          n_iters = t + 1
-          gx, ggx = gradient(x.dot(w.transpose), fun)
-          new_w = decorrelation(gx.transpose.dot(x) / n_samples - w * ggx / n_samples)
-          err = (new_w - w).abs.max
-          w = new_w
-          break if err <= tol
-        end
-        [w, n_iters]
-      end
-
-      def decorrelation(w)
-        eig_vals, eig_vecs = Numo::Linalg.eigh(w.dot(w.transpose))
-        decorr_mat = (eig_vecs * (1 / Numo::NMath.sqrt(eig_vals))).dot(eig_vecs.transpose)
-        decorr_mat.dot(w)
-      end
-
-      def gradient(x, func)
-        case func
-        when 'exp'
-          grad_exp(x, @params[:alpha])
-        when 'cube'
-          grad_cube(x)
-        else
-          grad_logcosh(x, @params[:alpha])
-        end
-      end
-
-      def grad_logcosh(x, alpha)
-        gx = Numo::NMath.tanh(alpha * x)
-        ggx = (alpha * (1 - gx**2)).sum(0)
-        [gx, ggx]
-      end
-
-      def grad_exp(x, alpha)
-        squared_x = x**2
-        exp_x = Numo::NMath.exp(-0.5 * alpha * squared_x)
-        gx = exp_x * x
-        ggx = (exp_x * (1 - alpha * squared_x)).sum(0)
-        [gx, ggx]
-      end
-
-      def grad_cube(x)
-        [x**3, (3 * x**2).sum(0)]
-      end
-    end
-  end
-end