Implementando Gaussian Naive Bayes en Python: Una Guía Completa
Tabla de Contenidos
- Introducción a Gaussian Naive Bayes
- Entendiendo el Conjunto de Datos
- Preprocesamiento de Datos
- Manejo de Datos Faltantes
- Codificación de Variables Categóricas
- Selección de Características
- Escalado de Características
- Implementación del Modelo
- K-Vecinos Más Cercanos (KNN)
- Regresión Logística
- Gaussian Naive Bayes
- Evaluación del Modelo
- Visualización de Límites de Decisión
- Ajuste de Hiperparámetros
- Conclusión
- Referencias
1. Introducción a Gaussian Naive Bayes
Gaussian Naive Bayes (GNB) es un algoritmo de clasificación probabilístico basado en el Teorema de Bayes, que asume que las características siguen una distribución normal. Es particularmente efectivo para datos continuos y ofrece simplicidad en la implementación con requerimientos computacionales relativamente bajos. A pesar de sus suposiciones simplistas, GNB a menudo ofrece un rendimiento notable, especialmente en tareas de clasificación de texto y diagnóstico médico.
Características Clave de Gaussian Naive Bayes:
- Modelo Probabilístico: Proporciona probabilidades para las predicciones.
- Suposición de Independencia de Características: Simplifica el cálculo al asumir la independencia de las características.
- Eficiencia: Fases de entrenamiento y predicción rápidas.
2. Entendiendo el Conjunto de Datos
Para nuestra implementación, utilizaremos dos conjuntos de datos:
- Conjunto de Datos de Flores Iris: Un conjunto de datos clásico en aprendizaje automático, que comprende 150 muestras de flores iris de tres especies diferentes (Setosa, Virginica y Versicolor). Cada muestra tiene cuatro características: longitud del sépalo, ancho del sépalo, longitud del pétalo y ancho del pétalo.
- Conjunto de Datos WeatherAUS: Obtenido de Kaggle, este conjunto de datos contiene datos meteorológicos de estaciones meteorológicas australianas, incluyendo características como temperatura, precipitaciones, humedad y velocidad del viento.
3. Preprocesamiento de Datos
Un preprocesamiento de datos efectivo es crucial para construir modelos de aprendizaje automático robustos. Recorreremos los pasos esenciales de preprocesamiento aplicados al conjunto de datos WeatherAUS.
a. Manejo de Datos Faltantes
Los datos faltantes pueden distorsionar los resultados de tu análisis. Empleamos dos estrategias para manejar los valores faltantes:
- Características Numéricas: Imputadas utilizando la estrategia de la media.
- Características Categóricas: Imputadas utilizando la estrategia de la más frecuente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import numpy as np import pandas as pd from sklearn.impute import SimpleImputer # Load the dataset data = pd.read_csv('weatherAUS.csv') # Separate features and target X = data.iloc[:, :-1] y = data.iloc[:, -1] # Identify numerical and categorical columns numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns categorical_cols = X.select_dtypes(include=['object']).columns # Impute numerical features with mean imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols]) # Impute categorical features with the most frequent value imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent') X[categorical_cols] = imp_freq.fit_transform(X[categorical_cols]) |
b. Codificación de Variables Categóricas
Los algoritmos de aprendizaje automático requieren entrada numérica. Aplicamos Codificación de Etiquetas y Codificación One-Hot para transformar variables categóricas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
from sklearn.preprocessing import LabelEncoder, OneHotEncoder from sklearn.compose import ColumnTransformer # Label Encoding for binary categorical variables le = LabelEncoder() y = le.fit_transform(y) # Function for encoding def EncodingSelection(X, threshold=10): string_cols = list(X.select_dtypes(include=['object']).columns) one_hot_encoding_cols = [] for col in string_cols: unique_vals = len(X[col].unique()) if unique_vals == 2 or unique_vals > threshold: X[col] = le.fit_transform(X[col]) else: one_hot_encoding_cols.append(col) # One-Hot Encoding for remaining categorical variables if one_hot_encoding_cols: ct = ColumnTransformer([('encoder', OneHotEncoder(), one_hot_encoding_cols)], remainder='passthrough') X = ct.fit_transform(X) return X X = EncodingSelection(X) |
c. Selección de Características
Para mejorar el rendimiento del modelo y reducir el costo computacional, seleccionamos las características más relevantes usando el método SelectKBest con la función de puntaje Chi-Cuadrado.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sklearn.feature_selection import SelectKBest, chi2 from sklearn.preprocessing import MinMaxScaler # Scale features scaler = MinMaxScaler() X_scaled = scaler.fit_transform(X) # Select top 2 features kbest = SelectKBest(score_func=chi2, k=2) X_selected = kbest.fit_transform(X_scaled, y) print(f"Selected Features Shape: {X_selected.shape}") |
d. Escalado de Características
Estandarizar las características asegura que cada característica contribuya de manera equitativa al resultado, lo cual es especialmente importante para algoritmos basados en distancia como KNN.
|
1 2 3 4 |
from sklearn.preprocessing import StandardScaler scaler = StandardScaler(with_mean=False) X_scaled = scaler.fit_transform(X_selected) |
4. Implementación del Modelo
Implementaremos tres modelos de clasificación: K-Vecinos Más Cercanos (KNN), Regresión Logística y Gaussian Naive Bayes.
a. K-Vecinos Más Cercanos (KNN)
KNN clasifica un punto de datos basándose en la etiqueta mayoritaria de sus vecinos más cercanos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split # Split the dataset X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.20, random_state=1) # Initialize and train KNN knn = KNeighborsClassifier(n_neighbors=3) knn.fit(X_train, y_train) # Predict and evaluate y_pred_knn = knn.predict(X_test) knn_accuracy = accuracy_score(y_pred_knn, y_test) print(f"KNN Accuracy: {knn_accuracy:.2f}") |
|
1 |
KNN Accuracy: 0.80 |
b. Regresión Logística
La Regresión Logística modela la probabilidad de una variable dependiente categórica.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn.linear_model import LogisticRegression # Initialize and train Logistic Regression lr = LogisticRegression(random_state=0, max_iter=200) lr.fit(X_train, y_train) # Predict and evaluate y_pred_lr = lr.predict(X_test) lr_accuracy = accuracy_score(y_pred_lr, y_test) print(f"Logistic Regression Accuracy: {lr_accuracy:.2f}") |
|
1 |
Logistic Regression Accuracy: 0.83 |
c. Gaussian Naive Bayes
GaussianNB asume que los valores continuos asociados con cada clase están distribuidos normalmente.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn.naive_bayes import GaussianNB # Initialize and train GaussianNB gnb = GaussianNB() gnb.fit(X_train, y_train) # Predict and evaluate y_pred_gnb = gnb.predict(X_test) gnb_accuracy = accuracy_score(y_pred_gnb, y_test) print(f"Gaussian Naive Bayes Accuracy: {gnb_accuracy:.2f}") |
|
1 |
Gaussian Naive Bayes Accuracy: 0.80 |
5. Evaluación del Modelo
La evaluación del modelo es esencial para entender qué tan bien tus modelos se desempeñan con datos no vistos. Utilizamos el Score de Precisión como nuestra métrica principal.
| Modelo | Precisión |
|---|---|
| K-Vecinos Más Cercanos (KNN) | 80% |
| Regresión Logística | 83% |
| Gaussian Naive Bayes | 80% |
Entre los modelos probados, Regresión Logística supera a KNN y Gaussian Naive Bayes en este conjunto de datos, destacando la importancia de la selección del modelo basada en las características de los datos.
6. Visualización de Límites de Decisión
Visualizar los límites de decisión ayuda a entender cómo diferentes clasificadores separan los datos. Utilizaremos el conjunto de datos de Flores Iris para este propósito.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
from mlxtend.plotting import plot_decision_regions import matplotlib.pyplot as plt from sklearn import datasets def visualize_decision_regions(X, y, model): plot_decision_regions(X, y, clf=model) plt.xlabel('Feature 1') plt.ylabel('Feature 2') plt.title(f'Decision Boundary for {model.__class__.__name__}') plt.show() # Load Iris dataset iris = datasets.load_iris() X_iris = iris.data[:, :2] # First two features y_iris = iris.target # Initialize classifiers knn_iris = KNeighborsClassifier(n_neighbors=3) knn_iris.fit(X_iris, y_iris) lr_iris = LogisticRegression(random_state=0, max_iter=200) lr_iris.fit(X_iris, y_iris) gnb_iris = GaussianNB() gnb_iris.fit(X_iris, y_iris) # Visualize decision boundaries visualize_decision_regions(X_iris, y_iris, knn_iris) visualize_decision_regions(X_iris, y_iris, lr_iris) visualize_decision_regions(X_iris, y_iris, gnb_iris) |
- K-Vecinos Más Cercanos (KNN): Captura límites más complejos basados en la proximidad.
- Regresión Logística: Límites de decisión lineales.
- Gaussian Naive Bayes: Límites curvos debido a las suposiciones probabilísticas.
7. Ajuste de Hiperparámetros
Mientras que nuestros experimentos iniciales proporcionan un buen punto de partida, afinar los hiperparámetros puede mejorar aún más el rendimiento del modelo. Técnicas como Búsqueda de Grid y Búsqueda Aleatoria pueden emplearse para encontrar el conjunto óptimo de hiperparámetros para cada clasificador.
|
1 2 3 4 5 6 7 8 9 |
from sklearn.model_selection import GridSearchCV # Example: Hyperparameter tuning for KNN param_grid = {'n_neighbors': range(1, 10)} grid_knn = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5) grid_knn.fit(X_train, y_train) print(f"Best KNN Parameters: {grid_knn.best_params_}") print(f"Best KNN Accuracy: {grid_knn.best_score_:.2f}") |
8. Conclusión
Implementar Gaussian Naive Bayes en Python es directo, gracias a bibliotecas como scikit-learn. A pesar de su simplicidad, GNB ofrece un rendimiento competitivo, lo que lo convierte en una herramienta valiosa en el arsenal de aprendizaje automático. Sin embargo, como se demostró, el rendimiento del modelo depende de la naturaleza del conjunto de datos. La Regresión Logística, por ejemplo, superó a GNB y KNN en nuestros experimentos con el conjunto de datos WeatherAUS.
Principales Conclusiones:
- Preprocesamiento de Datos: Manejar datos faltantes y codificar variables categóricas son pasos críticos.
- Selección de Características: Seleccionar características relevantes puede mejorar el rendimiento del modelo y reducir la carga computacional.
- Selección de Modelo: Siempre experimenta con múltiples modelos para identificar el mejor desempeño para tu conjunto de datos específico.
- Visualización: Entender los límites de decisión proporciona insights sobre cómo los modelos segregan los datos.
Siguiendo los pasos delineados en esta guía, puedes implementar y evaluar efectivamente Gaussian Naive Bayes junto con otros algoritmos de clasificación para tomar decisiones informadas en tus proyectos de aprendizaje automático.