Fundamentos Conceptuales

Las Máquinas de Vectores de Soporte (SVM) son algoritmos de aprendizaje supervisado que idantifican hiperplanos óptimos para clasificación o regresión:

• Clasificación: Maximizar el margen entre categorías
• Regresión: Minimizar puntos fuera de la banda ε

   Hiperplano: w·x + b = 0
      ▲             ▲
      |             |
+1    |  Vectores   |    -1
      |    soporte  |
      |     ✦ ✦     |
      |   ✦     ✦   |
      |✦         ✦  |
      └─────────────┘
         Margen máximo

Fundamentos Matemáticos

Caso linealmente separable:

\min_{w,b} \frac{1}{2}||w||^2 \quad \text{s.a} \quad y_i(w·x_i + b) \geq 1

• w: Vector normal (orientación del hiperplano)
• b: Término de sesgo (posición del hiperplano)

Transformación no lineal:

K(x_i, x_j) = \phi(x_i)·\phi(x_j)

Implementación Básica en Python

import numpy as np

class ClasificadorSVM:
    def __init__(self, reg=1.0, tasa_aprendizaje=0.01, iteraciones=1000):
        self.reg = reg
        self.eta = tasa_aprendizaje
        self.iteraciones = iteraciones
        
    def entrenar(self, X, etiquetas):
        n_muestras, n_caracteristicas = X.shape
        self.w = np.zeros(n_caracteristicas)
        self.b = 0
        y_ = np.where(etiquetas <= 0, -1, 1)
        
        for _ in range(self.iteraciones):
            for i, muestra in enumerate(X):
                condicion = y_[i] * (np.dot(muestra, self.w) - self.b) >= 1
                if condicion:
                    self.w -= self.eta * (2 * self.reg * self.w)
                else:
                    self.w -= self.eta * (2 * self.reg * self.w - muestra * y_[i])
                    self.b -= self.eta * y_[i]
    
    def predecir(self, X):
        return np.sign(np.dot(X, self.w) - self.b)

Aplicación con Scikit-Learn

from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.preprocessing import StandardScaler

X, y = make_classification(n_muestras=1000, caracteristicas=20)
escalador = StandardScaler()
X_escalado = escalador.fit_transform(X)

modelo_svm = SVC(
    C=1.0,
    nucleo='rbf',
    gamma='escala',
    probabilidad=True
)

modelo_svm.ajustar(X_escalado, y)
vectores_soporte = modelo_svm.vectores_soporte_

Seelección de Funciones Kernel

Optimización de Parámetros

from sklearn.model_selection import GridSearchCV

parametros = {'C': [0.1, 1, 10], 'gamma': [0.1, 1, 10], 'nucleo': ['rbf','lineal']}
busqueda = GridSearchCV(SVC(), parametros, cv=5)
busqueda.ajustar(X_entrenamiento, y_entrenamiento)

Implementación para Regresión

from sklearn.svm import SVR

modelo_regresion = SVR(
    nucleo='rbf',
    C=1.0,
    epsilon=0.2
)
modelo_regresion.ajustar(X_entrenamiento, y_entrenamiento)

Visualización de Vectores Soporte

import matplotlib.pyplot as plt

plt.scatter(X_pca[:,0], X_pca[:,1], c=y_entrenamiento)
plt.scatter(vectores_soporte[:,0], vectores_soporte[:,1], 
            s=100, facecolors='none', edgecolors='k')
plt.contour(XX, YY, Z, colors='k', levels=[-1,0,1], linestyles=['--','-','--'])

Ventajas y Limitaciones

Fortalezas:

• Efectivo en espacios dimensionales altos
• Resistente a sobreajuste mediante regularización
• Eficiente en memoria

Desafíos:

• Escalabilidad limitada en grandes conjuntos
• Sensibilidad a parámetros
• Interpretabilidad reducida

Técnicas de Optimización

• Normalización de características
• Uso de LinearSVC para núcleos lineales
• Aproximación de kernels con Nystroem

from sklearn.kernel_approximation import Nystroem
transformador = Nystroem(n_components=300)
X_transformado = transformador.ajustar_transformar(X)

Clasificación Multiclase

• Uno-vs-Uno: Construye clasificadores binarios por pares
• Uno-vs-Resto: Un clasificador por clase contra las demás

Casos de Uso

• Reconocimiento de imágenes
• Clasificación de texto
• Diagnóstico médico
• Detección de fraudes