Source code for traveltimes_prediction.models.algorithms.svr_wrapper
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
import numpy as np
from ..base_model import BaseModel
[docs]class SVRWrapper(BaseModel, SVR):
"""
Class - wrapper for SVR.
"""
name = 'SVR'
def __init__(self, **kwargs):
"""
Constructor.
:param dict kwargs:
"""
super().__init__(**kwargs)
self.scaler = StandardScaler()
self.min_y_train = None
[docs] def fit(self, X, y, sample_weight=None):
"""
Method for fitting of the estimator.
:param numpy.ndarray X:
:param numpy.ndarray y:
:param numpy.ndarray sample_weight:
:return: object - self
"""
self._get_descriptors(X)
self.scaler = self.scaler.fit(X)
X = self.scaler.transform(X)
self.min_y_train = np.percentile(y, 10)
super().fit(X, y, sample_weight)
return self
[docs] def predict(self, X):
"""
Method for prediction the output value.
:param numpy.ndarray X:
:return: list
"""
X = self._impute_prediction_sample(X=X)
X = self.scaler.transform(X)
return self._coerce(super().predict(X=X))
@staticmethod
[docs] def load(model):
"""
Method for loading of the already dumped model - recreating it.
:param dict model:
:return: instance of SVRWrapper
"""
inst = SVRWrapper()
inst.support_ = np.array(model['support_'])
inst.support_vectors_ = np.array(model['support_vectors_'])
inst.dual_coef_ = np.array(model['dual_coef_'])
inst._dual_coef_ = np.array(model['_dual_coef_'])
inst.intercept_ = np.array(model['intercept_'])
inst._intercept_ = np.array(model['_intercept_'])
inst._sparse = model['_sparse']
inst.shape_fit_ = model['shape_fit_']
inst.n_support_ = np.array(model['n_support_'])
inst.probA_ = np.array(model['probA_'])
inst.probB_ = np.array(model['probB_'])
inst._gamma = model['_gamma']
inst.min_y_train = model['min_y_train']
inst.scaler.scale_ = np.array(model['scaler']['scale_'])
inst.scaler.mean_ = np.array(model['scaler']['mean_'])
inst.scaler.var_ = np.array(model['scaler']['var_'])
inst.scaler.n_samples_seen_d = model['scaler']['n_samples_seen_']
inst._median_imputer = np.array(model['_median_imputer'])
return inst
[docs] def dump(self):
"""
Method for dumping of the model.
:return: dict
"""
d = dict()
d['model'] = dict()
d['model']['support_'] = self.support_.tolist()
d['model']['support_vectors_'] = self.support_vectors_.tolist()
d['model']['dual_coef_'] = self.dual_coef_.tolist()
d['model']['_dual_coef_'] = self._dual_coef_.tolist()
d['model']['intercept_'] = self.intercept_.tolist()
d['model']['_intercept_'] = self._intercept_.tolist()
d['model']['_sparse'] = self._sparse
d['model']['shape_fit_'] = self.shape_fit_
d['model']['n_support_'] = self.n_support_.tolist()
d['model']['probA_'] = self.probA_.tolist()
d['model']['probB_'] = self.probB_.tolist()
d['model']['_gamma'] = self._gamma
d['model']['min_y_train'] = self.min_y_train
d['model']['scaler'] = dict()
d['model']['scaler']['scale_'] = self.scaler.scale_.tolist()
d['model']['scaler']['mean_'] = self.scaler.mean_.tolist()
d['model']['scaler']['var_'] = self.scaler.var_.tolist()
d['model']['scaler']['n_samples_seen_'] = self.scaler.n_samples_seen_
d['model']['_median_imputer'] = self._median_imputer.tolist()
d['model_type'] = self.name
return d