Class: Rumale::LinearModel::SVR

Inherits:
BaseEstimator show all
Includes:
Base::Regressor
Defined in:
rumale-linear_model/lib/rumale/linear_model/svr.rb

Overview

Note:

Rumale::SVM provides linear and kernel support vector regressor based on LIBLINEAR and LIBSVM. If you prefer execution speed, you should use Rumale::SVM::LinearSVR. github.com/yoshoku/rumale-svm

SVR is a class that implements Support Vector Regressor with the squared epsilon-insensitive loss.

Examples:

require 'rumale/linear_model/svr'

estimator = Rumale::LinearModel::SVR.new(reg_param: 1.0, epsilon: 0.1)
estimator.fit(training_samples, traininig_target_values)
results = estimator.predict(testing_samples)

Instance Attribute Summary

Attributes inherited from BaseEstimator

#bias_term, #weight_vec

Attributes inherited from Base::Estimator

#params

Instance Method Summary collapse

Methods included from Base::Regressor

#score

Constructor Details

#initialize(reg_param: 1.0, fit_bias: true, bias_scale: 1.0, epsilon: 0.1, max_iter: 1000, tol: 1e-4, n_jobs: nil, verbose: false) ⇒ SVR

Create a new regressor with Support Vector Machine by the SGD optimization.

Parameters:

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

    The regularization parameter.

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

    The flag indicating whether to fit the bias term.

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

    The scale of the bias term.

  • epsilon (Float) (defaults to: 0.1) —

    The margin of tolerance.

  • max_iter (Integer) (defaults to: 1000) —

    The maximum number of epochs that indicates how many times the whole data is given to the training process.

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

    The tolerance of loss for terminating optimization.

  • n_jobs (Integer) (defaults to: nil) —

    The number of jobs for running the fit method in parallel. If nil is given, the method does not execute in parallel. If zero or less is given, it becomes equal to the number of processors. This parameter is ignored if the Parallel gem is not loaded.

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

    The flag indicating whether to output loss during iteration.



42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'rumale-linear_model/lib/rumale/linear_model/svr.rb', line 42

def initialize(reg_param: 1.0, fit_bias: true, bias_scale: 1.0, epsilon: 0.1, max_iter: 1000, tol: 1e-4,
               n_jobs: nil, verbose: false)
  super()
  @params = {
    reg_param: reg_param,
    fit_bias: fit_bias,
    bias_scale: bias_scale,
    epsilon: epsilon,
    max_iter: max_iter,
    tol: tol,
    n_jobs: n_jobs,
    verbose: verbose
  }
end

Instance Method Details

#fit(x, y) ⇒ SVR

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.

  • y (Numo::DFloat) —

    (shape: [n_samples, n_outputs]) The target values to be used for fitting the model.

Returns:

  • (SVR) —

    The learned regressor itself.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'rumale-linear_model/lib/rumale/linear_model/svr.rb', line 62

def fit(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)

  n_outputs = y.shape[1].nil? ? 1 : y.shape[1]
  n_features = x.shape[1]

  if n_outputs > 1
    @weight_vec = Numo::DFloat.zeros(n_outputs, n_features)
    @bias_term = Numo::DFloat.zeros(n_outputs)
    if enable_parallel?
      models = parallel_map(n_outputs) { |n| partial_fit(x, y[true, n]) }
      n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = models[n] }
    else
      n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
    end
  else
    @weight_vec, @bias_term = partial_fit(x, y)
  end

  self
end

#predict(x) ⇒ Numo::DFloat

Predict values for samples.

Parameters:

  • x (Numo::DFloat) —

    (shape: [n_samples, n_features]) The samples to predict the values.

Returns:

  • (Numo::DFloat) —

    (shape: [n_samples, n_outputs]) Predicted values per sample.



90
91
92
93
94
 
# File 'rumale-linear_model/lib/rumale/linear_model/svr.rb', line 90

def predict(x)
  x = ::Rumale::Validation.check_convert_sample_array(x)

  x.dot(@weight_vec.transpose) + @bias_term
end