¿Qué es SVM?
El nombre completo en inglés de VM es Support Vector Machines, lo llamamos máquina de vectores de soporte. La máquina de vectores de soporte es un algoritmo que utilizamos para la clasificación. Comencemos nuestro viaje SVM en forma de una historia corta.
Hace mucho tiempo, el día de San Valentín, un héroe fue a salvar a su amante, pero el diablo en el cielo jugó con él.
El diablo pareció colocar bolas de dos colores regularmente sobre la mesa y dijo: "¿Usas un palo para separarlas? Requisito: intenta aplicarlo aún después de poner más bolas". Entonces el héroe las puso así, ¿hizo un buen trabajo
?
Luego el diablo colocó más bolas sobre la mesa y una de ellas parecía estar en el lado equivocado. Obviamente, el héroe necesita hacer ajustes en el palo.
SVM intenta colocar el palo en la mejor posición para que haya tanto espacio como sea posible en ambos lados del palo. Este espacio es la distancia entre la pelota y el palo.
Bueno, aunque los Devils pongan más balones, los palos siguen siendo una buena línea divisoria.
Ahora, el héroe no tiene ningún palo que le ayude a separar los dos tipos de bolas, ¿qué debe hacer ahora? Por supuesto, como en todas las películas de artes marciales, el héroe golpea la mesa y la pelota sale volando por los aires. Luego, confiando en la ligereza del héroe, éste agarró un trozo de papel y lo insertó entre los dos tipos de bolas.
Ahora, mirando estas bolas desde la perspectiva del diablo en el aire, parece que están separadas por una curva.
Más tarde, los adultos aburridos llamaron a estas bolas datos, a los palos clasificadores, al truco de encontrar la brecha máxima lo llamaron optimización, a golpear la mesa lo llamaron kernelling y al trozo de papel lo llamaron hiperplano.
Para dar una visión general:
Cuando se trata de un problema de clasificación y los datos son linealmente separables, es decir, cuando dos tipos de bolas se pueden separar con un palo, solo necesitamos colocar el palo en una posición que maximice la distancia entre la bola y el palo. El proceso de encontrar este intervalo máximo se llama optimización. Sin embargo, la realidad suele ser muy cruel: los datos generales son linealmente inseparables, es decir, no existe ningún palo que pueda clasificar bien los dos tipos de bolas. En este momento, debemos ser como un héroe, recoger las bolas y usar un trozo de papel en lugar de un palo para clasificarlas. Para hacer volar los datos, lo que necesitamos es una función kernel (kernel) , y el papel utilizado para cortar la bola es un hiperplano .
modelo matematico
Support Vector Machine (SVM) es un tipo de clasificación lineal generalizada de datos basada en el aprendizaje supervisado. Su límite de decisión es el hiperplano de margen máximo que resuelve la muestra de aprendizaje. SVM puede realizar una clasificación no lineal a través de funciones del kernel y es uno de los métodos de aprendizaje del kernel más comunes.
Las máquinas de vectores de soporte (máquinas de vectores de soporte) encuentran un hiperplano para segmentar la muestra, el principio de segmentación es maximizar el intervalo y finalmente transformarlo en un problema de programación cuadrática convexa para resolver. Puede resolver tanto la separabilidad lineal como la imposibilidad lineal, y puede resolver tanto problemas de clasificación como de regresión.
Maximizar el intervalo
Cuando las muestras de entrenamiento sean separables linealmente, use la maximización de margen estricto (Hard Margin SVM) o cuando sean aproximadamente linealmente separables, use la maximización de software (Soft Margin SVM). La función kernel y la maximización del margen suave se utilizan cuando las muestras de entrenamiento son linealmente inseparables.
En problemas prácticos, a menudo hay situaciones en las que el límite de decisión no es único, lo cual es un problema mal planteado. Dado el conjunto de muestras de entrenamiento
D = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , … , ( xm , ym ) } , yi ∈ { − 1 , 1 } D = \{(x_{1} , y_ {1}), (x_ {2}, y_ {2}), \dots , (x_ {m}, y_ {m})\}, y_ {i} \in \{-1, 1\}D={( x1,y1) ,( x2,y2) ,…,( xm,ym)} ,yyo∈{
-1 , _1 } La idea básica del algoritmo de clasificación es encontrar un hiperplano divisorio en el espacio muestral de acuerdo con el conjunto de entrenamiento. Sin embargo, puede haber muchos hiperplanos divisorios que pueden separar las muestras de entrenamiento. Entonces, ¿cuál deberíamos trabajar duro? ¿encontrar?
Se espera que la línea recta encontrada por svm esté lo más lejos posible del punto rojo y del punto azul más cercanos al límite de decisión, para garantizar la capacidad de generalización del modelo. SVM intenta encontrar un límite de decisión óptimo, que es el más alejado de las muestras más cercanas de las dos categorías. Los tres puntos en la figura están a la misma distancia del límite de decisión. Estos tres puntos se llaman vectores de soporte. La distancia entre dos líneas rectas paralelas al límite de decisión es el margen. SVM pretende maximizar el margen, por lo que este problema se transforma en un problema de optimización.
Problema de optimizacion
Ecuación del intervalo de clasificación
Svm maximiza el margen, margen = 2d, lo que corresponde a maximizar d, es decir, la distancia desde el punto a la línea recta es la mayor. Recuerde de la geometría analítica que el punto (x, y) (x,y) en el espacio bidimensional( x ,y ) a la rectaA x + B y + C = 0 Ax+By+C=0una x+por y+C=La fórmula de la distancia para 0 : ∣ A x + B y + C ∣ A 2 + B 2 \frac{\mid Ax+By+C \mid} {\sqrt{A^2+B^2}}A2 +B2∣ A x + B y + C ∣
Extenderlo a n-dimensional θ T ⋅ xb = 0 \theta^T \cdot x_{b}=0it⋅Xsegundo=0
dentro deθ \thetaθ contiene la intersección y los coeficientes,xb x_bXsegundojusto en xxAgregue una fila de constante 1 a la muestra x , que es la misma que en la regresión lineal anterior.
Si se saca la intersección, es w T x + b = 0 w^Tx + b = 0wT x+b=0El
w entre ellos es asignar un peso a cada dato de la muestra. Estas son dos formas diferentes de expresar la ecuación de una recta. Entonces, podemos obtener la nueva ecuación de distancia punto a línea:
∣ w T x + b ∣ ∥ w ∥ \frac{\mid w^Tx + b \mid}{\parallel w \parallel}∥ w ∥∣ wT x+b∣，其中∥ w ∥ = w 1 2 + w 2 2 + ⋯ + wn 2 \parallel w \parallel = \sqrt {w_{1}^2 + w_{2}^2 + \dots + w_{n}^2 }∥w∥=w12+w22+⋯+wnorte2
Restricciones
Parece que hemos obtenido con éxito la forma matemática de la función objetivo. Pero para encontrar el valor máximo de w. Tenemos que afrontar los siguientes problemas:
- ¿Cómo sabemos si el hiperplano clasifica correctamente los puntos muestrales?
- Sabemos que se requiere el valor máximo de la distancia d. Primero necesitamos encontrar el punto en el vector de soporte. ¿Cómo seleccionar el punto en el vector de soporte entre muchos puntos?
El problema que debemos enfrentar anteriormente es la condición de restricción, lo que significa que el rango de valores de la variable d que optimizamos es limitado y restringido. De hecho, las restricciones siempre han sido lo más problemático en los problemas de optimización.
Pero ahora que sabemos que estas restricciones existen, tenemos que usar lenguaje matemático para describirlas . Inserte una descripción de la imagen aquí . Sin embargo, el algoritmo SVM utiliza algunos trucos inteligentes para integrar estas restricciones en una desigualdad.
Hay dos tipos de puntos en este plano bidimensional y los marcamos respectivamente:
El punto rojo está marcado como 1, que especificamos artificialmente como una muestra positiva; la
estrella azul de cinco puntas está marcada como -1, que especificamos artificialmente como una muestra negativa.
Agregue una etiqueta de categoría yi a cada punto de muestra xi:
La línea recta en el medio es el límite de decisión w T x + b = 0 w^Tx+b=0wT x+b=0 , y las líneas rectas superior e inferior significan que la distancia debe ser mayor que d, entonces
{ w T x (i) + b ∥ w ∥ ≥ d ∀ y (i) = 1 w T x (i) + b ∥ w ∥ ≤ − d ∀ y ( i ) = − 1 \begin {cases} \frac{w^Tx^{(i)} + b} {\parallel w \parallel} \geq d \qquad \forall y^{ (i)} = 1 \\ \frac{w^Tx^{(i)} + b}{\parallel w \parallel} \leq -d \qquad \forall y^{(i)} = -1 \\ \end {casos}{
∥ w ∥wT x( i ) +b≥d∀ y( yo )=1∥ w ∥wT x( i ) +b≤− re∀ y( yo )=− 1
En este momento, supongamos que los dos tipos de muestras son 1 y -1 respectivamente. Luego divida los lados izquierdo y derecho de la fórmula anterior por d al mismo tiempo para obtener
{ w T x ( i ) + b ∥ w ∥ d ≥ 1 ∀ y ( i ) = 1 w T x ( i ) + b ∥ w ∥ d ≤ − 1 ∀ y ( i ) = − 1 \begin {cases} \frac{w^Tx^{(i)} + b} {\parallel w \parallel d} \geq 1 \qquad \forall y^{(i )} = 1 \\ \frac{w^Tx^{(i)} + b}{\parallel w \parallel d} \leq -1 \qquad \forall y^{(i)} = -1 \\ \ end {casos}{
∥ w ∥ rewT x( i ) +b≥1∀ y( yo )=1∥ w ∥ rewT x( i ) +b≤− 1∀ y( yo )=− 1
Donde |w| y d son ambos escalares (no afectan el cálculo del valor límite), en este momento se elimina el denominador y
{ w T x ( i ) + b ≥ 1 ∀ y ( i ) = 1 w T x ( i ) + b ≤ − 1 ∀ y ( i ) = − 1 \begin {cases} {w^Tx^{(i)} + b} \geq 1 \qquad \forall y^{(i)} = 1 \\ {w^ Tx^{(i)} + b} \leq -1 \qquad \forall y^{(i)} = -1 \\ \end {casos}{
wT x( yo )+b≥1∀ y( yo )=1wT x( yo )+b≤− 1∀ y( yo )=− 1
En este punto, se obtienen dos ecuaciones y luego se utiliza un pequeño truco para fusionar las dos ecuaciones en una.
yi ( w T x ( i ) + b ) ≥ 1 \boxed {y_{i} (w^Tx^{(i)} + b) \geq 1}yyo( wT x( yo )+segundo )≥1
Maximizar la función objetivo
Ahora, para poner nuestros pensamientos juntos, tenemos nuestra función objetivo:
max ∣ w T x + b ∣ ∥ w ∥ max \frac{\mid w^Tx +b \mid}{\parallel w \parallel}máximo _∥ w ∥∣ wT x+b∣
Nuestro objetivo de optimización es maximizar d. Ya hemos dicho que usamos puntos muestrales en el vector soporte para resolver el problema de maximización de d. Entonces, ¿cuáles son las características de los puntos de muestra en el vector de soporte?
∣ w T x + b ∣ = 1 |w^Tx+b|=1∣ wT x+segundo ∣=1Entonces
se traduce en maximizarmax 1 ∥ w ∥ max \frac{1}{\parallel w \parallel}máximo _∥ w ∥1Eso es minimizar min ∥ w ∥ min\parallel w \parallelmín.∥w∥Pero
a menudo, para facilitar la derivación,min 1 2 ∥ w ∥ 2 \boxed{min\frac{1}{2} \parallel w \parallel^2}mín.21∥w∥2
, pero este es un problema de optimización con restricciones, que consiste en satisfacer s.t.yi (w T x (i) + b) ≥ 1, i = 1, 2,…, m st \quad y_{i} (w ^Tx^{(i)} + b) \geq 1, \quad i=1,2,\dots,ms . t .yyo( wT x( yo )+segundo )≥1 ,i=1 ,2 ,…,m
aquí m es el número total de puntos de muestra y la abreviatura st significa "sujeto a", que significa "sujeto a ciertas condiciones". La fórmula anterior describe un problema típico de optimización de funciones cuadráticas bajo restricciones de desigualdad y también es el modelo matemático básico de la máquina de vectores de soporte.
Resolver problemas de optimización con restricciones requiere utilizar el método del multiplicador de Lagrange para obtener el problema dual. Entonces la función del problema:
L ( w , b , α ) = 1 2 ∥ w ∥ 2 + ∑ i = 1 m α i ( 1 − yi ( w T xi + b ) ) \boxed{L(w, b, \ alfa) = \frac{1}{2} \parallel w \parallel^2 + \sum_{i=1}^m \alpha_{i} (1-y_{i}(w^Tx_{i}+b) )}L ( w ,segundo ,un )=21∥w∥2+yo = 1∑mayo( 1−yyo( wT xyo+b ))
donde α i \alpha_iayoEs el multiplicador de Lagrange. Este es SVM de margen duro.
Margen suave y regularización SVM
Si un punto azul aparece cerca de un punto rojo durante la aplicación real, es decir, las dos categorías están relativamente cerca, pero la diferencia general con el punto azul es obvia, puede considerarse como un punto especial o un punto singular incorrecto. será engañoso y provocará que el límite final de clasificación del margen estricto sea una línea recta 1. En este momento, la capacidad de generalización del modelo es cuestionable. Normalmente, el punto azul extremadamente especial debe ignorarse como la línea recta 2 para garantizar que la mayoría de los datos estén más alejados de la línea recta. Quizás este sea el mejor límite de clasificación, lo que significa una mayor capacidad de generalización. Esto también puede explicar indirectamente que si la precisión del modelo es demasiado alta, puede provocar un sobreajuste del modelo.
Hay un ejemplo más general, es decir, si un punto azul se mezcla con un punto rojo, esto hará que el conjunto de datos sea linealmente inseparable. No existe una línea recta que pueda separar las dos categorías. En este caso, Margen duro Ya no se trata de si la capacidad de generalización es fuerte, sino de que no existe una línea recta que los separe.
Por lo tanto, no importa desde qué ángulo comience desde las dos situaciones anteriores, debe considerar darle al modelo svm una tolerancia parcial a fallas. Esto conduce a Soft Margin SVM.
min 1 2 ∥ w ∥ 2 , s . t . yi ( w T x ( i ) + b ) ≥ 1 − ζ i , ζ i > 0 , i = 1 , 2 , … , m min\frac{1}{ 2} \parallel w \parallel^2, \quad st \quad y_{i} (w^Tx^{(i)} + b) \geq 1 - \zeta_{i}, \\ \quad \zeta_{i } >0, \quad i=1,2,\puntos,mmín.21∥w∥2，s . t .yyo( wT x( yo )+segundo )≥1−gramoyo,gramoyo>0 ,i=1 ,2 ,…,En comparación con Hard Margin SVM, m
equivale a hacer que las condiciones sean más relajadas. Para entenderlo intuitivamente a partir del gráfico, equivale a relajar la línea recta anterior hasta convertirla en una línea de puntos. Además, el punto más importante esζ i \zeta_{i}gramoyoNo es un valor fijo, sino que corresponde a cada muestra xi x_iXyotener un ζ i \zeta_{i}gramoyo, pero para esto ζ i \zeta_{i}gramoyoTambién se requieren ciertas restricciones, lo que no significa que esta condición pueda flexibilizarse indefinidamente. Es decir, este espacio de tolerancia a fallos no puede ser demasiado grande, por lo que es necesario limitarlo.
L1 regular
min ( 1 2 ∥ w ∥ 2 + C ∑ i = 1 m ζ i ) , s . t . yi ( w T x ( i ) + b ) ≥ 1 − ζ i , ζ i ≥ 0 , i = 1 , 2 , … , m \boxed { min(\frac{1}{2} \parallel w \parallel^2 +C \sum_{i=1}^m \zeta_{i}), \quad st \quad y_ {i} (w^Tx^{(i)} + b) \geq 1 - \zeta_{i}, \\ \qquad \qquad \qquad \qquad \zeta_{i} \geq 0, \quad i=1 ,2,\puntos,m }mín (21∥w∥2+ Cyo = 1∑mgramoyo) ，s . t .yyo( wT x( yo )+segundo )≥1−gramoyo,gramoyo≥0 ,i=1 ,2 ,…,metro
Introduciendo un nuevo hiperparámetro C para sopesar la tolerancia a fallas y la función objetivo. De hecho, esto también puede entenderse como el hecho de que le hemos agregado un término regular L1 para evitar que el modelo se desarrolle en una dirección extrema, haciéndolo menos sensible a conjuntos de datos extremos y desconocido a lo desconocido, los datos tienen mejor capacidad de generalización. Este llamado regular L1 es diferente del regular L1 anterior en que no tiene valor absoluto, simplemente porque tiene restringido ζ i ≥ 0 \zeta_{i} \geq 0gramoyo≥0 , por lo que es razonable no sumar el valor absoluto. Cuanto más grande es C, más cerca está de una SVM de margen duro. Cuanto más pequeña es C, hay más espacio para la tolerancia a fallos. La diferencia entre la regularización de svm y la regularización de regresión lineal es que la posición de C es diferente. Lo actualizaré una vez que tenga una comprensión más profunda de los motivos específicos.
Luego existe la regularidad L1 y, en consecuencia, la regularidad L2, como sigue.
min ( 1 2 ∥ w ∥ 2 + C ∑ i = 1 m ζ i 2 ) , s . t . yi ( w T x ( i ) + b ) ≥ 1 − ζ i , ζ i > 0 , i = 1 , 2 , … , m \boxed { min(\frac{1}{2} \parallel w \parallel^2 +C \sum_{i=1}^m \zeta_{i}^2), \quad st \quad y_{i} (w^Tx^{(i)} + b) \geq 1 - \zeta_{i}, \\ \qquad \qquad \qquad \qquad \zeta_{i} >0, \quad i=1 ,2,\puntos,m }mín (21∥w∥2+ Cyo = 1∑mgramoi2) ，s . t .yyo( wT x( yo )+segundo )≥1−gramoyo,gramoyo>0 ,i=1 ,2 ,…,metro
Sklearnsvm
Cuando se utiliza SVM, es necesario estandarizar los datos al igual que KNN, porque ambos implican distancia. Porque cuando la escala de datos es demasiado diferente, por ejemplo, el eje horizontal 0-1 y el eje vertical 0-10000 en la figura siguiente. Por lo tanto, primero es necesaria la estandarización.
El primer paso es preparar un conjunto de datos de clasificación binaria simple:
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
"""
load_iris是一个经典的机器学习数据集，它包含了150个样本
这个数据集中的四个特征分别是花萼长度（sepal length）、花萼宽度（sepal width）、花瓣长度（petal length）和花瓣宽度（petal width），
它们都是以厘米（cm）为单位测量的。目标变量是鸢尾花的种类，
有三种不同的种类：Setosa、Versicolour和Virginica。
它们的中文名分别是山鸢尾、杂色鸢尾和维吉尼亚鸢尾。
"""
iris = datasets.load_iris()
x = iris.data
y = iris.target
# 只做一个简单的二分类,获取分类是山鸢尾、杂色鸢尾的数据，同时取2维的特征就行了
x = x[y<2, :2]
y = y[y<2]
#分别绘制出分类是0和1的点，不同的scatter颜色不一样
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()
Para implementar svm, primero use un archivo C relativamente grande.
# 标准化数据
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
#数据归一化
standardscaler = StandardScaler()
standardscaler.fit(x)
x_standard = standardscaler.transform(x)
svc = LinearSVC(C=1e9)
svc.fit(x_standard, y)
def plot_decision_boundary(model, axis):
x0, x1 = np.meshgrid(np.linspace(axis[0], axis[1], int((axis[1] - axis[0])*100)).reshape(1, -1),
np.linspace(axis[2], axis[3], int((axis[3] - axis[2])*100)).reshape(1, -1),)
x_new = np.c_[x0.ravel(), x1.ravel()]
y_predict = model.predict(x_new)
zz = y_predict.reshape(x0.shape)
from matplotlib.colors import ListedColormap
custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])
plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)
w = model.coef_[0]
b = model.intercept_[0]
# w0*x0 + w1*x1 + b = 0
# x1 = -w0/w1 * x0 - b/w1
plot_x = np.linspace(axis[0], axis[1], 200)
up_y = -w[0]/w[1] * plot_x - b/w[1] + 1/w[1]
down_y = -w[0]/w[1] * plot_x - b/w[1] - 1/w[1]
up_index = (up_y >= axis[2]) & (up_y <= axis[3])
down_index = (down_y >= axis[2]) & (down_y <= axis[3])
plt.plot(plot_x[up_index], up_y[up_index], color='black')
plt.plot(plot_x[down_index], down_y[down_index], color='black')
plot_decision_boundary(svc, axis=[-3, 3, -3, 3])
plt.scatter(x_standard[y==0, 0], x_standard[y==0, 1], color='red')
plt.scatter(x_standard[y==1, 0], x_standard[y==1, 1], color='blue')
plt.show()
Utilice una C más pequeña y compare el efecto de diferentes valores de C.
svc2 = LinearSVC(C=0.01)
svc2.fit(x_standard, y)
plot_decision_boundary(svc2, axis=[-3, 3, -3, 3])
plt.scatter(x_standard[y==0, 0], x_standard[y==0, 1], color='red')
plt.scatter(x_standard[y==1, 0], x_standard[y==1, 1], color='blue')
plt.show()
Comparando las dos imágenes, podemos encontrar que cuando C es más pequeño, un punto rojo se divide por error en azul, lo que verifica una vez más que cuando C es más pequeño, significa que hay más margen de error.
Usando características polinómicas en SVM
De lo que hemos estado hablando antes es de svm lineal. Para svm, también puede resolver problemas no lineales. Por analogía con la idea de regresión lineal a regresión no lineal, primero se utilizan características polinómicas.
Primero genere el conjunto de datos:
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
x, y = datasets.make_moons()
x.shape
# (100, 2)
y.shape
# (100,)
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()
Luego agregue algo de ruido aleatorio a los datos:
x, y = datasets.make_moons(noise=0.15, random_state=666)
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()
Utilice polinomio, normalización, svm lineal
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.svm import LinearSVC
from sklearn.pipeline import Pipeline
def PolynomiaSVC(degree, C=1.0):
return Pipeline([
('poly', PolynomialFeatures(degree=degree)),
('std_scale', StandardScaler()),
('linear_svc', LinearSVC(C=C))
])
poly_svc = PolynomiaSVC(degree=3)
poly_svc.fit(x, y)
def plot_decision_boundary(model, axis):
x0, x1 = np.meshgrid(np.linspace(axis[0], axis[1], int((axis[1] - axis[0])*100)).reshape(1, -1),
np.linspace(axis[2], axis[3], int((axis[3] - axis[2])*100)).reshape(1, -1),)
x_new = np.c_[x0.ravel(), x1.ravel()]
y_predict = model.predict(x_new)
zz = y_predict.reshape(x0.shape)
from matplotlib.colors import ListedColormap
custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])
plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)
plot_decision_boundary(poly_svc, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x1[y1==0, 0], x1[y1==0, 1])
plt.scatter(x1[y1==1, 0], x1[y1==1, 1])
plt.show()
Además de utilizar este método para agregar características polinómicas y luego introducirlas en un servicio lineal, existe otra forma de lograr funciones similares.
from sklearn.svm import SVC
# 这种方法训练的过程并不完全是先将数据进行标准化，再使用linearSVC这么一个过程
# SVC中默认的C=0
def PolynomiaKernelSVC(degree, C=1.0):
return Pipeline([
('std_scale', StandardScaler()),
('kernel_svc', SVC(kernel='poly', degree=degree, C=C))
])
poly_kernel_svc = PolynomiaKernelSVC(degree=3)
poly_kernel_svc.fit(x1, y1)
# Pipeline(memory=None,
# steps=[('std_scale', StandardScaler(copy=True, with_mean=True, with_std=True)),
# ('kernel_svc', SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
# decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
# kernel='poly', max_iter=-1, probability=False, random_state=None,
# shrinking=True, tol=0.001, verbose=False))])
plot_decision_boundary(poly_kernel_svc, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x1[y1==0, 0], x1[y1==0, 1])
plt.scatter(x1[y1==1, 0], x1[y1==1, 1])
plt.show()
Este método es la función del núcleo en svm. A continuación, se explicará en detalle la función del núcleo.
¿Qué es la función del núcleo?
En tareas reales, es posible que el espacio muestral original no tenga un hiperplano que pueda dividir correctamente las dos categorías. Para tal problema, la muestra se puede asignar desde el espacio original a un espacio de características de mayor dimensión, de modo que la muestra esté en este espacio de características Internamente separable linealmente. Por lo tanto, la función de la función del núcleo es hacer que los datos originalmente linealmente inseparables sean linealmente separables. A continuación se muestra un procedimiento que utiliza el mapeo de núcleo polinómico.
Después de convertir a la siguiente función, los datos se vuelven linealmente separables.
Funciones del kernel de uso común:
1. Kernel lineal: k (xi, xj) = xi T xj + ck(x_{i}, x_{j}) = x_{i}^T x_{j} + ck ( xyo,Xj)=XitXj+c
2. Núcleo polinomial:k (xi, xj) = (xi T xj + c) dk(x_{i}, x_{j}) = (x_{i}^T x_{j} + c)^dk ( xyo,Xj)=( xitXj+c )d , cuando d=1, degenera en un núcleo lineal.
3. RBF del núcleo gaussiano:k ( xi , xj ) = exp ( − ∥ xi − xj ∥ 2 2 σ 2 ) , σ > 0 k(x_{i}, x_{j}) = exp(-\frac{\ paralelo x_{i} - x_{j} \paralelo ^2}{2\sigma ^2}), \sigma >0k ( xyo,Xj)=e x p ( −2p _2∥x _yo−x _j∥2) ,pag>0 es el núcleo RBF de ancho de banda del núcleo gaussiano: Núcleo de función de base radial
4. Núcleo laplaciano:k ( xi , xj ) = exp ( − ∥ xi − xj ∥ σ ) , σ > 0 k(x_{i}, x_ { j}) = exp(-\frac{\parallel x_{i} - x_{j} \parallel}{\sigma}), \sigma > 0k ( xyo,Xj)=e x p ( −pag∥x _yo−x _j∥) , pag.>0
5、Sigmoidea：k ( xi , xj ) = tanh ( β xi T xj + θ ) k(x_{i}, x_{j}) = tanh(\beta x_{i}^T x_{j} + \theta)k ( xyo,Xj)=el él ( β xitXj+yo )
Función del núcleo gaussiano
La función del núcleo gaussiano es una función del núcleo de uso común, que generalmente se usa en algoritmos de aprendizaje automático, como la máquina de vectores de soporte (SVM). Puede asignar datos del espacio original a un espacio de dimensiones superiores, de modo que las muestras originalmente inseparables puedan separarse en el nuevo espacio.
En términos sencillos, la función del núcleo gaussiano es como una "medida de similitud" que puede calcular la similitud entre dos muestras. Cuando usamos la función del núcleo gaussiano, primero seleccionamos un punto central, luego calculamos la distancia entre cada punto de muestra y el punto central, y usamos la distancia como medida de similitud. Esta distancia suele estar ponderada por una función de distribución gaussiana, de donde proviene el nombre de función núcleo gaussiana.
Más específicamente, la función del núcleo gaussiano puede convertir dos puntos de muestra xi x_iXyoy xj x_jXjAsigne un espacio de dimensiones superiores, calcule su producto interno en el nuevo espacio y obtenga la siguiente fórmula:
K ( xi , xj ) = exp ( − γ ∣ ∣ xi − xj ∣ ∣ 2 ) K(x_i, x_j) = \exp(-\gamma ||x_i - x_j||^2)k ( xyo,Xj)=exp ( − γ ∣∣ xyo−Xj∣ ∣2 )
Entre ellos, γ \gammaγ es un parámetro que controla el ancho de la distribución gaussiana,∣ ∣ xi − xj ∣ ∣ 2 ||x_i - x_j||^2∣∣x _yo−Xj∣ ∣2 es el punto de muestraxi x_iXyoy xj x_jXjEl cuadrado de la distancia euclidiana entre Cuando γ \gammaCuando el valor de γ es grande, el valor máximo de la distribución gaussiana se volverá más estrecho y la medida de similitud prestará más atención a la distancia entre los dos puntos de muestra; cuandoγ \gammaCuando el valor de γ es pequeño, el valor máximo de la distribución gaussiana se hará más amplio y la medida de similitud será más suave, centrándose en la similitud general entre los dos puntos de muestra.
En general, la función del núcleo gaussiano es una medida de similitud muy flexible y potente que se puede utilizar en muchos algoritmos de aprendizaje automático, especialmente cuando se trata de problemas de clasificación no lineal.
A continuación, podemos comprender todo el proceso de mapeo de manera más intuitiva a través del mapeo de funciones del núcleo gaussiano.
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(-4, 5, 1)
# array([-4, -3, -2, -1, 0, 1, 2, 3, 4])
y = np.array((x >= -2) & (x <= 2), dtype='int')
# array([0, 0, 1, 1, 1, 1, 1, 0, 0])
plt.scatter(x[y==0], [0] * len(x[y==0]))
plt.scatter(x[y==1], [0] * len(x[y==1]))
plt.show()
Después del núcleo gaussiano
def gaussian(x, l):
gamma = 1.0
return np.exp(-gamma *(x-l)**2)
l1, l2 = -1, 1
x_new = np.empty((len(x), 2))
for i,data in enumerate(x):
x_new[i, 0] = gaussian(data, l1)
x_new[i, 1] = gaussian(data, l2)
plt.scatter(x_new[y==0, 0], x_new[y==0, 1])
plt.scatter(x_new[y==1, 0], x_new[y==1, 1])
plt.show()
De hecho, el proceso de realización de la función real del núcleo gaussiano no es fijo γ \gammaγ , pero para cada punto de datos esγ \gammaγ ,determina el radio de gamma = 1.0 y tiene
lo siguiente:g ( x ) = 1 σ 2 π e − 1 2 ( x − µ σ ) g(x)= \frac{1}{\sigma \sqrt{2 \pi } } e^{-\frac{1}{2}(\frac{x - \mu}{\sigma})}g ( x )=pag2 p.m.1mi−21(pagx - metro)
dondeμ \muμ determina la posición central de la función,σ \sigmaσ determina el grado de cercanía de todo el gráfico,σ \sigmaCuanto menor es σ , más alta es la imagen y la imagen está relativamente concentrada. Opuestoa σ \sigmaCuanto mayor es σ , más dispersa está la gráfica.
K ( xi , xj ) = e − γ ∥ xi − xj ∥ 2 K(x_{i},x_{j}) = e^{-\gamma \parallel x_{i} - x_{j} \parallel ^2 }k ( xyo,Xj)=mi− γ ∥ xyo−x _j∥2
γ \gammaCuanto mayor es γ , más amplia es la distribución gaussiana;
γ\gammaCuanto menor es γ , más estrecha es la distribución gaussiana.
A continuación, utilice la función del núcleo gaussiano encapsulada en sklearn:
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
x, y = datasets.make_moons(noise=0.15, random_state=666)
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline
def RBFKernelSVC(gamma=1.0):
return Pipeline([
('std_scale', StandardScaler()),
('svc', SVC(kernel='rbf', gamma=gamma))
])
svc = RBFKernelSVC(gamma=1.0)
svc.fit(x, y)
def plot_decision_boundary(model, axis):
x0, x1 = np.meshgrid(np.linspace(axis[0], axis[1], int((axis[1] - axis[0])*100)).reshape(1, -1),
np.linspace(axis[2], axis[3], int((axis[3] - axis[2])*100)).reshape(1, -1),)
x_new = np.c_[x0.ravel(), x1.ravel()]
y_predict = model.predict(x_new)
zz = y_predict.reshape(x0.shape)
from matplotlib.colors import ListedColormap
custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])
plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)
plot_decision_boundary(svc, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()
svc_gamma100 = RBFKernelSVC(gamma=100)
svc_gamma100.fit(x, y)
plot_decision_boundary(svc_gamma100, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()
svc_gamma10 = RBFKernelSVC(gamma=10)
svc_gamma10.fit(x, y)
plot_decision_boundary(svc_gamma10, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()
svc_gamma01 = RBFKernelSVC(gamma=0.1)
svc_gamma01.fit(x, y)
plot_decision_boundary(svc_gamma01, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()
Gamma equivale a ajustar la complejidad del modelo. Cuanto más pequeña es la gamma, menor es la complejidad del modelo. Cuanto mayor es la gamma, mayor es la complejidad del modelo. Por lo tanto, es necesario ajustar la gamma del hiperparámetro para equilibrar el sobreajuste y el desajuste.
Fuente del texto y ejemplos de este artículo:
- https://cuijiahua.com/blog/2017/11/ml_8_svm_1.html
- https://zhuanlan.zhihu.com/p/79679104