Tutorial ScikitLearn: Regresión KNN KNeighborsRegressor

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

El algoritmo de k vecinos más cercanos (K-Nearest Neighbors, KNN) es un método de aprendizaje supervisado que se utiliza tanto para problemas de clasificación como de regresión. En el contexto de la regresión, KNN predice el valor de una variable continua basándose en los valores de sus k vecinos más próximos en el espacio de características.

El principio fundamental de KNN para regresión es que las observaciones con valores de predictores similares tienden a tener respuestas similares. Para predecir el valor de una nueva instancia, el algoritmo identifica los k vecinos más cercanos en el conjunto de entrenamiento y calcula una estimación, normalmente a través de la media o la mediana de los valores objetivo de esos vecinos.

La definición de proximidad entre observaciones se basa en una métrica de distancia, siendo la distancia euclidiana la más común en espacios de características continuas. Sin embargo, otras métricas como la distancia de Manhattan o la distancia de Minkowski también pueden ser utilizadas, dependiendo de la naturaleza de los datos y las características.

La elección del parámetro k, que representa el número de vecinos a considerar, es crucial para el rendimiento del modelo. Un valor pequeño de k puede hacer que el modelo sea sensible al ruido y a los valores atípicos, lo que conduce a un sobreajuste. Por el contrario, un valor grande de k puede suavizar demasiado las predicciones, induciendo un subajuste y perdiendo patrones locales importantes.

El algoritmo KNN para regresión no realiza ningún supuesto paramétrico sobre la distribución de los datos, lo que lo hace un método no paramétrico. Esto significa que puede capturar relaciones no lineales entre las variables predictoras y la variable objetivo. No obstante, su rendimiento puede verse afectado en altas dimensiones debido a la maldición de la dimensionalidad, ya que las distancias entre puntos tienden a volverse menos significativas.

Otra consideración importante es el coste computacional. Dado que KNN es un algoritmo basado en instancias, toda la base de datos de entrenamiento debe ser almacenada y recorrida para cada predicción, lo que puede ser ineficiente para conjuntos de datos muy grandes. Técnicas como el uso de estructuras de datos eficientes, como el kd-tree o el ball tree, pueden aliviar este problema mejorando la eficiencia en la búsqueda de vecinos cercanos.

La ponderación de los vecinos puede mejorar la precisión de las predicciones. En lugar de dar igual importancia a todos los vecinos, se puede emplear una ponderación inversamente proporcional a la distancia, de modo que los vecinos más cercanos tengan un mayor impacto en la predicción que los más lejanos.

Preprocesados específicos para KNN

El algoritmo KNN basa sus predicciones en la distancia entre las observaciones, por lo que el preprocesamiento de los datos es crucial para obtener resultados precisos. Uno de los pasos más importantes es la normalización o escalado de las características. Si las variables tienen escalas diferentes, aquellas con valores numéricos más grandes pueden dominar el cálculo de distancias, sesgando el algoritmo. Por ello, es habitual utilizar técnicas como el MinMaxScaler o el StandardScaler de Scikit Learn para ajustar las variables a una escala común.

Además, es importante tratar las variables categóricas adecuadamente. Dado que KNN utiliza métricas de distancia, es necesario convertir las variables categóricas en representaciones numéricas. La codificación mediante One-Hot Encoding es una opción común, ya que evita introducir un orden arbitrario entre categorías. Scikit Learn proporciona la clase OneHotEncoder para realizar esta transformación de manera eficiente.

La reducción de la dimensionalidad es otra consideración clave. El rendimiento de KNN puede deteriorarse en espacios de alta dimensión debido a la maldición de la dimensionalidad. Métodos como el Análisis de Componentes Principales (PCA) pueden usarse para reducir el número de características mientras se conserva la mayor parte de la variabilidad de los datos. Esto no solo mejora la eficiencia computacional, sino que también puede aumentar la precisión del modelo.

El tratamiento de valores atípicos es esencial, ya que KNN es sensible a su presencia. Los outliers pueden distorsionar las distancias y, por ende, afectar las predicciones. Es recomendable identificar y, si es necesario, eliminar o ajustar estos valores mediante técnicas estadísticas o herramientas como Isolation Forest o Local Outlier Factor disponibles en Scikit Learn.

También es importante manejar los valores faltantes antes de aplicar KNN. Las distancias no pueden calcularse si existen datos ausentes. Se pueden imputar los valores faltantes utilizando métodos como la imputación con la media o la mediana, o emplear el KNNImputer de Scikit Learn, que utiliza un enfoque basado en vecinos para estimar los valores perdidos.

Por último, seleccionar las características relevantes puede mejorar el rendimiento del modelo. No todas las variables pueden aportar información útil, y algunas pueden introducir ruido. Técnicas de selección de características, como SelectKBest o Recursive Feature Elimination (RFE), permiten identificar y conservar las variables más significativas para la predicción.

Un preprocesamiento adecuado que incluya escalado, codificación de variables categóricas, reducción de dimensionalidad, tratamiento de valores atípicos y faltantes, y selección de características es fundamental para optimizar el rendimiento del algoritmo KNN en tareas de regresión.

Modelo KNeighborsRegressor en Scikit learn

El KNeighborsRegressor es una clase de Scikit Learn que implementa el algoritmo de k vecinos más cercanos para tareas de regresión. Este modelo predice el valor de una nueva instancia basándose en los valores de sus k vecinos más próximos en el espacio de características.

Para utilizar KNeighborsRegressor, es necesario importarlo desde el módulo neighbors de Scikit Learn. A continuación, se crea una instancia del modelo, especificando el número de vecinos k y otros parámetros relevantes. El modelo se entrena utilizando el método fit, y se realizan predicciones con el método predict.

A continuación se muestra un ejemplo de cómo utilizar KNeighborsRegressor en un conjunto de datos. Primero, importamos las librerías necesarias y cargamos los datos:

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import train_test_split

# Supongamos que tenemos nuestras características X y el objetivo y
X = np.array([[...], [...], ...])
y = np.array([...])

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

Tras preparar los datos, se instancia el modelo especificando el número de vecinos, por ejemplo k=5:

# Creamos una instancia de KNeighborsRegressor con k=5
knn_reg = KNeighborsRegressor(n_neighbors=5)

Entrenamos el modelo utilizando el método fit, pasándole los datos de entrenamiento:

# Entrenamos el modelo con los datos de entrenamiento
knn_reg.fit(X_train, y_train)

Una vez entrenado el modelo, podemos realizar predicciones sobre nuevos datos o sobre el conjunto de prueba:

# Realizamos predicciones con el modelo entrenado
y_pred = knn_reg.predict(X_test)

Para evaluar el rendimiento del modelo, podemos utilizar métricas como el error cuadrático medio (MSE) o el coeficiente de determinación (R²):

from sklearn.metrics import mean_squared_error, r2_score

# Calculamos el error cuadrático medio
mse = mean_squared_error(y_test, y_pred)

# Calculamos el coeficiente de determinación R²
r2 = r2_score(y_test, y_pred)

print(f"Error cuadrático medio: {mse}")
print(f"Coeficiente de determinación R²: {r2}")

El KNeighborsRegressor admite varios parámetros que permiten ajustar su comportamiento, como la métrica de distancia, la ponderación de los vecinos y el algoritmo utilizado para la búsqueda de los vecinos más cercanos. Estos parámetros permiten personalizar el modelo para adaptarse mejor a los datos y se explorarán con más detalle en secciones posteriores.

Es importante asegurarse de que las características de los datos estén correctamente preprocesadas antes de entrenar el modelo. Como el algoritmo se basa en distancias, las variables deben estar escaladas adecuadamente, por lo que técnicas de escalado o normalización son fundamentales para obtener resultados precisos.

Además, el KNeighborsRegressor puede manejar datos multidimensionales y no asume ninguna forma funcional específica entre las variables independientes y la variable dependiente, lo que lo hace flexible para capturar relaciones no lineales en los datos.

Parámetros de KNeighborsRegressor

El modelo KNeighborsRegressor de Scikit Learn ofrece diversos parámetros que permiten ajustar su comportamiento para optimizar el rendimiento en tareas de regresión. Comprender y configurar adecuadamente estos parámetros es esencial para obtener predicciones precisas y eficientes.

n_neighbors:

• Número entero que establece cuántos vecinos más cercanos se considerarán para realizar la predicción.
• Valor por defecto: 5.
• Consideraciones:
  • Menor número: Captura patrones locales, pero puede ser sensible al ruido.
  • Mayor número: Estimaciones más suaves, pero puede perder detalles importantes.
• Recomendación: Probar diferentes valores con validación cruzada.

weights:

• Define cómo se ponderan los vecinos en la predicción.
• Opciones:
  • 'uniform': Todos los vecinos tienen el mismo peso.
  • 'distance': Pondera inversamente proporcional a la distancia, los vecinos más cercanos tienen mayor influencia.
  • Función personalizada: Se puede proporcionar una función que reciba las distancias y devuelva una matriz de pesos.
• Consideración: Elegir 'distance' cuando la proximidad influya significativamente en la variable objetivo.

algorithm:

• Algoritmo utilizado para encontrar los vecinos más cercanos.
• Opciones:
  • 'auto': Selección automática según los datos.
  • 'ball_tree': Utiliza un Ball Tree.
  • 'kd_tree': Emplea un KD Tree.
  • 'brute': Busca por fuerza bruta computando todas las distancias.
• Valor por defecto: 'auto'.
• Consideración: Manualmente útil en grandes conjuntos de datos.

leaf_size:

• Tamaño de las hojas en los algoritmos Ball Tree y KD Tree.
• Valor por defecto: 30.
• Consideraciones:
  • Valores menores: Mayor precisión, pero más tiempo de cómputo.
  • Ajustar para optimizar velocidad y memoria en casos particulares.

p:

• Potencia del parámetro Minkowski para la métrica de distancia.
• Opciones:
  • p=1: Distancia de Manhattan.
  • p=2: Distancia Euclidiana (por defecto).
  • Valores mayores: Distancias de orden superior.
• Consideración: Ajustar según las características de los datos.

metric:

• Métrica de distancia utilizada para encontrar los vecinos.
• Opciones:
  • 'minkowski': Métrica general (por defecto).
  • 'euclidean': Distancia Euclidiana.
  • 'manhattan': Distancia de Manhattan.
  • 'chebyshev': Distancia de Chebyshev.
  • Función personalizada: Para cálculos específicos de distancia.
• Consideración: Seleccionar la métrica adecuada según las escalas y distribuciones de las características.

metric_params:

• Diccionario para argumentos adicionales de la métrica de distancia.
• Ejemplo: Pesos o coeficientes específicos para métricas personalizadas.

n_jobs:

• Número de procesadores para computar distancias y encontrar vecinos.
• Opciones:
  • Entero positivo: Número exacto de CPU.
  • -1: Utiliza todos los procesadores disponibles.
• Consideración: Acelera el cómputo en grandes conjuntos de datos.

A continuación se presenta un ejemplo de cómo configurar algunos de estos parámetros al instanciar el modelo KNeighborsRegressor:

from sklearn.neighbors import KNeighborsRegressor

# Creación del modelo con parámetros personalizados
knn_reg = KNeighborsRegressor(
    n_neighbors=10,
    weights='distance',
    algorithm='ball_tree',
    leaf_size=20,
    p=2,
    metric='minkowski',
    n_jobs=-1
)

En este ejemplo, se ha establecido n_neighbors en 10 para considerar más vecinos, y weights en 'distance' para dar más importancia a los vecinos cercanos. El algorithm se ha fijado en 'ball_tree' para optimizar la búsqueda en un espacio de características de alta dimensión. Además, n_jobs se ha configurado en -1 para aprovechar todos los núcleos de procesamiento disponibles.

Es importante tener en cuenta que la elección de los parámetros debe basarse en las características específicas del conjunto de datos y en objetivos concretos del modelo. Realizar un análisis exploratorio y probar diferentes configuraciones puede conducir a un mejor rendimiento.

La utilización de técnicas como la búsqueda en cuadrícula (GridSearchCV) o la búsqueda aleatoria (RandomizedSearchCV) de Scikit Learn permite automatizar el proceso de ajuste de hiperparámetros. Estas herramientas evalúan múltiples combinaciones de parámetros utilizando validación cruzada para identificar la configuración óptima.

Al configurar el parámetro metric, es fundamental asegurarse de que las características estén adecuadamente escaladas. Si se utilizan distancias basadas en magnitudes, las variables con escalas más grandes pueden dominar el cálculo de distancias. Aplicar métodos de normalización o estandarización garantiza que todas las características contribuyan de manera equilibrada.

Finalmente, al definir una función personalizada para los parámetros weights o metric, se debe asegurar que la función cumpla con los requisitos de Scikit Learn y esté correctamente implementada para evitar errores durante el entrenamiento o la predicción.

Interpretabilidad de KNeighborsRegressor en Scikit Learn

La interpretabilidad en modelos de aprendizaje automático es fundamental para comprender cómo se generan las predicciones y qué influencia tienen las características en el resultado. Aunque el KNeighborsRegressor es un modelo no paramétrico, es posible analizar su comportamiento y extraer información valiosa sobre la relación entre las variables independientes y la variable objetivo.

Una forma de abordar la interpretabilidad del KNeighborsRegressor es examinando los vecinos más cercanos que el modelo utiliza para realizar las predicciones. Para una instancia dada, el modelo identifica los k vecinos más próximos en el espacio de características y calcula la predicción como la media (o ponderación) de sus valores objetivo. Analizar estos vecinos puede proporcionar insights sobre cómo los datos locales influyen en la predicción.

Por ejemplo, para una nueva observación, se pueden identificar cuáles son sus vecinos más cercanos y visualizar sus características y valores objetivo. Esto permite entender si los vecinos tienen características similares y cómo contribuyen al resultado final. A continuación se muestra cómo obtener los índices de los vecinos más cercanos utilizando el método kneighbors:

import numpy as np
from sklearn.neighbors import KNeighborsRegressor

# Supongamos que el modelo ya ha sido entrenado con X_train e y_train
knn_reg = KNeighborsRegressor(n_neighbors=5)
knn_reg.fit(X_train, y_train)

# Seleccionamos una instancia de prueba
X_new = X_test[0].reshape(1, -1)

# Obtenemos las distancias y los índices de los vecinos más cercanos
distancias, indices = knn_reg.kneighbors(X_new)

print("Distancias a los vecinos más cercanos:", distancias)
print("Índices de los vecinos más cercanos:", indices)

Con los índices obtenidos, es posible inspeccionar las características y valores objetivo de los vecinos en X_train e y_train. Esto ayuda a verificar si los vecinos seleccionados son coherentes y si sus valores objetivo justifican la predicción realizada. Además, al analizar las distancias, se puede determinar qué tan similares son las observaciones vecinas a la instancia de interés.

Otra herramienta útil para interpretar el KNeighborsRegressor es la visualización en dos dimensiones de las características junto con las predicciones. Aunque en datasets con múltiples características esto puede ser complejo, seleccionar dos variables relevantes y representar los datos en un plano puede proporcionar una comprensión intuitiva del modelo. Por ejemplo:

import matplotlib.pyplot as plt

# Seleccionamos dos características para la visualización
caracteristica_1 = 0
caracteristica_2 = 1

plt.scatter(X_train[:, caracteristica_1], X_train[:, caracteristica_2], c=y_train, cmap='viridis', label='Datos de entrenamiento')
plt.scatter(X_new[:, caracteristica_1], X_new[:, caracteristica_2], c='red', label='Nueva instancia')
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.legend()
plt.colorbar(label='Valor objetivo')
plt.show()

Esta gráfica permite observar la posición de la nueva instancia respecto a los datos de entrenamiento y cómo se distribuyen los valores objetivo en el espacio de características. La coloreación según el valor objetivo facilita la identificación de patrones y tendencias locales.

Además, si se utiliza ponderación por distancia en el modelo (weights='distance'), es posible analizar cómo las distancias afectan a la predicción. Las instancias más cercanas tienen mayor peso, por lo que su influencia es más significativa. Evaluar el impacto de cada vecino en la predicción puede hacerse calculando los pesos manualmente:

# Calculamos los pesos inversamente proporcionales a la distancia
pesos = 1 / distancias

# Normalizamos los pesos para que sumen 1
pesos_normalizados = pesos / np.sum(pesos)

print("Pesos normalizados de los vecinos:", pesos_normalizados)

Interpretar estos pesos normalizados ayuda a entender cuánto aporta cada vecino a la predicción final. Un vecino con un peso significativamente mayor indica que tiene un valor objetivo crítico para el resultado del modelo.

Aunque el KNeighborsRegressor no proporciona coeficientes o importancias de características como los modelos lineales o los árboles de decisión, es posible evaluar la relevancia de las variables mediante el análisis de sensibilidad. Una técnica común es calcular el impacto en la predicción al variar individualmente cada característica mientras se mantienen las demás constantes. Por ejemplo:

# Copiamos la instancia original
X_variado = X_new.copy()

# Definimos un rango de valores para la característica a analizar
valores = np.linspace(np.min(X_train[:, caracteristica_1]), np.max(X_train[:, caracteristica_1]), 100)

# Almacenamos las predicciones
predicciones = []

for valor in valores:
    X_variado[0, caracteristica_1] = valor
    prediccion = knn_reg.predict(X_variado)
    predicciones.append(prediccion[0])

# Graficamos el efecto de la característica en la predicción
plt.plot(valores, predicciones)
plt.xlabel('Valor de la Característica 1')
plt.ylabel('Predicción')
plt.title('Impacto de la Característica 1 en la Predicción')
plt.show()

Este análisis muestra cómo la variación en una característica específica influye en la predicción del modelo, lo que permite identificar qué variables tienen un mayor efecto en el resultado. Repetir este procedimiento para cada característica proporciona una visión más completa de la sensibilidad del modelo.

Además, es posible utilizar técnicas de explicabilidad global, como la importancia de características basada en permutación. Aunque no es nativa del KNeighborsRegressor, Scikit Learn ofrece el método permutation_importance en el módulo inspection para evaluar la importancia de cada característica en el modelo:

from sklearn.inspection import permutation_importance

# Calculamos la importancia de características por permutación
resultados = permutation_importance(knn_reg, X_test, y_test, n_repeats=10, random_state=42)

importancias = resultados.importances_mean

# Visualizamos las importancias
indices = np.argsort(importancias)
plt.barh(range(X_test.shape[1]), importancias[indices])
plt.yticks(range(X_test.shape[1]), np.array(features_names)[indices])
plt.xlabel('Importancia')
plt.title('Importancia de las Características')
plt.show()

Este enfoque mide la disminución en la precisión del modelo cuando se permutan aleatoriamente los valores de una característica, lo que indica su relevancia para las predicciones. Las características con mayor disminución en la precisión son consideradas más importantes.

Por último, utilizar herramientas de interpretabilidad local como LIME (Local Interpretable Model-agnostic Explanations) o SHAP (SHapley Additive exPlanations) puede ser muy beneficioso. Estas técnicas proporcionan explicaciones intuitivas de las predicciones individuales del modelo, independientemente de su naturaleza interna. A continuación se muestra un ejemplo utilizando SHAP:

import shap

# Creamos un objeto explainer para el modelo KNN
explainer = shap.KernelExplainer(knn_reg.predict, X_train)

# Calculamos los valores SHAP para la instancia de interés
shap_values = explainer.shap_values(X_new)

# Visualizamos la explicación de la predicción
shap.initjs()
shap.force_plot(explainer.expected_value, shap_values, X_new)

Los valores SHAP proporcionan una medida de la contribución de cada característica a la predicción realizada, facilitando una comprensión detallada de cómo el modelo utiliza las variables para generar sus resultados.

En conclusión, aunque el KNeighborsRegressor es un modelo basado en proximidad y no ofrece coeficientes explícitos, existen múltiples estrategias para interpretar sus predicciones. Analizar los vecinos más cercanos, visualizar el impacto de las características, emplear técnicas de importancia por permutación y utilizar herramientas como SHAP permiten extraer información valiosa y comprender en profundidad el comportamiento del modelo.