rumale-svm 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8853a60f150df418c30832c66b04f6531a1f3fa16f96ed3cb2286ca88a553dbe
-  data.tar.gz: aded967a3b1f82ded39b07ef3e1f435959f26c8d8392fb212acee3fcd006366f
+  metadata.gz: d027826bfde557a8e724b62252182549d71a3bc90ebcfa7b3e5f4a4f915a553e
+  data.tar.gz: ba0baf950d204dcbf993b41c99ca8a79a63b0ffac87fe5204211c7b56759374e
 SHA512:
-  metadata.gz: 3f2ff48c445b9b5cfc804a17acb3f0c2563512eca01482c81c18fa8e662f9855e45abaede8ab5d7a8b087de84c131f2863f730d0313374b6af97480509fdd18f
-  data.tar.gz: 53747b28e162327cb11a9a5db9343d6baaad09e636909d8149c8ced58ba930a757b6251252968ddc7a7187c651abc56fb0ed046fde3ec6fcdc6a0d718404f420
+  metadata.gz: 65f9a78800033bdbc0354d146cf6150d35aa4924c07164a7bfe578704642d4cde0d49a604fcf5dd75a135462282ee2e18fbcf9157773ce8d827c5a671be6eaa6
+  data.tar.gz: c3d8da2ad2790c8cc656194c1dd0a083a5dbc364ef3b14c768cf5edcb83449d4ef0d61f3d00d8b358171c492e09f2053bd73c7e3b56418234d996fd70945c23b

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.10.0
+- Add Rumale::SVM::RandomRecursiveSVC that is classifier with random recursive support vector machine.
+- Add type declaration files for RandomRecursiveSVC and LocallyLinearSVC.
+
 # 0.9.0
 - Add Rumale::SVM::LocallyLinearSVC that is classifier with locally linear support vector machine.
 

data/lib/rumale/svm/random_recursive_svc.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'rumale/utils'
+require 'rumale/base/estimator'
+require 'rumale/base/classifier'
+require 'rumale/svm/linear_svc'
+
+module Rumale
+  module SVM
+    # RandomRecursiveSVC is a class that implements Random Recursive Support Vector Classifier.
+    #
+    # @example
+    #   require 'rumale/svm'
+    #
+    #   estimator = Rumale::SVM::RandomRecursiveSVC.new(n_hidden_layers: 2, beta: 0.5, random_seed: 1)
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Vinyals, O., Jia, Y., Deng, L., and Darrell, T., "Learning with Recursive Perceptual Representations," In Proc. NIPS'12, pp. 2825--2833, 2012.
+    class RandomRecursiveSVC < Rumale::Base::Estimator
+      include Rumale::Base::Classifier
+
+      # Return the classifiers for each layer.
+      # @return [Array<LinearSVC>]
+      attr_reader :classifiers
+
+      # Return the random matrices for each hidden layer.
+      # @return [Array<Numo::DFloat>] (shape: [n_classes, n_features])
+      attr_reader :random_matrices
+
+      # Create a new classifier with Random Recursive Support Vector Machine.
+      #
+      # @param n_hidden_layers [Integer] The number of hidden layers.
+      # @param beta [Float] The weight parameter for the degree of moving the original data.
+      # @param penalty [String] The type of norm used in the penalization ('l2' or 'l1').
+      # @param loss [String] The type of loss function ('squared_hinge' or 'hinge').
+      #   This parameter is ignored if penalty = 'l1'.
+      # @param dual [Boolean] The flag indicating whether to solve dual optimization problem.
+      #   When n_samples > n_features, dual = false is more preferable.
+      #   This parameter is ignored if loss = 'hinge'.
+      # @param reg_param [Float] The regularization parameter.
+      # @param fit_bias [Boolean] The flag indicating whether to fit the bias term.
+      # @param bias_scale [Float] The scale of the bias term.
+      #   This parameter is ignored if fit_bias = false.
+      # @param tol [Float] The tolerance of termination criterion.
+      # @param verbose [Boolean] The flag indicating whether to output learning process message
+      # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
+      def initialize(n_hidden_layers: 2, beta: 0.5, penalty: 'l2', loss: 'squared_hinge', dual: true, reg_param: 1.0,
+                     fit_bias: true, bias_scale: 1.0, tol: 1e-3, verbose: false, random_seed: nil)
+        super()
+        @params = {
+          n_hidden_layers: n_hidden_layers,
+          beta: beta,
+          penalty: penalty == 'l1' ? 'l1' : 'l2',
+          loss: loss == 'hinge' ? 'hinge' : 'squared_hinge',
+          dual: dual,
+          reg_param: reg_param.to_f,
+          fit_bias: fit_bias,
+          bias_scale: bias_scale.to_f,
+          tol: tol.to_f,
+          verbose: verbose,
+          random_seed: random_seed || Random.rand(4_294_967_295)
+        }
+        @rng = Random.new(@params[:random_seed])
+      end
+
+      # Fit the model with given training data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) 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 [RandomRecursiveSVC] The learned classifier itself.
+      def fit(x, y)
+        partial_fit(x, y)
+        self
+      end
+
+      # Calculate confidence scores for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
+      def decision_function(x)
+        @classifiers.last.decision_function(transform(x))
+      end
+
+      # Predict class labels for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
+      def predict(x)
+        @classifiers.last.predict(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_features]) The output of last hidden layer.
+      def transform(x)
+        d = x
+        s = Numo::DFloat.zeros(x.shape)
+        @random_matrices.each_with_index do |w, n|
+          o = @classifiers[n].predict_proba(d)
+          s += o.dot(w)
+          d = sigmoid(x + @params[:beta] * s)
+        end
+        d
+      end
+
+      private
+
+      def partial_fit(x, y)
+        @classifiers = []
+        @random_matrices = []
+        sub_rng = @rng.dup
+        n_classes = y.to_a.uniq.size
+        n_features = x.shape[1]
+        d = x
+        s = Numo::DFloat.zeros(x.shape)
+        @params[:n_hidden_layers].times do
+          svc = LinearSVC.new(**linear_svc_params).fit(d, y)
+          o = svc.predict_proba(d)
+          w = ::Rumale::Utils.rand_normal([n_classes, n_features], sub_rng)
+          s += o.dot(w)
+          d = sigmoid(x + @params[:beta] * s)
+          @classifiers << svc
+          @random_matrices << w
+        end
+        svc = LinearSVC.new(**linear_svc_params).fit(d, y)
+        @classifiers << svc
+      end
+
+      def linear_svc_params
+        @params.reject { |key, _| RRSVC_PARAMS.include?(key) }.merge(probability: true)
+      end
+
+      def sigmoid(x)
+        0.5 * (Numo::NMath.tanh(0.5 * x) + 1.0)
+      end
+
+      RRSVC_PARAMS = %i[n_hidden_layers beta].freeze
+
+      private_constant :RRSVC_PARAMS
+    end
+  end
+end

data/lib/rumale/svm/version.rb

@@ -5,6 +5,6 @@ module Rumale
   # This module consists of Rumale interfaces for suppor vector machine algorithms using LIBSVM and LIBLINEAR.
   module SVM
     # The version of Rumale::SVM you are using.
-    VERSION = '0.9.0'
+    VERSION = '0.10.0'
   end
 end

data/lib/rumale/svm.rb

@@ -11,3 +11,4 @@ require 'rumale/svm/linear_svr'
 require 'rumale/svm/logistic_regression'
 require 'rumale/svm/linear_one_class_svm'
 require 'rumale/svm/locally_linear_svc'
+require 'rumale/svm/random_recursive_svc'

data/sig/rumale/svm/locally_linear_svc.rbs

@@ -0,0 +1,32 @@
+# TypeProf 0.21.8
+
+# Classes
+module Rumale
+  module SVM
+    class LocallyLinearSVC
+      @params: {reg_param: Float, reg_param_local: Float, max_iter: Integer, n_anchors: Integer, tol: Float, n_neighbors: Integer, fit_bias: bool, bias_scale: Float, random_seed: Integer}
+      @rng: Random
+      @coeff: Numo::DFloat
+
+      attr_reader classes: Numo::Int32
+      attr_reader anchors: Numo::DFloat
+      attr_reader weight_vec: Numo::DFloat
+      attr_reader bias_term: Numo::DFloat
+      def initialize: (?reg_param: Float, ?reg_param_local: Float, ?max_iter: Integer, ?tol: Float, ?n_anchors: Integer, ?n_neighbors: Integer, ?fit_bias: bool, ?bias_scale: Float, ?random_seed: (nil | Integer)) -> void
+      def fit: (Numo::DFloat x, Numo::Int32 y) -> LocallyLinearSVC
+      def decision_function: (Numo::DFloat x) -> Numo::DFloat
+      def predict: (Numo::DFloat x) -> Numo::Int32
+
+      private
+
+      def partial_fit: (Numo::DFloat base_x, Numo::Int32 bin_y) -> [Numo::DFloat, Numo::DFloat]
+      def local_coordinates: (Numo::DFloat xi) -> Numo::DFloat
+      def find_neighbors: (Numo::DFloat xi) -> Numo::Int32
+      def find_anchors: (Numo::DFloat x) -> void
+      def assign_anchors: (Numo::DFloat x) -> Integer
+      def fit_bias?: -> bool
+      def expand_feature: (Numo::DFloat x) -> Numo::DFloat
+      def multiclass_problem?: -> bool
+    end
+  end
+end

data/sig/rumale/svm/random_recursive_svc.rbs

@@ -0,0 +1,27 @@
+# TypeProf 0.21.8
+
+# Classes
+module Rumale
+  module SVM
+    class RandomRecursiveSVC
+      @params: {n_hidden_layers: Integer, beta: Float, penalty: String, loss: String, dual: bool, reg_param: Float, fit_bias: bool, bias_scale: Float, tol: Float, verbose: bool, random_seed: Integer}
+      @rng: Random
+
+      attr_reader classifiers: Array[Rumale::SVM::LinearSVC]
+      attr_reader random_matrices: Array[Numo::DFloat]
+      def initialize: (?n_hidden_layers: Integer, ?beta: Float, ?penalty: String, ?loss: String, ?dual: bool, ?reg_param: Float, ?fit_bias: bool, ?bias_scale: Float, ?tol: Float, ?verbose: bool, ?random_seed: (nil | Integer)) -> void
+      def fit: (Numo::DFloat x, Numo::Int32 y) -> RandomRecursiveSVC
+      def decision_function: (Numo::DFloat x) -> Numo::DFloat
+      def predict: (Numo::DFloat x) -> Numo::Int32
+      def transform: (Numo::DFloat x) -> Numo::DFloat
+
+      private
+
+      def partial_fit: (Numo::DFloat x, Numo::DFloat y) -> void
+      def linear_svc_params: -> (Hash[:beta | :bias_scale | :dual | :fit_bias | :loss | :n_hidden_layers | :penalty | :random_seed | :reg_param | :tol | :verbose, Float | Integer | String | bool])
+      def sigmoid: (Numo::DFloat x) -> Numo::DFloat
+
+      RRSVC_PARAMS: [:n_hidden_layers, :beta]
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale-svm
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-25 00:00:00.000000000 Z
+date: 2023-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-liblinear
@@ -74,6 +74,7 @@ files:
 - lib/rumale/svm/nu_svc.rb
 - lib/rumale/svm/nu_svr.rb
 - lib/rumale/svm/one_class_svm.rb
+- lib/rumale/svm/random_recursive_svc.rb
 - lib/rumale/svm/svc.rb
 - lib/rumale/svm/svr.rb
 - lib/rumale/svm/version.rb
@@ -81,10 +82,12 @@ files:
 - sig/rumale/svm/linear_one_class_svm.rbs
 - sig/rumale/svm/linear_svc.rbs
 - sig/rumale/svm/linear_svr.rbs
+- sig/rumale/svm/locally_linear_svc.rbs
 - sig/rumale/svm/logistic_regression.rbs
 - sig/rumale/svm/nu_svc.rbs
 - sig/rumale/svm/nu_svr.rbs
 - sig/rumale/svm/one_class_svm.rbs
+- sig/rumale/svm/random_recursive_svc.rbs
 - sig/rumale/svm/svc.rbs
 - sig/rumale/svm/svr.rbs
 homepage: https://github.com/yoshoku/rumale-svm
@@ -111,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Rumale::SVM provides support vector machine algorithms using LIBSVM and LIBLINEAR