Implementación de SVM y Kernel SVM con Scikit-Learn de Python

Una máquina de vectores de soporte (SVM) es un tipo de algoritmo de clasificación de aprendizaje automático supervisado. Las SVM se introdujeron inicialmente en la década de 1960 y luego se refinaron...

Una máquinas de vectores soporte (SVM) es un tipo de algoritmo de clasificación de aprendizaje automático supervisado. Las SVM se introdujeron inicialmente en la década de 1960 y luego se refinaron en la década de 1990. Sin embargo, solo ahora se están volviendo extremadamente populares debido a su capacidad para lograr resultados brillantes. Las SVM se implementan de una manera única en comparación con otros algoritmos de aprendizaje automático.

En este artículo veremos qué son los algoritmos de máquinas de vectores de soporte, la breve teoría detrás de la máquina de vectores de soporte y su implementación en la biblioteca Scikit-Learn de Python. Luego avanzaremos hacia un concepto SVM avanzado, conocido como Kernel SVM, y también lo implementaremos con la ayuda de Scikit-Learn.

SVM simple

En el caso de datos linealmente separables en dos dimensiones, como se muestra en la Fig. 1, un algoritmo típico de aprendizaje automático intenta encontrar un límite que divida los datos de tal manera que se pueda minimizar el error de clasificación errónea. Si observa detenidamente la figura 1, puede haber varios límites que dividen correctamente los puntos de datos. Las dos líneas discontinuas y la línea continua clasifican los datos correctamente.

Múltiples límites de decisión{.img-responsive}

Fig 1: Límites de Decisión Múltiple

SVM se diferencia de los demás algoritmos de clasificación en que elige el límite de decisión que maximiza la distancia desde los puntos de datos más cercanos de todas las clases. Una SVM no solo encuentra un límite de decisión; encuentra el límite de decisión más óptimo.

El límite de decisión más óptimo es el que tiene un margen máximo desde los puntos más cercanos de todas las clases. Los puntos más cercanos al límite de decisión que maximizan la distancia entre el límite de decisión y los puntos se denominan vectores de soporte, como se ve en la Fig. 2. El límite de decisión en el caso de las máquinas de vectores de soporte se denomina clasificador de margen máximo o hiperplano de margen máximo. .

Límite de decisión con vectores de soporte{.img-responsive}

Fig. 2: Límite de decisión con vectores de soporte

Hay matemáticas complejas involucradas detrás de encontrar los vectores de soporte, calcular el margen entre el límite de decisión y los vectores de soporte y maximizar este margen. En este tutorial no entraremos en los detalles de las matemáticas, sino que veremos cómo se implementan SVM y Kernel SVM a través de la biblioteca Python Scikit-Learn.

Implementación de SVM con Scikit-Learn

El conjunto de datos que vamos a usar en esta sección es el mismo que usamos en la sección de clasificación del tutorial de arbol de decision.

Nuestra tarea es predecir si un billete de banco es auténtico o no en función de cuatro atributos del billete, es decir, la asimetría de la imagen transformada en wavelet, la varianza de la imagen, la entropía de la imagen y la curtosis de la imagen. Este es un problema de clasificación binaria y usaremos el algoritmo SVM para resolver este problema. El resto de la sección consta de pasos estándar de aprendizaje automático.

Importación de bibliotecas

El siguiente script importa las bibliotecas requeridas:

1
2
3
4
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

Importación del conjunto de datos

Los datos están disponibles para su descarga en el siguiente enlace:

https://drive.google.com/file/d/13nw-uRXPY8XIZQxKRNZ3yYlho-CYm_Qt/view

La información detallada sobre los datos está disponible en el siguiente enlace:

https://archive.ics.uci.edu/ml/datasets/banknote+authentication

Descargue el conjunto de datos del enlace de la unidad de Google y guárdelo localmente en su máquina. Para este ejemplo, el archivo CSV para el conjunto de datos se almacena en la carpeta "Conjuntos de datos" de la unidad D en mi computadora con Windows. El script lee el archivo desde esta ruta. Puede cambiar la ruta del archivo para su computadora en consecuencia.

Para leer datos del archivo CSV, la forma más sencilla es usar el método read_csv de la biblioteca pandas. El siguiente código lee los datos del billete de la moneda del banco en el marco de datos de pandas:

1
bankdata = pd.read_csv("D:/Datasets/bill_authentication.csv")

Análisis de datos exploratorios {#análisis de datos exploratorios}

Hay formas prácticamente ilimitadas de analizar conjuntos de datos con una variedad de bibliotecas de Python. En aras de la simplicidad, solo comprobaremos las dimensiones de los datos y veremos los primeros registros. Para ver las filas y columnas y de los datos, ejecute el siguiente comando:

1
bankdata.shape

En la salida verás (1372,5). Esto significa que el conjunto de datos de billetes de banco tiene 1372 filas y 5 columnas.

Para tener una idea de cómo se ve realmente nuestro conjunto de datos, ejecute el siguiente comando:

1
bankdata.head()

La salida se verá así:

  Variance   Skewness   Curtosis   Entropy    Class

0 3,62160 8,6661 -2,8073 -0,44699 0 1 4,54590 8,1674 -2,4586 -1,46210 0 2 3,86600 -2,6383 1,9242 0,10645 0 3 3,45660 9,5228 -4,0112 -3,59440 0 4 0,32924 -4,4552 4,5718 -0,98880 0

Puede ver que todos los atributos del conjunto de datos son numéricos. La etiqueta también es numérica, es decir, 0 y 1.

Preprocesamiento de datos {#preprocesamiento de datos}

El preprocesamiento de datos implica (1) dividir los datos en atributos y etiquetas y (2) dividir los datos en conjuntos de entrenamiento y prueba.

Para dividir los datos en atributos y etiquetas, ejecute el siguiente código:

1
2
X = bankdata.drop('Class', axis=1)
y = bankdata['Class']

En la primera línea del script anterior, todas las columnas del marco de datos bankdata se almacenan en la variable X excepto la columna "Clase", que es la columna de la etiqueta. El método drop() descarta esta columna.

En la segunda línea, solo la columna de clase se almacena en la variable y. En este momento, la variable X contiene atributos, mientras que la variable y contiene las etiquetas correspondientes.

Una vez que los datos se dividen en atributos y etiquetas, el último paso de preprocesamiento consiste en dividir los datos en conjuntos de entrenamiento y prueba. Afortunadamente, la biblioteca model_selection de la biblioteca Scikit-Learn contiene el método train_test_split que nos permite dividir los datos sin problemas en conjuntos de entrenamiento y prueba.

Ejecute el siguiente script para hacerlo:

1
2
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Entrenamiento del algoritmo

Hemos dividido los datos en conjuntos de entrenamiento y prueba. Ahora es el momento de entrenar nuestro SVM en los datos de entrenamiento. Scikit-Learn contiene la biblioteca svm, que contiene clases integradas para diferentes algoritmos SVM. Como vamos a realizar una tarea de clasificación, usaremos la clase de clasificador de vector de soporte, que está escrita como SVC en la biblioteca svm de Scikit-Learn. Esta clase toma un parámetro, que es el tipo de kernel. Esto es muy importante. En el caso de una SVM simple, simplemente establecemos este parámetro como "lineal", ya que las SVM simples solo pueden clasificar datos separables linealmente. Veremos núcleos no lineales en la siguiente sección.

Se llama al método fit de la clase SVC para entrenar el algoritmo en los datos de entrenamiento, que se pasan como parámetro al método fit. Ejecute el siguiente código para entrenar el algoritmo:

1
2
3
from sklearn.svm import SVC
svclassifier = SVC(kernel='linear')
svclassifier.fit(X_train, y_train)

Hacer predicciones

Para realizar predicciones se utiliza el método predict de la clase SVC. Echa un vistazo al siguiente código:

1
y_pred = svclassifier.predict(X_test)

Evaluación del algoritmo

Las medidas de matriz de confusión, precisión, recuperación y F1 son las métricas más utilizadas para las tareas de clasificación. La biblioteca metrics de Scikit-Learn\ contiene los métodos classification_report y confusion_matrix, que se pueden usar fácilmente para averiguar los valores de estas importantes métricas.

Aquí está el código para encontrar estas métricas:

1
2
3
from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test,y_pred))
print(classification_report(y_test,y_pred))

Resultados

Los resultados de la evaluación son los siguientes:

1
2
3
4
5
6
7
8
[[152    0]
 [  1  122]]
              precision   recall   f1-score   support

           0       0.99     1.00       1.00       152
           1       1.00     0.99       1.00       123

avg / total        1.00     1.00       1.00       275

A partir de los resultados se puede observar que SVM superó ligeramente al algoritmo del árbol de decisión. Solo hay una clasificación errónea en el caso del algoritmo SVM en comparación con cuatro clasificaciones erróneas en el caso del algoritmo del árbol de decisión.

Núcleo SVM

En la sección anterior, vimos cómo se puede usar el algoritmo SVM simple para encontrar el límite de decisión para datos linealmente separables. Sin embargo, en el caso de datos separables no linealmente, como el que se muestra en la Fig. 3, no se puede utilizar una línea recta como límite de decisión.

Datos separables no linealmente{.img-responsive}

Fig. 3: Datos separables no lineales

En el caso de datos separables no linealmente, no se puede utilizar el algoritmo SVM simple. Más bien, se usa una versión modificada de SVM, llamada Kernel SVM.

Básicamente, el kernel SVM proyecta las dimensiones inferiores de datos separables no linealmente a datos separables linealmente en dimensiones superiores de tal manera que los puntos de datos que pertenecen a diferentes clases se asignan a diferentes dimensiones. Nuevamente, hay matemáticas complejas involucradas en esto, pero no tiene que preocuparse por eso para usar SVM. Más bien, podemos simplemente usar la biblioteca Scikit-Learn de Python para implementar y usar el kernel SVM.

Implementación de Kernel SVM con Scikit-Learn

La implementación de Kernel SVM con Scikit-Learn es similar a la SVM simple. En esta sección, usaremos el famoso conjunto de datos del iris para predecir la categoría a la que pertenece una planta en base a cuatro atributos: sépalo-ancho, sépalo -largo, ancho de pétalo y largo de pétalo.

El conjunto de datos se puede descargar desde el siguiente enlace:

https://archive.ics.uci.edu/ml/datasets/iris4

El resto de los pasos son pasos típicos de aprendizaje automático y necesitan muy poca explicación hasta que lleguemos a la parte donde entrenamos nuestro Kernel SVM.

Importación de bibliotecas

1
2
3
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

Importación del conjunto de datos

1
2
3
4
5
6
7
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

# Assign colum names to the dataset
colnames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

# Read dataset to pandas dataframe
irisdata = pd.read_csv(url, names=colnames)

Preprocesamiento

1
2
X = irisdata.drop('Class', axis=1)
y = irisdata['Class']

División de prueba de tren

1
2
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Entrenamiento del algoritmo

Para entrenar el kernel SVM, usamos la misma clase SVC de la biblioteca svm de Scikit-Learn. La diferencia radica en el valor del parámetro kernel de la clase SVC. En el caso de la SVM simple, usamos "linear" como valor para el parámetro del kernel. Sin embargo, para kernel SVM puede usar kernel gaussiano, polinomial, sigmoide o computable. Implementaremos núcleos polinómicos, gaussianos y sigmoides para ver cuál funciona mejor para nuestro problema.

1. Núcleo polinómico {#1núcleo polinomial}

En el caso de núcleo polinomio, también hay que pasar un valor para el parámetro grado de la clase SVC. Esto básicamente es el grado del polinomio. Eche un vistazo a cómo podemos usar un kernel polinomial para implementar kernel SVM:

1
2
3
from sklearn.svm import SVC
svclassifier = SVC(kernel='poly', degree=8)
svclassifier.fit(X_train, y_train)

Hacer predicciones

Ahora, una vez que hemos entrenado el algoritmo, el siguiente paso es hacer predicciones sobre los datos de prueba.

Ejecute el siguiente script para hacerlo:

1
y_pred = svclassifier.predict(X_test)

Evaluación del algoritmo

Como de costumbre, el paso final de cualquier algoritmo de aprendizaje automático es realizar evaluaciones para el núcleo polinomial. Ejecute el siguiente script:

1
2
3
from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

La salida para el kernel SVM que usa un kernel polinomial se ve así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
[[11  0  0]
 [ 0 12  1]
 [ 0  0  6]]
                 precision   recall   f1-score   support

    Iris-setosa       1.00     1.00       1.00        11
Iris-versicolor       1.00     0.92       0.96        13
 Iris-virginica       0.86     1.00       0.92         6

    avg / total       0.97     0.97       0.97        30

Ahora repitamos los mismos pasos para los núcleos gaussiano y sigmoide.

2. Núcleo gaussiano

Eche un vistazo a cómo podemos usar el kernel polinomial para implementar kernel SVM:

1
2
3
from sklearn.svm import SVC
svclassifier = SVC(kernel='rbf')
svclassifier.fit(X_train, y_train)

Para usar el kernel gaussiano, debe especificar 'rbf' como valor para el parámetro Kernel de la clase SVC.

Predicción y evaluación

1
y_pred = svclassifier.predict(X_test)
1
2
3
from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

La salida de Kernel SVM con kernel gaussiano se ve así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
[[11  0  0]
 [ 0 13  0]
 [ 0  0  6]]
                 precision   recall   f1-score   support

    Iris-setosa       1.00     1.00       1.00        11
Iris-versicolor       1.00     1.00       1.00        13
 Iris-virginica       1.00     1.00       1.00         6

    avg / total       1.00     1.00       1.00        30

3. Núcleo sigmoide

Finalmente, usemos un kernel sigmoide para implementar Kernel SVM. Echa un vistazo al siguiente script:

1
2
3
from sklearn.svm import SVC
svclassifier = SVC(kernel='sigmoid')
svclassifier.fit(X_train, y_train)

Para usar el kernel sigmoide, debe especificar 'sigmoid' como valor para el parámetro kernel de la clase SVC.

Predicción y evaluación

1
y_pred = svclassifier.predict(X_test)
1
2
3
from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

La salida de Kernel SVM con Sigmoid kernel se ve así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
[[ 0  0 11]
 [ 0  0 13]
 [ 0  0  6]]
                 precision   recall   f1-score   support

    Iris-setosa       0.00     0.00       0.00        11
Iris-versicolor       0.00     0.00       0.00        13
 Iris-virginica       0.20     1.00       0.33         6

    avg / total       0.04     0.20       0.07        30

Comparación del rendimiento del kernel

Si comparamos el rendimiento de los diferentes tipos de núcleos, podemos ver claramente que el núcleo sigmoide es el que peor se comporta. Esto se debe a que la función sigmoidea devuelve dos valores, 0 y 1, por lo que es más adecuada para problemas de clasificación binaria. Sin embargo, en nuestro caso teníamos tres clases de salida.

Entre el kernel gaussiano y el kernel polinomial, podemos ver que el kernel gaussiano logró una tasa de predicción perfecta del 100 %, mientras que el kernel polinomial clasificó incorrectamente una instancia. Por lo tanto, el núcleo gaussiano se desempeñó un poco mejor. Sin embargo, no existe una regla estricta y rápida sobre qué kernel funciona mejor en cada escenario. Se trata de probar todos los núcleos y seleccionar el que tenga los mejores resultados en su conjunto de datos de prueba.

Yendo más lejos: proyecto de extremo a extremo portátil

¿Tu naturaleza inquisitiva te hace querer ir más allá? Recomendamos consultar nuestro Proyecto guiado: ["Predicción práctica del precio de la vivienda: aprendizaje automático en Python"](https://wikihtp.com/courses/hands-on-house- precio-predicción-aprendizaje-máquina-en-python/#cta){target="_blank"}.

[](https://wikihtp.com/ cursos/predicción-de-precio-de-la-casa-práctica-aprendizaje-de-máquina-en-python/#cta)

En este proyecto guiado, aprenderá a crear potentes modelos tradicionales de aprendizaje automático, así como modelos de aprendizaje profundo, utilizar Ensemble Learning y capacitar a los meta-aprendices para predecir los precios de la vivienda a partir de una bolsa de modelos Scikit-Learn y Keras.

Con Keras, la API de aprendizaje profundo creada sobre Tensorflow, experimentaremos con arquitecturas, crearemos un conjunto de modelos apilados y entrenaremos una red neuronal meta-aprendizaje (modelo de nivel 1) para calcular el precio de un casa.

El aprendizaje profundo es sorprendente, pero antes de recurrir a él, se recomienda intentar resolver el problema con técnicas más simples, como los algoritmos de aprendizaje superficial. Nuestro rendimiento de referencia se basará en un algoritmo de Regresión de bosque aleatorio. Además, exploraremos la creación de conjuntos de modelos a través de Scikit-Learn a través de técnicas como embalaje y votación.

Este es un proyecto integral y, como todos los proyectos de aprendizaje automático, comenzaremos con Análisis exploratorio de datos, seguido de Preprocesamiento de datos y, finalmente, Creación de modelos superficiales y Aprendizaje profundo para ajustarse a los datos que hemos explorado y limpiado previamente.

Conclusión

En este artículo estudiamos SVM tanto simples como kernel. Estudiamos la intuición detrás del algoritmo SVM y cómo se puede implementar con la biblioteca Scikit-Learn de Python. También estudiamos diferentes tipos de kernels que se pueden usar para implementar kernel SVM. Le sugiero que intente implementar estos algoritmos en conjuntos de datos del mundo real disponibles en lugares como kaggle.com.

También le sugiero que explore las matemáticas reales detrás de SVM. Aunque no necesariamente lo necesitará para usar el algoritmo SVM, sigue siendo muy útil para saber qué sucede realmente detrás de escena mientras su algoritmo encuentra límites de decisión. cisión.