SVR
¶
-
class
ibex.sklearn.svm.
SVR
(kernel='rbf', degree=3, gamma='auto', coef0=0.0, tol=0.001, C=1.0, epsilon=0.1, shrinking=True, cache_size=200, verbose=False, max_iter=-1)¶ Bases:
sklearn.svm.classes.SVR
,ibex._base.FrameMixin
Note
The documentation following is of the class wrapped by this class. There are some changes, in particular:
- A parameter
X
denotes apandas.DataFrame
. - A parameter
y
denotes apandas.Series
.
Note
The documentation following is of the original class wrapped by this class. This class wraps the attribute
coef_
.Example:
>>> import pandas as pd >>> import numpy as np >>> from ibex.sklearn import datasets >>> from ibex.sklearn.linear_model import LinearRegression as PdLinearRegression
>>> iris = datasets.load_iris() >>> features = iris['feature_names'] >>> iris = pd.DataFrame( ... np.c_[iris['data'], iris['target']], ... columns=features+['class'])
>>> iris[features] sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) 0 5.1 3.5 1.4 0.2 1 4.9 3.0 1.4 0.2 2 4.7 3.2 1.3 0.2 3 4.6 3.1 1.5 0.2 4 5.0 3.6 1.4 0.2 ...
>>> from ibex.sklearn import svm as pd_svm >>> >>> prd = pd_svm.SVR(kernel='linear').fit(iris[features], iris['class']) >>> >>> prd.coef_ sepal length (cm) ... sepal width (cm) ... petal length (cm) ... petal width (cm) ... dtype: float64
Note
The documentation following is of the original class wrapped by this class. This class wraps the attribute
intercept_
.Example:
>>> import pandas as pd >>> import numpy as np >>> from ibex.sklearn import datasets >>> from ibex.sklearn.linear_model import LinearRegression as PdLinearRegression
>>> iris = datasets.load_iris() >>> features = iris['feature_names'] >>> iris = pd.DataFrame( ... np.c_[iris['data'], iris['target']], ... columns=features+['class'])
>>> iris[features] sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) 0 5.1 3.5 1.4 0.2 1 4.9 3.0 1.4 0.2 2 4.7 3.2 1.3 0.2 3 4.6 3.1 1.5 0.2 4 5.0 3.6 1.4 0.2 ...
>>> >>> from ibex.sklearn import svm as pd_svm >>> >>> prd = pd_svm.SVR(kernel='linear').fit(iris[features], iris['class']) >>> >>> #scalar intercept >>> type(prd.intercept_) <class 'numpy.float64'>
Epsilon-Support Vector Regression.
The free parameters in the model are C and epsilon.
The implementation is based on libsvm.
Read more in the User Guide.
- C : float, optional (default=1.0)
- Penalty parameter C of the error term.
- epsilon : float, optional (default=0.1)
- Epsilon in the epsilon-SVR model. It specifies the epsilon-tube within which no penalty is associated in the training loss function with points predicted within a distance epsilon from the actual value.
- kernel : string, optional (default=’rbf’)
- Specifies the kernel type to be used in the algorithm. It must be one of ‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’ or a callable. If none is given, ‘rbf’ will be used. If a callable is given it is used to precompute the kernel matrix.
- degree : int, optional (default=3)
- Degree of the polynomial kernel function (‘poly’). Ignored by all other kernels.
- gamma : float, optional (default=’auto’)
- Kernel coefficient for ‘rbf’, ‘poly’ and ‘sigmoid’. If gamma is ‘auto’ then 1/n_features will be used instead.
- coef0 : float, optional (default=0.0)
- Independent term in kernel function. It is only significant in ‘poly’ and ‘sigmoid’.
- shrinking : boolean, optional (default=True)
- Whether to use the shrinking heuristic.
- tol : float, optional (default=1e-3)
- Tolerance for stopping criterion.
- cache_size : float, optional
- Specify the size of the kernel cache (in MB).
- verbose : bool, default: False
- Enable verbose output. Note that this setting takes advantage of a per-process runtime setting in libsvm that, if enabled, may not work properly in a multithreaded context.
- max_iter : int, optional (default=-1)
- Hard limit on iterations within solver, or -1 for no limit.
- support_ : array-like, shape = [n_SV]
- Indices of support vectors.
- support_vectors_ : array-like, shape = [nSV, n_features]
- Support vectors.
- dual_coef_ : array, shape = [1, n_SV]
- Coefficients of the support vector in the decision function.
- coef_ : array, shape = [1, n_features]
Weights assigned to the features (coefficients in the primal problem). This is only available in the case of a linear kernel.
coef_ is readonly property derived from dual_coef_ and support_vectors_.
- intercept_ : array, shape = [1]
- Constants in decision function.
- sample_weight : array-like, shape = [n_samples]
- Individual weights for each sample
>>> from sklearn.svm import SVR >>> import numpy as np >>> n_samples, n_features = 10, 5 >>> np.random.seed(0) >>> y = np.random.randn(n_samples) >>> X = np.random.randn(n_samples, n_features) >>> clf = SVR(C=1.0, epsilon=0.2) >>> clf.fit(X, y) SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.2, gamma='auto', kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
- NuSVR
- Support Vector Machine for regression implemented using libsvm using a parameter to control the number of support vectors.
- LinearSVR
- Scalable Linear Support Vector Machine for regression implemented using liblinear.
-
fit
(X, y, sample_weight=None)¶ Note
The documentation following is of the class wrapped by this class. There are some changes, in particular:
- A parameter
X
denotes apandas.DataFrame
. - A parameter
y
denotes apandas.Series
.
Fit the SVM model according to the given training data.
- X : {array-like, sparse matrix}, shape (n_samples, n_features)
- Training vectors, where n_samples is the number of samples and n_features is the number of features. For kernel=”precomputed”, the expected shape of X is (n_samples, n_samples).
- y : array-like, shape (n_samples,)
- Target values (class labels in classification, real numbers in regression)
- sample_weight : array-like, shape (n_samples,)
- Per-sample weights. Rescale C per sample. Higher weights force the classifier to put more emphasis on these points.
- self : object
- Returns self.
If X and y are not C-ordered and contiguous arrays of np.float64 and X is not a scipy.sparse.csr_matrix, X and/or y may be copied.
If X is a dense array, then the other methods will not support sparse matrices as input.
- A parameter
-
predict
(X)¶ Note
The documentation following is of the class wrapped by this class. There are some changes, in particular:
- A parameter
X
denotes apandas.DataFrame
. - A parameter
y
denotes apandas.Series
.
Perform regression on samples in X.
For an one-class model, +1 (inlier) or -1 (outlier) is returned.
- X : {array-like, sparse matrix}, shape (n_samples, n_features)
- For kernel=”precomputed”, the expected shape of X is (n_samples_test, n_samples_train).
y_pred : array, shape (n_samples,)
- A parameter
-
score
(X, y, sample_weight=None)¶ Note
The documentation following is of the class wrapped by this class. There are some changes, in particular:
- A parameter
X
denotes apandas.DataFrame
. - A parameter
y
denotes apandas.Series
.
Returns the coefficient of determination R^2 of the prediction.
The coefficient R^2 is defined as (1 - u/v), where u is the residual sum of squares ((y_true - y_pred) ** 2).sum() and v is the total sum of squares ((y_true - y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a R^2 score of 0.0.
- X : array-like, shape = (n_samples, n_features)
- Test samples.
- y : array-like, shape = (n_samples) or (n_samples, n_outputs)
- True values for X.
- sample_weight : array-like, shape = [n_samples], optional
- Sample weights.
- score : float
- R^2 of self.predict(X) wrt. y.
- A parameter
- A parameter