Guia Abrangente para Preprocessamento de Dados e Construção de Modelos para Aprendizado de Máquina

Índice

Introdução
Importando e Explorando Dados
Tratamento de Dados Faltantes
- Dados Numéricos
- Dados Categóricos
Codificação de Variáveis Categóricas
Seleção de Atributos
Divisão Treino-Teste
Escalonamento de Atributos
- Padronização
- Normalização
Construção de Modelos de Regressão
Avaliação do Modelo
Conclusão

1. Introdução

O preprocessamento de dados é uma fase crítica no pipeline de aprendizado de máquina. Envolve a transformação de dados brutos em um formato adequado para modelagem, aumentando assim o desempenho e a precisão dos modelos preditivos. Este artigo ilustra o processo passo a passo de preprocessamento de dados e construção de modelos usando um conjunto de dados meteorológicos obtido do Kaggle.

2. Importando e Explorando Dados

Antes de mergulhar no preprocessamento, é essencial carregar e entender o conjunto de dados.

import pandas as pd
import seaborn as sns

# Load the dataset
data = pd.read_csv('weatherAUS.csv')

# Display the last five rows
print(data.tail())

import pandas as pd

import seaborn as sns

# Load the dataset

data = pd.read_csv('weatherAUS.csv')

# Display the last five rows

print(data.tail())

Exemplo de Saída:

        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

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

Entender a estrutura do conjunto de dados é crucial para um preprocessamento eficaz. Use .info() e .describe() para obter insights sobre os tipos de dados e resumos estatísticos.

3. Tratamento de Dados Faltantes

Dados faltantes podem distorcer os resultados da sua análise. É vital tratá-los adequadamente.

Dados Numéricos

Para colunas numéricas, valores faltantes podem ser imputados usando estratégias como média, mediana ou moda.

import numpy as np
from sklearn.impute import SimpleImputer

# Identify numerical columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])

# Initialize the imputer with a mean strategy
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Fit and transform the data
X.iloc[:, numerical_cols] = imp_mean.fit_transform(X.iloc[:, numerical_cols])

import numpy as np

from sklearn.impute import SimpleImputer

# Identify numerical columns

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

# Initialize the imputer with a mean strategy

imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Fit and transform the data

X.iloc[:, numerical_cols] = imp_mean.fit_transform(X.iloc[:, numerical_cols])

Dados Categóricos

Para colunas categóricas, valores faltantes podem ser imputados usando o valor mais frequente.

# Identify string columns
string_cols = list(np.where((X.dtypes == object))[0])

# Initialize the imputer with the most frequent strategy
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform the data
X.iloc[:, string_cols] = imp_freq.fit_transform(X.iloc[:, string_cols])

# Identify string columns

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

# Initialize the imputer with the most frequent strategy

imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform the data

X.iloc[:, string_cols] = imp_freq.fit_transform(X.iloc[:, string_cols])

4. Codificação de Variáveis Categóricas

Modelos de aprendizado de máquina requerem entrada numérica. Assim, variáveis categóricas precisam ser codificadas adequadamente.

Codificação de Rótulos

A Codificação de Rótulos transforma rótulos categóricos em valores numéricos. É adequada para categorias binárias ou dados ordinais.

from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    return le.fit_transform(series)

from sklearn import preprocessing

def LabelEncoderMethod(series):

le = preprocessing.LabelEncoder()

return le.fit_transform(series)

Codificação One-Hot

A Codificação One-Hot converte variáveis categóricas em uma matriz binária. É ideal para dados nominais com mais de duas categorias.

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)

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 com Base em Limite

Para simplificar o processo de codificação, você pode criar uma função que seleciona o método de codificação com base no número de categorias em cada coluna.

def EncodingSelection(X, threshold=10):
    # Select string columns
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    # Decide on encoding based on the number of unique categories
    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)
                
    # Apply One-Hot Encoding to selected columns
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

# Apply encoding selection
X = EncodingSelection(X)

def EncodingSelection(X, threshold=10):

# Select string columns

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

one_hot_encoding_indices = []

# Decide on encoding based on the number of unique categories

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)

# Apply One-Hot Encoding to selected columns

X = OneHotEncoderMethod(one_hot_encoding_indices, X)

return X

# Apply encoding selection

X = EncodingSelection(X)

5. Seleção de Atributos

A seleção de atributos envolve selecionar os atributos mais relevantes para a construção do modelo. Técnicas como análise de correlação, mapas de calor e métodos como SelectKBest podem ser empregadas para identificar atributos impactantes.

6. Divisão Treino-Teste

Dividir o conjunto de dados em conjuntos de treinamento e teste é essencial para avaliar o desempenho do modelo em dados não vistos.

from sklearn.model_selection import train_test_split

# Split the data
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: (164, 199)

from sklearn.model_selection import train_test_split

# Split the data

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: (164, 199)

7. Escalonamento de Atributos

O escalonamento de atributos garante que todos os atributos contribuam igualmente para o resultado. Ajuda a acelerar a convergência do gradiente descendente.

Padronização

A padronização transforma os dados para terem média zero e desvio padrão um.

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)

print(X_train.shape)
# Output: (164, 199)

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)

print(X_train.shape)

# Output: (164, 199)

Normalização

A normalização escala os dados para um intervalo fixo, tipicamente entre 0 e 1.

from sklearn.preprocessing import MinMaxScaler

min_max_scaler = MinMaxScaler()
X_train = min_max_scaler.fit_transform(X_train)
X_test = min_max_scaler.transform(X_test)

from sklearn.preprocessing import MinMaxScaler

min_max_scaler = MinMaxScaler()

X_train = min_max_scaler.fit_transform(X_train)

X_test = min_max_scaler.transform(X_test)

8. Construção de Modelos de Regressão

Uma vez que os dados estão pré-processados, diversos modelos de regressão podem ser construídos e avaliados. Abaixo estão implementações de vários algoritmos de regressão populares.

Regressão Linear

Um algoritmo fundamental que modela a relação entre a variável dependente e uma ou mais variáveis independentes.

from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

# Initialize and train the model
model = LinearRegression()
model.fit(X_train, y_train)

# Predict and evaluate
y_pred = model.predict(X_test)
score = r2_score(y_test, y_pred)
print(f"Linear Regression R2 Score: {score}")
# Output: 0.09741670577134398

from sklearn.linear_model import LinearRegression

from sklearn.metrics import r2_score

# Initialize and train the model

model = LinearRegression()

model.fit(X_train, y_train)

# Predict and evaluate

y_pred = model.predict(X_test)

score = r2_score(y_test, y_pred)

print(f"Linear Regression R2 Score: {score}")

# Output: 0.09741670577134398

Regressão Polinomial

Melhora o modelo linear adicionando termos polinomiais, capturando relações não lineares.

from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures

# Initialize polynomial features and linear regression
poly = PolynomialFeatures(degree=2)
X_train_poly = poly.fit_transform(X_train)
model = LinearRegression()

# Train and predict
model.fit(X_train_poly, y_train)
X_test_poly = poly.transform(X_test)
y_pred = model.predict(X_test_poly)
score = r2_score(y_test, y_pred)
print(f"Polynomial Regression R2 Score: {score}")
# Output: -0.4531422286977287

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import PolynomialFeatures

# Initialize polynomial features and linear regression

poly = PolynomialFeatures(degree=2)

X_train_poly = poly.fit_transform(X_train)

model = LinearRegression()

# Train and predict

model.fit(X_train_poly, y_train)

X_test_poly = poly.transform(X_test)

y_pred = model.predict(X_test_poly)

score = r2_score(y_test, y_pred)

print(f"Polynomial Regression R2 Score: {score}")

# Output: -0.4531422286977287

Nota: Um escore R² negativo indica um desempenho ruim do modelo.

Regressor de Árvore de Decisão

Um modelo não linear que divide os dados em subconjuntos com base nos valores dos atributos.

from sklearn.tree import DecisionTreeRegressor

# Initialize and train the model
model = DecisionTreeRegressor(max_depth=4)
model.fit(X_train, y_train)

# Predict and evaluate
y_pred = model.predict(X_test)
score = r2_score(y_test, y_pred)
print(f"Decision Tree Regressor R2 Score: {score}")
# Output: 0.883961900453219

from sklearn.tree import DecisionTreeRegressor

# Initialize and train the model

model = DecisionTreeRegressor(max_depth=4)

model.fit(X_train, y_train)

# Predict and evaluate

y_pred = model.predict(X_test)

score = r2_score(y_test, y_pred)

print(f"Decision Tree Regressor R2 Score: {score}")

# Output: 0.883961900453219

Regressor de Floresta Aleatória

Um método de ensemble que combina múltiplas árvores de decisão para melhorar o desempenho e reduzir o overfitting.

from sklearn.ensemble import RandomForestRegressor

# Initialize and train the model
model = RandomForestRegressor(n_estimators=25, random_state=10)
model.fit(X_train, y_train)

# Predict and evaluate
y_pred = model.predict(X_test)
score = r2_score(y_test, y_pred)
print(f"Random Forest Regressor R2 Score: {score}")
# Output: 0.9107611439295349

from sklearn.ensemble import RandomForestRegressor

# Initialize and train the model

model = RandomForestRegressor(n_estimators=25, random_state=10)

model.fit(X_train, y_train)

# Predict and evaluate

y_pred = model.predict(X_test)

score = r2_score(y_test, y_pred)

print(f"Random Forest Regressor R2 Score: {score}")

# Output: 0.9107611439295349

Regressor AdaBoost

Outra técnica de ensemble que combina aprendizes fracos para formar um preditor forte.

from sklearn.ensemble import AdaBoostRegressor

# Initialize and train the model
model = AdaBoostRegressor(random_state=0, n_estimators=100)
model.fit(X_train, y_train)

# Predict and evaluate
y_pred = model.predict(X_test)
score = r2_score(y_test, y_pred)
print(f"AdaBoost Regressor R2 Score: {score}")
# Output: 0.8806696893560713

from sklearn.ensemble import AdaBoostRegressor

# Initialize and train the model

model = AdaBoostRegressor(random_state=0, n_estimators=100)

model.fit(X_train, y_train)

# Predict and evaluate

y_pred = model.predict(X_test)

score = r2_score(y_test, y_pred)

print(f"AdaBoost Regressor R2 Score: {score}")

# Output: 0.8806696893560713

Regressor XGBoost

Uma poderosa estrutura de boosting de gradiente otimizada para velocidade e desempenho.

import xgboost as xgb

# Initialize and train the model
model = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)
model.fit(X_train, y_train)

# Predict and evaluate
y_pred = model.predict(X_test)
score = r2_score(y_test, y_pred)
print(f"XGBoost Regressor R2 Score: {score}")
# Output: 0.8947431439987505

import xgboost as xgb

# Initialize and train the model

model = xgb.XGBRegressor(

n_estimators=100,

reg_lambda=1,

gamma=0,

max_depth=3,

learning_rate=0.05

)

model.fit(X_train, y_train)

# Predict and evaluate

y_pred = model.predict(X_test)

score = r2_score(y_test, y_pred)

print(f"XGBoost Regressor R2 Score: {score}")

# Output: 0.8947431439987505

Regressor Máquina de Vetores de Suporte (SVM)

A SVM pode ser adaptada para tarefas de regressão, capturando relações complexas.

from sklearn.svm import SVR

# Initialize and train the model
model = SVR()
model.fit(X_train, y_train)

# Predict and evaluate
y_pred = model.predict(X_test)
score = r2_score(y_test, y_pred)
print(f"SVM Regressor R2 Score: {score}")
# Output: -0.02713944090388254

from sklearn.svm import SVR

# Initialize and train the model

model = SVR()

model.fit(X_train, y_train)

# Predict and evaluate

y_pred = model.predict(X_test)

score = r2_score(y_test, y_pred)

print(f"SVM Regressor R2 Score: {score}")

# Output: -0.02713944090388254

Nota: O escore R² negativo significa que o modelo está se desempenhando pior do que uma linha horizontal.

9. Avaliação do Modelo

O Escore R² é uma métrica comum para avaliar modelos de regressão. Indica a proporção da variância na variável dependente que é previsível a partir das variáveis independentes.

R² Positivo: O modelo explica uma parte da variância.
R² Negativo: O modelo falha em explicar a variância, desempenhando-se pior do que um modelo ingênuo baseado na média.

Neste guia, o Regressor de Floresta Aleatória obteve o maior escore R² de aproximadamente 0.91, indicando um desempenho forte nos dados de teste.

10. Conclusão

Um preprocessamento de dados eficaz estabelece a base para construir modelos robustos de aprendizado de máquina. Ao tratar meticulosamente os dados faltantes, selecionar técnicas de codificação apropriadas e escalar atributos, você aprimora a qualidade dos seus dados, levando a um desempenho melhorado do modelo. Entre os modelos de regressão explorados, métodos de ensemble como Floresta Aleatória e AdaBoost demonstraram capacidades preditivas superiores no conjunto de dados meteorológicos. Lembre-se sempre de avaliar seus modelos de forma abrangente e escolher aquele que melhor se alinha com os objetivos do seu projeto.

Abrace essas estratégias de preprocessamento e modelagem para desbloquear todo o potencial dos seus conjuntos de dados e impulsionar soluções de aprendizado de máquina impactantes.