Machine Learning 101 — KNN (K Nearest Neighbors)

Machine Learning es una rama de la inteligencia artificial que se enfoca en el estudio y desarrollo de algoritmos que permiten a las computadoras aprender y mejorar a través de la experiencia. Durante los próximos meses comenzaré a revisar estos temas y hoy comenzaré por uno de los algoritmos más populares y ampliamente utilizados en el aprendizaje automático: el algoritmo KNN.

KNN, que significa K-Nearest Neighbors, es un algoritmo de aprendizaje automático supervisado utilizado para clasificación y regresión. En esencia, el algoritmo KNN se basa en encontrar los K puntos más cercanos a un punto de datos de entrada y determinar la clase o valor de salida en función de los valores de estos puntos de datos cercanos.

La idea detrás del algoritmo KNN es simple: si los puntos de datos cercanos a un punto de entrada tienen una clase similar, es probable que el punto de entrada pertenezca a esa misma clase. Por ejemplo, si estamos tratando de clasificar una imagen de un animal como un perro o un gato, el algoritmo KNN buscará las imágenes de perros y gatos más cercanas a la imagen de entrada y determinará la clase de la imagen de entrada en función de la mayoría de las clases de las imágenes más cercanas.

El algoritmo KNN es muy flexible y puede funcionar con cualquier tipo de datos, ya sean numéricos, categóricos o incluso imágenes. Además, es fácil de entender e implementar, lo que lo hace popular entre los principiantes en el aprendizaje automático. Sin embargo, el algoritmo KNN también tiene algunas limitaciones, como la necesidad de almacenar todos los datos de entrenamiento, lo que puede ser problemático para grandes conjuntos de datos.

Implementación en Python

Como un ejemplo práctico vamos a ver la implementación de este modelo en Python que es uno de los lenguajes mas populares para machine learning.

import numpy as np
from collections import Counter


def euclidean_distance(x1, x2):
    return np.sqrt(np.sum((x1-x2)**2))


class KNN:

    def __init__(self, k=3):
        self.k = k

    def fit(self, X, y):
        self.X_train = X
        self.y_train = y

    def predict(self, X):
        predicted_labels = [self._predict(x) for x in X]
        return np.array(predicted_labels)

    def _predict(self, x):
        # Calculo las distancias
        distances = [euclidean_distance(x, x_train)
                     for x_train in self.X_train]
        # Encontrar las k muestras mas cercanas
        k_indices = np.argsort(distances)[:self.k]
        k_nearest_labels = [self.y_train[i] for i in k_indices]
        # Voto de la mayoría, etiquetas mas comunes
        most_common = Counter(k_nearest_labels).most_common(1)
        return most_common[0][0]

La clase KNN tiene tres métodos:

El método init es el constructor de la clase y toma un argumento k que especifica el número de vecinos más cercanos que se utilizarán para clasificar los puntos de datos.

El método fit toma los datos de entrenamiento X y las etiquetas y y los almacena en la instancia de la clase para su uso posterior en el método predict.

El método predict toma un conjunto de datos X y clasifica cada punto de datos en función de los k vecinos más cercanos en los datos de entrenamiento. Retorna un array de las etiquetas predichas.

El método _predict es un método auxiliar utilizado por el método predict. Toma un punto de datos x y encuentra los k vecinos más cercanos en los datos de entrenamiento. Luego utiliza una “votación de la mayoría” para predecir la etiqueta del punto de datos basado en las etiquetas de los vecinos más cercanos.

Finalmente con la siguiente clase podemos testear este desarrollo

from knn import KNN
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
cmap = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])

iris = datasets.load_iris()
X, y = iris.data, iris.target

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

#Descomentar para ver el set de datos con el que trabajamos

# print(X_train.shape)
# print(X_train[0])

# print(y_train.shape)
# print(y_train)

# plt.figure()
# plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap, edgecolor='k', s=20)
# plt.show()

clf = KNN(k=3)
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)

accuracy = np.sum(predictions == y_test) / len(y_test)
print(accuracy)

Este código y otros ejemplos que voy a seguir agregando a medida que avance con nuevos conceptos pueden encontrarse en el siguiente repositorio

En resumen, el algoritmo KNN es uno de los algoritmos de aprendizaje automático más populares y ampliamente utilizados, y se utiliza en una variedad de aplicaciones, desde la clasificación de imágenes hasta la predicción de precios de acciones. Aunque tiene algunas limitaciones, sigue siendo una herramienta poderosa para cualquier persona interesada en el aprendizaje automático.