sklearn.svm .SVR¶
class sklearn.svm. SVR ( * , kernel = ‘rbf’ , degree = 3 , gamma = ‘scale’ , coef0 = 0.0 , tol = 0.001 , C = 1.0 , epsilon = 0.1 , shrinking = True , cache_size = 200 , verbose = False , max_iter = -1 ) [source] ¶
Epsilon-Support Vector Regression.
The free parameters in the model are C and epsilon.
The implementation is based on libsvm. The fit time complexity is more than quadratic with the number of samples which makes it hard to scale to datasets with more than a couple of 10000 samples. For large datasets consider using LinearSVR or SGDRegressor instead, possibly after a Nystroem transformer or other Kernel Approximation .
Read more in the User Guide .
Parameters : kernel or callable, default=’rbf’
Specifies the kernel type to be used in the algorithm. If none is given, ‘rbf’ will be used. If a callable is given it is used to precompute the kernel matrix.
degree int, default=3
Degree of the polynomial kernel function (‘poly’). Must be non-negative. Ignored by all other kernels.
gamma or float, default=’scale’
Kernel coefficient for ‘rbf’, ‘poly’ and ‘sigmoid’.
- if gamma=’scale’ (default) is passed then it uses 1 / (n_features * X.var()) as value of gamma,
- if ‘auto’, uses 1 / n_features
- if float, must be non-negative.
Changed in version 0.22: The default value of gamma changed from ‘auto’ to ‘scale’.
coef0 float, default=0.0
Independent term in kernel function. It is only significant in ‘poly’ and ‘sigmoid’.
tol float, default=1e-3
Tolerance for stopping criterion.
C float, default=1.0
Regularization parameter. The strength of the regularization is inversely proportional to C. Must be strictly positive. The penalty is a squared l2 penalty.
epsilon float, 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. Must be non-negative.
shrinking bool, default=True
Whether to use the shrinking heuristic. See the User Guide .
cache_size float, default=200
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, default=-1
Hard limit on iterations within solver, or -1 for no limit.
Attributes : class_weight_ ndarray of shape (n_classes,)
Multipliers of parameter C for each class. Computed based on the class_weight parameter.
Deprecated since version 1.2: class_weight_ was deprecated in version 1.2 and will be removed in 1.4.
coef_ ndarray of shape (1, n_features)
Weights assigned to the features when kernel=»linear» .
dual_coef_ ndarray of shape (1, n_SV)
Coefficients of the support vector in the decision function.
fit_status_ int
0 if correctly fitted, 1 otherwise (will raise warning)
intercept_ ndarray of shape (1,)
Constants in decision function.
n_features_in_ int
Number of features seen during fit .
New in version 0.24.
feature_names_in_ ndarray of shape ( n_features_in_ ,)
Names of features seen during fit . Defined only when X has feature names that are all strings.
New in version 1.0.
n_iter_ int
Number of iterations run by the optimization routine to fit the model.
New in version 1.1.
n_support_ ndarray of shape (1,), dtype=int32
Number of support vectors for each class.
shape_fit_ tuple of int of shape (n_dimensions_of_X,)
Array dimensions of training vector X .
support_ ndarray of shape (n_SV,)
Indices of support vectors.
support_vectors_ ndarray of shape (n_SV, n_features)
Support Vector Machine for regression implemented using libsvm using a parameter to control the number of support vectors.
Scalable Linear Support Vector Machine for regression implemented using liblinear.
>>> from sklearn.svm import SVR >>> from sklearn.pipeline import make_pipeline >>> from sklearn.preprocessing import StandardScaler >>> import numpy as np >>> n_samples, n_features = 10, 5 >>> rng = np.random.RandomState(0) >>> y = rng.randn(n_samples) >>> X = rng.randn(n_samples, n_features) >>> regr = make_pipeline(StandardScaler(), SVR(C=1.0, epsilon=0.2)) >>> regr.fit(X, y) Pipeline(steps=[('standardscaler', StandardScaler()), ('svr', SVR(epsilon=0.2))])
fit (X, y[, sample_weight])
Fit the SVM model according to the given training data.
Get metadata routing of this object.
Get parameters for this estimator.
Perform regression on samples in X.
score (X, y[, sample_weight])
Return the coefficient of determination of the prediction.
Request metadata passed to the fit method.
Set the parameters of this estimator.
Request metadata passed to the score method.
Weights assigned to the features when kernel=»linear» .
Returns : ndarray of shape (n_features, n_classes) fit ( X , y , sample_weight = None ) [source] ¶
Fit the SVM model according to the given training data.
Parameters : X of shape (n_samples, n_features) or (n_samples, n_samples)
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 of shape (n_samples,)
Target values (class labels in classification, real numbers in regression).
sample_weight array-like of shape (n_samples,), default=None
Per-sample weights. Rescale C per sample. Higher weights force the classifier to put more emphasis on these points.
Returns : self object
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.
Get metadata routing of this object.
Please check User Guide on how the routing mechanism works.
Returns : routing MetadataRequest
A MetadataRequest encapsulating routing information.
Get parameters for this estimator.
Parameters : deep bool, default=True
If True, will return the parameters for this estimator and contained subobjects that are estimators.
Returns : params dict
Parameter names mapped to their values.
Number of support vectors for each class.
Perform regression on samples in X.
For an one-class model, +1 (inlier) or -1 (outlier) is returned.
Parameters : X of shape (n_samples, n_features)
For kernel=”precomputed”, the expected shape of X is (n_samples_test, n_samples_train).
Returns : y_pred ndarray of shape (n_samples,)
The predicted values.
Return the coefficient of determination of the prediction.
The coefficient of determination \(R^2\) is defined as \((1 — \frac)\) , 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.
Parameters : X array-like of shape (n_samples, n_features)
Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead with shape (n_samples, n_samples_fitted) , where n_samples_fitted is the number of samples used in the fitting for the estimator.
y array-like of shape (n_samples,) or (n_samples, n_outputs)
True values for X .
sample_weight array-like of shape (n_samples,), default=None
Returns : score float
\(R^2\) of self.predict(X) w.r.t. y .
The \(R^2\) score used when calling score on a regressor uses multioutput=’uniform_average’ from version 0.23 to keep consistent with default value of r2_score . This influences the score method of all the multioutput regressors (except for MultiOutputRegressor ).
Request metadata passed to the fit method.
Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config ). Please see User Guide on how the routing mechanism works.
The options for each parameter are:
- True : metadata is requested, and passed to fit if provided. The request is ignored if metadata is not provided.
- False : metadata is not requested and the meta-estimator will not pass it to fit .
- None : metadata is not requested, and the meta-estimator will raise an error if the user provides it.
- str : metadata should be passed to the meta-estimator with this given alias instead of the original name.
The default ( sklearn.utils.metadata_routing.UNCHANGED ) retains the existing request. This allows you to change the request for some parameters and not others.
New in version 1.3.
This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline . Otherwise it has no effect.
Parameters : sample_weight str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
Metadata routing for sample_weight parameter in fit .
Returns : self object
The updated object.
Set the parameters of this estimator.
The method works on simple estimators as well as on nested objects (such as Pipeline ). The latter have parameters of the form __ so that it’s possible to update each component of a nested object.
Parameters : **params dict
Returns : self estimator instance
set_score_request ( * , sample_weight : Union [ bool , None , str ] = ‘$UNCHANGED$’ ) → SVR [source] ¶
Request metadata passed to the score method.
Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config ). Please see User Guide on how the routing mechanism works.
The options for each parameter are:
- True : metadata is requested, and passed to score if provided. The request is ignored if metadata is not provided.
- False : metadata is not requested and the meta-estimator will not pass it to score .
- None : metadata is not requested, and the meta-estimator will raise an error if the user provides it.
- str : metadata should be passed to the meta-estimator with this given alias instead of the original name.
The default ( sklearn.utils.metadata_routing.UNCHANGED ) retains the existing request. This allows you to change the request for some parameters and not others.
New in version 1.3.
This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline . Otherwise it has no effect.
Parameters : sample_weight str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED
Metadata routing for sample_weight parameter in score .
Returns : self object
Support Vector Regression using Python
Usually, Most of us get confused between support vector machine(SVM) and support vector regression(SVR). Well, the basic difference is that SVM is used in the classification, and SVR is used in the regression.
What exactly is an SVR? To understand what SVR is we are going to compare it with the linear regression.
As we all know, in linear regression we draw the linear line through the data points, then we project a vertical projection of the data points on the regression line to find the minimum distance.
We will do something like that but instead of drawing only the regression line, we will draw a tube(you can see the dotted lines in the above image). We won’t have to worry about the points which are inside the tube or on the dotted line. Now, the points which are outside the tube, we will project their vertical projection on the dotted lines, not on the main axis line of the tube. This will reduce our errors, and we will have the minimum distances.
This method is called a support vector because the points which are outside the tube are called vectors.
We can use support vector regression on nonlinear data points using the different types kernels.
Kernel:
It is the method in which we use linear regression to solve non-linear regression problems. Different types of kernels,
- Linear
- Polynomial
- Gaussian RBF
- Exponential RBF, and many more
I will provide a link to my Kaggle notebook in the end.
Data:
We will use the dataset of Red wine which contains the quality of the wine. It has 13 columns with 1599 rows. There aren’t any missing values in the dataset.
Importing the libraries and dataset:
We will use Numpy, Pandas, and Scikit-learn libraries. After importing the dataset we will drop the first column of the dataset cause it contains the indexing so we won’t be needing it.
Now we will separate our dataset into independent(X) and dependent(y) variables.
#importing the libraries
import numpy as np
import pandas as pd#importing the dataset
dataset = pd.read_csv('Name_of_the_dataset.csv')
# Removing the unnecessary column
dataset.drop(['Unnamed: 0'], axis = 1, inplace = True)# seprating the dataset
X = X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, -1:].values
Splitting the dataset into training and testing sets:
We will use the scikit-learn library to split the dataset. The training set contains most of the data.
# Spliting the datdset
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
Feature Scaling:
Feature scaling refers to putting the values in the same range or same scale so that no variable is dominated by the other. We will not apply feature scaling on testing datasets. If the column contains dummy variables(binary values), then we won’t apply feature scaling on them.
from sklearn.preprocessing import StandardScaler
X_sc = StandardScaler()
y_sc = StandardScaler()
X_train = X_sc.fit_transform(X_train)
y_train = y_sc.fit_transform(y_train)
Training the dataset:
We will use the training set to train the dataset with the SVR model. You can use all the kernels and see which’s giving you the best result.
from sklearn.svm import SVR
regrassor = SVR(kernel = 'rbf')
regrassor.fit(X_train, y_train)
Predicting the result:
We have to use the inverse_transform() method from the StandardScaler class to inverse our values.
y_pred = regrassor.predict(X_sc.transform(X_test))
y_pred = y_sc.inverse_transform(y_pred)
Visualize the predicted and real values:
y_test = y_test.flatten()
df = pd.DataFrame()
df
1.4. Метод опорных векторов SVM ¶
Метод опорных векторов (Support Vector Machines — SVM) — это набор контролируемых методов обучения, используемых для классификации , регрессии и обнаружения выбросов .
- Эффективен в пространствах больших размеров.
- По-прежнему эффективен в случаях, когда количество измерений превышает количество образцов.
- Использует подмножество обучающих точек в функции принятия решений (называемых опорными векторами), поэтому это также эффективно с точки зрения памяти.
- Универсальность: для функции принятия решения могут быть указаны различные функции ядра . Предоставляются общие ядра, но также можно указать собственные ядра.
К недостаткам опорных векторных машин можно отнести:
- Если количество функций намного превышает количество выборок, избегайте чрезмерной подгонки при выборе функций ядра, и термин регуляризации имеет решающее значение.
- SVM не предоставляют напрямую оценки вероятностей, они рассчитываются с использованием дорогостоящей пятикратной перекрестной проверки (см. Оценки и вероятности ниже).
Метод опорных векторов в scikit-learn поддерживают как плотные ( numpy.ndarray и конвертируемые в это numpy.asarray ), так и разреженные (любые scipy.sparse ) выборочные векторы в качестве входных данных. Однако, чтобы использовать SVM для прогнозирования разреженных данных, он должен соответствовать этим данным. Для оптимальной производительности используйте C-порядковый numpy.ndarray (плотный) или scipy.sparse.csr_matrix (разреженный) с dtype=float64 .
1.4.1. Классификация
SVC , NuSVC и LinearSVC являются классами, способными выполнять двоичную и мультиклассовую классификацию набора данных.
SVC и NuSVC являются аналогичными методами, но принимают несколько разные наборы параметров и имеют разные математические формулировки (см. раздел Математическая формулировка ). С другой стороны, LinearSVC это еще одна (более быстрая) реализация классификации опорных векторов для случая линейного ядра. Обратите внимание, что LinearSVC параметр не принимает kernel , так как предполагается, что он линейный. Ему также не хватает некоторых атрибутов SVC и NuSVC , например support_ .
Как и другие классификаторы SVC , NuSVC и LinearSVC в качестве входных двух массивов: массив X формы (n_samples, n_features), проведение обучающих выборок, и массив y из класса меток (строки или целые числа), в форме (n_samples):
>>> from sklearn import svm >>> X = [[0, 0], [1, 1]] >>> y = [0, 1] >>> clf = svm.SVC() >>> clf.fit(X, y) SVC()
После установки модель может быть использована для прогнозирования новых значений:
>>> clf.predict([[2., 2.]]) array([1])
Функция принятия решения SVM (подробно описанная в математической формулировке ) зависит от некоторого подмножества обучающих данных, называемых опорными векторами. Некоторые свойства этих опорных векторов можно найти в атрибутах support_vectors_ , support_ а также n_support_ :
>>> # get support vectors >>> clf.support_vectors_ array([[0., 0.], [1., 1.]]) >>> # get indices of support vectors >>> clf.support_ array([0, 1]. ) >>> # get number of support vectors for each class >>> clf.n_support_ array([1, 1]. )
- SVM: максимальное поле, разделяющее гиперплоскость ,
- Нелинейный SVM
- SVM-Anova: SVM с одномерным выбором функций ,
1.4.1.1. Мультиклассовая классификация
SVC и NuSVC реализовать подход «один против одного» для классификации по нескольким классам. Всего построены n_classes * (n_classes — 1) / 2 классификаторов, каждый из которых обучает данные из двух классов. Чтобы обеспечить согласованный интерфейс с другими классификаторами, опция decision_function_shape позволяет монотонно преобразовывать результаты классификаторов «один против одного» в функцию принятия решения формы «один против остальных» (n_samples, n_classes) .
>>> X = [[0], [1], [2], [3]] >>> Y = [0, 1, 2, 3] >>> clf = svm.SVC(decision_function_shape='ovo') >>> clf.fit(X, Y) SVC(decision_function_shape='ovo') >>> dec = clf.decision_function([[1]]) >>> dec.shape[1] # 4 classes: 4*3/2 = 6 6 >>> clf.decision_function_shape = "ovr" >>> dec = clf.decision_function([[1]]) >>> dec.shape[1] # 4 classes 4
С другой стороны, LinearSVC реализует мультиклассовую стратегию «один против остальных», таким образом обучая n_classes модели.
>>> lin_clf = svm.LinearSVC() >>> lin_clf.fit(X, Y) LinearSVC() >>> dec = lin_clf.decision_function([[1]]) >>> dec.shape[1] 4
См. « Математическая формулировка» для полного описания решающей функции.
Обратите внимание, что LinearSVC также реализуется альтернативная мультиклассовая стратегия, так называемая мультиклассовая SVM, сформулированная Краммером и Зингером 16 , с использованием этой опции multi_class=’crammer_singer’ . На практике обычно предпочтительнее использовать классификацию «один против остальных», поскольку результаты в основном схожи, но время выполнения значительно меньше.
Для «один против остальных» LinearSVC атрибуты coef_ и intercept_ имеют форму (n_classes, n_features) и (n_classes, ) соответственно. Каждая строка коэффициентов соответствует одному из классификаторов n_classes «один против остальных» и аналогичных для перехватов в порядке класса «один».
В случае «один против одного» SVC и NuSVC расположение атрибутов немного сложнее. В случае линейного ядра атрибуты coef_ и intercept_ имеют форму (n_classes * (n_classes — 1) / 2, n_features) и (n_classes * (n_classes — 1) / 2) соответственно. Это похоже на схему LinearSVC , описанную выше, где каждая строка теперь соответствует двоичному классификатору. Порядок для классов от 0 до n: «0 против 1», «0 против 2»,… «0 против n», «1 против 2», «1 против 3», «1 против n»,. . . «П-1 против п».
Форма dual_coef_ является (n_classes-1, n_SV) с довольно трудно макетом обхвата. Столбцы соответствуют опорным векторам, включенным в любой из n_classes * (n_classes — 1) / 2 классификаторов «один на один». Каждый из опорных векторов используется в n_classes — 1 классификаторах. Эти n_classes — 1 записи в каждой строке соответствует двойственным коэффициентам для этих классификаторов.
Это может быть яснее на примере: рассмотрим проблему трех классов с классом 0, имеющим три опорных вектора. $v_0^0$,$v_0^1$,$v_0^2$ и классы 1 и 2, имеющие два опорных вектора $v_1^0$,$v_1^1$ а также $v_2^0$,$v_2^1$ соответственно. Для каждого опорного вектора $v_i^j$, есть два двойственных коэффициента. Назовем коэффициент опоры вектором $v_i^j$ в классификаторе между классами $i$ а также $k$ $\alpha^_$. Тогда dual_coef_ выглядит так:
| $\alpha^_$ | $\alpha^_$ | Коэффициенты для КА класса 0 |
| $\alpha^_$ | $\alpha^_$ | Коэффициенты для КА класса 0 |
| $\alpha^_$ | $\alpha^_$ | Коэффициенты для КА класса 0 |
| $\alpha^_$ | $\alpha^_$ | Коэффициенты для КА класса 1 |
| $\alpha^_$ | $\alpha^_$ | Коэффициенты для КА класса 1 |
| $\alpha^_$ | $\alpha^_$ | Коэффициенты для КА 2 класса |
| $\alpha^_$ | $\alpha^_$ | Коэффициенты для КА 2 класса |
1.4.1.2. Результаты и вероятности
Метод decision_function из SVC и NuSVC дает по классам баллов для каждого образца (или единого показателя на образец в двоичном случае). Если для параметра конструктора probability установлено значение True , включаются оценки вероятности членства в классе (из методов predict_proba и predict_log_proba ). В двоичном случае вероятности калибруются с использованием шкалы Платта 9 : логистическая регрессия по оценкам SVM, согласованная с помощью дополнительной перекрестной проверки данных обучения. В случае мультикласса это расширяется в соответствии с 10 .
Та же процедура калибровки вероятности доступна для всех оценщиков через CalibratedClassifierCV (см. Калибровка вероятности ). В случае SVC и NuSVC эта процедура встроена в libsvm, которая используется под капотом, поэтому она не полагается на scikit-learn CalibratedClassifierCV .
Перекрестная проверка, связанная с масштабированием Platt, — дорогостоящая операция для больших наборов данных. Кроме того, оценки вероятности могут не соответствовать оценкам:
- «argmax» оценок может не быть argmax вероятностей.
- в бинарной классификации образец может быть помечен predict как принадлежащий к положительному классу, даже если выход predict_proba с оставляет менее 0,5; и аналогично, он может быть помечен как отрицательный, даже если выход predict_proba больше 0,5.
Известно также, что метод Платта имеет теоретические проблемы. Если требуются оценки достоверности, но они не обязательно должны быть вероятностями, то рекомендуется установить probability=False и использовать decision_function вместо predict_proba .
Обратите внимание, что когда decision_function_shape=’ovr’ и n_classes > 2, в отличие от decision_function, метод predict не пытается разорвать связи по умолчанию. Вы можете установить break_ties=True, чтобы вывод predict был таким же, как np.argmax(clf.decision_function(…), axis=1), иначе всегда будет возвращаться первый класс среди связанных классов; но имейте в виду, что это связано с вычислительными затратами. См. Пример разрыва связи SVM в примере .
1.4.1.3. Несбалансированные проблемы
В задачах, где желательно придать большее значение определенным классам или определенным отдельным образцам, можно использовать параметры class_weight и sample_weight .
SVC (но не NuSVC ) реализует параметр class_weight в fit методе. Это словарь формы , где значение — это число с плавающей точкой number > 0, которое устанавливает С для параметра класса class_label значение C * value. На рисунке ниже показана граница решения несбалансированной проблемы с поправкой на вес и без нее.
SVC , NuSVC , SVR , NuSVR , LinearSVC , LinearSVR и OneClassSVM осуществить также веса для отдельных образцов в fit методе через sample_weight параметр. Подобно тому class_weight , это устанавливает параметр C для i-го примера равным C * sample_weight[i], что побуждает классификатор правильно определять эти образцы. На рисунке ниже показано влияние взвешивания выборки на границу принятия решения. Размер кружков пропорционален весу образца:
- SVM: разделяющая гиперплоскость для несбалансированных классов
- SVM: взвешенные образцы ,
1.4.2. Регрессия
Метод классификации опорных векторов может быть расширен для решения задач регрессии. Этот метод называется регрессией опорных векторов.
Модель, созданная с помощью классификации опорных векторов (как описано выше), зависит только от подмножества обучающих данных, потому что функция затрат для построения модели не заботится о точках обучения, которые лежат за пределами поля. Аналогичным образом модель, созданная с помощью регрессии опорных векторов, зависит только от подмножества обучающих данных, поскольку функция стоимости игнорирует образцы, прогноз которых близок к их целевому значению.
Есть три различных реализаций опорных векторов регрессии: SVR , NuSVR и LinearSVR . LinearSVR обеспечивает более быструю реализацию, чем, SVR но учитывает только линейное ядро, но NuSVR реализует несколько иную формулировку, чем SVR и LinearSVR . См. Подробности реализации для получения дополнительной информации.
Как и в случае с классами классификации, метод соответствия будет принимать в качестве аргументов векторы X, y, только в этом случае ожидается, что y будет иметь значения с плавающей запятой вместо целочисленных значений:
>>> from sklearn import svm >>> X = [[0, 0], [2, 2]] >>> y = [0.5, 2.5] >>> regr = svm.SVR() >>> regr.fit(X, y) SVR() >>> regr.predict([[1, 1]]) array([1.5])
1.4.3. Оценка плотности, обнаружение новизны
Класс OneClassSVM реализует одноклассную SVM, которая используется для обнаружения выбросов.
См. Раздел Обнаружение новинок и выбросов для описания и использования OneClassSVM.
1.4.4. Сложность
Машины опорных векторов — мощные инструменты, но их требования к вычислениям и хранению быстро растут с увеличением числа обучающих векторов. Ядром SVM является задача квадратичного программирования (QP), отделяющая опорные векторы от остальной части обучающих данных. Решатель QP, используемый реализацией на основе libsvm, масштабируется между $O(n_ \times n_^2)$ а также $O(n_ \times n_^3)$ в зависимости от того, насколько эффективно используется кеш libsvm на практике (зависит от набора данных). Если данные очень скудныеnfeatures следует заменить на среднее количество ненулевых функций в векторной выборке.
Для линейного случая, алгоритм , используемый в LinearSVC по liblinear реализации является гораздо более эффективным , чем его libsvm SVC аналог и может масштабироваться почти линейно миллионы образцов и/или функций.
1.4.5. Советы по практическому использованию
- Избегая копирования данных : Для SVC , SVR , NuSVC и NuSVR если данные , передаваемые в некоторых методов не C упорядоченный непрерывный и двойной точности, то он будет скопирован перед вызовом основной реализации C. Вы можете проверить, является ли данный массив numpy непрерывным, проверив его flags атрибут.
>>> from sklearn.pipeline import make_pipeline >>> from sklearn.preprocessing import StandardScaler >>> from sklearn.svm import SVC >>> clf = make_pipeline(StandardScaler(), SVC())
См. Раздел « Предварительная обработка данных» для получения более подробной информации о масштабировании и нормализации.
- Что касается shrinking параметра, цитируя 12 : мы обнаружили, что если количество итераций велико, то сжатие может сократить время обучения. Однако, если мы решим проблему оптимизации слабо (например, используя большой допуск остановки), код без использования сжатия может быть намного быстрее.
- Параметр nu в NuSVC / OneClassSVM / NuSVR приближает долю ошибок обучения и опорных векторов.
- В SVC случае, если данные несбалансированы (например, много положительных и мало отрицательных), установите class_weight=’balanced’ и/или попробуйте разные параметры штрафа C .
- Случайность базовых реализаций : базовые реализации SVC и NuSVC используют генератор случайных чисел только для перетасовки данных для оценки вероятности (когда probability установлено значение True ). Этой случайностью можно управлять с помощью random_state параметра. Если probability установлено значение, False эти оценки не являются случайными и random_state не влияют на результаты. Базовая OneClassSVM реализация аналогична реализациям SVC и NuSVC . Поскольку оценка вероятности не предусмотрена OneClassSVM , она не является случайной.
1.4.6. Функции ядра
Функция ядра может быть любой из следующих:
- линейный: $\langle x, x’\rangle$.
- полином: $(\gamma \langle x, x’\rangle + r)^d$, где dуказывается параметром degree , $r$ по coef0 .
- rbf: $\exp(-\gamma |x-x’|^2)$, где $\gamma$ указывается параметром gamma , должно быть больше 0.
- сигмовидный $\tanh(\gamma \langle x,x’\rangle + r)$, где $r$ указывается coef0 .
Разные ядра задаются kernel параметром:
>>> linear_svc = svm.SVC(kernel='linear') >>> linear_svc.kernel 'linear' >>> rbf_svc = svm.SVC(kernel='rbf') >>> rbf_svc.kernel 'rbf'
1.4.6.1. Параметры ядра RBF
При обучении SVM с ядром Радиальной Базовой Функции (Radial Basis Function — RBF) необходимо учитывать два параметра: C и gamma . Параметр C , общий для всех ядер SVM, компенсирует неправильную классификацию обучающих примеров простотой поверхности принятия решений. Низкое значение C делает поверхность принятия решения гладкой, а высокое C правильные классификации всех обучающих примеров. gamma определяет, какое влияние имеет один обучающий пример. Чем больше gamma , тем ближе другие примеры должны быть затронуты.
Правильный выбор C и gamma имеет решающее значение для производительности SVM. Рекомендуется использовать GridSearchCV с C и gamma экспоненциально далеко друг от друга, чтобы выбрать хорошие значения.
1.4.6.2. Пользовательские ядра
Вы можете определить свои собственные ядра, указав ядро как функцию Python или предварительно вычислив матрицу Грама.
Классификаторы с пользовательскими ядрами ведут себя так же, как и любые другие классификаторы, за исключением того, что:
- Поле support_vectors_ теперь пустое, в нем хранятся только индексы опорных векторов support_
- Ссылка (а не копия) первого аргумента fit() метода сохраняется для использования в будущем. Если этот массив изменится между использованием fit() и predict() вы получите неожиданные результаты.
1.4.6.2.1. Использование функций Python в качестве ядер
Вы можете использовать собственные определенные ядра, передав функцию kernel параметру.
Ваше ядро должно принимать в качестве аргументов две матрицы формы (n_samples_1, n_features), (n_samples_2, n_features) и возвращает матрицу ядра в форме (n_samples_1, n_samples_2)
Следующий код определяет линейное ядро и создает экземпляр классификатора, который будет использовать это ядро:
>>> import numpy as np >>> from sklearn import svm >>> def my_kernel(X, Y): . return np.dot(X, Y.T) . >>> clf = svm.SVC(kernel=my_kernel)
1.4.6.2.2. Используя матрицу Грама
Вы можете передать предварительно вычисленные ядра, используя kernel=’precomputed’ параметр. Затем вы должны передать матрицу Грама вместо X к fit и predict методам. Должны быть предоставлены значения ядра между всеми обучающими векторами и тестовыми векторами:
>>> import numpy as np >>> from sklearn.datasets import make_classification >>> from sklearn.model_selection import train_test_split >>> from sklearn import svm >>> X, y = make_classification(n_samples=10, random_state=0) >>> X_train , X_test , y_train, y_test = train_test_split(X, y, random_state=0) >>> clf = svm.SVC(kernel='precomputed') >>> # linear kernel computation >>> gram_train = np.dot(X_train, X_train.T) >>> clf.fit(gram_train, y_train) SVC(kernel='precomputed') >>> # predict on training examples >>> gram_test = np.dot(X_test, X_train.T) >>> clf.predict(gram_test) array([0, 1, 0])
1.4.7. Математическая постановка
Машина опорных векторов конструирует гиперплоскость или набор гиперплоскостей в пространстве большой или бесконечной размерности, которые можно использовать для классификации, регрессии или других задач. Интуитивно хорошее разделение достигается за счет гиперплоскости, которая имеет наибольшее расстояние до ближайших точек обучающих данных любого класса (так называемый функциональный запас), поскольку, как правило, чем больше запас, тем ниже ошибка обобщения классификатора. На рисунке ниже показана функция решения для линейно разделяемой задачи с тремя образцами на границах запаса, называемыми «векторами поддержки»:
В общем, когда проблема не является линейно разделимой, опорные векторы являются выборками в пределах границ поля.
Мы рекомендуем 13 и 14 как хорошие справочные материалы по теории и практике SVM.
1.4.7.1. SVC
Данные обучающие векторы $x_i \in \mathbb^p$, i = 1,…, n, в двух классах, и вектор $y \in \left\^n$ наша цель найти $w \in\mathbb^p$ а также $b \in \mathbb$ такой, что предсказание, данное $\text (w^T\phi(x) + b)$ подходит для большинства образцов.
SVC решает следующую основную проблему:
$$\min_ \frac w^T w + C \sum_^ \zeta_i$$
$$\textrm y_i (w^T \phi (x_i) + b) \geq 1 — \zeta_i,$$
$$\zeta_i \geq 0, i=1, …, n$$
Интуитивно мы пытаемся максимизировать маржу (минимизируя $||w||^2 = w^Tw$), при этом налагается штраф, если образец неправильно классифицирован или находится в пределах границ маржи. В идеале значение $y_i(w^T \phi (x_i) + b)$ было бы $\geq 1$ для всех образцов, что указывает на идеальный прогноз. Но обычно проблемы не всегда можно идеально отделить с помощью гиперплоскости, поэтому мы позволяем некоторым образцам находиться на расстоянии $\zeta_i$ от их правильной границы поля. Срок штрафа C контролирует силу этого штрафа и, как результат, действует как параметр обратной регуляризации (см. Примечание ниже).
Двойственная проблема первобытного:
$$\min_ \frac \alpha^T Q \alpha — e^T \alpha$$
$$\textrm y^T \alpha = 0$$
$$0 \leq \alpha_i \leq C, i=1, …, n$$
где e вектор всех единиц, а $Q$ является n от n положительно полуопределенная матрица, $Q_ \equiv y_i y_j K(x_i, x_j)$, где $K(x_i, x_j) = \phi (x_i)^T \phi (x_j)$ это ядро. Условияαi называются двойственными коэффициентами, и они ограничены сверху величиной $C$. Это двойное представление подчеркивает тот факт, что обучающие векторы неявно отображаются в более высокое (возможно, бесконечное) пространство с помощью функции $\phi$: см. трюк с ядром .
Как только проблема оптимизации решена, выходные данные функции решения для данной выборкиx становится:
$$\sum_
и предсказанный класс соответствуют его знаку. Нам нужно только просуммировать по опорным векторам (то есть выборкам, которые лежат в пределах поля), потому что двойные коэффициенты $\alpha_i$ равны нулю для остальных образцов.
Доступ к этим параметрам можно получить через атрибуты, dual_coef_ содержащие продукт.yiαi, support_vectors_ который содержит опорные векторы и intercept_ независимый член $b$
В то время как модели SVM, полученные из libsvm и liblinear, используют в C качестве параметра регуляризации, большинство других оценщиков используют alpha . Точная эквивалентность между степенью регуляризации двух моделей зависит от точной целевой функции, оптимизированной моделью. Например, когда используется оценка Ridge регрессии, связь между ними задается как $C = \frac$
1.4.7.2. LinearSVC
Первичную задачу можно эквивалентно сформулировать как
$$\min_ \frac w^T w + C \sum_\max(0, y_i (w^T \phi(x_i) + b)),$$
где мы используем потерю шарнира . Это форма, которая напрямую оптимизируется LinearSVC , но, в отличие от двойной формы, она не включает внутренние продукты между семплами, поэтому знаменитый трюк с ядром не может быть применен. Вот почему только линейное ядро поддерживается LinearSVC ($\phi$ — тождественная функция).
1.4.7.3. NuSVC
В ν-SVC рецептура 15 представляет собой повторную параметризацию $C$-SVC и, следовательно, математически эквивалентен.
Мы вводим новый параметр $\nu$ (вместо $C$), который контролирует количество опорных векторов и маржинальных ошибок :$\nu \in (0, 1]$ — это верхняя граница доли маржинальных ошибок и нижняя граница доли опорных векторов. Погрешность маржи соответствует образцу, лежащему не на той стороне границы маржи: она либо неправильно классифицирована, либо классифицирована правильно, но не выходит за пределы маржи.
1.4.7.4. SVR
Данные обучающие векторы $x_i \in \mathbb^p$, i = 1,…, n, и вектор $y \in \mathbb^n$ $\varepsilon$-SVR решает следующую основную проблему:
$$\min_ \frac w^T w + C \sum_^ (\zeta_i + \zeta_i^*)$$
$$\textrm y_i — w^T \phi (x_i) — b \leq \varepsilon + \zeta_i,$$
$$w^T \phi (x_i) + b — y_i \leq \varepsilon + \zeta_i^*,$$
$$\zeta_i, \zeta_i^* \geq 0, i=1, …, n$$
Здесь мы штрафуем образцы, прогноз которых не ниже εподальше от их истинной цели. Эти образцы штрафуют цель на $\zeta_i$ или $\zeta_i^*$, в зависимости от того, лежат ли их прогнозы выше или ниже $\varepsilon$ диапазона.
Двойная проблема:
$$\min_ \frac (\alpha — \alpha^*)^T Q (\alpha — \alpha^*) + \varepsilon e^T (\alpha + \alpha^*) — y^T (\alpha — \alpha^*)$$
$$\textrm e^T (\alpha — \alpha^*) = 0$$
$$0 \leq \alpha_i, \alpha_i^* \leq C, i=1, …, n$$
где $e$ вектор всех единиц, $Q$ является $n$ от $n$ положительно полуопределенная матрица, $Q_ \equiv K(x_i, x_j) = \phi (x_i)^T \phi (x_j)$ это ядро. Здесь обучающие векторы неявно отображаются в более высокое (возможно, бесконечное) пространство с помощью функции $\phi$.
Прогноз такой:
$$\sum_(\alpha_i — \alpha_i^*) K(x_i, x) + b$$
К этим параметрам можно получить доступ через атрибуты, dual_coef_ которые содержат разницу $\alpha_i — \alpha_i^*$ , support_vectors_ который содержит опорные векторы и intercept_ независимый член
1.4.7.5. LinearSVR
Первичную задачу можно эквивалентно сформулировать как
$$\min_ \frac w^T w + C \sum_\max(0, |y_i — (w^T \phi(x_i) + b)| — \varepsilon),$$
где мы используем нечувствительные к эпсилону потери, т. е. ошибки менее $\varepsilon$ игнорируются. Это форма, которая напрямую оптимизируется LinearSVR .
1.4.8. Детали реализации
Внутри мы используем libsvm 12 и liblinear 11 для обработки всех вычислений. Эти библиотеки обернуты с использованием C и Cython. Описание реализации и детали используемых алгоритмов см. В соответствующих документах.
- Платт «Вероятностные выходы для SVM и сравнения с регуляризованными методами правдоподобия» .
- Ву, Линь и Вен, «Оценки вероятности для классификации нескольких классов путем попарного связывания» , JMLR 5: 975-1005, 2004.
- Фан, Ронг-Эн и др., «LIBLINEAR: библиотека для большой линейной классификации». , Журнал исследований машинного обучения 9. августа (2008): 1871-1874.
- Чанг и Лин, LIBSVM: библиотека для машин опорных векторов .
- Епископ, Распознавание образов и машинное обучение , глава 7 Машины с разреженным ядром
- «Учебное пособие по регрессии опорных векторов » , Алекс Дж. Смола, Бернхард Шёлкопф — Архив статистики и вычислений Том 14, выпуск 3, август 2004 г., с. 199-222.
- Schölkopf et. al Новые алгоритмы опорных векторов
- Краммер и Зингер об алгоритмической реализации векторных машин на основе многоклассового ядра , JMLR 2001.
Если вы хотите помочь проекту с переводом, то можно обращаться по следующему адресу support@scikit-learn.ru
© 2007 — 2020, scikit-learn developers (BSD License).
Краткий обзор алгоритма машинного обучения Метод Опорных Векторов (SVM)
Как известно, задачи машинного обучения разделены на две основные категории — классификация и регрессия. В зависимости от того, какая из этих задач перед нами стоит, и какой у нас имеется датасет для этой задачи, мы выбираем какой именно алгоритм использовать.
Метод Опорных Векторов или SVM (от англ. Support Vector Machines) — это линейный алгоритм используемый в задачах классификации и регрессии. Данный алгоритм имеет широкое применение на практике и может решать как линейные так и нелинейные задачи. Суть работы “Машин” Опорных Векторов проста: алгоритм создает линию или гиперплоскость, которая разделяет данные на классы.
Теория
Основной задачей алгоритма является найти наиболее правильную линию, или гиперплоскость разделяющую данные на два класса. SVM это алгоритм, который получает на входе данные, и возвращает такую разделяющую линию.
Рассмотрим следующий пример. Допустим у нас есть набор данных, и мы хотим классифицировать и разделить красные квадраты от синих кругов (допустим позитивное и отрицательное). Основной целью в данной задаче будет найти “идеальную” линию которая разделит эти два класса.
Найдите идеальную линию, или гиперплоскость, которая разделит набор данных на синий и красный классы.
На первый взгляд, не так уж и сложно, правда?
Но, как вы можете заметить, нет одной, уникальной, линии, которая бы решала такую задачу. Мы можем подобрать бесконечное множество таких линий, которые могут разделить эти два класса. Как же именно SVM находит “идеальную” линию, и что в его понимании “идеальная”?
Взгляните на пример ниже, и подумайте какая из двух линий (желтая или зеленая) лучше всего разделяет два класса, и подходит под описаниие “идеальной”?
Какая линия лучше разделяет набор данных по вашему мнению?
Если вы выбрали желтую прямую, я вас поздравляю: это та самая линия, которую бы выбрал алгоритм. В данном примере мы можем интуитивно понять что желтая линия разделяет и соответственно классифицирует два класса лучше зеленой.
В случае с зеленой линией — она расположена слишком близко к красному классу. Несмотря на то, что она верно классифицировала все объекты текущего набора данных, такая линия не будет генерализованной — не будет так же хорошо вести себя с незнакомым набором данных. Задача нахождения генерализованной разделяющей двух классов является одной из основных задач в машинном обучении.
Как SVM находит лучшую линию
Алгоритм SVM устроен таким образом, что он ищет точки на графике, которые расположены непосредственно к линии разделения ближе всего. Эти точки называются опорными векторами. Затем, алгоритм вычисляет расстояние между опорными векторами и разделяющей плоскостью. Это расстояние которое называется зазором. Основная цель алгоритма — максимизировать расстояние зазора. Лучшей гиперплоскостью считается такая гиперплоскость, для которой этот зазор является максимально большим.
Довольно просто, не так ли? Рассмотрим следующий пример, с более сложным датасетом, который нельзя разделить линейно.
Очевидно, что этот набор данных нельзя разделить линейно. Мы не можем начертить прямую линию, которая бы классифицировала эти данные. Но, этот датасет можно разделить линейно, добавив дополнительное измерение, которое мы назовем осью Z. Представим, что координаты на оси Z регулируются следующим ограничением:
Таким образом, ордината Z представлена из квадрата расстояния точки до начала оси.
Ниже приведена визуализация того же набора данных, на оси Z.
Теперь данные можно разделить линейно. Допустим пурпурная линия разделяющая данные z=k, где k константа. Если
, то следовательно и
— формула окружности. Таким образом, мы можем спроэцировать наш линейный разделитель, обратно к исходному количеству измерений выборки, используя эту трансформацию.
В результате, мы можем классифицировать нелинейный набор данных добавив к нему дополнительное измерение, а затем, привести обратно к исходному виду используя математическую трансформацию. Однако, не со всеми наборами данных можно с такой же легкостью провернуть такую трансформацию. К счастью, имплементация этого алгоритма в библиотеке sklearn решает эту задачу за нас.
Гиперплоскость
Теперь, когда мы ознакомились с логикой алгоритма, перейдем к формальному определению гиперплоскости
Гиперплоскость — это n-1 мерная подплоскость в n-мерном Евклидовом пространстве, которая разделяет пространство на две отдельные части.
Например, представим что наша линия представлена в виде одномерного Евклидова пространства (т.е. наш набор данных лежит на прямой). Выберите точку на этой линии. Эта точка разделит набор данных, в нашем случае линию, на две части. У линии есть одна мера, а у точки 0 мер. Следовательно, точка — это гиперплоскость линии.
Для двумерного датасета, с которым мы познакомились ранее, разделяющая прямая была той самой гиперплоскостью. Проще говоря, для n-мерного пространства существует n-1 мерная гиперплоскость, разделяющая это пространство на две части.
import numpy as np X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]]) y = np.array([1, 1, 2, 2])Точки представлены в виде массива X, а классы к которому они принадлежат в виде массива y.
Теперь мы обучим нашу модель этой выборкой. Для данного примера я задал линейный параметр “ядра” классификатора (kernel).
from sklearn.svm import SVC clf = SVC(kernel='linear') clf = SVC.fit(X, y) Предсказание класса нового объекта
prediction = clf.predict([[0,6]])Настройка параметров
Параметры — это аргументы которые вы передаете при создании классификатора. Ниже я привел несколько самых важных настраиваемых параметров SVM:
Данный параметр помогает отрегулировать ту тонкую грань между “гладкостью” и точностью классификации объектов обучающей выборки. Чем больше значение “С” тем больше объектов обучающей выборки будут правильно классифицированы.
В данном примере есть несколько порогов принятия решений, которые мы можем определить для этой конкретной выборки. Обратите внимание на прямую (представлена на графике в виде зеленой линии) порога решений. Она довольно таки проста, и по этой причине, несколько объектов были классифицированы неверно. Эти точки, которые были классифицированы неправильно называются выбросами в данных.
Мы также можем настроить параметры таким образом, что в конечном итоге получим более изогнутую линию (светло-голубой порог решений), которая будет классфицировать асболютно все данные обучающей выборки правильно. Конечно, в таком случае, шансы того, что наша модель сможет генерализовать и показать столь же хорошие результаты на новых данных, катастрофически мала. Следовательно, если вы пытаетесь достигнуть точности при обучении модели, вам стоит нацелиться на что-то более ровное, прямое. Чем выше число “С” тем более запутанная гиперплоскость будет в вашей модели, но и выше число верно-классифицированных объектов обучающей выборки. Поэтому, важно “подкручивать” параметры модели под конкретный набор данных, чтобы избежать переобучения но, в то же время достигнуть высокой точности.
В официальной документации библиотека SciKit Learn говорится, что гамма определяет насколько далеко каждый из элементов в наборе данных имеет влияние при определении “идеальной линии”. Чем ниже гамма, тем больше элементов, даже тех, которые достаточно далеки от разделяющей линии, принимают участие в процессе выбора этой самой линии. Если же, гамма высокая, тогда алгоритм будет “опираться” только на тех элементах, которые наиболее близки к самой линии.
Если задать уровень гаммы слишком высоким, тогда в процессе принятия решения о расположении линии будут учавствовать только самые близкие к линии элементы. Это поможет игнорировать выбросы в данных. Алгоритм SVM устроен таким образом, что точки расположенные наиболее близко относительно друг друга имеют больший вес при принятии решения. Однако при правильной настройке «C» и «gamma» можно добиться оптимального результата, который построит более линейную гиперплоскость игнорирующую выбросы, и следовательно, более генерализуемую.
Заключение
Я искренне надеюсь, что эта статья помогла вам разобраться в сути работы SVM или Метода Опорных Векторов. Я жду от вас любых комментариев и советов. В последующих публикациях я расскажу о математической составляющей SVM и о проблемах оптимизации.