Class: Rumale::SVM::SVC

Inherits:
Base::Estimator
  • Object
show all
Includes:
Base::Classifier
Defined in:
lib/rumale/svm/svc.rb

Overview

SVC is a class that provides Kernel C-Support Vector Classifier in LIBSVM with Rumale interface.

Examples:

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)

Instance Method Summary collapse

Constructor Details

#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) ⇒ SVC

Create a new classifier with Kernel C-Support Vector Classifier.

Parameters:

  • reg_param (Float) (defaults to: 1.0) —

    The regularization parameter.

  • kernel (String) (defaults to: 'rbf') —

    The type of kernel function (‘rbf’, ‘linear’, ‘poly’, ‘sigmoid’, and ‘precomputed’).

  • degree (Integer) (defaults to: 3) —

    The degree parameter in polynomial kernel function.

  • gamma (Float) (defaults to: 1.0) —

    The gamma parameter in rbf/poly/sigmoid kernel function.

  • coef0 (Float) (defaults to: 0.0) —

    The coefficient in poly/sigmoid kernel function.

  • shrinking (Boolean) (defaults to: true) —

    The flag indicating whether to use the shrinking heuristics.

  • probability (Boolean) (defaults to: true) —

    The flag indicating whether to train the parameter for probability estimation.

  • cache_size (Float) (defaults to: 200.0) —

    The cache memory size in MB.

  • tol (Float) (defaults to: 1e-3) —

    The tolerance of termination criterion.

  • verbose (Boolean) (defaults to: false) —

    The flag indicating whether to output learning process message

  • random_seed (Integer/Nil) (defaults to: nil) —

    The seed value using to initialize the random generator.



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/rumale/svm/svc.rb', line 32

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)
  super()
  @params = {}
  @params[:reg_param] = reg_param.to_f
  @params[:kernel] = kernel
  @params[:degree] = degree.to_i
  @params[:gamma] = gamma.to_f
  @params[:coef0] = coef0.to_f
  @params[:shrinking] = shrinking
  @params[:probability] = probability
  @params[:cache_size] = cache_size.to_f
  @params[:tol] = tol.to_f
  @params[:verbose] = verbose
  @params[:random_seed] = random_seed.nil? ? nil : random_seed.to_i
end

Instance Method Details

#decision_function(x) ⇒ Numo::DFloat

Calculate confidence scores for samples.

Parameters:

  • x (Numo::DFloat) —

    (shape: [n_samples, n_features]) The samples to compute the scores. If the kernel is ‘precomputed’, the shape of x must be [n_samples, n_training_samples].

Returns:

  • (Numo::DFloat) —

    (shape: [n_samples, n_classes]) Confidence score per sample.



69
70
71
72
73
74
 
# File 'lib/rumale/svm/svc.rb', line 69

def decision_function(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

#duel_coef ⇒ Numo::DFloat

Return the coefficients of the support vector in decision function.

Returns:

  • (Numo::DFloat) —

    (shape: [n_classes - 1, n_support_vectors])



136
137
138
 
# File 'lib/rumale/svm/svc.rb', line 136

def duel_coef
  @model[:sv_coef]
end

#fit(x, y) ⇒ SVC

Fit the model with given training data.

Parameters:

  • x (Numo::DFloat) —

    (shape: [n_samples, n_features]) The training data to be used for fitting the model. If the kernel is ‘precomputed’, x must be a square distance matrix (shape: [n_samples, n_samples]).

  • y (Numo::Int32) —

    (shape: [n_samples]) The labels to be used for fitting the model.

Returns:

  • (SVC) —

    The learned classifier itself.



55
56
57
58
59
60
61
62
 
# File 'lib/rumale/svm/svc.rb', line 55

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)
  xx = precomputed_kernel? ? add_index_col(x) : x
  @model = Numo::Libsvm.train(xx, y, libsvm_params)
  self
end

#intercept ⇒ Numo::DFloat

Return the intercepts in decision function.

Returns:

  • (Numo::DFloat) —

    (shape: [n_classes * (n_classes - 1) / 2])



142
143
144
 
# File 'lib/rumale/svm/svc.rb', line 142

def intercept
  @model[:rho]
end

#marshal_dump ⇒ Hash

Dump marshal data.

Returns:

  • (Hash) —

    The marshal data about SVC.



103
104
105
106
 
# File 'lib/rumale/svm/svc.rb', line 103

def marshal_dump
  { params: @params,
    model: @model }
end

#marshal_load(obj) ⇒ nil

Load marshal data.

Returns:

  • (nil) 


110
111
112
113
114
 
# File 'lib/rumale/svm/svc.rb', line 110

def marshal_load(obj)
  @params = obj[:params]
  @model = obj[:model]
  nil
end

#n_support ⇒ Numo::Int32

Return the number of support vectors for each class.

Returns:

  • (Numo::Int32) —

    (shape: [n_classes])



130
131
132
 
# File 'lib/rumale/svm/svc.rb', line 130

def n_support
  @model[:nSV]
end

#predict(x) ⇒ Numo::Int32

Predict class labels for samples.

Parameters:

  • x (Numo::DFloat) —

    (shape: [n_samples, n_features]) The samples to predict the labels. If the kernel is ‘precomputed’, the shape of x must be [n_samples, n_training_samples].

Returns:

  • (Numo::Int32) —

    (shape: [n_samples]) Predicted class label per sample.



81
82
83
84
85
86
 
# File 'lib/rumale/svm/svc.rb', line 81

def predict(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

#predict_proba(x) ⇒ Numo::DFloat

Predict class probability for samples. This method works correctly only if the probability parameter is true.

Parameters:

  • x (Numo::DFloat) —

    (shape: [n_samples, n_features]) The samples to predict the probailities. If the kernel is ‘precomputed’, the shape of x must be [n_samples, n_training_samples].

Returns:

  • (Numo::DFloat) —

    (shape: [n_samples, n_classes]) Predicted probability of each class per sample.



94
95
96
97
98
99
 
# File 'lib/rumale/svm/svc.rb', line 94

def predict_proba(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

#prob_a ⇒ Numo::DFloat

Return the probability parameter alpha.

Returns:

  • (Numo::DFloat) —

    (shape: [n_classes * (n_classes - 1) / 2])



148
149
150
 
# File 'lib/rumale/svm/svc.rb', line 148

def prob_a
  @model[:probA]
end

#prob_b ⇒ Numo::DFloat

Return the probability parameter beta.

Returns:

  • (Numo::DFloat) —

    (shape: [n_classes * (n_classes - 1) / 2])



154
155
156
 
# File 'lib/rumale/svm/svc.rb', line 154

def prob_b
  @model[:probB]
end

#support ⇒ Numo::Int32

Return the indices of support vectors.

Returns:

  • (Numo::Int32) —

    (shape: [n_support_vectors])



118
119
120
 
# File 'lib/rumale/svm/svc.rb', line 118

def support
  @model[:sv_indices]
end

#support_vectors ⇒ Numo::DFloat

Return the support_vectors.

Returns:

  • (Numo::DFloat) —

    (shape: [n_support_vectors, n_features])



124
125
126
 
# File 'lib/rumale/svm/svc.rb', line 124

def support_vectors
  precomputed_kernel? ? del_index_col(@model[:SV]) : @model[:SV]
end