Guia Abrangente para Pré-processamento de Dados em Problemas de Classificação em Aprendizado de Máquina
Índice
- Introdução aos Problemas de Classificação
- Importação de Dados e Visão Geral
- Tratamento de Dados Ausentes
- Codificação de Variáveis Categóricas
- Seleção de Atributos
- Divisão de Treino e Teste
- Escalonamento de Atributos
- Conclusão
Introdução aos Problemas de Classificação
Classificação é uma técnica de aprendizado supervisionado usada para prever rótulos categóricos. Envolve atribuir dados de entrada a categorias pré-definidas com base em dados históricos. Os modelos de classificação variam desde algoritmos simples como Regressão Logística até os mais complexos como Florestas Aleatórias e Redes Neurais. O sucesso desses modelos depende não apenas do algoritmo escolhido, mas significativamente de como os dados são preparados e pré-processados.
Importação de Dados e Visão Geral
Antes de mergulhar no pré-processamento, é essencial entender e importar o conjunto de dados. Para este guia, usaremos o conjunto de dados WeatherAUS do Kaggle, que contém observações meteorológicas diárias em toda a Austrália.
|
1 2 3 4 5 6 7 8 9 |
# Importing necessary libraries import pandas as pd import seaborn as sns # Loading the dataset data = pd.read_csv('weatherAUS.csv') # Displaying the last five rows of the dataset data.tail() |
Saída:
|
1 2 3 4 5 6 7 8 |
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 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 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 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 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 NaN SE 28.0 SSE ... 24.0 1019.4 1016.5 3.0 2.0 15.1 26.0 No 0.0 No [5 rows x 24 columns] |
O conjunto de dados compreende várias características como temperatura, precipitação, umidade, velocidade do vento e mais, que são vitais para prever se vai chover amanhã (RainTomorrow).
Tratamento de Dados Ausentes
Conjuntos de dados do mundo real frequentemente contêm dados ausentes ou incompletos. Tratar essas lacunas é crucial para garantir a confiabilidade do modelo. Abordaremos os dados ausentes em duas categorias: Numéricos e Categóricos.
A. Dados Numéricos
Para atributos numéricos, uma estratégia comum é substituir os valores ausentes por medidas estatísticas como a média, mediana ou moda. Aqui, usaremos a média para imputar valores ausentes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import numpy as np from sklearn.impute import SimpleImputer # Identifying numerical columns numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0]) # Initializing the imputer with mean strategy imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') # Fitting the imputer on numerical columns imp_mean.fit(X.iloc[:, numerical_cols]) # Transforming the data X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols]) |
B. Dados Categóricos
Para atributos categóricos, o valor mais frequente (moda) é uma substituição adequada para dados ausentes.
|
1 2 3 4 5 6 7 8 9 10 11 |
# Identifying categorical columns string_cols = list(np.where((X.dtypes == np.object))[0]) # Initializing the imputer with most frequent strategy imp_mean = SimpleImputer(missing_values=np.nan, strategy='most_frequent') # Fitting the imputer on categorical columns imp_mean.fit(X.iloc[:, string_cols]) # Transforming the data X.iloc[:, string_cols] = imp_mean.transform(X.iloc[:, string_cols]) |
Codificação de Variáveis Categóricas
Modelos de aprendizado de máquina requerem entrada numérica. Portanto, é essencial converter variáveis categóricas em formatos numéricos. Podemos alcançar isso usando Codificação de Rótulos e Codificação One-Hot.
A. Codificação de Rótulos
Codificação de Rótulos atribui um número inteiro único a cada categoria única em um atributo. É simples, mas pode introduzir relações ordinais onde não existem.
|
1 2 3 4 5 6 7 8 |
from sklearn import preprocessing def LabelEncoderMethod(series): le = preprocessing.LabelEncoder() return le.fit_transform(series) # Encoding the target variable y = LabelEncoderMethod(y) |
B. Codificação One-Hot
Codificação One-Hot cria colunas binárias para cada categoria, eliminando relações ordinais e garantindo que cada categoria seja tratada distintamente.
|
1 2 3 4 5 6 |
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) |
Seleção de Codificação para Atributos
Dependendo do número de categorias únicas, é eficiente escolher entre Codificação de Rótulos e Codificação One-Hot.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
def EncodingSelection(X, threshold=10): # Step 1: Select the string columns string_cols = list(np.where((X.dtypes == np.object))[0]) one_hot_encoding_indices = [] # Step 2: Apply Label Encoding or mark for One-Hot Encoding based on category count 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) # Step 3: Apply One-Hot Encoding where necessary X = OneHotEncoderMethod(one_hot_encoding_indices, X) return X # Applying encoding selection X = EncodingSelection(X) |
Saída:
|
1 |
(142193, 23) |
Esta etapa reduz o espaço de atributos selecionando apenas os atributos codificados mais relevantes.
Seleção de Atributos
Nem todos os atributos contribuem igualmente para a tarefa de previsão. A seleção de atributos ajuda a identificar e reter os atributos mais informativos, melhorando o desempenho do modelo e reduzindo a sobrecarga computacional.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
from sklearn.feature_selection import SelectKBest, chi2 from sklearn import preprocessing # Initializing SelectKBest with chi-squared statistic kbest = SelectKBest(score_func=chi2, k=10) # Scaling features using MinMaxScaler before feature selection MMS = preprocessing.MinMaxScaler() x_temp = MMS.fit_transform(X) # Fitting SelectKBest x_temp = kbest.fit(x_temp, y) # Selecting top features based on scores best_features = np.argsort(x_temp.scores_)[-13:] features_to_delete = np.argsort(x_temp.scores_)[:-13] # Dropping the least important features X = np.delete(X, features_to_delete, axis=1) # Verifying the new shape print(X.shape) |
Saída:
|
1 |
(142193, 13) |
Este processo reduz o conjunto de atributos de 23 para 13, focando nos atributos mais impactantes para a nossa tarefa de classificação.
Divisão de Treino e Teste
Para avaliar o desempenho do nosso modelo de classificação, precisamos dividir o conjunto de dados em subconjuntos de treinamento e teste.
|
1 2 3 4 5 6 7 |
from sklearn.model_selection import train_test_split # Splitting the data: 80% training and 20% testing X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1) # Displaying the shape of training data print(X_train.shape) |
Saída:
|
1 |
(113754, 13) |
Escalonamento de Atributos
O escalonamento de atributos garante que todos os atributos contribuam igualmente para o resultado, especialmente importante para algoritmos sensíveis às magnitudes dos atributos como Máquinas de Vetores de Suporte ou K-Vizinhos Mais Próximos.
Padronização
Padronização reajusta os dados para terem uma média de zero e um desvio padrão de um.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from sklearn import preprocessing # Initializing the StandardScaler sc = preprocessing.StandardScaler(with_mean=False) # Fitting the scaler on training data sc.fit(X_train) # Transforming both training and testing data X_train = sc.transform(X_train) X_test = sc.transform(X_test) # Verifying the shape after scaling print(X_train.shape) print(X_test.shape) |
Saída:
|
1 2 |
(113754, 13) (28439, 13) |
Nota: O parâmetro with_mean=False é usado para evitar problemas com matrizes de dados esparsos resultantes da Codificação One-Hot.
Conclusão
O pré-processamento de dados é uma etapa crítica na construção de modelos de classificação robustos e precisos. Ao tratar meticulosamente dados ausentes, codificar variáveis categóricas, selecionar atributos relevantes e escalar, estabelecemos uma base sólida para qualquer modelo de aprendizado de máquina. Este guia forneceu uma abordagem prática usando Python e suas poderosas bibliotecas, garantindo que seus problemas de classificação estejam bem preparados para o treinamento e a avaliação do modelo. Lembre-se, o ditado “lixo entra, lixo sai” é verdadeiro no aprendizado de máquina; portanto, investir tempo no pré-processamento de dados traz dividendos no desempenho do modelo.
Palavras-chave: Problemas de Classificação, Pré-processamento de Dados, Aprendizado de Máquina, Limpeza de Dados, Seleção de Atributos, Codificação de Rótulos, Codificação One-Hot, Escalonamento de Atributos, Python, Pandas, Scikit-learn, Modelos de Classificação