Support Vector Machine o SVM es uno de los algoritmos de aprendizaje supervisado más populares, que se utiliza tanto para problemas de clasificación como de regresión. Sin embargo, se utiliza principalmente para problemas de clasificación en aprendizaje automático.

El objetivo del algoritmo SVM es crear la mejor línea o límite de decisión que pueda segregar el espacio de n dimensiones en clases para que podamos colocar fácilmente el nuevo punto de datos en la categoría correcta en el futuro. Este límite de mejor decisión se llama hiperplano.

SVM elige los puntos/vectores extremos que ayudan a crear el hiperplano. Estos casos extremos se denominan vectores de soporte y, por lo tanto, el algoritmo se denomina máquina de vectores de soporte. Considere el siguiente diagrama en el que hay dos categorías diferentes que se clasifican mediante un límite de decisión o hiperplano:

Ejemplo: SVM se puede entender con el ejemplo que hemos usado en el clasificador KNN. Supongamos que vemos un gato extraño que también tiene algunas características de los perros, por lo que si queremos un modelo que pueda identificar con precisión si es un gato o un perro, dicho modelo se puede crear utilizando el algoritmo SVM. Primero entrenaremos a nuestro modelo con muchas imágenes de perros y gatos para que pueda aprender sobre diferentes características de perros y gatos, y luego lo probaremos con esta extraña criatura. Entonces, cuando el vector de soporte crea un límite de decisión entre estos dos datos (gato y perro) y elige casos extremos (vectores de soporte), verá el caso extremo de gato y perro. Según los vectores de soporte, lo clasificará como un gato. Considere el siguiente diagrama:

El algoritmo SVM se puede utilizar para Detección de rostros, clasificación de imágenes, categorización de texto, etc.

matriz de cadenas del programa c

Tipos de SVM

SVM puede ser de dos tipos:

SVM lineal:El SVM lineal se utiliza para datos linealmente separables, lo que significa que si un conjunto de datos se puede clasificar en dos clases utilizando una sola línea recta, dichos datos se denominan datos linealmente separables y se utiliza un clasificador denominado clasificador SVM lineal.SVM no lineal:El SVM no lineal se utiliza para datos separados no linealmente, lo que significa que si un conjunto de datos no se puede clasificar utilizando una línea recta, dichos datos se denominan datos no lineales y el clasificador utilizado se denomina clasificador SVM no lineal.

Hiperplano y vectores de soporte en el algoritmo SVM:

Hiperplano: Puede haber múltiples líneas/límites de decisión para segregar las clases en un espacio de n dimensiones, pero necesitamos encontrar el mejor límite de decisión que ayude a clasificar los puntos de datos. Este mejor límite se conoce como hiperplano de SVM.

Las dimensiones del hiperplano dependen de las características presentes en el conjunto de datos, lo que significa que si hay 2 características (como se muestra en la imagen), entonces el hiperplano será una línea recta. Y si hay 3 características, entonces el hiperplano será un plano bidimensional.

Siempre creamos un hiperplano que tiene un margen máximo, lo que significa la distancia máxima entre los puntos de datos.

Vectores de soporte:

Los puntos de datos o vectores que están más cerca del hiperplano y que afectan la posición del hiperplano se denominan vectores de soporte. Dado que estos vectores soportan el hiperplano, se denomina vector de soporte.

¿Cómo funciona SVM?

SVM lineal:

El funcionamiento del algoritmo SVM se puede entender con un ejemplo. Supongamos que tenemos un conjunto de datos que tiene dos etiquetas (verde y azul) y que el conjunto de datos tiene dos características x1 y x2. Queremos un clasificador que pueda clasificar el par (x1, x2) de coordenadas en verde o azul. Considere la siguiente imagen:

Entonces, como es un espacio bidimensional, simplemente usando una línea recta, podemos separar fácilmente estas dos clases. Pero puede haber varias líneas que puedan separar estas clases. Considere la siguiente imagen:

Por tanto, el algoritmo SVM ayuda a encontrar la mejor línea o límite de decisión; este mejor límite o región se llama como hiperplano . El algoritmo SVM encuentra el punto más cercano de las líneas de ambas clases. Estos puntos se llaman vectores de soporte. La distancia entre los vectores y el hiperplano se llama margen . Y el objetivo de SVM es maximizar este margen. El hiperplano con margen máximo se llama hiperplano óptimo .

SVM no lineal:

cómo generar números aleatorios en java

Si los datos están ordenados linealmente, podemos separarlos usando una línea recta, pero para datos no lineales, no podemos dibujar una sola línea recta. Considere la siguiente imagen:

Entonces, para separar estos puntos de datos, necesitamos agregar una dimensión más. Para datos lineales, hemos utilizado dos dimensiones xey, por lo que para datos no lineales, agregaremos una tercera dimensión z. Se puede calcular como:

 z=x<sup>2</sup> +y<sup>2</sup> 

Al agregar la tercera dimensión, el espacio muestral quedará como se muestra a continuación:

Ahora, SVM dividirá los conjuntos de datos en clases de la siguiente manera. Considere la siguiente imagen:

Dado que estamos en el espacio tridimensional, parece un plano paralelo al eje x. Si lo convertimos en espacio 2d con z=1, quedará como:

Por tanto, obtenemos una circunferencia de radio 1 en el caso de datos no lineales.

Implementación de Python de la máquina de vectores de soporte

Ahora implementaremos el algoritmo SVM usando Python. Aquí usaremos el mismo conjunto de datos. datos del usuario , que hemos utilizado en Regresión logística y clasificación KNN.

Paso de preprocesamiento de datos

Hasta el paso de preprocesamiento de datos, el código seguirá siendo el mismo. A continuación se muestra el código:

 #Data Pre-processing Step # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test) 

Después de ejecutar el código anterior, preprocesaremos los datos. El código dará el conjunto de datos como:

La salida escalada para el conjunto de prueba será:

Ajustar el clasificador SVM al conjunto de entrenamiento:

Ahora el conjunto de entrenamiento se instalará en el clasificador SVM. Para crear el clasificador SVM, importaremos SVC clase de Sklearn.svm biblioteca. A continuación se muestra el código para ello:

 from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train) 

En el código anterior, hemos utilizado núcleo = 'lineal' , ya que aquí estamos creando SVM para datos linealmente separables. Sin embargo, podemos cambiarlo por datos no lineales. Y luego ajustamos el clasificador al conjunto de datos de entrenamiento (x_train, y_train)

Producción:

 Out[8]: SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='auto_deprecated', kernel='linear', max_iter=-1, probability=False, random_state=0, shrinking=True, tol=0.001, verbose=False) 

El rendimiento del modelo se puede alterar cambiando el valor de C (factor de regularización), gamma y kernel .

Predicción del resultado del conjunto de pruebas:
Ahora, predeciremos el resultado del conjunto de prueba. Para ello crearemos un nuevo vector y_pred. A continuación se muestra el código para ello:

 #Predicting the test set result y_pred= classifier.predict(x_test) 

Después de obtener el vector y_pred, podemos comparar el resultado de y_pred y y_prueba para comprobar la diferencia entre el valor real y el valor previsto.

Producción: A continuación se muestra el resultado para la predicción del conjunto de prueba:

Creando la matriz de confusión:
Ahora veremos el rendimiento del clasificador SVM y cuántas predicciones incorrectas hay en comparación con el clasificador de regresión logística. Para crear la matriz de confusión, necesitamos importar el matriz de confusión Función de la biblioteca sklearn. Después de importar la función, la llamaremos usando una nueva variable. cm . La función toma dos parámetros, principalmente y_true (los valores reales) y y_pred (el valor objetivo devuelto por el clasificador). A continuación se muestra el código para ello:

 #Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred) 

Producción:

Como podemos ver en la imagen de salida de arriba, hay 66+24= 90 predicciones correctas y 8+2= 10 predicciones correctas. Por lo tanto, podemos decir que nuestro modelo SVM mejoró en comparación con el modelo de regresión logística.

Visualizando el resultado del conjunto de entrenamiento:
Ahora visualizaremos el resultado del conjunto de entrenamiento, a continuación se muestra el código correspondiente:

 from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red', 'green'))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Producción:

Al ejecutar el código anterior, obtendremos el resultado como:

algoritmo para bfs

Como podemos ver, el resultado anterior parece similar al resultado de la regresión logística. En el resultado, obtuvimos la línea recta como hiperplano porque tenemos usó un núcleo lineal en el clasificador . Y también hemos comentado anteriormente que para el espacio 2d, el hiperplano en SVM es una línea recta.

Visualizando el resultado del conjunto de pruebas:

 #Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Producción:

Al ejecutar el código anterior, obtendremos el resultado como:

Como podemos ver en la imagen de salida de arriba, el clasificador SVM ha dividido a los usuarios en dos regiones (Comprados o No comprados). Los usuarios que compraron el SUV se encuentran en la región roja con los puntos de dispersión rojos. Y los usuarios que no compraron el SUV se encuentran en la región verde con puntos de dispersión verdes. El hiperplano ha dividido las dos clases en variables compradas y no compradas.