html
Dominando Modelos de Classificação: Um Template Abrangente em Python para Ciência de Dados
Índice
- Introdução aos Modelos de Classificação
- Configurando o Seu Ambiente
- Importação e Exploração de Dados
- Tratamento de Dados Ausentes
- Codificação de Variáveis Categóricas
- Seleção de Características
- Divisão de Treino e Teste
- Escalonamento de Características
- Construção e Avaliação de Modelos
- Conclusão
1. Introdução aos Modelos de Classificação
Modelos de classificação são a pedra angular do aprendizado de máquina supervisionado, permitindo a previsão de rótulos discretos com base em características de entrada. Esses modelos são fundamentais em várias aplicações, desde detecção de spam em e-mails até diagnóstico médico. Dominar esses modelos envolve entender o pré-processamento de dados, engenharia de características, seleção de modelos e métricas de avaliação.
2. Configurando o Seu Ambiente
Antes de mergulhar na construção de modelos, certifique-se de que seu ambiente Python está equipado com as bibliotecas necessárias. Veja como você pode configurar seu ambiente:
|
|
# Install necessary libraries !pip install pandas seaborn scikit-learn xgboost |
Importe as bibliotecas essenciais:
|
|
import pandas as pd import seaborn as sns import numpy as np from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler, LabelEncoder, OneHotEncoder from sklearn.impute import SimpleImputer from sklearn.compose import ColumnTransformer from sklearn.feature_selection import SelectKBest, chi2 from sklearn.metrics import accuracy_score from sklearn.neighbors import KNeighborsClassifier from sklearn.linear_model import LogisticRegression from sklearn.naive_bayes import GaussianNB from sklearn.svm import SVC from sklearn.tree import DecisionTreeClassifier from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier import xgboost as xgb |
3. Importação e Exploração de Dados
Para este tutorial, usaremos o Conjunto de Dados do Tempo da Austrália do Kaggle. Este conjunto de dados abrangente fornece diversas características relacionadas ao clima que são ideais para construir modelos de classificação.
|
|
# Import data data = pd.read_csv('weatherAUS.csv') # Ensure the CSV file is in your working directory print(data.tail()) |
Saída de Exemplo:
|
|
Date Location MinTemp MaxTemp Rainfall Evaporation Sunshine WindGustDir WindGustSpeed WindDir9am ... Humidity3pm Pressure9am Pressure3pm Cloud9am Cloud3pm Temp9am Temp3pm RainToday RISK_MM RainTomorrow 142188 2017-06-20 Uluru 3.5 21.8 0.0 NaN E 31.0 ESE ... 27.0 1024.7 1021.2 NaN NaN 9.4 20.9 No 0.0 No 142189 2017-06-21 Uluru 2.8 23.4 0.0 NaN E 31.0 SE ... 24.0 1024.6 1020.3 NaN NaN 10.1 22.4 No 0.0 No 142190 2017-06-22 Uluru 3.6 25.3 0.0 NaN NNW 22.0 SE ... 21.0 1023.5 1019.1 NaN NaN 10.9 24.5 No 0.0 No 142191 2017-06-23 Uluru 5.4 26.9 0.0 NaN N 37.0 SE ... 24.0 1021.0 1016.8 NaN NaN 12.5 26.1 No 0.0 No 142192 2017-06-24 Uluru 7.8 27.0 0.0 NaN SE 28.0 SSE ... 24.0 1019.4 1016.5 3.0 2.0 15.1 26.0 No 0.0 No |
4. Tratamento de Dados Ausentes
A integridade dos dados é crucial para construir modelos confiáveis. Vamos abordar os valores ausentes tanto em características numéricas quanto categóricas.
Tratamento de Dados Numéricos Ausentes
Use o SimpleImputer do Scikit-learn para preencher valores numéricos ausentes com a média de cada coluna.
|
|
from sklearn.impute import SimpleImputer # Separate features and target X = data.iloc[:, :-1] # All columns except the last one y = data.iloc[:, -1] # Target column # Identify numeric columns numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns # Impute missing numeric values with mean imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols]) |
Tratamento de Dados Categóricos Ausentes
Para variáveis categóricas, preencha os valores ausentes com o valor mais frequente (moda).
|
|
# Identify categorical columns categorical_cols = X.select_dtypes(include=['object']).columns # Impute missing categorical values 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]) |
5. Codificação de Variáveis Categóricas
Modelos de aprendizado de máquina requerem entrada numérica. Portanto, variáveis categóricas precisam ser codificadas. Usaremos Codificação de Rótulo para categorias binárias e Codificação One-Hot para categorias multiclasse.
Codificação de Rótulo
|
|
from sklearn.preprocessing import LabelEncoder le = LabelEncoder() y = le.fit_transform(y) # Encoding the target variable |
Codificação One-Hot
Implemente um método para lidar com a codificação com base no número de categorias únicas.
|
|
from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder def one_hot_encode(columns, data): ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), columns)], remainder='passthrough') return ct.fit_transform(data) # Example usage: # X = one_hot_encode(['WindGustDir', 'WindDir9am'], X) |
Alternativamente, automatize o processo de codificação com base em limiares de categorias únicas.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
def encoding_selection(X, threshold=10): # Identify string columns string_cols = X.select_dtypes(include=['object']).columns one_hot_encoding_cols = [] for col in string_cols: unique_count = X[col].nunique() if unique_count == 2 or unique_count > threshold: X[col] = le.fit_transform(X[col]) else: one_hot_encoding_cols.append(col) if one_hot_encoding_cols: X = one_hot_encode(one_hot_encoding_cols, X) return X X = encoding_selection(X) |
6. Seleção de Características
Reduzir o número de características pode melhorar o desempenho do modelo e reduzir o custo computacional. Usaremos SelectKBest com o teste Qui-Quadrado para selecionar as principais características.
|
|
from sklearn.feature_selection import SelectKBest, chi2 from sklearn.preprocessing import MinMaxScaler # Scale features scaler = MinMaxScaler() X_scaled = scaler.fit_transform(X) # Select top K features k = 10 # You can adjust this based on your requirement selector = SelectKBest(score_func=chi2, k=k) X_selected = selector.fit_transform(X_scaled, y) # Get selected feature indices selected_indices = selector.get_support(indices=True) selected_features = X.columns[selected_indices] print("Selected Features:", selected_features) |
7. Divisão de Treino e Teste
Dividir o conjunto de dados em conjuntos de treino e teste é essencial para avaliar o desempenho do modelo em dados não vistos.
|
|
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1) print("Training set shape:", X_train.shape) print("Test set shape:", X_test.shape) |
Saída:
|
|
Training set shape: (113754, 10) Test set shape: (28439, 10) |
8. Escalonamento de Características
Padronizar as características garante que cada uma contribua igualmente para os cálculos de distância em algoritmos como KNN e SVM.
|
|
from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_train = scaler.fit_transform(X_train) X_test = scaler.transform(X_test) print("Scaled Training set shape:", X_train.shape) print("Scaled Test set shape:", X_test.shape) |
Saída:
|
|
Scaled Training set shape: (113754, 10) Scaled Test set shape: (28439, 10) |
9. Construção e Avaliação de Modelos
Com os dados pré-processados, podemos agora construir e avaliar vários modelos de classificação. Avaliaremos os modelos com base em suas pontuações de acurácia.
K-Nearest Neighbors (KNN)
|
|
from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score knn = KNeighborsClassifier(n_neighbors=3) knn.fit(X_train, y_train) y_pred = knn.predict(X_test) print("KNN Accuracy:", accuracy_score(y_test, y_pred)) |
Saída:
Regressão Logística
|
|
from sklearn.linear_model import LogisticRegression log_reg = LogisticRegression(random_state=0, max_iter=200) log_reg.fit(X_train, y_train) y_pred = log_reg.predict(X_test) print("Logistic Regression Accuracy:", accuracy_score(y_test, y_pred)) |
Saída:
|
|
Logistic Regression Accuracy: 0.99996 |
Gaussian Naive Bayes
|
|
from sklearn.naive_bayes import GaussianNB gnb = GaussianNB() gnb.fit(X_train, y_train) y_pred = gnb.predict(X_test) print("GaussianNB Accuracy:", accuracy_score(y_test, y_pred)) |
Saída:
|
|
GaussianNB Accuracy: 0.97437 |
Support Vector Machine (SVM)
|
|
from sklearn.svm import SVC svm = SVC() svm.fit(X_train, y_train) y_pred = svm.predict(X_test) print("SVM Accuracy:", accuracy_score(y_test, y_pred)) |
Saída:
Decision Tree Classifier
|
|
from sklearn.tree import DecisionTreeClassifier dtc = DecisionTreeClassifier() dtc.fit(X_train, y_train) y_pred = dtc.predict(X_test) print("Decision Tree Accuracy:", accuracy_score(y_test, y_pred)) |
Saída:
|
|
Decision Tree Accuracy: 1.0 |
Random Forest Classifier
|
|
from sklearn.ensemble import RandomForestClassifier rfc = RandomForestClassifier(n_estimators=500, max_depth=5) rfc.fit(X_train, y_train) y_pred = rfc.predict(X_test) print("Random Forest Accuracy:", accuracy_score(y_test, y_pred)) |
Saída:
|
|
Random Forest Accuracy: 1.0 |
AdaBoost Classifier
|
|
from sklearn.ensemble import AdaBoostClassifier abc = AdaBoostClassifier() abc.fit(X_train, y_train) y_pred = abc.predict(X_test) print("AdaBoost Accuracy:", accuracy_score(y_test, y_pred)) |
Saída:
XGBoost Classifier
|
|
import xgboost as xgb xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss') xgb_model.fit(X_train, y_train) y_pred = xgb_model.predict(X_test) print("XGBoost Accuracy:", accuracy_score(y_test, y_pred)) |
Saída:
Nota: O aviso referente à métrica de avaliação no XGBoost pode ser suprimido definindo explicitamente o parâmetro eval_metric, como mostrado acima.
10. Conclusão
Construir modelos de classificação não precisa ser assustador. Com uma abordagem estruturada para pré-processamento de dados, codificação, seleção de características e avaliação de modelos, você pode desenvolver de forma eficiente modelos robustos adaptados às suas necessidades específicas. O template mestre ilustrado neste artigo serve como um guia abrangente, agilizando o fluxo de trabalho desde a ingestão de dados até a avaliação do modelo. Seja você um iniciante ou um cientista de dados experiente, aproveitar tais templates pode aumentar a produtividade e o desempenho do modelo.
Principais Pontos:
- Pré-processamento de Dados: Limpe e prepare seus dados meticulosamente para garantir a precisão do modelo.
- Técnicas de Codificação: Codifique adequadamente as variáveis categóricas para se adequar a diferentes algoritmos.
- Seleção de Características: Utilize métodos de seleção de características para melhorar a eficiência e o desempenho do modelo.
- Diversidade de Modelos: Experimente com vários modelos para identificar o melhor desempenho para o seu conjunto de dados.
- Métricas de Avaliação: Vá além da acurácia; considere outras métricas como precisão, recall e F1-score para uma avaliação holística.
Abrace essas práticas e potencialize seus projetos de ciência de dados com clareza e precisão!
