k-vecinos más cercanos (KNN)

El k-vecinos más cercanos (KNN, k-Nearest Neighbors) clasifica cada ejemplo nuevo preguntándole a los datos que más se le parecen: mira sus $k$ vecinos más cercanos y se queda con la clase mayoritaria. Es el clasificador más intuitivo que existe, y no "entrena" nada.

La idea: pregúntale a tus vecinos

¿Este correo es spam? KNN busca los $k$ correos más parecidos entre los que ya conoce y hace que voten. Si la mayoría era spam, el nuevo también se etiqueta como spam. La intuición es la del refrán: dime con quién andas y te diré quién eres.

Cómo funciona

Para clasificar un punto nuevo:

1. Calcula su distancia a todos los ejemplos conocidos.
2. Se queda con los $k$ más cercanos.
3. Vota: la clase más frecuente entre esos vecinos gana.

No hay fase de entrenamiento: el modelo simplemente guarda los datos y hace todo el trabajo al momento de predecir. Por eso se le llama un método perezoso (lazy learning) y no paramétrico: no asume ninguna forma para la frontera de decisión.

La distancia

El "parecido" se mide con una distancia, casi siempre la euclidiana:

$$d(\mathbf{x},{\mathbf{x}}^{\prime })=\sqrt{\sum _{j=1}^p(x_j-x_j^{\prime }{)}^2}$$

Como todo depende de esta distancia, escalar las variables es obligatorio: si una variable va de 0 a 1.000.000 y otra de 0 a 1, la primera dominaría por completo el cálculo.

Elegir k: el equilibrio sesgo-varianza

El valor de $k$ controla cuán "suave" es la frontera de decisión, y es un ejemplo perfecto del compromiso sesgo-varianza:

• $k$ pequeño (p. ej. 1): la frontera sigue cada punto, muy sensible al ruido → alta varianza (sobreajuste).
• $k$ grande: promedia muchos vecinos, frontera muy suave que ignora el detalle → alto sesgo (subajuste).

Se elige un $k$ intermedio con validación cruzada. Un truco común es usar un $k$ impar en problemas binarios, para evitar empates en la votación.

En código

scikit-learn lo resuelve con la misma interfaz de siempre; lo clave es escalar antes:

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

# KNN se apoya en distancias, así que escalamos las variables primero.
modelo = make_pipeline(
    StandardScaler(),
    KNeighborsClassifier(n_neighbors=5),  # k = 5 vecinos que votan
).fit(X_train, y_train)

modelo.predict(X_test)

Límites que conviene recordar

• Costoso al predecir: comparar contra todos los datos guardados es lento si hay muchos ejemplos.
• Maldición de la dimensionalidad: con muchas variables, "cercano" pierde sentido y el método se degrada (ahí ayuda PCA).
• Sensible a la escala y a variables irrelevantes.

Para llevar

KNN clasifica por mayoría entre los $k$ vecinos más cercanos: simple, sin entrenamiento y sorprendentemente competitivo. El valor de $k$ encarna el equilibrio sesgo-varianza, y escalar las variables es imprescindible. Es el clasificador más intuitivo; en la próxima lección veremos uno que traza una frontera con criterio geométrico: las Máquinas de Vectores de Soporte.