Dominando la Clasificación Multiclase con K-Nearest Neighbors (KNN): Una Guía Integral

Tabla de Contenidos

Introducción a la Clasificación
Clasificación Binaria vs. Multiclase
Entendiendo K-Nearest Neighbors (KNN)
Implementando KNN para Clasificación Multiclase
Estudio de Caso: Clasificando Géneros Musicales Bangla
1. Descripción del Conjunto de Datos
2. Pasos de Preprocesamiento de Datos
Construyendo y Evaluando el Modelo KNN
Conclusión
Preguntas Frecuentes

Introducción a la Clasificación

La clasificación es una técnica de aprendizaje supervisado donde el objetivo es predecir etiquetas categóricas para los datos de entrada proporcionados. Se utiliza ampliamente en diversas aplicaciones, como la detección de spam en correos electrónicos, reconocimiento de imágenes, diagnóstico médico y más. Las tareas de clasificación pueden categorizarse ampliamente en dos tipos: clasificación binaria y clasificación multiclase.

Clasificación Binaria vs. Multiclase

Clasificación Binaria: Esto implica categorizar datos en dos clases distintas. Por ejemplo, determinar si un correo electrónico es spam o no spam.
Clasificación Multiclase: Esto extiende la clasificación binaria a escenarios donde hay más de dos clases. Por ejemplo, clasificar diferentes géneros de música o tipos de vehículos.

Entender la diferencia es crucial ya que influye en la elección de algoritmos y métricas de evaluación.

Entendiendo K-Nearest Neighbors (KNN)

K-Nearest Neighbors (KNN) es un algoritmo de aprendizaje automático simple pero poderoso utilizado tanto para tareas de clasificación como de regresión. A continuación, se desglosa cómo funciona KNN:

Aprendizaje Basado en Instancias: KNN no construye un modelo explícito. En su lugar, memoriza el conjunto de datos de entrenamiento.
Medición de Distancia: Para hacer una predicción, KNN calcula la distancia entre el nuevo punto de datos y todos los puntos en el conjunto de entrenamiento.
Mecanismo de Votación: Para la clasificación, KNN selecciona los ‘k’ vecinos más cercanos y asigna la clase más común entre ellos al nuevo punto de datos.
Elección de ‘k’: El número de vecinos, ‘k’, es un hiperparámetro crucial. Un ‘k’ pequeño puede hacer que el modelo sea sensible al ruido, mientras que un ‘k’ grande puede suavizar los límites de decisión.

KNN es particularmente efectivo para la clasificación multiclase debido a su capacidad inherente para manejar múltiples clases a través de la votación.

Implementando KNN para Clasificación Multiclase

Implementar KNN para clasificación multiclase implica varios pasos, incluyendo preprocesamiento de datos, selección de características, escalado y evaluación del modelo. Exploremos estos pasos a través de un estudio de caso práctico.

Estudio de Caso: Clasificando Géneros Musicales Bangla

En esta sección, realizaremos una implementación práctica de clasificación multiclase usando KNN en un conjunto de datos de música Bangla. El objetivo es categorizar canciones en diferentes géneros basados en varias características de audio.

Descripción del Conjunto de Datos

El Conjunto de Datos de Música Bangla comprende datos de 1,742 canciones categorizadas en seis géneros distintos. Cada canción se describe utilizando 31 características, incluyendo atributos de audio como tasa de cruce por cero, centroide espectral, frecuencia de croma y MFCCs (Coeficientes Cepstrales en la Frecuencia de Mel).

Características Clave:

Características Numéricas: Como cruce por cero, centroide espectral, rolloff espectral, etc.
Características Categóricas: Nombres de archivos y etiquetas que indican el género.

Variable Objetivo: La etiqueta de género (label) que indica la categoría musical.

Pasos de Preprocesamiento de Datos

El preprocesamiento de datos es un paso crítico en los flujos de trabajo de aprendizaje automático. Un preprocesamiento adecuado asegura que los datos estén limpios, consistentes y sean adecuados para el entrenamiento del modelo.

Manejo de Datos Faltantes

Por Qué Importa: Los datos faltantes pueden sesgar los resultados y reducir la efectividad del modelo. Es esencial abordar los valores faltantes para mantener la integridad de los datos.

Pasos:

Datos Numéricos:
- Usar la estrategia de Imputación de la Media para llenar los valores faltantes.
- Implementado usando SimpleImputer con strategy='mean'.
Datos Categóricos:
- Usar la estrategia de Imputación de la Más Frecuente para llenar los valores faltantes.
- Implementado usando SimpleImputer con strategy='most_frequent'.

Implementación en Python:

import numpy as np
from sklearn.impute import SimpleImputer

# Manejo de datos numéricos
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])

# Manejo de datos categóricos
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
string_cols = list(np.where((X.dtypes == object))[0])
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])

import numpy as np

from sklearn.impute import SimpleImputer

# Manejo de datos numéricos

imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])

imp_mean.fit(X.iloc[:, numerical_cols])

X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])

# Manejo de datos categóricos

imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

string_cols = list(np.where((X.dtypes == object))[0])

imp_freq.fit(X.iloc[:, string_cols])

X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])

Codificación de Variables Categóricas

Por Qué Importa: Los modelos de aprendizaje automático requieren entradas numéricas. Las variables categóricas necesitan ser convertidas a un formato numérico.

Dos Métodos de Codificación Principales:

Codificación de Etiquetas:
- Asigna un entero único a cada categoría.
- Adecuado para variables categóricas binarias u ordinales.
Codificación One-Hot:
- Crea columnas binarias para cada categoría.
- Adecuado para variables categóricas nominales con más de dos categorías.

Estrategia de Codificación:

Categorías con Dos Clases o Más de un Umbral: Aplicar codificación de etiquetas.
Otras Categorías: Aplicar codificación one-hot.

Implementación en Python:

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Función de Codificación de Etiquetas
def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)

# Función de Codificación One-Hot
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough')
    return columnTransformer.fit_transform(data)

# Función de Selección de Codificación
def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_values = len(pd.unique(X[X.columns[col]]))
        if unique_values == 2 or unique_values > threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

# Aplicar Selección de Codificación
X = EncodingSelection(X)

from sklearn.compose import ColumnTransformer

from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Función de Codificación de Etiquetas

def LabelEncoderMethod(series):

le = LabelEncoder()

return le.fit_transform(series)

# Función de Codificación One-Hot

def OneHotEncoderMethod(indices, data):

columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough')

return columnTransformer.fit_transform(data)

# Función de Selección de Codificación

def EncodingSelection(X, threshold=10):

string_cols = list(np.where((X.dtypes == object))[0])

one_hot_encoding_indices = []

for col in string_cols:

unique_values = len(pd.unique(X[X.columns[col]]))

if unique_values == 2 or unique_values > threshold:

X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])

else:

one_hot_encoding_indices.append(col)

X = OneHotEncoderMethod(one_hot_encoding_indices, X)

return X

# Aplicar Selección de Codificación

X = EncodingSelection(X)

Selección de Características

Por Qué Importa: Seleccionar las características correctas mejora el rendimiento del modelo al eliminar datos irrelevantes o redundantes, reducir el sobreajuste y mejorar la eficiencia computacional.

Método de Selección de Características Utilizado:

SelectKBest con Prueba de Chi-Cuadrado:
- Evalúa la relación entre cada característica y la variable objetivo.
- Selecciona las ‘k’ características con las puntuaciones más altas.

Implementación en Python:

from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler

# Inicializar SelectKBest
kbest = SelectKBest(score_func=chi2, k=12)
scaler = MinMaxScaler()

# Ajustar y transformar los datos
X_scaled = scaler.fit_transform(X)
kbest.fit(X_scaled, y)

# Obtener las mejores características
best_features = np.argsort(kbest.scores_)[-12:]
features_to_delete = np.argsort(kbest.scores_)[:-12]
X = np.delete(X, features_to_delete, axis=1)

from sklearn.feature_selection import SelectKBest, chi2

from sklearn.preprocessing import MinMaxScaler

# Inicializar SelectKBest

kbest = SelectKBest(score_func=chi2, k=12)

scaler = MinMaxScaler()

# Ajustar y transformar los datos

X_scaled = scaler.fit_transform(X)

kbest.fit(X_scaled, y)

# Obtener las mejores características

best_features = np.argsort(kbest.scores_)[-12:]

features_to_delete = np.argsort(kbest.scores_)[:-12]

X = np.delete(X, features_to_delete, axis=1)

Escalado de Características

Por Qué Importa: El escalado asegura que todas las características contribuyan por igual a los cálculos de distancia en KNN, evitando que las características con escalas mayores dominen.

Método de Escalado Utilizado:

Estandarización:
- Transforma los datos para que tengan una media de cero y una desviación estándar de uno.
- Implementado usando StandardScaler.

Implementación en Python:

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Dividir el conjunto de datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)

# Inicializar y ajustar el escalador
scaler = StandardScaler(with_mean=False)
scaler.fit(X_train)

# Transformar los datos
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

from sklearn.preprocessing import StandardScaler

from sklearn.model_selection import train_test_split

# Dividir el conjunto de datos

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)

# Inicializar y ajustar el escalador

scaler = StandardScaler(with_mean=False)

scaler.fit(X_train)

# Transformar los datos

X_train = scaler.transform(X_train)

X_test = scaler.transform(X_test)

Construyendo y Evaluando el Modelo KNN

Con los datos preprocesados y preparados, el siguiente paso es construir el modelo KNN y evaluar su rendimiento.

Entrenamiento del Modelo

Pasos:

Inicializar el Clasificador KNN:
- Configurar el número de vecinos (k=8 en este caso).
Entrenar el Modelo:
- Ajustar el clasificador KNN en los datos de entrenamiento.
Predecir:
- Usar el modelo entrenado para hacer predicciones en el conjunto de prueba.
Evaluar:
- Calcular la puntuación de exactitud para evaluar el rendimiento del modelo.

Implementación en Python:

from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Inicializar KNN con k=8
knnClassifier = KNeighborsClassifier(n_neighbors=8)

# Entrenar el modelo
knnClassifier.fit(X_train, y_train)

# Hacer predicciones
y_pred = knnClassifier.predict(X_test)

# Evaluar exactitud
accuracy = accuracy_score(y_pred, y_test)
print(f"Model Accuracy: {accuracy:.2f}")

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score

# Inicializar KNN con k=8

knnClassifier = KNeighborsClassifier(n_neighbors=8)

# Entrenar el modelo

knnClassifier.fit(X_train, y_train)

# Hacer predicciones

y_pred = knnClassifier.predict(X_test)

# Evaluar exactitud

accuracy = accuracy_score(y_pred, y_test)

print(f"Model Accuracy: {accuracy:.2f}")

Salida:

Model Accuracy: 0.68

1	Model Accuracy: 0.68

Interpretación: El modelo KNN alcanzó una exactitud de aproximadamente 68%, lo que indica que clasificó correctamente el 68% de las canciones en el conjunto de prueba.

Optimización de Hiperparámetros

Ajustar el número de vecinos (‘k’) puede impactar significativamente el rendimiento del modelo. Es recomendable experimentar con diferentes valores de ‘k’ para encontrar el equilibrio óptimo entre sesgo y varianza.

# Experimentar con diferentes valores de k
for k in range(3, 21, 2):
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train, y_train)
    y_pred = knn.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f"k={k}, Accuracy={accuracy:.2f}")

# Experimentar con diferentes valores de k

for k in range(3, 21, 2):

knn = KNeighborsClassifier(n_neighbors=k)

knn.fit(X_train, y_train)

y_pred = knn.predict(X_test)

accuracy = accuracy_score(y_pred, y_test)

print(f"k={k}, Accuracy={accuracy:.2f}")

Salida de Muestra:

k=3, Accuracy=0.65
k=5, Accuracy=0.66
k=7, Accuracy=0.67
k=9, Accuracy=0.68
...
k=19, Accuracy=0.65

k=3, Accuracy=0.65

k=5, Accuracy=0.66

k=7, Accuracy=0.67

k=9, Accuracy=0.68

...

k=19, Accuracy=0.65

Mejor Rendimiento: En este escenario, un valor de k de 9 produjo la mayor exactitud.

Conclusión

La clasificación multiclase es una tarea fundamental en el aprendizaje automático, que permite la categorización de puntos de datos en múltiples clases. El algoritmo K-Nearest Neighbors (KNN), conocido por su simplicidad y efectividad, demuestra ser un fuerte contendiente para tales tareas. A través de esta guía integral, hemos explorado las complejidades de implementar KNN para clasificación multiclase, enfatizando la importancia del preprocesamiento de datos, la selección de características y la evaluación del modelo.

Siguiendo el enfoque sistemático delineado—desde el manejo de datos faltantes y la codificación de variables categóricas hasta la selección de características relevantes y el escalado—puedes aprovechar al máximo el potencial de KNN para tus problemas de clasificación multiclase. Recuerda, la clave para un modelo exitoso radica no solo en el algoritmo sino también en la calidad y preparación de los datos.

Preguntas Frecuentes

1. ¿Cuál es la principal diferencia entre la clasificación binaria y la multiclase?

La clasificación binaria implica categorizar datos en dos clases distintas, mientras que la clasificación multiclase extiende esto a escenarios con más de dos clases.

2. ¿Por qué es importante el escalado de características para KNN?

KNN se basa en cálculos de distancia para determinar los vecinos más cercanos. Sin escalado, las características con escalas mayores pueden influir desproporcionadamente en las métricas de distancia, llevando a predicciones sesgadas.

3. ¿Cómo elijo el número óptimo de vecinos (k) en KNN?

El ‘k’ óptimo equilibra el sesgo y la varianza. Generalmente se determina mediante experimentación, como la validación cruzada, para identificar el valor de ‘k’ que proporciona la mayor exactitud.

4. ¿Puede KNN manejar tanto datos numéricos como categóricos?

KNN funciona principalmente con datos numéricos. Las variables categóricas deben ser codificadas en formatos numéricos antes de aplicar KNN.

5. ¿Cuáles son algunas alternativas a KNN para la clasificación multiclase?

Las alternativas incluyen algoritmos como Máquinas de Vectores de Soporte (SVM), Árboles de Decisión, Bosques Aleatorios y Redes Neuronales, cada uno con sus propias fortalezas y casos de uso adecuados.