Class: SVMKit::LinearModel::SVR

Inherits:
SGDLinearEstimator show all
Includes:
Base::Regressor
Defined in:
lib/svmkit/linear_model/svr.rb

Overview

SVR is a class that implements Support Vector Regressor with mini-batch stochastic gradient descent optimization.

Reference

    1. Shalev-Shwartz and Y. Singer, “Pegasos: Primal Estimated sub-GrAdient SOlver for SVM,” Proc. ICML’07, pp. 807–814, 2007.

Examples:

estimator =
  SVMKit::LinearModel::SVR.new(reg_param: 1.0, epsilon: 0.1, max_iter: 1000, batch_size: 20, random_seed: 1)
estimator.fit(training_samples, traininig_target_values)
results = estimator.predict(testing_samples)

Instance Attribute Summary collapse

Attributes included from Base::BaseEstimator

#params

Instance Method Summary collapse

Methods included from Base::Regressor

#score

Constructor Details

#initialize(reg_param: 1.0, fit_bias: false, bias_scale: 1.0, epsilon: 0.1, max_iter: 1000, batch_size: 20, optimizer: nil, random_seed: nil) ⇒ 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: false) —

    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 iterations.

  • batch_size (Integer) (defaults to: 20) —

    The size of the mini batches.

  • optimizer (Optimizer) (defaults to: nil) —

    The optimizer to calculate adaptive learning rate. If nil is given, Nadam is used.

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

    The seed value using to initialize the random generator.



47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/svmkit/linear_model/svr.rb', line 47

def initialize(reg_param: 1.0, fit_bias: false, bias_scale: 1.0, epsilon: 0.1,
               max_iter: 1000, batch_size: 20, optimizer: nil, random_seed: nil)
  check_params_float(reg_param: reg_param, bias_scale: bias_scale, epsilon: epsilon)
  check_params_integer(max_iter: max_iter, batch_size: batch_size)
  check_params_boolean(fit_bias: fit_bias)
  check_params_type_or_nil(Integer, random_seed: random_seed)
  check_params_positive(reg_param: reg_param, bias_scale: bias_scale, epsilon: epsilon,
                        max_iter: max_iter, batch_size: batch_size)
  super(reg_param: reg_param, fit_bias: fit_bias, bias_scale: bias_scale,
        max_iter: max_iter, batch_size: batch_size, optimizer: optimizer, random_seed: random_seed)
  @params[:epsilon] = epsilon
end

Instance Attribute Details

#bias_term ⇒ Numo::DFloat (readonly)

Return the bias term (a.k.a. intercept) for SVR.

Returns:

  • (Numo::DFloat) —

    (shape: [n_outputs])



30
31
32
 
# File 'lib/svmkit/linear_model/svr.rb', line 30

def bias_term
  @bias_term
end

#rng ⇒ Random (readonly)

Return the random generator for performing random sampling.

Returns:

  • (Random) 


34
35
36
 
# File 'lib/svmkit/linear_model/svr.rb', line 34

def rng
  @rng
end

#weight_vec ⇒ Numo::DFloat (readonly)

Return the weight vector for SVR.

Returns:

  • (Numo::DFloat) —

    (shape: [n_outputs, n_features])



26
27
28
 
# File 'lib/svmkit/linear_model/svr.rb', line 26

def weight_vec
  @weight_vec
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.



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/svmkit/linear_model/svr.rb', line 65

def fit(x, y)
  check_sample_array(x)
  check_tvalue_array(y)
  check_sample_tvalue_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)
    n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
  else
    @weight_vec, @bias_term = partial_fit(x, y)
  end

  self
end

#marshal_dump ⇒ Hash

Dump marshal data.

Returns:

  • (Hash) —

    The marshal data about SVR.



95
96
97
98
99
100
 
# File 'lib/svmkit/linear_model/svr.rb', line 95

def marshal_dump
  { params: @params,
    weight_vec: @weight_vec,
    bias_term: @bias_term,
    rng: @rng }
end

#marshal_load(obj) ⇒ nil

Load marshal data.

Returns:

  • (nil) 


104
105
106
107
108
109
110
 
# File 'lib/svmkit/linear_model/svr.rb', line 104

def marshal_load(obj)
  @params = obj[:params]
  @weight_vec = obj[:weight_vec]
  @bias_term = obj[:bias_term]
  @rng = obj[:rng]
  nil
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.



88
89
90
91
 
# File 'lib/svmkit/linear_model/svr.rb', line 88

def predict(x)
  check_sample_array(x)
  x.dot(@weight_vec.transpose) + @bias_term
end