Tutorial ScikitLearn: Regresión SVM con SVR

Introducción teórica a SVM para regresión

Las Máquinas de Soporte Vectorial para regresión (SVR, por sus siglas en inglés) son una extensión de las SVM utilizadas en clasificación, adaptadas para resolver problemas de regresión. Mientras que en clasificación se busca encontrar un hiperplano que separa las clases de la mejor manera, en regresión el objetivo es encontrar una función que aproxime los datos con una tolerancia específica.

El concepto clave en SVR es la idea de margen. En lugar de buscar minimizar el error de predicción para cada punto, SVR intenta encontrar una función que tenga una desviación máxima $(\epsilon)$ de los valores reales para todos los datos de entrenamiento, y al mismo tiempo sea lo más plana posible.

Matemáticamente, el problema se formula como la minimización de una función de coste que equilibra la complejidad del modelo y el grado en que los residuos superan la tolerancia $(\epsilon)$. Esto se expresa como:

$$
\min_{w,b,\xi, \xi^*} \frac{1}{2} |w|^2 + C \sum_{i=1}^{n} (\xi_i + \xi_i^*)
$$

Sujeto a:

$$
y_i - (w^T x_i + b) \leq \epsilon + \xi_i \
(w^T x_i + b) - y_i \leq \epsilon + \xi_i^* \
\xi_i, \xi_i^* \geq 0
$$

Donde:

• $(w)$ es el vector de coeficientes.
• $(b)$ es el término independiente.
• $(\xi_i, \xi_i^*)$ son variables de holgura que permiten penalizar las desviaciones superiores a $(\epsilon)$.
• $(C)$ es un parámetro de regularización que controla el equilibrio entre el ajuste al conjunto de entrenamiento y la complejidad del modelo.

La función de pérdida utilizada es conocida como pérdida $(\epsilon)$-insensible, donde los errores dentro de la banda de tolerancia $(\epsilon)$ no se consideran penalizaciones en el modelo. De este modo, SVR busca una solución lo más simple posible que generalice bien a datos no vistos.

Una característica importante de SVR es el uso de kernels o funciones núcleo. Los kernels permiten transformar los datos originales a un espacio de mayor dimensionalidad donde es más fácil ajustar una función lineal a datos que originalmente no lo son. Los kernels más comunes utilizados en SVR son:

• Kernel lineal: adecuado para datos linealmente separables.
• Kernel polinomial: permite modelar relaciones polinomiales de grado (d).
• Kernel RBF (Función Base Radial): es el más utilizado y puede modelar relaciones no lineales complejas.
• Kernel sigmoide: similar a las funciones de activación en redes neuronales.

El uso de kernels en SVR permite manejar problemas de regresión tanto lineales como no lineales de manera eficiente, sin incrementar el coste computacional asociado al cálculo en espacios de alta dimensionalidad.

En SVR, solo un subconjunto de los datos de entrenamiento contribuye a la definición de la función de regresión final. Estos datos se denominan vectores de soporte y son aquellos cuyos errores están exactamente en el límite de la tolerancia $(\epsilon)$ o lo superan. Los vectores de soporte son cruciales porque contienen la información necesaria para describir el modelo, lo que hace que SVR sea una técnica eficiente en términos de recursos computacionales.

La capacidad de SVR para controlar la complejidad del modelo a través del parámetro $(C)$ y para manejar desviaciones dentro de una tolerancia $(\epsilon)$ la hace especialmente útil en conjuntos de datos con ruido. Al ignorar errores menores que $(\epsilon)$, el modelo es más robusto frente a valores atípicos y puede generalizar mejor.

Preprocesados específicos para SVR

Para obtener resultados óptimos al utilizar Máquinas de Vectores de Soporte para regresión (SVR), es fundamental aplicar ciertos preprocesados específicos que preparen adecuadamente los datos. La escala de las variables juega un papel crucial en el rendimiento del modelo SVR, especialmente cuando se utilizan kernels que se basan en distancias.

Uno de los pasos esenciales es la normalización o escalado de las características. Debido a que los algoritmos de SVR calculan distancias entre puntos, las características con escalas mayores pueden dominar el cálculo y afectar negativamente al modelo. Por ello, es recomendable utilizar transformaciones como StandardScaler, que ajusta las características para que tengan media cero y desviación estándar uno, o MinMaxScaler, que reescala las características al rango [0, 1].

Además, es importante prestar atención a la presencia de valores atípicos en los datos. Los outliers pueden influir de manera significativa en el modelo SVR, deteriorando su capacidad de generalización. En estos casos, el uso de RobustScaler puede ser más apropiado, ya que es menos sensible a valores extremos y utiliza estadísticas como la mediana y el rango intercuartílico para el escalado.

Cuando se trabaja con SVR y se utiliza el kernel RBF (Radial Basis Function), es recomendable considerar la normalización de las características. El kernel RBF es sensible a la distancia entre los puntos, por lo que escalar las características asegura que todas contribuyan de manera equitativa al cálculo de las similitudes. Por otro lado, si el modelo utiliza un kernel lineal, el escalado sigue siendo importante, pero el impacto puede ser menor en comparación con kernels basados en distancias.

En términos de preprocesamiento de las variables categóricas, aunque SVR es un modelo que trabaja con variables numéricas, es posible incluir variables categóricas mediante técnicas de codificación. La codificación one-hot es una opción común, pero debe manejarse con cuidado para evitar la maldición de la dimensionalidad si hay muchas categorías únicas. En estos casos, puede ser útil aplicar técnicas de reducción de dimensionalidad después de la codificación.

A continuación, se presenta un ejemplo de cómo aplicar el escalado a los datos antes de entrenar un modelo SVR en Scikit Learn:

from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# Creación del pipeline con escalado y modelo SVR
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('svr', SVR(kernel='rbf'))
], memory = None)

# Entrenamiento del modelo
pipeline.fit(X_train, y_train)

# Realización de predicciones
y_pred = pipeline.predict(X_test)

En este ejemplo, se utiliza un Pipeline para encadenar el escalado de las características con StandardScaler y el modelo SVR con kernel RBF. Esto garantiza que el escalado se aplique correctamente durante el entrenamiento y al realizar predicciones sobre nuevos datos.

Es también recomendable ajustar los parámetros del modelo SVR mediante técnicas de validación cruzada y búsqueda de hiperparámetros. El escalado previo de los datos asegura que la búsqueda sea más efectiva, ya que los parámetros como C, epsilon y gamma en el kernel RBF son sensibles a la escala de las características.

Si se trabaja con datos altamente dimensionales, es posible que el rendimiento computacional del SVR se vea afectado. En estos casos, es beneficioso aplicar técnicas de selección o extracción de características para reducir la dimensionalidad antes de entrenar el modelo. Métodos como PCA (Análisis de Componentes Principales) pueden ayudar a mantener la información más relevante y facilitar el aprendizaje del SVR.

Modelado con SVR en Scikit Learn

Para implementar un modelo de Máquina de Vectores de Soporte para regresión (SVR) en Scikit Learn, se utiliza la clase sklearn.svm.SVR. Este estimador permite ajustar modelos de regresión basados en el algoritmo SVR, aprovechando la flexibilidad de los kernels para capturar relaciones lineales y no lineales en los datos.

Para comenzar, es habitual importar la clase SVR y otras herramientas necesarias:

from sklearn.svm import SVR
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

A continuación, se carga el conjunto de datos y se divide en conjunto de entrenamiento y conjunto de prueba:

X = datos.drop('objetivo', axis=1)
y = datos['objetivo']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Es importante mencionar que, en muchos casos, se debe realizar un escalado de las características antes de entrenar el modelo SVR, ya que este algoritmo es sensible a la escala de los datos.

Una vez preparados los datos, se instancia el modelo SVR. Por defecto, el kernel RBF es el más utilizado:

modelo_svr = SVR(kernel='rbf')

El siguiente paso es ajustar el modelo a los datos de entrenamiento:

modelo_svr.fit(X_train, y_train)

Tras el entrenamiento, se pueden realizar predicciones sobre el conjunto de prueba:

y_pred = modelo_svr.predict(X_test)

Para evaluar el rendimiento del modelo, se utiliza una métrica adecuada, como el error cuadrático medio:

error = mean_squared_error(y_test, y_pred)
print(f'Error cuadrático medio: {error}')

Es posible que se desee optimizar el modelo ajustando los hiperparámetros. Para ello, se puede utilizar una búsqueda con GridSearchCV:

from sklearn.model_selection import GridSearchCV

parametros = {
    'kernel': ['rbf', 'linear', 'poly'],
    'C': [0.1, 1, 10],
    'epsilon': [0.01, 0.1, 1]
}

grid_search = GridSearchCV(SVR(), parametros, cv=5, scoring='neg_mean_squared_error')
grid_search.fit(X_train, y_train)

Tras la búsqueda, se pueden obtener los mejores parámetros:

mejores_parametros = grid_search.best_params_
print('Mejores parámetros:', mejores_parametros)

Con los hiperparámetros óptimos, se vuelve a entrenar el modelo:

modelo_optimo = SVR(**mejores_parametros)
modelo_optimo.fit(X_train, y_train)

Y se evalúa su rendimiento:

y_pred_optimo = modelo_optimo.predict(X_test)
error_optimo = mean_squared_error(y_test, y_pred_optimo)
print(f'Error cuadrático medio con modelo óptimo: {error_optimo}')

Es fundamental considerar que el tiempo de entrenamiento de un SVR puede incrementarse significativamente con el tamaño del conjunto de datos, ya que la complejidad computacional del algoritmo es mayor en comparación con otros modelos de regresión. Por ello, es recomendable utilizar técnicas de muestreo o considerar algoritmos alternativos para conjuntos de datos muy grandes.

Además, para conjuntos de datos con un gran número de muestras, se puede optar por utilizar el estimador LinearSVR, que implementa una versión más eficiente para el caso lineal:

from sklearn.svm import LinearSVR

modelo_lineal_svr = LinearSVR()
modelo_lineal_svr.fit(X_train, y_train)

En cuanto a la interpretación de los resultados, aunque los modelos SVR no son intrínsecamente interpretables, se pueden analizar los coeficientes en el caso de utilizar un kernel lineal:

coeficientes = modelo_lineal_svr.coef_
print('Coeficientes del modelo:', coeficientes)

Al implementar SVR en Scikit Learn, es posible integrarlo en un pipeline para automatizar el flujo de trabajo y garantizar que los preprocesamientos se aplican de forma consistente:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

pipeline = Pipeline([
    ('escalado', StandardScaler()),
    ('svr', SVR(kernel='rbf'))
], memory = None)

pipeline.fit(X_train, y_train)

El uso de un pipeline también facilita la validación cruzada y la búsqueda de hiperparámetros en conjunto con los pasos de preprocesamiento.

Es relevante mencionar que el ajuste de los parámetros del modelo, como C, epsilon y gamma, es crucial para obtener un buen rendimiento. Estos parámetros controlan la regularización, la tolerancia al error y la forma del kernel, respectivamente.

Para problemas que requieren mayor flexibilidad en el kernel, se puede definir un kernel personalizado:

def kernel_personalizado(X, Y):
    return np.dot(X, Y.T) ** 2

modelo_personalizado = SVR(kernel=kernel_personalizado)
modelo_personalizado.fit(X_train, y_train)

Finalmente, al trabajar con SVR, es esencial evaluar el modelo no solo con métricas de error, sino también analizando las gráficas de predicción frente a los valores reales, para detectar patrones no capturados o posibles sobreajustes.

Parámetros de SVR

Al utilizar la clase SVR de Scikit Learn, es fundamental comprender los parámetros que permiten personalizar el comportamiento del modelo de Máquinas de Vectores de Soporte para regresión. Estos parámetros influyen en la capacidad del modelo para ajustarse a los datos y generalizar a nuevos casos. A continuación, se detallan los principales parámetros y cómo afectan al rendimiento del modelo.

C: Parámetro de regularización

El parámetro C controla el equilibrio entre el error en los datos de entrenamiento y la regularización del modelo. Un valor alto de C busca minimizar los errores de entrenamiento, permitiendo menos margen para los errores, lo que puede conducir a un modelo sobreajustado. Por el contrario, un valor bajo de C aumenta la regularización, permitiendo un margen más amplio y tolerando más errores en el entrenamiento, lo que puede mejorar la generalización.

# Ejemplo de uso del parámetro C
from sklearn.svm import SVR

svr_model = SVR(C=10.0)

epsilon: Margen de tolerancia

El parámetro epsilon define el ancho de la banda epsilon-insensible alrededor de la función de regresión en la que no se penalizan los errores. Ajustar epsilon permite controlar la sensibilidad del modelo a los errores; valores más altos de epsilon resultan en un modelo más suavizado, mientras que valores más bajos ajustan el modelo más estrechamente a los datos.

# Configuración del valor de epsilon
svr_model = SVR(epsilon=0.2)

kernel: Tipo de núcleo

El parámetro kernel especifica la función de kernel que transforma los datos a un espacio de mayor dimensionalidad. Los kernels más comunes son:

• 'linear': Utiliza un kernel lineal. Adecuado para relaciones lineales entre las características y la variable objetivo.
• 'poly': Kernel polinómico. Permite modelar relaciones no lineales de grado degree.
• 'rbf': Función base radial (RBF). Es el kernel por defecto y modela relaciones no lineales complejas.
• 'sigmoid': Kernel sigmoideo. Similar a las funciones de activación en redes neuronales.

# Utilización de un kernel polinómico
svr_model = SVR(kernel='poly', degree=3)

degree: Grado del polinomio

Este parámetro es relevante cuando se utiliza kernel='poly'. El parámetro degree indica el grado del polinomio utilizado en el kernel polinómico. Un grado más alto permite capturar relaciones más complejas, pero puede aumentar el riesgo de sobreajuste.

# Kernel polinómico de grado 5
svr_model = SVR(kernel='poly', degree=5)

gamma: Coeficiente del kernel

El parámetro gamma afecta a los kernels 'rbf', 'poly' y 'sigmoid', y determina la influencia de un solo ejemplo de entrenamiento. Un valor alto de gamma hace que la influencia alcance solo a los puntos cercanos, creando modelos más complejos. Un valor bajo extiende la influencia a puntos más lejanos, resultando en modelos más suavizados.

# Ajuste del parámetro gamma
svr_model = SVR(kernel='rbf', gamma='scale')  # 'scale' es la configuración por defecto

Por defecto, gamma puede ser 'scale' o 'auto':

• 'scale': Valor predeterminado desde Scikit Learn 0.22. Calcula gamma = 1 / (n_features * X.var()).
• 'auto': Establece gamma = 1 / n_features.

coef0: Término independiente en kernels polinómicos y sigmoideos

El parámetro coef0 es relevante para los kernels 'poly' y ‘sigmoid’. Controla el término independiente en el kernel, lo que puede influir en la forma de la función de decisión. Ajustar coef0 es importante cuando se trabaja con datos donde la relación entre las características y la variable objetivo no está centrada en el origen.

# Definición de coef0 en un kernel sigmoideo
svr_model = SVR(kernel='sigmoid', coef0=0.1)

shrinking: Heurística de reducción

El parámetro booleano shrinking determina si se utiliza la heurística de reducción. Cuando shrinking=True, el algoritmo ignora los vectores de soporte que no aportan significativamente al modelo durante el proceso de optimización, lo que puede mejorar la eficiencia computacional.

# Desactivación de la heurística de reducción
svr_model = SVR(shrinking=False)

tol: Tolerancia para el criterio de parada

El parámetro tol establece la tolerancia para el criterio de parada del algoritmo de optimización. Es el mínimo cambio requerido en el error para continuar iterando. Valores más pequeños pueden aumentar la precisión del modelo pero también el tiempo de cómputo.

# Ajuste de la tolerancia
svr_model = SVR(tol=1e-4)

cache_size: Tamaño de la memoria caché

Este parámetro especifica el tamaño de la memoria caché (en MB) para almacenar el kernel durante el entrenamiento. Un tamaño mayor de cache_size puede acelerar el entrenamiento a costa de consumir más memoria RAM.

# Aumento del tamaño de la caché
svr_model = SVR(cache_size=200)

max_iter: Número máximo de iteraciones

El parámetro max_iter define el número máximo de iteraciones para el algoritmo de optimización. Un valor de -1 indica que no hay límite en el número de iteraciones. Establecer un límite puede ser útil para controlar el tiempo de entrenamiento en conjuntos de datos grandes.

# Limitación del número de iteraciones
svr_model = SVR(max_iter=1000)

verbose: Salida detallada del proceso

El parámetro verbose permite activar la salida de mensajes durante el proceso de ajuste del modelo. Esto puede ser útil para depurar y entender el comportamiento del algoritmo, especialmente en situaciones donde el tiempo de entrenamiento es prolongado.

# Activación de la salida detallada
svr_model = SVR(verbose=True)

Configuración de parámetros en conjunto

Es habitual ajustar varios parámetros simultáneamente para optimizar el rendimiento del modelo. La combinación adecuada depende de las características específicas del conjunto de datos y del problema a resolver. Utilizar técnicas como la búsqueda en cuadrícula (GridSearchCV) o la búsqueda aleatoria (RandomizedSearchCV) facilita la selección de los hiperparámetros óptimos.

from sklearn.model_selection import GridSearchCV

parametros = {
    'C': [0.1, 1, 10],
    'epsilon': [0.01, 0.1, 1],
    'kernel': ['rbf', 'poly'],
    'gamma': ['scale', 'auto'],
    'degree': [2, 3, 4]
}

svr = SVR()
grid_search = GridSearchCV(svr, parametros, cv=5, scoring='neg_mean_squared_error')
grid_search.fit(X_train, y_train)

print("Mejores parámetros:", grid_search.best_params_)

Importancia de la normalización de las características

Muchos de los parámetros, especialmente C y gamma, son sensibles a la escala de las características. Por ello, es esencial escalar o normalizar los datos antes de entrenar el modelo SVR. Utilizar transformaciones como StandardScaler o MinMaxScaler garantiza que el modelo interprete correctamente los parámetros establecidos.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('svr', SVR(C=1.0, epsilon=0.1, kernel='rbf'))
], memory = None)

pipeline.fit(X_train, y_train)

Consideraciones finales sobre los parámetros

La elección adecuada de los parámetros de SVR es crucial para obtener un modelo que equilibre bien el sesgo y la varianza. Comprender el impacto de cada parámetro permite ajustar el modelo de manera más informada, mejorando su capacidad predictiva y su rendimiento en conjuntos de datos no vistos.

Interpretabilidad de SVR en Scikit Learn

La interpretabilidad de los modelos es un aspecto fundamental en el aprendizaje automático, ya que permite comprender cómo un modelo produce sus predicciones. Sin embargo, en el caso de las Máquinas de Soporte Vectorial para regresión (SVR), la interpretabilidad puede ser un desafío, especialmente cuando se utilizan kernels no lineales como el RBF.

Las SVR son consideradas modelos de caja negra debido a que no proporcionan una relación explícita y directa entre las características de entrada y la variable objetivo. A pesar de esta limitación, existen métodos en Scikit Learn que permiten extraer información relevante para entender mejor el comportamiento del modelo y su proceso de decisión.

Una forma de aproximarse a la interpretabilidad es analizando los vectores de soporte, que son los puntos de datos que definen la hipersuperficie de regresión. En Scikit Learn, se puede acceder a estos vectores a través de los atributos support_, support_vectors_ y dual_coef_ del modelo SVR entrenado.

# Acceso a los vectores de soporte
vectores_soporte = modelo_svr.support_vectors_
coeficientes_duales = modelo_svr.dual_coef_
indices_soporte = modelo_svr.support_

# Mostrar información sobre los vectores de soporte
print(f'Número de vectores de soporte: {len(vectores_soporte)}')
print(f'Índices de los vectores de soporte: {indices_soporte}')

En este ejemplo, support_vectors_ contiene las coordenadas de los vectores de soporte en el espacio de características, mientras que dual_coef_ almacena los coeficientes duales que ponderan la influencia de cada vector de soporte en la predicción. Analizar estos vectores proporciona insights sobre qué muestras son más relevantes para el modelo y cómo contribuyen a las predicciones.

Cuando se utiliza un kernel lineal, la interpretabilidad mejora significativamente. Es posible acceder a los coeficientes del modelo, similares a los de una regresión lineal tradicional, mediante el atributo coef_.

# Modelo SVR con kernel lineal
from sklearn.svm import SVR

modelo_lineal_svr = SVR(kernel='linear')
modelo_lineal_svr.fit(X_train, y_train)

# Obtención de los coeficientes del modelo
coeficientes = modelo_lineal_svr.coef_
intercepto = modelo_lineal_svr.intercept_

print(f'Coeficientes del modelo: {coeficientes}')
print(f'Intercepto del modelo: {intercepto}')

Los coeficientes indican la importancia de cada característica en la predicción del modelo. Un coeficiente positivo significa que, al aumentar el valor de esa característica, la predicción tiende a aumentar, mientras que un coeficiente negativo indica lo contrario. El intercepto representa el valor predicho cuando todas las características son cero.

Para modelos SVR con kernels no lineales, como el kernel RBF, los coeficientes directos no están disponibles, lo que dificulta la interpretación tradicional. En estos casos, se pueden emplear técnicas como las gráficas de dependencia parcial (Partial Dependence Plots) para visualizar la relación entre las características y la variable objetivo.

from sklearn.inspection import PartialDependenceDisplay

# Gráfico de dependencia parcial para una característica específica
PartialDependenceDisplay.from_estimator(modelo_svr, X_train, features=[0])
plt.show()

Los gráficos de dependencia parcial muestran cómo cambia la predicción promedio del modelo al variar una característica, manteniendo las demás constantes. Esto ayuda a entender el efecto individual de una característica en la predicción.

Otra herramienta útil es la importancia de las características basada en permutaciones. Esta técnica evalúa el impacto de cada característica en el rendimiento del modelo al permutar sus valores y medir el aumento en el error.

from sklearn.inspection import permutation_importance

# Cálculo de la importancia de las características
importancias = permutation_importance(modelo_svr, X_test, y_test, n_repeats=10, random_state=42)

# Visualización de las importancias
import pandas as pd

resultados = pd.DataFrame({'Características': X.columns, 'Importancia Media': importancias.importances_mean})
resultados = resultados.sort_values(by='Importancia Media', ascending=False)

print(resultados)

La importancia por permutación ofrece una medida de cuán dependiente es el modelo de cada característica. Características con una mayor disminución en el rendimiento al permutarlas son consideradas más importantes.

Para una interpretación más profunda, se pueden utilizar técnicas avanzadas como SHAP (SHapley Additive exPlanations), que proporcionan valores que explican la contribución de cada característica a una predicción específica.

import shap

# Creación del explainer de SHAP
explainer = shap.KernelExplainer(modelo_svr.predict, X_train)

# Cálculo de los valores SHAP para un subconjunto de datos
shap_values = explainer.shap_values(X_test.iloc[:50])

# Visualización del resumen de los valores SHAP
shap.summary_plot(shap_values, X_test.iloc[:50])

El uso de valores SHAP permite desglosar individualmente las predicciones del modelo, mostrando cómo cada característica influye en el resultado. Esto es especialmente útil para modelos complejos donde la interpretación directa no es posible.

Es importante señalar que la interpretabilidad en modelos SVR con kernels no lineales es limitada y puede requerir un esfuerzo computacional significativo. Además, la correlación entre características puede afectar la interpretación, por lo que es recomendable analizar la multicolinealidad y, si es necesario, aplicar métodos de selección de características o reducción de la dimensionalidad.

Otra aproximación para mejorar la interpretabilidad es analizar el espacio transformado por el kernel. Aunque este espacio es de alta dimensión y no directamente observable, algunos métodos permiten visualizar proyecciones que ayudan a entender cómo el kernel separa los datos.

Finalmente, la documentación detallada del proceso de modelado y el establecimiento de un protocolo de interpretación son esenciales para garantizar que los resultados del modelo SVR sean comprensibles y justificados. Esto incluye registrar las decisiones tomadas durante el preprocesamiento, la selección de hiperparámetros y las técnicas de interpretación utilizadas.