SVM: una herramienta poderosa para la clasificación

En el mundo de la inteligencia artificial y el aprendizaje automático, SVM es una de las herramientas más poderosas para la clasificación de datos. SVM significa Support Vector Machine o Máquina de Vectores de Soporte, en español. Es un algoritmo de aprendizaje supervisado que se utiliza para clasificar datos en dos o más categorías.

¿Cómo funciona SVM?

El objetivo de SVM es encontrar la mejor separación posible entre los datos de diferentes categorías. En otras palabras, SVM busca una línea o un hiperplano que pueda separar los datos en diferentes categorías. Esta línea o hiperplano se llama el límite de decisión.

En SVM, se utilizan vectores de soporte para encontrar el límite de decisión. Un vector de soporte es un punto de datos que está más cerca del límite de decisión y es el que tiene mayor influencia en la posición del límite de decisión. SVM busca el límite de decisión que maximiza la distancia entre los vectores de soporte de las diferentes categorías. Esta distancia se llama margen.

En resumen, SVM utiliza los vectores de soporte para encontrar el límite de decisión que maximiza el margen entre las diferentes categorías.

¿Cuáles son las ventajas de SVM?

SVM tiene varias ventajas sobre otros algoritmos de clasificación:

Es efectivo en espacios de alta dimensionalidad.
Es efectivo en casos en los que el número de dimensiones es mayor que el número de muestras.
Es resistente a la presencia de valores atípicos en los datos.
Es muy versátil, ya que se pueden utilizar diferentes funciones kernel para adaptarse a diferentes tipos de datos.

¿Qué son las funciones kernel?

Las funciones kernel son una parte importante de SVM. Son funciones que se utilizan para transformar los datos de entrada en un espacio de mayor dimensión. La idea detrás de las funciones kernel es que, si los datos no son separables en su espacio original, es posible que sean separables en un espacio de mayor dimensión.

Hay varios tipos de funciones kernel que se pueden utilizar en SVM. Algunos ejemplos son:

Función lineal
Función polinómica
Función radial
Función sigmoide

Función lineal

La función lineal es la función kernel más simple y se utiliza cuando los datos son linealmente separables en su espacio original. La función lineal simplemente calcula el producto punto entre los vectores de entrada:


k(x, y) = x * y

Función polinómica

La función polinómica se utiliza cuando los datos son separables por una curva polinómica. La función polinómica utiliza un parámetro d para controlar el grado del polinomio:


k(x, y) = (x * y + c)^d

Función radial

La función radial se utiliza cuando los datos no son separables linealmente. La función radial utiliza un parámetro gamma para controlar la flexibilidad del límite de decisión:


k(x, y) = exp(-gamma * ||x - y||^2)

Función sigmoide

La función sigmoide se utiliza cuando los datos no son linealmente separables y se asemejan a una función sigmoide. La función sigmoide utiliza dos parámetros, alpha y beta:


k(x, y) = tanh(alpha * x * y + beta)

¿Cómo se entrena un modelo SVM?

Para entrenar un modelo SVM, se necesita un conjunto de datos de entrenamiento que contenga ejemplos de cada categoría. El modelo SVM utiliza estos datos de entrenamiento para encontrar el límite de decisión que separa las diferentes categorías.

En SVM, se utiliza una técnica llamada optimización convexa para encontrar el límite de decisión óptimo. La optimización convexa es un método matemático para encontrar el mínimo o máximo de una función en un espacio convexo.

A continuación, se muestra un ejemplo de cómo entrenar un modelo SVM en Python utilizando la biblioteca Scikit-learn:


from sklearn import svm
from sklearn.datasets import make_blobs

# Generar datos sintéticos
X, y = make_blobs(n_samples=100, centers=2, random_state=0)

# Crear modelo SVM
clf = svm.SVC(kernel='linear', C=1)
clf.fit(X, y)

# Predecir nuevas muestras
clf.predict([[0, 0], [2, 2]])

# Salida esperada: array([0, 1])

¿Cómo se evalúa un modelo SVM?

Para evaluar un modelo SVM, se utiliza un conjunto de datos de prueba que no se utilizó en el entrenamiento del modelo. El modelo SVM clasifica estos datos de prueba en diferentes categorías y se compara con las etiquetas de categoría reales. Se utilizan diferentes métricas de evaluación, como la precisión, el recall y la puntuación F1, para evaluar la calidad del modelo SVM.

A continuación, se muestra un ejemplo de cómo evaluar un modelo SVM en Python utilizando la biblioteca Scikit-learn:


from sklearn import svm
from sklearn.datasets import make_blobs
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Generar datos sintéticos
X, y = make_blobs(n_samples=100, centers=2, random_state=0)

# Dividir datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Crear modelo SVM y entrenar con datos de entrenamiento
clf = svm.SVC(kernel='linear', C=1)
clf.fit(X_train, y_train)

# Predecir etiquetas de prueba y evaluar precisión
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

# Imprimir precisión
print("Precisión:", accuracy)

Visualización del límite de decisión en SVM

Una forma útil de visualizar el límite de decisión en SVM es mediante el uso de gráficos. A continuación se muestra un ejemplo de cómo visualizar el límite de decisión en SVM utilizando Python y la biblioteca Matplotlib:


import matplotlib.pyplot as plt
import numpy as np
from sklearn import svm

# Generar datos sintéticos
X, y = make_blobs(n_samples=100, centers=2, random_state=0)

# Crear modelo SVM
clf = svm.SVC(kernel='linear', C=1)
clf.fit(X, y)

# Crear gráfico de dispersión de datos
plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=plt.cm.Paired)

# Crear línea de límite de decisión
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()

# Crear malla para evaluar modelo
xx = np.linspace(xlim[0], xlim[1], 30)
yy = np.linspace(ylim[0], ylim[1], 30)
YY, XX = np.meshgrid(yy, xx)
xy = np.vstack([XX.ravel(), YY.ravel()]).T
Z = clf.decision_function(xy).reshape(XX.shape)

# Visualizar límite de decisión y márgenes
ax.contour(XX, YY, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,
           linestyles=['--', '-', '--'])
ax.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], s=100,
           linewidth=1, facecolors='none', edgecolors='k')

plt.show()