svmkit 0.7.3 → 0.8.1

data/lib/svmkit/clustering/k_means.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'svmkit/validation'
-require 'svmkit/base/base_estimator'
-require 'svmkit/base/cluster_analyzer'
-require 'svmkit/pairwise_metric'
-
-module SVMKit
-  # This module consists of classes that implement cluster analysis methods.
-  module Clustering
-    # KMeans is a class that implements K-Means cluster analysis.
-    # The current implementation uses the Euclidean distance for analyzing the clusters.
-    #
-    # @example
-    #   analyzer = SVMKit::Clustering::KMeans.new(n_clusters: 10, max_iter: 50)
-    #   cluster_labels = analyzer.fit_predict(samples)
-    #
-    # *Reference*
-    # - D. Arthur and S. Vassilvitskii, "k-means++: the advantages of careful seeding," Proc. SODA'07, pp. 1027--1035, 2007.
-    class KMeans
-      include Base::BaseEstimator
-      include Base::ClusterAnalyzer
-      include Validation
-
-      # Return the centroids.
-      # @return [Numo::DFloat] (shape: [n_clusters, n_features])
-      attr_reader :cluster_centers
-
-      # Return the random generator.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new cluster analyzer with K-Means method.
-      #
-      # @param n_clusters [Integer] The number of clusters.
-      # @param init [String] The initialization method for centroids ('random' or 'k-means++').
-      # @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_clusters: 8, init: 'k-means++', max_iter: 50, tol: 1.0e-4, random_seed: nil)
-        check_params_integer(n_clusters: n_clusters, max_iter: max_iter)
-        check_params_float(tol: tol)
-        check_params_string(init: init)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
-        check_params_positive(n_clusters: n_clusters, max_iter: max_iter)
-        @params = {}
-        @params[:n_clusters] = n_clusters
-        @params[:init] = init == 'random' ? 'random' : 'k-means++'
-        @params[:max_iter] = max_iter
-        @params[:tol] = tol
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @cluster_centers = nil
-        @rng = Random.new(@params[:random_seed])
-      end
-
-      # Analysis clusters with given training data.
-      #
-      # @overload fit(x) -> KMeans
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
-      # @return [KMeans] The learned cluster analyzer itself.
-      def fit(x, _y = nil)
-        check_sample_array(x)
-        init_cluster_centers(x)
-        @params[:max_iter].times do |_t|
-          cluster_labels = assign_cluster(x)
-          old_centers = @cluster_centers.dup
-          @params[:n_clusters].times do |n|
-            assigned_bits = cluster_labels.eq(n)
-            @cluster_centers[n, true] = x[assigned_bits.where, true].mean(axis: 0) if assigned_bits.count > 0
-          end
-          error = Numo::NMath.sqrt(((old_centers - @cluster_centers)**2).sum(axis: 1)).mean
-          break if error <= @params[:tol]
-        end
-        self
-      end
-
-      # Predict cluster labels for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the cluster label.
-      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
-      def predict(x)
-        check_sample_array(x)
-        assign_cluster(x)
-      end
-
-      # Analysis clusters and assign samples to clusters.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for cluster analysis.
-      # @return [Numo::Int32] (shape: [n_samples]) Predicted cluster label per sample.
-      def fit_predict(x)
-        check_sample_array(x)
-        fit(x)
-        predict(x)
-      end
-
-      # Dump marshal data.
-      # @return [Hash] The marshal data.
-      def marshal_dump
-        { params: @params,
-          cluster_centers: @cluster_centers,
-          rng: @rng }
-      end
-
-      # Load marshal data.
-      # @return [nil]
-      def marshal_load(obj)
-        @params = obj[:params]
-        @cluster_centers = obj[:cluster_centers]
-        @rng = obj[:rng]
-        nil
-      end
-
-      private
-
-      def assign_cluster(x)
-        distance_matrix = PairwiseMetric.euclidean_distance(x, @cluster_centers)
-        distance_matrix.min_index(axis: 1) - Numo::Int32[*0.step(distance_matrix.size - 1, @cluster_centers.shape[0])]
-      end
-
-      def init_cluster_centers(x)
-        # random initialize
-        n_samples = x.shape[0]
-        rand_id = [*0...n_samples].sample(@params[:n_clusters], random: @rng)
-        @cluster_centers = x[rand_id, true].dup
-        return unless @params[:init] == 'k-means++'
-        # k-means++ initialize
-        (1...@params[:n_clusters]).each do |n|
-          distance_matrix = PairwiseMetric.euclidean_distance(x, @cluster_centers[0...n, true])
-          min_distances = distance_matrix.flatten[distance_matrix.min_index(axis: 1)]
-          probs = min_distances**2 / (min_distances**2).sum
-          cum_probs = probs.cumsum
-          selected_id = cum_probs.gt(@rng.rand).where.to_a.first
-          @cluster_centers[n, true] = x[selected_id, true].dup
-        end
-      end
-    end
-  end
-end

data/lib/svmkit/dataset.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require 'csv'
-
-module SVMKit
-  # 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 zero_based [Boolean] Whether the column index starts from 0 (true) or 1 (false).
-      #
-      # @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, zero_based: false)
-        ftvecs = []
-        labels = []
-        n_features = 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 = max_idx if n_features < max_idx
-        end
-        [convert_to_matrix(ftvecs, n_features), 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
-
-      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)
-        mat = []
-        data.each do |ft|
-          vec = Array.new(n_features) { 0 }
-          ft.each { |el| vec[el[0]] = el[1] }
-          mat.push(vec)
-        end
-        Numo::NArray.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.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/svmkit/decomposition/nmf.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'svmkit/validation'
-require 'svmkit/base/base_estimator'
-require 'svmkit/base/transformer'
-
-module SVMKit
-  module Decomposition
-    # NMF is a class that implements Non-negative Matrix Factorization.
-    #
-    # @example
-    #   decomposer = SVMKit::Decomposition::NMF.new(n_components: 2)
-    #   representaion = decomposer.fit_transform(samples)
-    #
-    # *Reference*
-    # - W. Xu, X. Liu, and Y.Gong, "Document Clustering Based On Non-negative Matrix Factorization," Proc. SIGIR' 03 , pp. 267--273, 2003.
-    class NMF
-      include Base::BaseEstimator
-      include Base::Transformer
-      include Validation
-
-      # Returns the factorization matrix.
-      # @return [Numo::DFloat] (shape: [n_components, n_features])
-      attr_reader :components
-
-      # Return the random generator.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new transformer with NMF.
-      #
-      # @param n_components [Integer] The number of components.
-      # @param max_iter [Integer] The maximum number of iterations.
-      # @param tol [Float] The tolerance of termination criterion.
-      # @param eps [Float] A small value close to zero to avoid zero division error.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_components: 2, max_iter: 500, tol: 1.0e-4, eps: 1.0e-16, random_seed: nil)
-        check_params_integer(n_components: n_components, max_iter: max_iter)
-        check_params_float(tol: tol, eps: eps)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
-        check_params_positive(n_components: n_components, max_iter: max_iter, tol: tol, eps: eps)
-        @params = {}
-        @params[:n_components] = n_components
-        @params[:max_iter] = max_iter
-        @params[:tol] = tol
-        @params[:eps] = eps
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @components = nil
-        @rng = Random.new(@params[:random_seed])
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> NMF
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @return [NMF] The learned transformer itself.
-      def fit(x, _y = nil)
-        check_sample_array(x)
-        partial_fit(x)
-        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)
-        check_sample_array(x)
-        partial_fit(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)
-        check_sample_array(x)
-        partial_fit(x, false)
-      end
-
-      # Inverse transform the given transformed data with the learned model.
-      #
-      # @param z [Numo::DFloat] (shape: [n_samples, n_components]) The data to be restored into original space with the learned model.
-      # @return [Numo::DFloat] (shape: [n_samples, n_featuress]) The restored data.
-      def inverse_transform(z)
-        check_sample_array(z)
-        z.dot(@components)
-      end
-
-      # Dump marshal data.
-      # @return [Hash] The marshal data.
-      def marshal_dump
-        { params: @params,
-          components: @components,
-          rng: @rng }
-      end
-
-      # Load marshal data.
-      # @return [nil]
-      def marshal_load(obj)
-        @params = obj[:params]
-        @components = obj[:components]
-        @rng = obj[:rng]
-        nil
-      end
-
-      private
-
-      def partial_fit(x, update_comps = true)
-        # initialize some variables.
-        n_samples, n_features = x.shape
-        scale = Math.sqrt(x.mean / @params[:n_components])
-        @components = rand_uniform([@params[:n_components], n_features]) * scale if update_comps
-        coefficients = rand_uniform([n_samples, @params[:n_components]]) * scale
-        # optimization.
-        @params[:max_iter].times do
-          # update
-          if update_comps
-            nume = coefficients.transpose.dot(x)
-            deno = coefficients.transpose.dot(coefficients).dot(@components) + @params[:eps]
-            @components *= (nume / deno)
-          end
-          nume = x.dot(@components.transpose)
-          deno = coefficients.dot(@components).dot(@components.transpose) + @params[:eps]
-          coefficients *= (nume / deno)
-          # normalize
-          norm = Numo::NMath.sqrt((@components**2).sum(1)) + @params[:eps]
-          @components /= norm.expand_dims(1) if update_comps
-          coefficients *= norm
-          # check convergence
-          err = ((x - coefficients.dot(@components))**2).sum(1).mean
-          break if err < @params[:tol]
-        end
-        coefficients
-      end
-
-      def rand_uniform(shape)
-        rnd_vals = Array.new(shape.inject(:*)) { @rng.rand }
-        Numo::DFloat.asarray(rnd_vals).reshape(shape[0], shape[1])
-      end
-    end
-  end
-end

data/lib/svmkit/decomposition/pca.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'svmkit/validation'
-require 'svmkit/base/base_estimator'
-require 'svmkit/base/transformer'
-
-module SVMKit
-  # Module for matrix decomposition algorithms.
-  module Decomposition
-    # PCA is a class that implements Principal Component Analysis.
-    #
-    # @example
-    #   decomposer = SVMKit::Decomposition::PCA.new(n_components: 2)
-    #   representaion = decomposer.fit_transform(samples)
-    #
-    # *Reference*
-    # - A. Sharma and K K. Paliwal, "Fast principal component analysis using fixed-point algorithm," Pattern Recognition Letters, 28, pp. 1151--1155, 2007.
-    class PCA
-      include Base::BaseEstimator
-      include Base::Transformer
-      include Validation
-
-      # Returns the principal components.
-      # @return [Numo::DFloat] (shape: [n_components, n_features])
-      attr_reader :components
-
-      # Returns the mean vector.
-      # @return [Numo::DFloat] (shape: [n_features]
-      attr_reader :mean
-
-      # Return the random generator.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new transformer with PCA.
-      #
-      # @param n_components [Integer] The number of principal components.
-      # @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, max_iter: 100, tol: 1.0e-4, random_seed: nil)
-        check_params_integer(n_components: n_components, max_iter: max_iter)
-        check_params_float(tol: tol)
-        check_params_type_or_nil(Integer, random_seed: random_seed)
-        check_params_positive(n_components: n_components, max_iter: max_iter, tol: tol)
-        @params = {}
-        @params[:n_components] = n_components
-        @params[:max_iter] = max_iter
-        @params[:tol] = tol
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @components = nil
-        @mean = nil
-        @rng = Random.new(@params[:random_seed])
-      end
-
-      # Fit the model with given training data.
-      #
-      # @overload fit(x) -> PCA
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
-      # @return [PCA] The learned transformer itself.
-      def fit(x, _y = nil)
-        check_sample_array(x)
-        # initialize some variables.
-        @components = nil
-        n_samples, n_features = x.shape
-        # centering.
-        @mean = x.mean(0)
-        centered_x = x - @mean
-        # optimization.
-        covariance_mat = centered_x.transpose.dot(centered_x) / (n_samples - 1)
-        @params[:n_components].times do
-          comp_vec = random_vec(n_features)
-          @params[:max_iter].times do
-            updated = orthogonalize(covariance_mat.dot(comp_vec))
-            break if (updated.dot(comp_vec) - 1).abs < @params[:tol]
-            comp_vec = updated
-          end
-          @components = @components.nil? ? comp_vec : Numo::NArray.vstack([@components, comp_vec])
-        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)
-        check_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)
-        check_sample_array(x)
-        (x - @mean).dot(@components.transpose)
-      end
-
-      # Inverse transform the given transformed data with the learned model.
-      #
-      # @param z [Numo::DFloat] (shape: [n_samples, n_components]) The data to be restored into original space with the learned model.
-      # @return [Numo::DFloat] (shape: [n_samples, n_featuress]) The restored data.
-      def inverse_transform(z)
-        check_sample_array(z)
-        c = @components.shape[1].nil? ? @components.expand_dims(0) : @components
-        z.dot(c) + @mean
-      end
-
-      # Dump marshal data.
-      # @return [Hash] The marshal data.
-      def marshal_dump
-        { params: @params,
-          components: @components,
-          mean: @mean,
-          rng: @rng }
-      end
-
-      # Load marshal data.
-      # @return [nil]
-      def marshal_load(obj)
-        @params = obj[:params]
-        @components = obj[:components]
-        @mean = obj[:mean]
-        @rng = obj[:rng]
-        nil
-      end
-
-      private
-
-      def orthogonalize(pcvec)
-        unless @components.nil?
-          delta = @components.dot(pcvec) * @components.transpose
-          delta = delta.sum(1) unless delta.shape[1].nil?
-          pcvec -= delta
-        end
-        pcvec / Math.sqrt((pcvec**2).sum.abs) + 1.0e-12
-      end
-
-      def random_vec(n_features)
-        Numo::DFloat[*(Array.new(n_features) { @rng.rand })]
-      end
-    end
-  end
-end