S19L02-KNN en Python

html
Construyendo un Modelo de K-Nearest Neighbors (KNN) en Python: Una Guía Completa



Bienvenido a esta guía completa sobre cómo construir un K-Nearest Neighbors (KNN) en Python. Ya seas un entusiasta de la ciencia de datos o un profesional experimentado, este artículo te guiará a través de cada paso del desarrollo de un clasificador KNN, desde el preprocesamiento de datos hasta la evaluación del modelo. Al final de esta guía, tendrás una comprensión sólida de cómo implementar KNN utilizando las potentes bibliotecas de Python.

Tabla de Contenidos


    Introducción a K-Nearest Neighbors (KNN)
    Comprendiendo el Conjunto de Datos
    
        Preprocesamiento de Datos
        
            Manejo de Datos Faltantes
            Codificación de Variables Categóricas
            Selección de Características
            División de Entrenamiento y Prueba
            Escalado de Características
        
    
    Construyendo el Modelo KNN
    Evaluación del Modelo
    Conclusión
    Recursos Adicionales




Introducción a K-Nearest Neighbors (KNN) 

K-Nearest Neighbors (KNN) es un algoritmo de aprendizaje supervisado simple pero efectivo, utilizado para tareas de clasificación y regresión. El algoritmo KNN clasifica un punto de datos basándose en cómo están clasificados sus vecinos. Es intuitivo, fácil de implementar y no requiere una fase de entrenamiento, lo que lo hace eficiente para predicciones en tiempo real.

Características Clave de KNN:

    Aprendizaje Perezoso: KNN no construye un modelo interno; memoriza el conjunto de datos de entrenamiento.
    Basado en Instancias: Las predicciones se basan en instancias (vecinos) del conjunto de datos de entrenamiento.
    No Paramétrico: KNN no hace suposiciones acerca de la distribución subyacente de los datos.




Comprendiendo el Conjunto de Datos 

Para este tutorial, utilizaremos el conjunto de datos WeatherAUS de Kaggle. Este conjunto de datos contiene atributos meteorológicos registrados durante múltiples años en varias ubicaciones australianas.

Descripción del Conjunto de Datos:

    
        Características
        Variable Objetivo
    
    
        Date, Location, MinTemp, MaxTemp, Rainfall, Evaporation, Sunshine, WindGustDir, WindGustSpeed, WindDir9am, WindDir3pm, WindSpeed9am, WindSpeed3pm, Humidity9am, Humidity3pm, Pressure9am, Pressure3pm, Cloud9am, Cloud3pm, Temp9am, Temp3pm, RainToday, RISK_MM
        RainTomorrow (Sí/No)
    




Preprocesamiento de Datos 

El preprocesamiento de datos es un paso crucial en el aprendizaje automático. Implica transformar los datos crudos en un formato comprensible. Un preprocesamiento adecuado puede mejorar significativamente el rendimiento de los algoritmos de aprendizaje automático.

Manejo de Datos Faltantes 

Los datos faltantes pueden afectar negativamente el rendimiento de los modelos de aprendizaje automático. Manejaremos los valores faltantes tanto para características numéricas como categóricas.

Datos Numéricos


    Identificar Columnas Numéricas:
        



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


    
    Imputar Valores Faltantes con la Media:
        



		
		
			
			
Java
			
			from sklearn.impute import SimpleImputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
			
				
					
				
					1
2
3
4
				
						from sklearn.impute import SimpleImputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		


    


Datos Categóricos


    Identificar Columnas Categóricas:
        



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


    
    Imputar Valores Faltantes con la Moda (Más Frecuente):
        



		
		
			
			
Java
			
			imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
imp_mode.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mode.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
				
						imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
imp_mode.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mode.transform(X.iloc[:, string_cols])
					
				
			
		


    


Codificación de Variables Categóricas 

Los algoritmos de aprendizaje automático requieren entradas numéricas. Por lo tanto, necesitamos convertir las variables categóricas en formatos numéricos.

Codificación de Etiquetas
La codificación de etiquetas asigna a cada categoría un entero único basado en el orden alfabético.





		
		
			
			
Java
			
			from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    return le.fit_transform(series)
			
				
					
				
					1
2
3
4
5
				
						from sklearn import preprocessing
 
def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    return le.fit_transform(series)
					
				
			
		



Codificación One-Hot
La codificación One-Hot crea columnas binarias para cada categoría.





		
		
			
			
Java
			
			from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
 
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
					
				
			
		



Función de Selección de Codificación
Esta función decide si aplicar Codificación de Etiquetas o Codificación One-Hot basado en el número de categorías únicas.





		
		
			
			
Java
			
			def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []

    for col in string_cols:
        length = len(pd.unique(X[X.columns[col]]))
        if length == 2 or length > 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
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
 
    for col in string_cols:
        length = len(pd.unique(X[X.columns[col]]))
        if length == 2 or length > 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 Codificación:




		
		
			
			
Java
			
			X = EncodingSelection(X)
			
				
					
				
					1
				
						X = EncodingSelection(X)
					
				
			
		



Selección de Características 

Seleccionar características relevantes puede mejorar el rendimiento del modelo.


    Aplicar SelectKBest con la Prueba Chi-Cuadrado:
        



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

kbest = SelectKBest(score_func=chi2, k=10)
MMS = preprocessing.MinMaxScaler()
x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)
best_features = np.argsort(x_temp.scores_)[-13:]
features_to_delete = np.argsort(x_temp.scores_)[:-13]
X = np.delete(X, features_to_delete, axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing
 
kbest = SelectKBest(score_func=chi2, k=10)
MMS = preprocessing.MinMaxScaler()
x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)
best_features = np.argsort(x_temp.scores_)[-13:]
features_to_delete = np.argsort(x_temp.scores_)[:-13]
X = np.delete(X, features_to_delete, axis=1)
					
				
			
		


    
    Forma Resultante:
        



		
		
			
			
Java
			
			print(X.shape)  # Output: (142193, 13)
			
				
					
				
					1
				
						print(X.shape)  # Output: (142193, 13)
					
				
			
		


    


División de Entrenamiento y Prueba 

Dividir el conjunto de datos en conjuntos de entrenamiento y prueba asegura que el modelo se evalúe con datos no vistos.





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
print(X_train.shape)  # Output: (113754, 13)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.model_selection import train_test_split
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
print(X_train.shape)  # Output: (113754, 13)
					
				
			
		



Escalado de Características 

El escalado de características estandariza el rango de las variables independientes, asegurando que cada característica contribuya por igual al resultado.


    Estandarización:
        



		
		
			
			
Java
			
			from sklearn import preprocessing
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
				
						from sklearn import preprocessing
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
					
				
			
		


    
    Verificar Formas:
        



		
		
			
			
Java
			
			print(X_train.shape)  # Output: (113754, 13)
print(X_test.shape)   # Output: (28439, 13)
			
				
					
				
					1
2
				
						print(X_train.shape)  # Output: (113754, 13)
print(X_test.shape)   # Output: (28439, 13)
					
				
			
		


    




Construyendo el Modelo KNN 

Con los datos preprocesados, ahora estamos listos para construir el clasificador KNN.


    Importar KNeighborsClassifier:
        



		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
			
				
					
				
					1
				
						from sklearn.neighbors import KNeighborsClassifier
					
				
			
		


    
    Inicializar el Clasificador:
        



		
		
			
			
Java
			
			knnClassifier = KNeighborsClassifier(n_neighbors=3)
			
				
					
				
					1
				
						knnClassifier = KNeighborsClassifier(n_neighbors=3)
					
				
			
		


    
    Entrenar el Modelo:
        



		
		
			
			
Java
			
			knnClassifier.fit(X_train, y_train)
			
				
					
				
					1
				
						knnClassifier.fit(X_train, y_train)
					
				
			
		


    
    Realizar Predicciones:
        



		
		
			
			
Java
			
			y_pred = knnClassifier.predict(X_test)
			
				
					
				
					1
				
						y_pred = knnClassifier.predict(X_test)
					
				
			
		


    
    Ejemplo de Predicción Única:
        



		
		
			
			
Java
			
			single_prediction = knnClassifier.predict([X_test[0]])
print(single_prediction)  # Output: [1] (1 indica 'Sí' para RainTomorrow)
			
				
					
				
					1
2
				
						single_prediction = knnClassifier.predict([X_test[0]])
print(single_prediction)  # Output: [1] (1 indica 'Sí' para RainTomorrow)
					
				
			
		


    
    Probabilidades de Predicción:
        



		
		
			
			
Java
			
			prediction_prob = knnClassifier.predict_proba([X_test[0]])
print(prediction_prob)  # Output: [[0.33333333 0.66666667]]
			
				
					
				
					1
2
				
						prediction_prob = knnClassifier.predict_proba([X_test[0]])
print(prediction_prob)  # Output: [[0.33333333 0.66666667]]
					
				
			
		


    




Evaluación del Modelo 

Evaluar el rendimiento del modelo es esencial para entender su precisión y fiabilidad.


    Importar Accuracy Score:
        



		
		
			
			
Java
			
			from sklearn.metrics import accuracy_score
			
				
					
				
					1
				
						from sklearn.metrics import accuracy_score
					
				
			
		


    
    Calcular Precisión:
        



		
		
			
			
Java
			
			accuracy = accuracy_score(y_pred, y_test) * 100
print(f"Accuracy: {accuracy:.2f}%")  # Output: Accuracy: 90.28%
			
				
					
				
					1
2
				
						accuracy = accuracy_score(y_pred, y_test) * 100
print(f"Accuracy: {accuracy:.2f}%")  # Output: Accuracy: 90.28%
					
				
			
		


    


Interpretación:

    El modelo KNN logró una precisión de 90.28%, indicando que predice correctamente el estado de lluvia para el día siguiente en más del 90% de los casos. Esta alta precisión sugiere que el modelo es adecuado para esta tarea de clasificación.




Conclusión 

En esta guía, hemos recorrido todo el proceso de construcción de un modelo K-Nearest Neighbors (KNN) en Python:


    Importación de Datos: Utilizando el conjunto de datos WeatherAUS.
    Preprocesamiento de Datos: Manejo de valores faltantes, codificación de variables categóricas y selección de características relevantes.
    División de Entrenamiento y Prueba & Escalado de Características: Preparando los datos para el entrenamiento y asegurando la uniformidad entre las características.
    Construcción del Modelo: Entrenamiento del clasificador KNN y realización de predicciones.
    Evaluación del Modelo: Evaluando la precisión del modelo.


El algoritmo KNN demuestra ser una opción robusta para tareas de clasificación, especialmente con datos bien preprocesados. Sin embargo, es esencial experimentar con diferentes hiperparámetros (como el número de vecinos) y técnicas de validación cruzada para mejorar aún más el rendimiento del modelo.



Recursos Adicionales 


    Documentación de Scikit-Learn
    Algoritmo KNN Explicado
    Manejo de Datos Faltantes en Python
    Técnicas de Escalado de Características




¡Feliz Modelado! 🚀



Descargo de responsabilidad: Este artículo se basa en una transcripción de un tutorial en video y complementado con ejemplos de código de Jupyter Notebook y scripts de Python. Asegúrate de adaptar y modificar el código según tu conjunto de datos y requisitos específicos.