rumale 0.22.4 → 0.22.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4936b7c7b0ed920383f88743f8eba2e827d586dae471e40a6974dd1fe19342fe
-  data.tar.gz: 5a33c242b3cd881b0003db5e5f2d77905d0571442eb7494a64dff08262ce0c14
+  metadata.gz: '058078489d3ff66d67432e1418ae786292c263e05e75b6703fb5a7e65e88bd46'
+  data.tar.gz: bd7ed9b223e0cd0074ffdd3e521b01c195f82909013c93f4736ab338d5920c96
 SHA512:
-  metadata.gz: b45a243c247610d918eeb6cfbb31c461e5773b5404c989fe7e0b8758e0482d165ea1e0cf1d61642d71233458821e1b92e45eb6ff0d0fcb11080c6c1e9692ef91
-  data.tar.gz: feddfc807995b08e753b1ad635901f2db8e806e300478a1f6bdb24a5bf1123cb7fbd0ee402da92ddcdd079a8ad653eec4224e22be9d2c6609ea73ea84bc47ca1
+  metadata.gz: 79ce4715a503b1b5a618526832adad5912daac72af3e8f1892ff2df14b7695e546419d6f85e5ea735abd2ea06da649a763f96c82b95eee75341934fa65fce93e
+  data.tar.gz: 5948583ec6c5ca10b320e09c447f9cc1e244dd3bfbf95800338dba2eb7e1b46a342d44020fa24c26a7161786feb63c82b0677654e4aa087c311337a606880a22

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.22.5
+- Add transformer class for calculating kernel matrix.
+  - [KernelCalculator](https://yoshoku.github.io/rumale/doc/Rumale/Preprocessing/KernelCalculator.html)
+- Add classifier class based on Ridge regression.
+  - [KernelRidgeClassifier](https://yoshoku.github.io/rumale/doc/Rumale/KernelMachine/KernelRidgeClassifier.html)
+- Add supported kernel functions to [Nystroem](https://yoshoku.github.io/rumale/doc/Rumale/KernelApproximation/Nystroem.html).
+- Add parameter for specifying the number of features to [load_libsvm_file](https://yoshoku.github.io/rumale/doc/Rumale/Dataset.html#load_libsvm_file-class_method).
+
 # 0.22.4
 - Add classifier and regressor classes for voting ensemble method.
   - [VotingClassifier](https://yoshoku.github.io/rumale/doc/Rumale/Ensemble/VotingClassifier.html)

data/lib/rumale.rb

@@ -35,6 +35,7 @@ require 'rumale/kernel_machine/kernel_svc'
 require 'rumale/kernel_machine/kernel_pca'
 require 'rumale/kernel_machine/kernel_fda'
 require 'rumale/kernel_machine/kernel_ridge'
+require 'rumale/kernel_machine/kernel_ridge_classifier'
 require 'rumale/multiclass/one_vs_rest_classifier'
 require 'rumale/nearest_neighbors/vp_tree'
 require 'rumale/nearest_neighbors/k_neighbors_classifier'
@@ -103,6 +104,7 @@ require 'rumale/preprocessing/one_hot_encoder'
 require 'rumale/preprocessing/ordinal_encoder'
 require 'rumale/preprocessing/binarizer'
 require 'rumale/preprocessing/polynomial_features'
+require 'rumale/preprocessing/kernel_calculator'
 require 'rumale/model_selection/k_fold'
 require 'rumale/model_selection/group_k_fold'
 require 'rumale/model_selection/stratified_k_fold'

data/lib/rumale/dataset.rb

@@ -12,22 +12,26 @@ module Rumale
       # 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, zero_based: false, dtype: Numo::DFloat)
+      def load_libsvm_file(filename, n_features: nil, zero_based: false, dtype: Numo::DFloat)
         ftvecs = []
         labels = []
-        n_features = 0
+        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 = max_idx if n_features < max_idx
+          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
 

data/lib/rumale/kernel_approximation/nystroem.rb

@@ -11,7 +11,7 @@ module Rumale
     # @example
     #   require 'numo/linalg/autoloader'
     #
-    #   transformer = Rumale::KernelApproximation::Nystroem.new(gamma: 1, n_components: 128, random_seed: 1)
+    #   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)
     #
@@ -39,12 +39,15 @@ module Rumale
 
       # Create a new transformer for mapping to kernel feature space with Nystrom method.
       #
-      # @param kernel [String] The type of kernel. This parameter is ignored in the current implementation.
-      # @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 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, n_components: 100, random_seed: nil)
-        check_params_numeric(gamma: gamma, n_components: n_components)
+      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
@@ -56,7 +59,7 @@ module Rumale
 
       # Fit the model with given training data.
       #
-      # @overload fit(x) -> RBF
+      # @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)
@@ -73,7 +76,7 @@ module Rumale
         @components = x[@component_indices, true]
 
         # calculate normalizing factor.
-        kernel_mat = Rumale::PairwiseMetric.rbf_kernel(@components, nil, @params[:gamma])
+        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)
@@ -98,9 +101,26 @@ module Rumale
       # @return [Numo::DFloat] (shape: [n_samples, n_components]) The transformed data.
       def transform(x)
         x = check_convert_sample_array(x)
-        z = Rumale::PairwiseMetric.rbf_kernel(x, @components, @params[:gamma])
+        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_machine/kernel_ridge_classifier.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/classifier'
+require 'rumale/preprocessing/label_binarizer'
+
+module Rumale
+  module KernelMachine
+    # KernelRidgeClassifier is a class that implements classifier based-on kernel ridge regression.
+    # It learns a classifier by converting labels to target values { -1, 1 } and performing kernel ridge regression.
+    #
+    # @example
+    #   require 'numo/linalg/autoloader'
+    #   require 'rumale'
+    #
+    #   kernel_mat_train = Rumale::PairwiseMetric::rbf_kernel(training_samples)
+    #   kridge = Rumale::KernelMachine::KernelRidgeClassifier.new(reg_param: 0.5)
+    #   kridge.fit(kernel_mat_train, traininig_values)
+    #
+    #   kernel_mat_test = Rumale::PairwiseMetric::rbf_kernel(test_samples, training_samples)
+    #   results = kridge.predict(kernel_mat_test)
+    class KernelRidgeClassifier
+      include Base::BaseEstimator
+      include Base::Classifier
+
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the weight vector.
+      # @return [Numo::DFloat] (shape: [n_training_sample, n_classes])
+      attr_reader :weight_vec
+
+      # Create a new regressor with kernel ridge classifier.
+      #
+      # @param reg_param [Float/Numo::DFloat] The regularization parameter.
+      def initialize(reg_param: 1.0)
+        @params = {}
+        @params[:reg_param] = reg_param
+        @classes = nil
+        @weight_vec = nil
+      end
+
+      # Fit the model with given training data.
+      #
+      # @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_training_samples]) The labels to be used for fitting the model.
+      # @return [KernelRidgeClassifier] 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 ArgumentError, 'Expect the kernel matrix of training data to be square.' unless x.shape[0] == x.shape[1]
+        raise 'KernelRidgeClassifier#fit requires Numo::Linalg but that is not loaded.' unless enable_linalg?
+
+        @encoder = Rumale::Preprocessing::LabelBinarizer.new
+        y_encoded = Numo::DFloat.cast(@encoder.fit_transform(y)) * 2 - 1
+        @classes = Numo::NArray[*@encoder.classes]
+
+        n_samples = x.shape[0]
+        reg_kernel_mat = x + Numo::DFloat.eye(n_samples) * @params[:reg_param]
+        @weight_vec = Numo::Linalg.solve(reg_kernel_mat, y_encoded, driver: 'sym')
+
+        self
+      end
+
+      # Calculate confidence scores for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_training_samples])
+      #     The kernel matrix between testing samples and training samples to predict values.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) The confidence score per sample.
+      def decision_function(x)
+        x = check_convert_sample_array(x)
+        x.dot(@weight_vec)
+      end
+
+      # Predict class labels for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_training_samples])
+      #     The kernel matrix between testing samples and training samples to predict the labels.
+      # @return [Numo::Int32] (shape: [n_testing_samples]) Predicted class label per sample.
+      def predict(x)
+        x = check_convert_sample_array(x)
+        scores = decision_function(x)
+        n_samples, n_classes = scores.shape
+        label_ids = scores.max_index(axis: 1) - Numo::Int32.new(n_samples).seq * n_classes
+        @classes[label_ids].dup
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/kernel_calculator.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+require 'rumale/pairwise_metric'
+
+module Rumale
+  module Preprocessing
+    # KernelCalculator is a class that calculates the kernel matrix with training data.
+    #
+    # @example
+    #   transformer = Rumale::Preprocessing::KernelCalculator.new(kernel: 'rbf', gamma: 0.5)
+    #   regressor = Rumale::KernelMachine::KernelRidge.new
+    #   pipeline = Rumale::Pipeline::Pipeline.new(
+    #     steps: { trs: transfomer, est: regressor }
+    #   )
+    #   pipeline.fit(x_train, y_train)
+    #   results = pipeline.predict(x_test)
+    class KernelCalculator
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Returns the training data for calculating kernel matrix.
+      # @return [Numo::DFloat] (shape: n_components, n_features)
+      attr_reader :components
+
+      # Create a new transformer that transforms feature vectors into a kernel matrix.
+      #
+      # @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.
+      def initialize(kernel: 'rbf', gamma: 1, degree: 3, coef: 1)
+        check_params_string(kernel: kernel)
+        check_params_numeric(gamma: gamma, coef: coef, degree: degree)
+        @params = {}
+        @params[:kernel] = kernel
+        @params[:gamma] = gamma
+        @params[:degree] = degree
+        @params[:coef] = coef
+        @components = nil
+      end
+
+      # Fit the model with given training data.
+      #
+      # @overload fit(x) -> KernelCalculator
+      #   @param x [Numo::NArray] (shape: [n_samples, n_features]) The training data to be used for calculating kernel matrix.
+      # @return [KernelCalculator] The learned transformer itself.
+      def fit(x, _y = nil)
+        x = check_convert_sample_array(x)
+        @components = x.dup
+        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 calculating kernel matrix.
+      # @return [Numo::DFloat] (shape: [n_samples, n_samples]) The calculated kernel matrix.
+      def fit_transform(x, y = nil)
+        x = check_convert_sample_array(x)
+        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 used for calculating kernel matrix with the training data.
+      # @return [Numo::DFloat] (shape: [n_samples, n_components]) The calculated kernel matrix.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        kernel_mat(x, @components)
+      end
+
+      private
+
+      def kernel_mat(x, y)
+        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/version.rb

@@ -3,5 +3,5 @@
 # Rumale is a machine learning library in Ruby.
 module Rumale
   # The version of Rumale you are using.
-  VERSION = '0.22.4'
+  VERSION = '0.22.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.22.4
+  version: 0.22.5
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-22 00:00:00.000000000 Z
+date: 2021-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -139,6 +139,7 @@ files:
 - lib/rumale/kernel_machine/kernel_fda.rb
 - lib/rumale/kernel_machine/kernel_pca.rb
 - lib/rumale/kernel_machine/kernel_ridge.rb
+- lib/rumale/kernel_machine/kernel_ridge_classifier.rb
 - lib/rumale/kernel_machine/kernel_svc.rb
 - lib/rumale/linear_model/base_sgd.rb
 - lib/rumale/linear_model/elastic_net.rb
@@ -183,6 +184,7 @@ files:
 - lib/rumale/pipeline/pipeline.rb
 - lib/rumale/preprocessing/bin_discretizer.rb
 - lib/rumale/preprocessing/binarizer.rb
+- lib/rumale/preprocessing/kernel_calculator.rb
 - lib/rumale/preprocessing/l1_normalizer.rb
 - lib/rumale/preprocessing/l2_normalizer.rb
 - lib/rumale/preprocessing/label_binarizer.rb