1.4. Машины опорных векторов

1.4.1. Классификация

SVC, NuSVC и LinearSVC — это классы, способные выполнять бинарную и многоклассовую классификацию набора данных.

SVC и NuSVC — это похожие методы, но принимающие несколько другие наборы параметров и имеющие разные математические формулировки (см. раздел Математическая формулировка). С другой стороны, LinearSVC — это еще одна (более быстрая) реализация классификации опорных векторов для случая линейного ядра. Она также лишена некоторых атрибутов SVC и NuSVC, таких как support_. LinearSVC использует squared_hinge потерю и из-за своей реализации в liblinear также регуляризует свободный член, если он рассматривается. Однако этот эффект можно уменьшить, тщательно настраивая параметр intercept_scaling, что позволяет члену свободного члена иметь другое поведение регуляризации по сравнению с другими признаками. Результаты классификации и оценка, следовательно, могут отличаться от результатов других двух классификаторов.

Как и другие классификаторы, 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-Anova: SVM с отбором признаков по методу ANOVA
• Построение вероятности классификации

1.4.2. Регрессия

Метод поддержки векторной классификации может быть расширен для решения регрессионных задач. Этот метод называется регрессией опорных векторов.

Модель, созданная с помощью классификации опорных векторов (как описано выше), зависит только от подмножества обучающих данных, потому что функция стоимости для построения модели не учитывает обучающие точки, которые лежат за пределами границы. Аналогично, модель, созданная с помощью регрессии опорных векторов, зависит только от подмножества обучающих данных, потому что функция стоимости игнорирует образцы, предсказание которых близко к их целевому значению.

Существует три различных реализации регрессии опорных векторов: SVR, NuSVR и LinearSVR. LinearSVR предоставляет более быструю реализацию, чем SVR, но учитывает только линейное ядро, в то время как NuSVR реализует несколько отличную формулу от SVR и LinearSVR. Благодаря своей реализации в liblinear LinearSVR также регламентирует сдвиг, если он рассматривается. Однако этот эффект можно уменьшить, тщательно настраивая параметр intercept_scaling, который позволяет сдвигу иметь другое поведение регуляризации по сравнению с другими признаками. Результаты классификации и оценка, следовательно, могут отличаться от результатов других двух классификаторов. Подробнее см. Подробные сведения об реализации.

Как и в классах для классификации, метод fit будет принимать в качестве аргументов векторы 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])

Примеры

• Регрессия опорных векторов (SVR) с линейными и нелинейными ядрами

1.4.3. Оценивание плотности, обнаружение новизны

Класс OneClassSVM реализует SVM одного класса, используемый для обнаружения выбросов.

См. Обнаружение новизны и выбросов для описания и использования OneClassSVM.

1.4.4. Сложность

Машины опорных векторов — мощные инструменты, но их вычислительные и требования к памяти быстро возрастают с увеличением числа обучающих векторов. Ядро SVM — это задача квадратичного программирования (QP), разделяющая опорные векторы от остальных обучающих данных. QP-решатель, используемый реализацией на основе libsvm, масштабируется от \(O(n_{features} \times n_{samples}^2)\) до \(O(n_{features} \times n_{samples}^3)\) в зависимости от эффективности использования кеша libsvm на практике (зависит от набора данных). Если данные очень разреженные, \(n_{features}\) следует заменить на среднее число ненулевых признаков в векторе образца.

В линейном случае алгоритм, используемый в LinearSVC с помощью реализации liblinear, намного эффективнее, чем его аналог на основе libsvm SVC и может масштабироваться почти линейно до миллионов образцов и/или признаков.

1.4.5. Советы по практическому применению

• Избегание копирования данных: Для SVC, SVR, NuSVC и NuSVR, если данные, переданные в определённые методы, не являются непрерывными в порядке C и двойной точности, они будут скопированы перед вызовом базовой C-реализации. Вы можете проверить, является ли заданный массив NumPy непрерывным в порядке C, просмотрев его атрибут flags.

  Для LinearSVC (и LogisticRegression) любой ввод, переданный в виде массива NumPy, будет скопирован и преобразован в внутреннее разреженное представление данных liblinear (числа с плавающей запятой двойной точности и целочисленные индексы 32-битного типа для ненулевых компонент). Если вы хотите обучить линейный классификатор большой размерности без копирования плотного массива NumPy с непрерывными данными двойной точности в порядке C как вход, мы рекомендуем использовать класс SGDClassifier вместо этого. Функция цели может быть настроена практически так же, как и для модели LinearSVC.

• Размер кэша ядра: Для SVC, SVR, NuSVC и NuSVR размер кэша ядра оказывает значительное влияние на время выполнения для более сложных задач. Если у вас достаточно оперативной памяти, рекомендуется установить cache_size на более высокое значение, чем значение по умолчанию 200 (МБ), например, 500 (МБ) или 1000 (МБ).

• Настройка C: C по умолчанию имеет значение 1, и это разумный выбор по умолчанию. Если у вас много шумных наблюдений, уменьшите его: уменьшение C соответствует большей регуляризации.

  LinearSVC и LinearSVR менее чувствительны к C при увеличении значения, и результаты предсказания перестают улучшаться после определённого порога. Одновременно, более большие значения C потребуют больше времени на обучение, иногда до 10 раз больше, как показано в [11].

• Алгоритмы опорных векторных машин не инвариантны к масштабированию, поэтому настоятельно рекомендуется масштабировать ваши данные. Например, масштабируйте каждый атрибут входного вектора X в диапазон [0,1] или [-1,+1], или стандартизируйте его, чтобы среднее значение было равно 0, а дисперсия — 1. Обратите внимание, что одинаковое масштабирование необходимо применить к тестовому вектору, чтобы получить осмысленные результаты. Это можно легко сделать, используя Pipeline:

  >>> 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 не предоставляется оценка вероятности, она не случайная.

  Базовая реализация LinearSVC использует генератор случайных чисел для выбора признаков при обучении модели с помощью двойного спуска по координатам (т.е. когда dual установлено в True). Поэтому нередко результаты для одних и тех же входных данных могут немного отличаться. Если это происходит, попробуйте уменьшить параметр tol. Эта случайность также может быть контролируема параметром random_state. Когда dual установлено в False, базовая реализация LinearSVC не случайная, и random_state не оказывает влияния на результаты.

• Использование L1-регуляризации, предоставляемой LinearSVC(penalty='l1', dual=False), приводит к разреженной (sparse) оценке, т. е. только подмножество весов признаков отличается от нуля и вносит вклад в функцию принятия решения. Увеличение C приводит к более сложной модели (выбирается больше признаков). Значение C, которое приводит к «нулевой» модели (все веса равны нулю), может быть вычислено с помощью l1_min_c.

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'

См. также Приближение ядер для решения, позволяющего использовать ядра RBF намного быстрее и масштабируемее.

>>> 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)

>>> 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. Математическая формулировка

Машина опорных векторов (Support Vector Machine, SVM) строит гиперплоскость или набор гиперплоскостей в пространстве высокой или бесконечной размерности, которые могут использоваться для классификации, регрессии или других задач. Интуитивно, хорошее разделение достигается гиперплоскостью, имеющей наибольшее расстояние до ближайших обучающих точек любого класса (так называемый функциональный отступ), так как, в общем случае, чем больше отступ, тем ниже обобщающая ошибка классификатора. На рисунке ниже показана функция принятия решения для линейно разделимой задачи, с тремя образцами на границах отступа, называемыми «опорными векторами»:

В общем случае, когда задача не является линейно разделимой, опорные векторы — это образцы внутри границ отступа.

Мы рекомендуем [13] и [14] в качестве хороших ссылок по теории и практическому применению SVM.

1.4.8. Детали реализации

Внутренне мы используем libsvm [12] и liblinear [11] для обработки всех вычислений. Эти библиотеки оборачиваются с помощью C и Cython. Для описания реализации и деталей используемых алгоритмов, пожалуйста, обратитесь к соответствующим статьям.

Ссылки