svmkit 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 917f85878296b940b497f13253e3d3b03047be8f154d554116c2629aaeea55dd
-  data.tar.gz: 16308e4638b15a55843f15b4e0d97886f27aae0cc236c59c590a8f9fe7f0e5c6
+  metadata.gz: d8486463886064e5aa5169dbed20101a01d01101483226cf96e38b377144e153
+  data.tar.gz: 79807cdbe9f10fba17cd91dbcd68c713180fd986e9b6fab575a849c762bb0d2e
 SHA512:
-  metadata.gz: d390d3ef0d7b06676e6d3c34479939b4a99ee01472816eacbe49fd3f40224ef5984620dfe6d335fb5b15e7213d3b0d17ba9441766e7cdd08c8bad9bff669db8d
-  data.tar.gz: ab2239c0d1297e18e31940e763875ac24668d8c4c3f30355f06bc5ed305c247ff0328e1d584c5ab70ce77d4d2f946dcc5f72f1eb4c3a25d9b0dcd38e1d246182
+  metadata.gz: 2ec6c45c99bda82813644b7b4a043a4dda27810e24e10b4588182cbc3dea106eb05ac013354177861ab4abf552d89670ea1f0d39d50976a232feedc0daee9030
+  data.tar.gz: 373a566f294bab3d6fb232516f5720a877b6e20999c3253ae49044d759f83b06999fef4e259df91b950fe49c395042c1a74675fadb326460a7e65d54048ca325

data/HISTORY.md

@@ -1,3 +1,7 @@
+# 0.6.0
+- Add class for Principal Component Analysis.
+- Add class for Non-negative Matrix Factorization.
+
 # 0.5.2
 - Add class for DBSCAN clustering.
 

data/README.md

@@ -10,7 +10,8 @@ SVMKit provides machine learning algorithms with interfaces similar to Scikit-Le
 SVMKit currently supports Linear / Kernel Support Vector Machine,
 Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
 Naive Bayes, Decision Tree, Random Forest, K-nearest neighbor classifier,
-K-Means, DBSCAN and cross-validation.
+K-Means, DBSCAN, Principal Component Analysis, Non-negative Matrix Factorization
+and cross-validation.
 
 ## Installation
 

data/lib/svmkit.rb

@@ -39,6 +39,8 @@ require 'svmkit/ensemble/random_forest_classifier'
 require 'svmkit/ensemble/random_forest_regressor'
 require 'svmkit/clustering/k_means'
 require 'svmkit/clustering/dbscan'
+require 'svmkit/decomposition/pca'
+require 'svmkit/decomposition/nmf'
 require 'svmkit/preprocessing/l2_normalizer'
 require 'svmkit/preprocessing/min_max_scaler'
 require 'svmkit/preprocessing/standard_scaler'

data/lib/svmkit/decomposition/nmf.rb

@@ -0,0 +1,147 @@
+# 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

@@ -0,0 +1,150 @@
+# 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

data/lib/svmkit/version.rb

@@ -3,5 +3,5 @@
 # SVMKit is a machine learning library in Ruby.
 module SVMKit
   # @!visibility private
-  VERSION = '0.5.2'.freeze
+  VERSION = '0.6.0'.freeze
 end

data/svmkit.gemspec

@@ -18,7 +18,8 @@ SVMKit provides machine learning algorithms with interfaces similar to Scikit-Le
 SVMKit currently supports Linear / Kernel Support Vector Machine,
 Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
 Naive Bayes, Decision Tree, Random Forest, K-nearest neighbor algorithm,
-K-Means, DBSCAN and cross-validation.
+K-Means, DBSCAN, Principal Component Analysis, Non-negative Matrix Factorization
+and cross-validation.
 MSG
   spec.homepage      = 'https://github.com/yoshoku/svmkit'
   spec.license       = 'BSD-2-Clause'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: svmkit
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-23 00:00:00.000000000 Z
+date: 2018-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -86,7 +86,8 @@ description: |
   SVMKit currently supports Linear / Kernel Support Vector Machine,
   Logistic Regression, Linear Regression, Ridge, Lasso, Factorization Machine,
   Naive Bayes, Decision Tree, Random Forest, K-nearest neighbor algorithm,
-  K-Means, DBSCAN and cross-validation.
+  K-Means, DBSCAN, Principal Component Analysis, Non-negative Matrix Factorization
+  and cross-validation.
 email:
 - yoshoku@outlook.com
 executables: []
@@ -118,6 +119,8 @@ files:
 - lib/svmkit/clustering/dbscan.rb
 - lib/svmkit/clustering/k_means.rb
 - lib/svmkit/dataset.rb
+- lib/svmkit/decomposition/nmf.rb
+- lib/svmkit/decomposition/pca.rb
 - lib/svmkit/ensemble/random_forest_classifier.rb
 - lib/svmkit/ensemble/random_forest_regressor.rb
 - lib/svmkit/evaluation_measure/accuracy.rb