rumale-svm 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec0ef314d44123fa222655004b099652d244c7fb9bea73569a4fe701974e43b1
-  data.tar.gz: ccaca04e1b3fe7691467a26a678f8978bc2f77e5a1b2e094b1af08923779588b
+  metadata.gz: 8853a60f150df418c30832c66b04f6531a1f3fa16f96ed3cb2286ca88a553dbe
+  data.tar.gz: aded967a3b1f82ded39b07ef3e1f435959f26c8d8392fb212acee3fcd006366f
 SHA512:
-  metadata.gz: 44b1ab01d131133ef5d9fb32ae4dfaff5ca1187e45c5a1b4f4ec3b198f515020baf85b5bb4a1bb110ae6e85d74f521af86661b4741a63828bd49288a138c9513
-  data.tar.gz: af83ab927ed5fbd630880b51fa2a0bf25c9aaad066a603d1ce6bf178c873ed669461eb46cdb23003b888799f11a5114fdf5405288d8129783c9495ec74799fd5
+  metadata.gz: 3f2ff48c445b9b5cfc804a17acb3f0c2563512eca01482c81c18fa8e662f9855e45abaede8ab5d7a8b087de84c131f2863f730d0313374b6af97480509fdd18f
+  data.tar.gz: 53747b28e162327cb11a9a5db9343d6baaad09e636909d8149c8ced58ba930a757b6251252968ddc7a7187c651abc56fb0ed046fde3ec6fcdc6a0d718404f420

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.9.0
+- Add Rumale::SVM::LocallyLinearSVC that is classifier with locally linear support vector machine.
+
+# 0.8.0
+- Refactor to support the new Rumale API.
+
 # 0.7.0
 - Support for probabilistic outputs with Rumale::SVM::OneClassSVM.
 - Update numo-libsvm depedency to v2.1 or higher.
@@ -6,7 +12,7 @@
 - Update numo-libsvm and numo-liblinear depedency to v2.0 or higher.
 
 # 0.5.1
-- Refator specs and config files.
+- Refactor specs and config files.
 
 # 0.5.0
 - Add type declaration files.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2019-2022 Atsushi Tatsuma
+Copyright (c) 2019-2023 Atsushi Tatsuma
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -1,18 +1,13 @@
 # Rumale::SVM
 
 [![Build Status](https://github.com/yoshoku/rumale-svm/workflows/build/badge.svg)](https://github.com/yoshoku/rumale-svm/actions?query=workflow%3Abuild)
-[![Coverage Status](https://coveralls.io/repos/github/yoshoku/rumale-svm/badge.svg?branch=main)](https://coveralls.io/github/yoshoku/rumale-svm?branch=main)
 [![Gem Version](https://badge.fury.io/rb/rumale-svm.svg)](https://badge.fury.io/rb/rumale-svm)
 [![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/rumale-svm/blob/main/LICENSE.txt)
 [![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/rumale-svm/doc/)
 
-Rumale::SVM provides support vector machine algorithms in
+Rumale::SVM provides support vector machine algorithms using
 [LIBSVM](https://www.csie.ntu.edu.tw/~cjlin/libsvm/) and [LIBLINEAR](https://www.csie.ntu.edu.tw/~cjlin/liblinear/)
 with [Rumale](https://github.com/yoshoku/rumale) interface.
-Many machine learning libraries use LIBSVM and LIBLINEAR as background libraries of support vector machine algorithms.
-On the other hand, Rumale implements support vector machine algorithms based on the mini-batch stochastic gradient descent method
-implemented in Ruby.
-Rumale::SVM adds the functions of support vector machine similar to general machine learning libraries to Rumale.
 
 ## Installation
 

data/lib/rumale/svm/linear_one_class_svm.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'numo/liblinear'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/validation'
 
 module Rumale
@@ -12,10 +12,7 @@ module Rumale
     #   estimator = Rumale::SVM::LinearOneClassSVM.new(nu: 0.05, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
-    class LinearOneClassSVM
-      include Base::BaseEstimator
-      include Validation
-
+    class LinearOneClassSVM < Rumale::Base::Estimator
       # Return the weight vector for LinearOneClassSVM.
       # @return [Numo::DFloat] (shape: [n_features])
       attr_reader :weight_vec
@@ -32,9 +29,7 @@ module Rumale
       # @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(nu: 0.05, reg_param: 1.0, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_numeric(nu: nu, reg_param: reg_param, tol: tol)
-        check_params_boolean(verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:nu] = nu.to_f
         @params[:reg_param] = reg_param.to_f
@@ -50,7 +45,7 @@ module Rumale
       #
       # @return [LinearOneClassSVM] The learned estimator itself.
       def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
+        x = Rumale::Validation.check_convert_sample_array(x)
         dummy = Numo::DFloat.ones(x.shape[0])
         @model = Numo::Liblinear.train(x, dummy, liblinear_params)
         @weight_vec = @model[:w].dup
@@ -63,8 +58,8 @@ module Rumale
       # @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)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         Numo::Liblinear.decision_function(x, liblinear_params, @model)
       end
 
@@ -73,8 +68,8 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples]) Predicted label per sample.
       def predict(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         Numo::Int32.cast(Numo::Liblinear.predict(x, liblinear_params, @model))
       end
 

data/lib/rumale/svm/linear_svc.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require 'numo/liblinear'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/base/classifier'
 require 'rumale/probabilistic_output'
+require 'rumale/validation'
 
 module Rumale
   module SVM
@@ -13,9 +14,8 @@ module Rumale
     #   estimator = Rumale::SVM::LinearSVC.new(penalty: 'l2', loss: 'squared_hinge', reg_param: 1.0, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
-    class LinearSVC
-      include Base::BaseEstimator
-      include Base::Classifier
+    class LinearSVC < Rumale::Base::Estimator
+      include Rumale::Base::Classifier
 
       # Return the weight vector for LinearSVC.
       # @return [Numo::DFloat] (shape: [n_classes, n_features])
@@ -43,10 +43,7 @@ module Rumale
       # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
       def initialize(penalty: 'l2', loss: 'squared_hinge', dual: true, reg_param: 1.0,
                      fit_bias: true, bias_scale: 1.0, probability: false, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_string(penalty: penalty, loss: loss)
-        check_params_numeric(reg_param: reg_param, bias_scale: bias_scale, tol: tol)
-        check_params_boolean(dual: dual, fit_bias: fit_bias, probability: probability, verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:penalty] = penalty == 'l1' ? 'l1' : 'l2'
         @params[:loss] = loss == 'hinge' ? 'hinge' : 'squared_hinge'
@@ -66,9 +63,9 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [LinearSVC] 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)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_label_array(y)
+        Rumale::Validation.check_sample_size(x, y)
         xx = fit_bias? ? expand_feature(x) : x
         @model = Numo::Liblinear.train(xx, y, liblinear_params)
         @weight_vec, @bias_term = weight_and_bias(@model[:w])
@@ -81,8 +78,8 @@ module Rumale
       # @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)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = fit_bias? ? expand_feature(x) : x
         Numo::Liblinear.decision_function(xx, liblinear_params, @model)
       end
@@ -92,8 +89,8 @@ module Rumale
       # @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)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = fit_bias? ? expand_feature(x) : x
         Numo::Int32.cast(Numo::Liblinear.predict(xx, liblinear_params, @model))
       end
@@ -104,8 +101,8 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         if binary_class?
           probs = Numo::DFloat.zeros(x.shape[0], 2)
           probs[true, 0] = 1.0 / (Numo::NMath.exp(@prob_param[0] * decision_function(x) + @prob_param[1]) + 1.0)

data/lib/rumale/svm/linear_svr.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require 'numo/libsvm'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/base/regressor'
+require 'rumale/validation'
 
 module Rumale
   module SVM
@@ -12,9 +13,8 @@ module Rumale
     #   estimator = Rumale::SVM::LinearSVR.new(reg_param: 1.0, random_seed: 1)
     #   estimator.fit(training_samples, traininig_target_values)
     #   results = estimator.predict(testing_samples)
-    class LinearSVR
-      include Base::BaseEstimator
-      include Base::Regressor
+    class LinearSVR < Rumale::Base::Estimator
+      include Rumale::Base::Regressor
 
       # Return the weight vector for LinearSVR.
       # @return [Numo::DFloat] (shape: [n_classes, n_features])
@@ -40,10 +40,7 @@ module Rumale
       # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
       def initialize(loss: 'squared_epsilon_insensitive', dual: true, reg_param: 1.0, epsilon: 0.1,
                      fit_bias: true, bias_scale: 1.0, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_string(loss: loss)
-        check_params_numeric(reg_param: reg_param, epsilon: epsilon, bias_scale: bias_scale, tol: tol)
-        check_params_boolean(dual: dual, fit_bias: fit_bias, verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:loss] = loss == 'epsilon_insensitive' ? 'epsilon_insensitive' : 'squared_epsilon_insensitive'
         @params[:dual] = dual
@@ -62,9 +59,9 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
       # @return [LinearSVR] The learned regressor itself.
       def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_tvalue_array(y)
-        check_sample_tvalue_size(x, y)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_target_value_array(y)
+        Rumale::Validation.check_sample_size(x, y)
         xx = fit_bias? ? expand_feature(x) : x
         @model = Numo::Liblinear.train(xx, y, liblinear_params)
         @weight_vec, @bias_term = weight_and_bias(@model[:w])
@@ -76,8 +73,8 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::DFloat] (shape: [n_samples]) Predicted value per sample.
       def predict(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = fit_bias? ? expand_feature(x) : x
         Numo::Liblinear.predict(xx, liblinear_params, @model)
       end

data/lib/rumale/svm/locally_linear_svc.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require 'rumale/base/estimator'
+require 'rumale/base/classifier'
+require 'rumale/pairwise_metric'
+require 'rumale/utils'
+require 'rumale/validation'
+
+module Rumale
+  module SVM
+    # LocallyLinearSVC is a class that implements Locally Linear Support Vector Classifier with the squared hinge loss.
+    # This classifier requires Numo::Linalg (or Numo::TinyLinalg) and Lbfgsb gems,
+    # but they are listed in the runtime dependencies of Rumale::SVM.
+    # Therefore, you should install and load Numo::Linalg and Lbfgsb gems explicitly to use this classifier.
+    #
+    # @example
+    #   require 'numo/linalg/autoloader'
+    #   require 'lbfgsb'
+    #   require 'rumale/svm'
+    #
+    #   estimator = Rumale::SVM::LocallyLinearSVC.new(reg_param: 1.0, n_anchors: 128)
+    #   estimator.fit(training_samples, traininig_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - Ladicky, L., and Torr, P H.S., "Locally Linear Support Vector Machines," Proc. ICML'11, pp. 985--992, 2011.
+    class LocallyLinearSVC < Rumale::Base::Estimator
+      include Rumale::Base::Classifier
+
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the anchor vectors.
+      # @return [Numo::DFloat] (shape: [n_anchors, n_features])
+      attr_reader :anchors
+
+      # Return the weight vector.
+      # @return [Numo::DFloat] (shape: [n_classes, n_anchors, n_features])
+      attr_reader :weight_vec
+
+      # Return the bias term (a.k.a. intercept).
+      # @return [Numo::DFloat] (shape: [n_classes, n_anchors])
+      attr_reader :bias_term
+
+      # Create a new classifier with Locally Linear Support Vector Machine.
+      #
+      # @param reg_param [Float] The regularization parameter for weight vector.
+      # @param reg_param_local [Float] The regularization parameter for local coordinate.
+      # @param max_iter [Integer] The maximum number of iterations.
+      # @param tol [Float] The tolerance of termination criterion for finding anchors with k-means algorithm.
+      # @param n_anchors [Integer] The number of anchors.
+      # @param n_neighbors [Integer] The number of neighbors.
+      # @param fit_bias [Boolean] The flag indicating whether to fit bias term.
+      # @param bias_scale [Float] The scale parameter for bias term.
+      # @param random_seed [Integer] The seed value using to initialize the random generator.
+      def initialize(reg_param: 1.0, reg_param_local: 1e-4, max_iter: 100, tol: 1e-4,
+                     n_anchors: 128, n_neighbors: 10, fit_bias: true, bias_scale: 1.0, random_seed: nil)
+        raise 'LocallyLinearSVC requires Numo::Linalg but that is not loaded' unless enable_linalg?(warning: false)
+
+        super()
+        @params = {
+          reg_param: reg_param,
+          reg_param_local: reg_param_local,
+          max_iter: max_iter,
+          n_anchors: n_anchors,
+          tol: tol,
+          n_neighbors: n_neighbors,
+          fit_bias: fit_bias,
+          bias_scale: bias_scale,
+          random_seed: random_seed || srand
+        }
+        @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 [LocallyLinearSVC] The learned classifier itself.
+      def fit(x, y)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_label_array(y)
+        Rumale::Validation.check_sample_size(x, y)
+        raise 'LocallyLinearSVC#fit requires Lbfgsb but that is not loaded' unless defined?(Lbfgsb)
+
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+
+        find_anchors(x)
+        n_samples, n_features = x.shape
+        @coeff = Numo::DFloat.zeros(n_samples, @params[:n_anchors])
+        n_samples.times do |i|
+          xi = x[i, true]
+          @coeff[i, true] = local_coordinates(xi)
+        end
+
+        x = expand_feature(x) if fit_bias?
+
+        if multiclass_problem?
+          n_classes = @classes.size
+          @weight_vec = Numo::DFloat.zeros(n_classes, @params[:n_anchors], n_features)
+          @bias_term = Numo::DFloat.zeros(n_classes, @params[:n_anchors])
+          n_classes.times do |n|
+            bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
+            w, b = partial_fit(x, bin_y)
+            @weight_vec[n, true, true] = w
+            @bias_term[n, true] = b
+          end
+        else
+          negative_label = @classes[0]
+          bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
+          @weight_vec, @bias_term = partial_fit(x, bin_y)
+        end
+
+        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)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        n_samples = x.shape[0]
+
+        if multiclass_problem?
+          n_classes = @classes.size
+          df = Numo::DFloat.zeros(n_samples, n_classes)
+          n_samples.times do |i|
+            xi = x[i, true]
+            coeff = local_coordinates(xi)
+            n_classes.times do |j|
+              df[i, j] = coeff.dot(@weight_vec[j, true, true]).dot(xi) + coeff.dot(@bias_term[j, true])
+            end
+          end
+        else
+          df = Numo::DFloat.zeros(n_samples)
+          n_samples.times do |i|
+            xi = x[i, true]
+            coeff = local_coordinates(xi)
+            df[i] = coeff.dot(@weight_vec).dot(xi) + coeff.dot(@bias_term)
+          end
+        end
+        df
+      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)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        n_samples = x.shape[0]
+
+        if multiclass_problem?
+          df = decision_function(x)
+          predicted = Array.new(n_samples) { |n| @classes[df[n, true].max_index] }
+        else
+          df = decision_function(x).ge(0.0).to_a
+          predicted = Array.new(n_samples) { |n| @classes[df[n]] }
+        end
+        Numo::Int32.asarray(predicted)
+      end
+
+      private
+
+      def partial_fit(base_x, bin_y) # rubocop:disable Metrics/AbcSize
+        fnc = proc do |w, x, y, coeff, reg_param|
+          n_anchors = coeff.shape[1]
+          n_samples, n_features = x.shape
+          w = w.reshape(n_anchors, n_features)
+          z = (coeff * x.dot(w.transpose)).sum(axis: 1)
+          t = 1 - y * z
+          indices = t.gt(0)
+          grad = reg_param * w
+          if indices.count.positive?
+            sx = x[indices, true]
+            sy = y[indices]
+            sc = coeff[indices, true]
+            sz = z[indices]
+            grad += 2.fdiv(n_samples) * (sc.transpose * (sz - sy)).dot(sx)
+          end
+          loss = 0.5 * reg_param * w.dot(w.transpose).trace + (x.class.maximum(0, t)**2).sum.fdiv(n_samples)
+          [loss, grad.reshape(n_anchors * n_features)]
+        end
+
+        n_features = base_x.shape[1]
+        sub_rng = @rng.dup
+        w_init = 2.0 * ::Rumale::Utils.rand_uniform(@params[:n_anchors] * n_features, sub_rng) - 1.0
+
+        res = Lbfgsb.minimize(
+          fnc: fnc, jcb: true, x_init: w_init, args: [base_x, bin_y, @coeff, @params[:reg_param]],
+          maxiter: @params[:max_iter], factr: @params[:tol] / Lbfgsb::DBL_EPSILON,
+          verbose: @params[:verbose] ? 1 : -1
+        )
+
+        w = res[:x].reshape(@params[:n_anchors], n_features)
+
+        if fit_bias?
+          [w[true, 0...-1].dup, w[true, -1].dup]
+        else
+          [w, Numo::DFloat.zeros(@params[:n_anchors])]
+        end
+      end
+
+      def local_coordinates(xi)
+        neighbor_ids = find_neighbors(xi)
+        diff = @anchors[neighbor_ids, true] - xi
+        gram_mat = diff.dot(diff.transpose)
+        gram_mat[gram_mat.diag_indices] += @params[:reg_param_local].fdiv(@params[:n_neighbors]) * gram_mat.trace
+        local_coeff = Numo::Linalg.solve(gram_mat, Numo::DFloat.ones(@params[:n_neighbors]))
+        local_coeff /= local_coeff.sum # + 1e-8
+        coeff = Numo::DFloat.zeros(@params[:n_anchors])
+        coeff[neighbor_ids] = local_coeff
+        coeff
+      end
+
+      def find_neighbors(xi)
+        diff = @anchors - xi
+        dist = (diff**2).sum(axis: 1)
+        dist.sort_index.to_a[0...@params[:n_neighbors]]
+      end
+
+      def find_anchors(x)
+        n_samples = x.shape[0]
+        sub_rng = @rng.dup
+        rand_id = Array.new(@params[:n_anchors]) { |_v| sub_rng.rand(0...n_samples) }
+        @anchors = x[rand_id, true].dup
+
+        @params[:max_iter].times do |_t|
+          center_ids = assign_anchors(x)
+          old_anchors = @anchors.dup
+          @params[:n_anchors].times do |n|
+            assigned_bits = center_ids.eq(n)
+            @anchors[n, true] = x[assigned_bits.where, true].mean(axis: 0) if assigned_bits.count.positive?
+          end
+          error = Numo::NMath.sqrt(((old_anchors - @anchors)**2).sum(axis: 1)).mean
+          break if error <= @params[:tol]
+        end
+      end
+
+      def assign_anchors(x)
+        distance_matrix = ::Rumale::PairwiseMetric.euclidean_distance(x, @anchors)
+        distance_matrix.min_index(axis: 1) - Numo::Int32[*0.step(distance_matrix.size - 1, @anchors.shape[0])]
+      end
+
+      def fit_bias?
+        @params[:fit_bias] == true
+      end
+
+      def expand_feature(x)
+        n_samples = x.shape[0]
+        Numo::NArray.hstack([x, Numo::DFloat.ones([n_samples, 1]) * @params[:bias_scale]])
+      end
+
+      def multiclass_problem?
+        @classes.size > 2
+      end
+    end
+  end
+end

data/lib/rumale/svm/logistic_regression.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'numo/liblinear'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/base/classifier'
 
 module Rumale
@@ -12,9 +12,8 @@ module Rumale
     #   estimator = Rumale::SVM::LogisticRegression.new(penalty: 'l2', dual: false, reg_param: 1.0, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
-    class LogisticRegression
-      include Base::BaseEstimator
-      include Base::Classifier
+    class LogisticRegression < Rumale::Base::Estimator
+      include Rumale::Base::Classifier
 
       # Return the weight vector for LogisticRegression.
       # @return [Numo::DFloat] (shape: [n_classes, n_features])
@@ -39,10 +38,7 @@ module Rumale
       # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
       def initialize(penalty: 'l2', dual: true, reg_param: 1.0,
                      fit_bias: true, bias_scale: 1.0, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_string(penalty: penalty)
-        check_params_numeric(reg_param: reg_param, bias_scale: bias_scale, tol: tol)
-        check_params_boolean(dual: dual, fit_bias: fit_bias, verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:penalty] = penalty == 'l1' ? 'l1' : 'l2'
         @params[:dual] = dual
@@ -60,9 +56,9 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [LogisticRegression] 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)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_label_array(y)
+        Rumale::Validation.check_sample_size(x, y)
         xx = fit_bias? ? expand_feature(x) : x
         @model = Numo::Liblinear.train(xx, y, liblinear_params)
         @weight_vec, @bias_term = weight_and_bias(@model[:w])
@@ -74,8 +70,8 @@ module Rumale
       # @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)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = fit_bias? ? expand_feature(x) : x
         Numo::Liblinear.decision_function(xx, liblinear_params, @model)
       end
@@ -85,8 +81,8 @@ module Rumale
       # @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)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = fit_bias? ? expand_feature(x) : x
         Numo::Int32.cast(Numo::Liblinear.predict(xx, liblinear_params, @model))
       end
@@ -97,8 +93,8 @@ module Rumale
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = fit_bias? ? expand_feature(x) : x
         Numo::Liblinear.predict_proba(xx, liblinear_params, @model)
       end

data/lib/rumale/svm/nu_svc.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require 'numo/libsvm'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/base/classifier'
+require 'rumale/validation'
 
 module Rumale
   module SVM
@@ -12,9 +13,8 @@ module Rumale
     #   estimator = Rumale::SVM::NuSVC.new(nu: 0.5, kernel: 'rbf', gamma: 10.0, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
-    class NuSVC
-      include Base::BaseEstimator
-      include Base::Classifier
+    class NuSVC < Rumale::Base::Estimator
+      include Rumale::Base::Classifier
 
       # Create a new classifier with Kernel Nu-Support Vector Classifier.
       #
@@ -31,10 +31,7 @@ module Rumale
       # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
       def initialize(nu: 0.5, kernel: 'rbf', degree: 3, gamma: 1.0, coef0: 0.0,
                      shrinking: true, probability: true, cache_size: 200.0, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_numeric(nu: nu, degree: degree, gamma: gamma, coef0: coef0, cache_size: cache_size, tol: tol)
-        check_params_string(kernel: kernel)
-        check_params_boolean(shrinking: shrinking, probability: probability, verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:nu] = nu.to_f
         @params[:kernel] = kernel
@@ -56,9 +53,9 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [NuSVC] 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)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_label_array(y)
+        Rumale::Validation.check_sample_size(x, y)
         xx = precomputed_kernel? ? add_index_col(x) : x
         @model = Numo::Libsvm.train(xx, y, libsvm_params)
         self
@@ -70,8 +67,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
       def decision_function(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = precomputed_kernel? ? add_index_col(x) : x
         Numo::Libsvm.decision_function(xx, libsvm_params, @model)
       end
@@ -82,8 +79,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
       def predict(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = precomputed_kernel? ? add_index_col(x) : x
         Numo::Int32.cast(Numo::Libsvm.predict(xx, libsvm_params, @model))
       end
@@ -95,8 +92,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = precomputed_kernel? ? add_index_col(x) : x
         Numo::Libsvm.predict_proba(xx, libsvm_params, @model)
       end

data/lib/rumale/svm/nu_svr.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require 'numo/libsvm'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/base/regressor'
+require 'rumale/validation'
 
 module Rumale
   module SVM
@@ -12,9 +13,8 @@ module Rumale
     #   estimator = Rumale::SVM::NuSVR.new(nu: 0.5, kernel: 'rbf', gamma: 10.0, random_seed: 1)
     #   estimator.fit(training_samples, traininig_target_values)
     #   results = estimator.predict(testing_samples)
-    class NuSVR
-      include Base::BaseEstimator
-      include Base::Regressor
+    class NuSVR < Rumale::Base::Estimator
+      include Rumale::Base::Regressor
 
       # Create a new regressor with Kernel Nu-Support Vector Regressor.
       #
@@ -30,10 +30,7 @@ module Rumale
       # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
       def initialize(nu: 0.5, kernel: 'rbf', degree: 3, gamma: 1.0, coef0: 0.0,
                      shrinking: true, cache_size: 200.0, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_numeric(nu: nu, degree: degree, gamma: gamma, coef0: coef0, cache_size: cache_size, tol: tol)
-        check_params_string(kernel: kernel)
-        check_params_boolean(shrinking: shrinking, verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:nu] = nu.to_f
         @params[:kernel] = kernel
@@ -54,9 +51,9 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
       # @return [NuSVR] The learned regressor itself.
       def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_tvalue_array(y)
-        check_sample_tvalue_size(x, y)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_target_value_array(y)
+        Rumale::Validation.check_sample_size(x, y)
         xx = precomputed_kernel? ? add_index_col(x) : x
         @model = Numo::Libsvm.train(xx, y, libsvm_params)
         self
@@ -68,8 +65,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::DFloat] (shape: [n_samples]) Predicted value per sample.
       def predict(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = precomputed_kernel? ? add_index_col(x) : x
         Numo::Libsvm.predict(xx, libsvm_params, @model)
       end

data/lib/rumale/svm/one_class_svm.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'numo/libsvm'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/validation'
 
 module Rumale
@@ -12,10 +12,7 @@ module Rumale
     #   estimator = Rumale::SVM::OneClassSVM.new(nu: 0.5, kernel: 'rbf', gamma: 10.0, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
-    class OneClassSVM
-      include Base::BaseEstimator
-      include Validation
-
+    class OneClassSVM < Rumale::Base::Estimator
       # Create a new estimator with One-class Support Vector Machine.
       #
       # @param nu [Float] The regularization parameter. The interval of nu is (0, 1].
@@ -31,10 +28,7 @@ module Rumale
       # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
       def initialize(nu: 1.0, kernel: 'rbf', degree: 3, gamma: 1.0, coef0: 0.0,
                      shrinking: true, probability: true, cache_size: 200.0, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_numeric(nu: nu, degree: degree, gamma: gamma, coef0: coef0, cache_size: cache_size, tol: tol)
-        check_params_string(kernel: kernel)
-        check_params_boolean(shrinking: shrinking, probability: probability, verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:nu] = nu.to_f
         @params[:kernel] = kernel
@@ -56,7 +50,7 @@ module Rumale
       #     If the kernel is 'precomputed', x must be a square distance matrix (shape: [n_samples, n_samples]).
       # @return [OneClassSVM] The learned estimator itself.
       def fit(x, _y = nil)
-        x = check_convert_sample_array(x)
+        x = Rumale::Validation.check_convert_sample_array(x)
         dummy = Numo::DFloat.ones(x.shape[0])
         @model = Numo::Libsvm.train(x, dummy, libsvm_params)
         self
@@ -68,8 +62,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
       def decision_function(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         Numo::Libsvm.decision_function(x, libsvm_params, @model)
       end
 
@@ -79,8 +73,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::Int32] (shape: [n_samples]) Predicted label per sample.
       def predict(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         Numo::Int32.cast(Numo::Libsvm.predict(x, libsvm_params, @model))
       end
 
@@ -91,9 +85,9 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        raise "#{self.class.name}\##{__method__} expects to be called after training the probablity parameters." unless trained_probs?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        raise "#{self.class.name}##{__method__} expects to be called after training the probablity parameters." unless trained_probs?
+        x = Rumale::Validation.check_convert_sample_array(x)
         Numo::Libsvm.predict_proba(x, libsvm_params, @model)
       end
 

data/lib/rumale/svm/svc.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require 'numo/libsvm'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/base/classifier'
+require 'rumale/validation'
 
 module Rumale
   module SVM
@@ -12,9 +13,8 @@ module Rumale
     #   estimator = Rumale::SVM::SVC.new(reg_param: 1.0, kernel: 'rbf', gamma: 10.0, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
-    class SVC
-      include Base::BaseEstimator
-      include Base::Classifier
+    class SVC < Rumale::Base::Estimator
+      include Rumale::Base::Classifier
 
       # Create a new classifier with Kernel C-Support Vector Classifier.
       #
@@ -31,10 +31,7 @@ module Rumale
       # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
       def initialize(reg_param: 1.0, kernel: 'rbf', degree: 3, gamma: 1.0, coef0: 0.0,
                      shrinking: true, probability: true, cache_size: 200.0, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_numeric(reg_param: reg_param, degree: degree, gamma: gamma, coef0: coef0, cache_size: cache_size, tol: tol)
-        check_params_string(kernel: kernel)
-        check_params_boolean(shrinking: shrinking, probability: probability, verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:reg_param] = reg_param.to_f
         @params[:kernel] = kernel
@@ -56,9 +53,9 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [SVC] 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)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_label_array(y)
+        Rumale::Validation.check_sample_size(x, y)
         xx = precomputed_kernel? ? add_index_col(x) : x
         @model = Numo::Libsvm.train(xx, y, libsvm_params)
         self
@@ -70,8 +67,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence score per sample.
       def decision_function(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = precomputed_kernel? ? add_index_col(x) : x
         Numo::Libsvm.decision_function(xx, libsvm_params, @model)
       end
@@ -82,8 +79,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
       def predict(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = precomputed_kernel? ? add_index_col(x) : x
         Numo::Int32.cast(Numo::Libsvm.predict(xx, libsvm_params, @model))
       end
@@ -95,8 +92,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
       def predict_proba(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = precomputed_kernel? ? add_index_col(x) : x
         Numo::Libsvm.predict_proba(xx, libsvm_params, @model)
       end

data/lib/rumale/svm/svr.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require 'numo/libsvm'
-require 'rumale/base/base_estimator'
+require 'rumale/base/estimator'
 require 'rumale/base/regressor'
+require 'rumale/validation'
 
 module Rumale
   module SVM
@@ -12,9 +13,8 @@ module Rumale
     #   estimator = Rumale::SVM::SVR.new(reg_param: 1.0, kernel: 'rbf', gamma: 10.0, random_seed: 1)
     #   estimator.fit(training_samples, traininig_target_values)
     #   results = estimator.predict(testing_samples)
-    class SVR
-      include Base::BaseEstimator
-      include Base::Regressor
+    class SVR < Rumale::Base::Estimator
+      include Rumale::Base::Regressor
 
       # Create a new regressor with Kernel Epsilon-Support Vector Regressor.
       #
@@ -31,11 +31,7 @@ module Rumale
       # @param random_seed [Integer/Nil] The seed value using to initialize the random generator.
       def initialize(reg_param: 1.0, epsilon: 0.1, kernel: 'rbf', degree: 3, gamma: 1.0, coef0: 0.0,
                      shrinking: true, cache_size: 200.0, tol: 1e-3, verbose: false, random_seed: nil)
-        check_params_numeric(reg_param: reg_param, degree: degree, epsilon: epsilon, gamma: gamma, coef0: coef0,
-                             cache_size: cache_size, tol: tol)
-        check_params_string(kernel: kernel)
-        check_params_boolean(shrinking: shrinking, verbose: verbose)
-        check_params_numeric_or_nil(random_seed: random_seed)
+        super()
         @params = {}
         @params[:reg_param] = reg_param.to_f
         @params[:epsilon] = epsilon.to_f
@@ -57,9 +53,9 @@ module Rumale
       # @param y [Numo::DFloat] (shape: [n_samples]) The target values to be used for fitting the model.
       # @return [SVR] The learned regressor itself.
       def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_tvalue_array(y)
-        check_sample_tvalue_size(x, y)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_target_value_array(y)
+        Rumale::Validation.check_sample_size(x, y)
         xx = precomputed_kernel? ? add_index_col(x) : x
         @model = Numo::Libsvm.train(xx, y, libsvm_params)
         self
@@ -71,8 +67,8 @@ module Rumale
       #   If the kernel is 'precomputed', the shape of x must be [n_samples, n_training_samples].
       # @return [Numo::DFloat] (shape: [n_samples]) Predicted value per sample.
       def predict(x)
-        raise "#{self.class.name}\##{__method__} expects to be called after training the model with the fit method." unless trained?
-        x = check_convert_sample_array(x)
+        raise "#{self.class.name}##{__method__} expects to be called after training the model with the fit method." unless trained?
+        x = Rumale::Validation.check_convert_sample_array(x)
         xx = precomputed_kernel? ? add_index_col(x) : x
         Numo::Libsvm.predict(xx, libsvm_params, @model)
       end

data/lib/rumale/svm/version.rb

@@ -2,9 +2,9 @@
 
 # Rumale is a machine learning library in Ruby.
 module Rumale
-  # This module consists of Rumale interfaces for suppor vector machine algorithms with LIBSVM and LIBLINEAR.
+  # 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.7.0'
+    VERSION = '0.9.0'
   end
 end

data/lib/rumale/svm.rb

@@ -10,3 +10,4 @@ require 'rumale/svm/linear_svc'
 require 'rumale/svm/linear_svr'
 require 'rumale/svm/logistic_regression'
 require 'rumale/svm/linear_one_class_svm'
+require 'rumale/svm/locally_linear_svc'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale-svm
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-15 00:00:00.000000000 Z
+date: 2023-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-liblinear
@@ -39,13 +39,10 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.1'
 - !ruby/object:Gem::Dependency
-  name: rumale
+  name: rumale-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '0.24'
   type: :runtime
@@ -53,13 +50,10 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '0.24'
-description: 'Rumale::SVM provides support vector machine algorithms of LIBSVM and
-  LIBLINEAR with Rumale interface.
+description: 'Rumale::SVM provides support vector machine algorithms using LIBSVM
+  and LIBLINEAR with Rumale interface.
 
   '
 email:
@@ -75,6 +69,7 @@ files:
 - lib/rumale/svm/linear_one_class_svm.rb
 - lib/rumale/svm/linear_svc.rb
 - lib/rumale/svm/linear_svr.rb
+- lib/rumale/svm/locally_linear_svc.rb
 - lib/rumale/svm/logistic_regression.rb
 - lib/rumale/svm/nu_svc.rb
 - lib/rumale/svm/nu_svr.rb
@@ -116,9 +111,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: Rumale::SVM provides support vector machine algorithms of LIBSVM and LIBLINEAR
+summary: Rumale::SVM provides support vector machine algorithms using LIBSVM and LIBLINEAR
   with Rumale interface.
 test_files: []