Primeros pasos con el aprendizaje automático de Python: notas de estudio de la máquina vectorial de soporte

---

prefacio

La mayoría de los algoritmos de aprendizaje automático tradicionales pueden lograr tareas de clasificación, pero estos modelos se enfocan en separar diferentes categorías de datos, es decir, su idea central es hacer que la pérdida del error de clasificación del modelo completo sea lo más pequeña posible. Sucedió que había un modelo de aprendizaje automático,No solo presta atención a si la clasificación puede separar por completo los datos de diferentes categorías, sino que también presta atención a si se puede maximizar el intervalo del límite de decisión obtenido por clasificación, es decir, si la distancia desde el punto de datos más cercano de cada categoría del límite de decisión puede estar más lejos, este es nuestro protagonista hoy: máquina de vectores de soporte.

---

1. Introducción a las máquinas de vectores de soporte

Las máquinas de vectores de soporte (SVM) son un modelo de dos categorías. Su modelo básico es un clasificador lineal con el intervalo más grande definido en el espacio de características. El intervalo más grande lo hace diferente del perceptrón; SVM también incluye la transformación del kernel. , lo que lo hace un clasificador sustancialmente no lineal. La estrategia de aprendizaje de SVM es maximizar el intervalo, lo que puede formalizarse como un problema de resolución de programación cuadrática convexa, que también es equivalente al problema de minimizar la función de pérdida de bisagra regularizada. El algoritmo de aprendizaje de SVM es el algoritmo de optimización para resolver la programación cuadrática convexa.

En segundo lugar, el principio matemático de la máquina de vectores de soporte.

Máquina de vectores de soporte, desde el punto de vista del nombre, es un modelo de límite de decisión formado por vectores de soporte (vectores de soporte), donde los vectores de soporte son un tipo especial de puntos de datos, que son algunos puntos de datos más cercanos al plano de decisión en el datos de categoría, que respaldan todo el plano de toma de decisiones, un poco como la columna vertebral del equipo, respaldan el desarrollo y el futuro de todo el equipo. El número de vectores de soporte es proporcional a la complejidad del modelo.

1. Cálculo de distancia

De manera similar a otros modelos de clasificación, usamos la distancia desde el punto hasta el plano de decisión como factor de optimización en la máquina de vectores de soporte, y extendemos el principio de cálculo de la distancia desde el punto hasta el plano de decisión en el espacio tridimensional para el espacio de alta dimensión

Sea la ecuación del plano de decisión
$$w^{TX}{\_}^{\prime }+b=0$$

Tomar cualquier punto de datos $x$ , sea wwel vector normal del plano de decisión$w$ , elegimos al azar un punto x ′ x'en el plano de decisión$X^{\prime }$ , luego$x{x}^{\prime }$ El vector entre dos puntos es$X-X^{\prime }$ , el vector$X-X^{\prime }$ y el vector normalwwEl vectorx − x ′ x - x'$se\; puede\; calcular\; mediante\; la\; multiplicación\; de\; puntos\; de\; w$$X-X^{\prime }$ en el vector normal$La\; longitud\; de\; la\; proyección\; en\; w$ (es decir, la distancia del punto al plano) y el vector normalwwEl producto de la longitud del$módulo\; w$$La\; longitud\; del\; módulo\; w$ es la distancia del punto al plano, que se sustituye en la ecuación del plano de decisión para eliminar$X^{\prime }$

$$dyos(x,b,w)=\frac{|w^T\cdot X+b|}{||con||}$$

También es aplicable al espacio de alta dimensión, pero la dimensión de cada vector de parámetros se vuelve mayor.

Teniendo en cuenta que el modelo de clasificación binaria necesita combinar las etiquetas de los datos de muestra, definimos el valor de la etiqueta del ejemplo positivo como 1, y el valor de la etiqueta del ejemplo negativo definido como -1, para un conjunto de datos dado $M$ e hiperplano$w\cdot X+b=0$ , define el hiperplano sobre el punto de muestra$\left(X_{},y_{}\right)$ es
$$dyos(x,b,w)=\frac{y_{}(w^T\cdot X_{}+segundo}{||con||}$$

A continuación, de acuerdo con la idea original, optimizamos la función objetivo maximizando la distancia desde el punto más cercano al plano de decisión.

2. Función objetivo

Suponemos que la distancia desde el punto más cercano al plano de decisión es $di{s}_{}$, esta distancia es lo que llamamos distancia del vector soporte al hiperplano. De acuerdo con la definición anterior, el problema de resolver el hiperplano de segmentación máxima del modelo SVM se puede expresar como la condición de restricción del problema de optimización es yi (
$$\frac{y_{}(w^T\cdot X_{}+segundo}{||con||}\ge di{s}_{}$$
La función objetivo del problema de optimización es
$$máx{.}_{w,}di{s}_{}$$

Para simplificar la función objetivo y las restricciones, divida ambos lados de las restricciones por $di{s}_{}$, escala e integra las restricciones para obtener
$$\frac{y_{}(w^T\cdot X_{}+segundo}{||w||reyo{s}_{}}\ge 1$$
$$y_{}(w^T\cdot X_{}+segundo)\ge 1$$

De acuerdo con la derivación de escala, $y_{}(w^T\cdot X_{}+segundo)\ge 1$ siempre se establece, y debido a la maximización$di{s}_{}$Equivale a maximizar $\frac{}{||con||}$, por lo que la función objetivo y las restricciones se pueden expresar finalmente como
$$min{\_}_{w,}\frac{||w|{|}^{}}{2}$$
$$y_{}(w^T\cdot X_{}+segundo)\ge 1$$

3. Solución óptima bajo restricciones

El método del multiplicador de Lagrange es un método para encontrar el extremo de funciones multivariadas bajo condiciones restringidas. Combinado con el método del multiplicador de Lagrange, podemos construir una nueva función objetivo. La función objetivo es resolver el problema dentro de la ruta de restricción , que w , $w,b,$La combinación de$a$$\frac{||w|{|}^{}}{2}$Alcanza el mínimo, donde $\varphi \left(x\right)$ es una transformación kernel, que es un método de transformación para mapear datos de baja dimensión a datos de alta dimensión
$$L(w,b,a)=\frac{||{con}^2}{2}-\sum _{yo=1}un\left(y_{}\right(w^T\cdot \varphi \left(x_{}\right)+segundo)-1)$$

De acuerdo con la idea del método del multiplicador de Lagrange, entonces la función objetivo es respectivamente para $w,b,a$ Encuentre las derivadas parciales y haga que las tres derivadas parciales sean iguales a 0, luego puede obtener la identidad del valor extremo bajo las restricciones, la identidad caracteriza a w , bw,b al tomar los valores extremos bajo las$w,b$ y$Relación\; \alpha$ , la simplificación de la ecuación de valor extremo puede obtener
$$\frac{\partial }{\partial w}=0\gg w=\sum _{yo=1}un{y}_{}\varphi \left(x_{}\right)$$
$$\frac{\partial }{\partial segundo}=0\gg 0=\sum _{yo=1}un{y}_{}$$

Sustituya la identidad del valor extremo en la función objetivo para eliminar $w,b$ , puedes obtener alrededor deα \alphafunción objetivo unaria para$\alpha$

Podemos obtener α \boldsymbol{\alpha } a través de este método de optimización$\alpha$ , y luego según$\alpha$ , podemos resolver para$wyb$ , y luego obtener nuestro objetivo original: encontrar el hiperplano, es decir, calcular la ecuación del plano de decisión.

4. Optimización de intervalo suave

Los datos en la vida real a menudo o en sí mismos no son linealmente separables pero aproximadamente linealmente separables, o linealmente separables pero ruidosos, las dos situaciones anteriores conducirán al soporte lineal de intervalo duro mencionado anteriormente en aplicaciones reales Las máquinas vectoriales ya no son prácticas. En el intervalo suave SVM, nuestro hiperplano de clasificación debe poder dividir las categorías de datos tanto como sea posible, y también hacer que el intervalo entre el vector de soporte y el hiperplano sea lo más grande posible.

En el intervalo blando $X_{}$es una "variable de holgura", es decir, una bisagra bisagraFunción$de\; pérdida$$de\; bisagra$$.$Cada muestra tiene una variable de holgura correspondiente, que caracteriza el grado en que los datos de la muestra no satisfacen las restricciones. Cuanto mayor sea el grado de insatisfacción, más probable es que el punto de datos se convierta en un punto de ruido atípico. CC

en la función objetivo del intervalo blando$C$ se denomina parámetro de penalización de regularización,$Cuanto\; mayor\; sea\; el\; valor\; de\; C$ , mayor será la penalización por clasificación y menor la tasa de tolerancia al error$Cuanto\; menor\; sea\; el\; valor\; de\; C$ , menor será la penalización por clasificación y mayor será la tasa de tolerancia al error. El seguimiento es consistente con la idea de soluciones linealmente separables.Aquí, primero usamos el método del multiplicador de Lagrange para obtener la función de Lagrange, y luego encontramos su problema dual.

5. Transformación de la función del kernel

En los problemas comunes de clasificación binaria, a menudo existe el problema de que los datos de baja dimensión no se pueden separar, pero si simplemente se realiza la operación del producto interno de la matriz, aparecerá un nuevo problema: el desastre de la dimensionalidad, es decir, el espacio original es tres -dimensional y se puede mapear a 20 dimensiones, esto también se puede manejar, pero si nuestras características de baja dimensión tienen 100 dimensiones, entonces se necesitan dimensiones más altas para el mapeo. En este momento, las dimensiones mapeadas crecerán explosivamente y la cantidad de el cálculo es demasiado grande para ser calculado. Las ventajas de las máquinas de vectores de soporte se reflejan principalmente en la resolución de problemas lineales inseparables. Resuelve inteligentemente la operación del producto interno en un espacio de alta dimensión mediante la introducción de la técnica de transformación de la función kernel, para resolver bien el problema de clasificación no lineal.

Las funciones del núcleo comúnmente utilizadas son

Núcleo lineal: $k(x,z)=X\cdot z$

Núcleo polinomial: $k(x,z)=(X\cdot z+1)pag$

Kernel gaussiano: $k(x,z)={mi}^{-\frac{|x-z{|}^{}}{2p{\_}^2}}$

Sigmoid核函数(Sigmoid Kernel)：$k(x,z)=lax\_\_\_\bullet z+r)$

Con la función kernel, podemos mapear datos linealmente inseparables de baja dimensión a alta dimensión para lograr efectos linealmente separables. Esta es la idea de realización de SVM no lineal

3. Python implementa una máquina de vectores de soporte

1. Comparación de sanciones

Python implementa la idea de la máquina de vectores de soporte. Primero, importa el paquete. Esta vez usamos el conjunto de datos de iris como un experimento. Tomamos dos características y etiquetas del conjunto de datos de iris, y luego instanciamos dos SVM de núcleo lineal. El el parámetro de regularización C es diferente, para luego definir el plano de decisión y la función de marcar el vector de soporte a llamar, y finalmente visualizarlo

import matplotlib.pyplot as plt
import numpy as np
from sklearn.svm import SVC
from sklearn.datasets import load_iris

iris = load_iris()
x = iris['data'][:, (1, 2)]
y = iris['target']

set_two_classes = (y==0) | (y==1)
x = x[set_two_classes]
y = y[set_two_classes]
svm_clf1 = SVC(kernel='linear', C=0.1)
svm_clf2 = SVC(kernel='linear', C=1000)
svm_clf1.fit(x, y)
svm_clf2.fit(x, y)

def plot_decision_boundary(svm_clf, xmin, xmax):
    w = svm_clf.coef_[0]
    b = svm_clf.intercept_[0]
    x0 = np.linspace(xmin, xmax, 200)
    decision_boundary = -w[0]/w[1] * x0 - b/w[1]
    margin = 1/w[1]
    gutter_up = decision_boundary + margin
    gutter_down = decision_boundary - margin
    svs = svm_clf.support_vectors_
    plt.scatter(svs[:, 0], svs[:, 1], s=200, facecolors='#FFAAAA')
    plt.plot(x0, decision_boundary, 'k-', linewidth=2)
    plt.plot(x0, gutter_up, 'k--', linewidth=2)
    plt.plot(x0, gutter_down, 'k--', linewidth=2)



plt.figure(figsize=(12, 8))
plt.subplot(121)
plot_decision_boundary(svm_clf1, 0, 6)
plt.plot(x[:, 0][y == 0], x[:, 1][y == 0], 'bs', label="Iris-Virginica")
plt.plot(x[:, 0][y == 1], x[:, 1][y == 1], 'ys', label="Iris-Versicolor")
plt.legend(loc="best", fontsize=12)
plt.xlabel("petal length", fontsize=12)
plt.ylabel("petal width", fontsize=12)
plt.title("C=0.1")
plt.axis([1, 5, 0.5, 5.5])
plt.subplot(122)
plot_decision_boundary(svm_clf2, 0, 6)
plt.plot(x[:, 0][y == 0], x[:, 1][y == 0], 'bs', label="Iris-Virginica")
plt.plot(x[:, 0][y == 1], x[:, 1][y == 1], 'ys', label="Iris-Versicolor")
plt.legend(loc="best", fontsize=12)
plt.xlabel("petal length", fontsize=12)
plt.ylabel("petal width", fontsize=12)
plt.title("C=1000")
plt.axis([1, 5, 0.5, 5.5])
plt.show()

2. Función de núcleo gaussiano

La idea de Python para realizar el mapeo del núcleo gaussiano es primero importar el paquete. Esta vez, experimentaremos con un conjunto de datos generado aleatoriamente, definiremos la expresión matemática de la función del núcleo gaussiano y la función de dibujo del conjunto de datos. , y luego sustituya los datos en la función del núcleo gaussiano para el cálculo, y finalmente visualícelo.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D



x1 = np.linspace(-2, 2, 30)
y1 = np.sqrt(4 - 2 * x1**2)
x2 = np.linspace(-1, 1, 30)
y2 = np.sqrt(2 - 2 * x2**2)

colors = ["blue", "green"]
types = ["bs", "g^"]

def plot_dataset(x, y, ty):
    plt.plot(x, y, ty, markersize=3)
    plt.grid(True, which='both')
    plt.xlabel(r"$x_1$", fontsize=12)
    plt.ylabel(r"$x_2$", fontsize=12, rotation=0)

# 定义高斯核函数
def gaussian_kernel(x1, y1, x2, y2, sigma=1):
    return np.exp(-((x1-y1)**2+(x2-y2)**2) / (2 * (sigma ** 2)))



# 计算高斯核函数矩阵
K1 = np.zeros((1, 30))
K2 = np.zeros((1, 30))
for i in range(1):
    for j in range(30):
       K1[i, j] = gaussian_kernel(x1[j], 0.0, y1[j], 1)
       K2[i, j] = gaussian_kernel(x2[j], 0.0, y2[j], 1)

# 画图
fig = plt.figure(figsize=(12, 8))

ax1 = fig.add_subplot(121)
plot_dataset(x1, y1, types[0])
plot_dataset(x2, y2, types[1])
ax2 = fig.add_subplot(122, projection='3d')
ax2.scatter(x1.flatten(), y1.flatten(), K1.flatten(), c=colors[0], cmap='rainbow')
ax2.scatter(x2.flatten(), y2.flatten(), K2.flatten(), c=colors[1], cmap='rainbow')
plt.show()

Se puede ver claramente que los datos linealmente inseparables en un espacio bidimensional se vuelven linealmente separables cuando se asignan a un espacio tridimensional.

3. SVM no lineal

La idea de Python para realizar SVM no lineal, primero guíe el paquete, esta vez usamos el conjunto de datos lunares como un experimento, tomamos dos características y etiquetas del conjunto de datos lunares, y luego instanciamos dos SVM con núcleos gaussianos, con diferentes parámetros de regularización C, $Hacer\; una\; comparación\; con\; diferentes\; parámetros\; \gamma$ , luego definir el plano de decisión y la función de dibujo que marca el vector de soporte a llamar, y finalmente enumerar y visualizar el dibujo

import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import make_moons
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

x, y = make_moons(n_samples=200, noise=0.23, random_state=36)
gamma1, gamma2 = 0.2, 6
C1, C2 = 0.1, 1000
hyperparams = (gamma1, C1), (gamma2, C1), (gamma1, C2), (gamma2, C2)
svm_clfs = []

def plot_dataset(x, y):
    plt.plot(x[:, 0][y == 0], x[:, 1][y == 0], "bs", markersize=3)
    plt.plot(x[:, 0][y == 1], x[:, 1][y == 1], "g^", markersize=3)
    plt.grid(True, which='both')
    plt.xlabel(r"$x_1$", fontsize=12)
    plt.ylabel(r"$x_2$", fontsize=12, rotation=0)

def plot_predictions(svm_clf):
    x0 = np.linspace(-2, 3, 200)
    x1 = np.linspace(-2, 3, 200)
    x0s, x1s = np.meshgrid(x0, x1)
    X = np.c_[x0s.ravel(), x1s.ravel()]
    y_pred = svm_clf.predict(X).reshape(x0s.shape)
    plt.contourf(x0s, x1s, y_pred, cmap=plt.cm.brg, alpha=0.3)

for gamma, C in hyperparams:
    rbf_svm_clf = Pipeline([("scaler", StandardScaler()),("svm_clf", SVC(kernel="rbf" ,C=C, gamma=gamma))])
    rbf_svm_clf.fit(x, y)
    svm_clfs.append(rbf_svm_clf)


plt.figure(figsize=(12, 8))

for i, svm_clf in enumerate(svm_clfs):
    plt.subplot(221+i)
    plot_predictions(svm_clf)
    plot_dataset(x, y)
    gamma, C = hyperparams[i]
    plt.title(r"$\gamma = {},C = {}$".format(gamma, C), fontsize=12)
plt.show()

---

Resumir

Lo anterior es el contenido de las notas de estudio de la máquina de vectores de soporte.Esta nota presenta brevemente los principios matemáticos y las ideas de implementación del programa de las máquinas de vectores de soporte. Las máquinas de vectores de soporte se utilizan ampliamente en los siguientes campos:

Reconocimiento de patrones: SVM puede procesar de manera efectiva datos de alta dimensión, por lo que se usa ampliamente en el campo del reconocimiento de patrones, como el reconocimiento facial, el reconocimiento de caracteres escritos a mano, el reconocimiento de voz, el reconocimiento de imágenes, etc.

Bioinformática: SVM se utiliza en el campo de la bioinformática para la clasificación de secuencias, clasificación de grupos, predicción, etc. para proteínas, ADN y ARN.

Predicción financiera: SVM se utiliza en el campo financiero para predecir precios de acciones, tipos de cambio de divisas, etc., y puede preparar ciertas estrategias para la gestión de activos y la gestión de recursos humanos a través del análisis de datos de transacciones en el mercado de valores.

Detección médica: SVM se puede utilizar para el diagnóstico de enfermedades, la predicción y la formulación de planes de tratamiento mediante el aprendizaje de los biomarcadores de los pacientes.

Visión por computadora: SVM se utiliza en la detección de objetos, clasificación de imágenes, segmentación de imágenes, etc. en el campo de la visión por computadora.

Clasificación de texto: SVM se utiliza en el campo de la clasificación de texto para spam, análisis de sentimientos, procesamiento de lenguaje natural, etc.