Implementando Gaussian Naive Bayes em Python: Um Guia Abrangente
Índice
- Introdução ao Gaussian Naive Bayes
- Entendendo o Conjunto de Dados
- Pré-processamento de Dados
- Tratamento de Dados Faltantes
- Codificação de Variáveis Categóricas
- Seleção de Características
- Escalonamento de Características
- Implementação do Modelo
- K-Nearest Neighbors (KNN)
- Regressão Logística
- Gaussian Naive Bayes
- Avaliação do Modelo
- Visualização de Fronteiras de Decisão
- Ajuste de Hiperparâmetros
- Conclusão
- Referências
1. Introdução ao Gaussian Naive Bayes
Gaussian Naive Bayes (GNB) é um algoritmo de classificação probabilística baseado no Teorema de Bayes, assumindo que as características seguem uma distribuição normal. É particularmente eficaz para dados contínuos e oferece simplicidade na implementação com requisitos computacionais relativamente baixos. Apesar de suas suposições simplistas, o GNB frequentemente apresenta um desempenho notavelmente bom, especialmente em tarefas de classificação de texto e diagnóstico médico.
Principais Características do Gaussian Naive Bayes:
- Modelo Probabilístico: Fornece probabilidades para as previsões.
- Assunção de Independência das Características: Simplifica o cálculo ao assumir independência entre as características.
- Eficiência: Fases de treinamento e previsão rápidas.
2. Entendendo o Conjunto de Dados
Para nossa implementação, utilizaremos dois conjuntos de dados:
- Conjunto de Dados de Flores Iris: Um conjunto de dados clássico em aprendizado de máquina, composto por 150 amostras de flores de íris de três espécies diferentes (Setosa, Virginica e Versicolor). Cada amostra possui quatro características: comprimento da sépala, largura da sépala, comprimento da pétala e largura da pétala.
- Conjunto de Dados WeatherAUS: Obtido de Kaggle, este conjunto de dados contém dados meteorológicos de estações de tempo australianas, incluindo características como temperatura, precipitação, umidade e velocidade do vento.
3. Pré-processamento de Dados
Um pré-processamento eficaz dos dados é crucial para a construção de modelos de aprendizado de máquina robustos. Vamos percorrer as etapas essenciais de pré-processamento aplicadas ao conjunto de dados WeatherAUS.
a. Tratamento de Dados Faltantes
Dados faltantes podem distorcer os resultados da sua análise. Utilizamos duas estratégias para lidar com valores ausentes:
- Características Numéricas: Imputadas usando a estratégia da média.
- Características Categóricas: Imputadas usando a estratégia mais frequente.
|
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. Codificação de Variáveis Categóricas
Algoritmos de aprendizado de máquina requerem entrada numérica. Aplicamos Label Encoding e One-Hot Encoding para transformar variáveis 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. Seleção de Características
Para melhorar o desempenho do modelo e reduzir o custo computacional, selecionamos as características mais relevantes usando o método SelectKBest com a função de pontuação Qui-Quadrado.
|
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. Escalonamento de Características
Padronizar as características garante que cada uma contribua igualmente para o resultado, o que é especialmente importante para algoritmos baseados em distância como o KNN.
|
1 2 3 4 |
from sklearn.preprocessing import StandardScaler scaler = StandardScaler(with_mean=False) X_scaled = scaler.fit_transform(X_selected) |
4. Implementação do Modelo
Implementaremos três modelos de classificação: K-Nearest Neighbors (KNN), Regressão Logística e Gaussian Naive Bayes.
a. K-Nearest Neighbors (KNN)
O KNN classifica um ponto de dados com base na maioria das etiquetas de seus vizinhos mais próximos.
|
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. Regressão Logística
A Regressão Logística modela a probabilidade de uma variável dependente 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
O GaussianNB assume que os valores contínuos associados a cada classe são distribuídos 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. Avaliação do Modelo
A avaliação do modelo é essencial para entender quão bem seus modelos performam em dados não vistos. Utilizamos a Precisão (Accuracy Score) como nossa métrica principal.
| Modelo | Precisão |
|---|---|
| K-Nearest Neighbors (KNN) | 80% |
| Regressão Logística | 83% |
| Gaussian Naive Bayes | 80% |
Entre os modelos testados, a Regressão Logística supera o KNN e o Gaussian Naive Bayes neste conjunto de dados, destacando a importância da seleção do modelo com base nas características dos dados.
6. Visualização de Fronteiras de Decisão
Visualizar as fronteiras de decisão ajuda a entender como diferentes classificadores separam os dados. Utilizaremos o conjunto de dados 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-Nearest Neighbors (KNN): Captura fronteiras mais complexas baseadas na proximidade.
- Regressão Logística: Fronteiras de decisão lineares.
- Gaussian Naive Bayes: Fronteiras curvas devido às suposições probabilísticas.
7. Ajuste de Hiperparâmetros
Embora nossos experimentos iniciais forneçam um bom ponto de partida, o ajuste fino dos hiperparâmetros pode ainda mais aprimorar o desempenho do modelo. Técnicas como Grid Search e Random Search podem ser empregadas para encontrar o conjunto ótimo de hiperparâmetros para cada classificador.
|
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. Conclusão
Implementar Gaussian Naive Bayes em Python é direto, graças a bibliotecas como o scikit-learn. Apesar de sua simplicidade, o GNB oferece um desempenho competitivo, tornando-se uma ferramenta valiosa no arsenal de aprendizado de máquina. No entanto, como demonstrado, o desempenho do modelo depende da natureza do conjunto de dados. A Regressão Logística, por exemplo, superou o GNB e o KNN em nossos experimentos com o conjunto de dados WeatherAUS.
Principais Aprendizados:
- Pré-processamento de Dados: Tratar dados faltantes e codificar variáveis categóricas são passos críticos.
- Seleção de Características: Selecionar características relevantes pode melhorar o desempenho do modelo e reduzir a sobrecarga computacional.
- Seleção de Modelo: Sempre experimente múltiplos modelos para identificar o melhor desempenhador para seu conjunto de dados específico.
- Visualização: Entender as fronteiras de decisão fornece insights sobre como os modelos segregam os dados.
Seguindo os passos delineados neste guia, você pode implementar e avaliar efetivamente o Gaussian Naive Bayes juntamente com outros algoritmos de classificação para tomar decisões informadas em seus projetos de aprendizado de máquina.