[Machine Learning][Python][Clasificación] Understanding Support Vector Machines with Python

Support Vector Machines con Python

Support Vector Machines (SVM) son algoritmos de aprendizaje supervisado muy potentes, a menudo utilizados para problemas de clasificación. Este artículo demuestra cómo utilizar SVM en Python con la biblioteca scikit-learn y proporciona una explicación de la teoría subyacente.

1. Implementación en Python

Código en Python:

import numpy as np  # Biblioteca para trabajar con arreglos y operaciones matemáticas
import matplotlib.pyplot as plt  # Biblioteca para crear gráficos y visualizaciones
from sklearn import datasets  # Módulo para cargar y manejar conjuntos de datos estándar
from sklearn.model_selection import train_test_split  # Función para dividir los datos en entrenamiento y prueba
from sklearn.svm import SVC  # Clase para implementar Support Vector Machines

# 1. Cargar datos
# Usaremos el dataset de iris, seleccionando solo dos clases para simplificar el problema
# datasets.load_iris(): Carga el conjunto de datos Iris incluido en scikit-learn
# Este dataset tiene 3 clases (setosa, versicolor, virginica) y 4 características.
iris = datasets.load_iris()
# Seleccionamos las dos primeras características (columnas) y excluimos la clase 2 para crear un problema binario
X = iris.data[iris.target != 2, :2]
y = iris.target[iris.target != 2]

# 2. Dividir los datos en entrenamiento y prueba
# train_test_split: Divide los datos en conjuntos de entrenamiento y prueba
# test_size=0.3: El 30% de los datos se usará para prueba
# random_state=42: Asegura que los resultados sean reproducibles
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 3. Crear y entrenar el modelo SVM
# SVC: Support Vector Classifier, implementa el modelo SVM
# kernel='linear': Utiliza un kernel lineal para la separación
# El kernel lineal busca una línea recta (o un hiperplano en dimensiones mayores) que separe las clases.
# C=1.0: Parámetro de regularización que controla el equilibrio entre margen amplio y errores de clasificación.
# Un valor de C más bajo permite más errores para maximizar el margen, mientras que un valor alto reduce errores a costa de márgenes más estrechos.
model = SVC(kernel='linear', C=1.0)
# fit(): Ajusta el modelo a los datos de entrenamiento
model.fit(X_train, y_train)

# 4. Visualizar el resultado
# Definir límites para el gráfico
# min() y max(): Obtienen el valor mínimo y máximo en las características para definir el rango de la gráfica
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
# np.meshgrid: Crea una cuadrícula de valores para evaluar el modelo en cada punto del espacio bidimensional
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),
                     np.arange(y_min, y_max, 0.01))

# Predicciones en la malla de puntos
# np.c_: Combina las coordenadas x e y en pares para realizar predicciones
# predict(): Realiza predicciones con el modelo entrenado
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
# reshape(): Reorganiza los datos en la forma de la cuadrícula para graficar
Z = Z.reshape(xx.shape)

# Dibujar la malla de decisión
# plt.contourf(): Dibuja las áreas de clasificación con colores
plt.contourf(xx, yy, Z, alpha=0.8, cmap=plt.cm.coolwarm)

# Dibujar los datos de entrenamiento
# plt.scatter(): Representa puntos en un gráfico de dispersión
# c=y: Usa los valores de las clases para colorear los puntos
# edgecolors='k': Define el color del borde de los puntos
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', cmap=plt.cm.coolwarm)
plt.xlabel('Característica 1')  # Etiqueta para el eje x
plt.ylabel('Característica 2')  # Etiqueta para el eje y
plt.title('Clasificación SVM con kernel lineal')  # Título del gráfico
plt.show()

# 5. Evaluar el modelo
# score(): Calcula la precisión del modelo en los datos de prueba
# Precisión: Proporción de predicciones correctas entre las totales
accuracy = model.score(X_test, y_test)
print(f'Precisión del modelo en los datos de prueba: {accuracy:.2f}')

2. Teoría Detrás de las SVM

• Las Support Vector Machines funcionan encontrando el hiperplano óptimo que separa las clases en el conjunto de datos mientras maximiza el margen entre ellas. El hiperplano se puede expresar como:

  w * x - b = 0

• Aquí, w es el vector de pesos, x es el vector de características, y b es el sesgo. El algoritmo optimiza el margen resolviendo:

  
  Minimize ||w||^2 / 2
  Subject to: y_i (w * x_i - b) >= 1
              

• Aquí, y_i es la etiqueta de clase (+1 o -1) para cada punto de datos x_i. La optimización garantiza que los puntos de datos estén en el lado correcto del hiperplano.

3. Conclusión

Las SVM son efectivas para problemas de clasificación binaria, especialmente cuando las clases son linealmente separables. Al usar kernels, las SVM también pueden manejar fronteras de decisión no lineales. La biblioteca scikit-learn facilita la implementación y experimentación con SVM en Python.