Implementação da Validação Cruzada K-Fold para Previsão de Preços de Carros Sem GridSearchCV

Índice

Introdução
Visão Geral do Conjunto de Dados
Pré-processamento de Dados
1. Tratamento de Dados Faltantes
2. Seleção de Atributos
Engenharia de Atributos
1. Codificação de Variáveis Categóricas
2. Escalonamento de Atributos
Construção de Modelos de Regressão
Implementação da Validação Cruzada K-Fold
Avaliação do Desempenho do Modelo
Conclusão

Introdução

Prever preços de carros é um problema clássico de regressão que envolve a previsão do preço de um veículo com base em várias características, como tamanho do motor, potência, tipo de combustível e muito mais. Implementar a Validação Cruzada K-Fold aumenta a confiabilidade do nosso modelo, garantindo que ele generalize bem para dados não vistos. Este artigo demonstra como pré-processar dados, criar atributos, construir vários modelos de regressão e avaliar seu desempenho usando a Validação Cruzada K-Fold em Python.

Visão Geral do Conjunto de Dados

Utilizaremos o conjunto de dados Previsão de Preços de Carros do Kaggle, que contém especificações detalhadas de diferentes modelos de carros juntamente com seus preços. O conjunto de dados inclui atributos como symboling, CarName, fueltype, aspiration, doornumber, carbody, entre muitos outros que influenciam o preço do carro.

Pré-processamento de Dados

O pré-processamento eficaz de dados é essencial para preparar o conjunto de dados para a modelagem. Isso envolve o tratamento de valores faltantes, a codificação de variáveis categóricas e a seleção de atributos relevantes.

Tratamento de Dados Faltantes

Dados Numéricos

Valores faltantes em atributos numéricos podem ser tratados usando medidas estatísticas. Utilizaremos a estratégia da média para imputar valores faltantes em colunas numéricas.

import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer

# Load the dataset
data = pd.read_csv('CarPrice.csv')
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Identify numerical columns
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns

# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])

import numpy as np

import pandas as pd

from sklearn.impute import SimpleImputer

# Load the dataset

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

X = data.iloc[:, :-1]

y = data.iloc[:, -1]

# Identify numerical columns

numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns

# Impute missing values with mean

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

X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])

Dados Categóricos

Para atributos categóricos, a estratégia do valor mais frequente é eficaz na imputação de valores faltantes.

from sklearn.impute import SimpleImputer

# Identify categorical columns
string_cols = X.select_dtypes(include=['object']).columns

# Impute missing values with the most frequent value
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_freq.fit_transform(X[string_cols])

from sklearn.impute import SimpleImputer

# Identify categorical columns

string_cols = X.select_dtypes(include=['object']).columns

# Impute missing values with the most frequent value

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

X[string_cols] = imp_freq.fit_transform(X[string_cols])

Seleção de Atributos

Selecionar atributos relevantes ajuda a reduzir a complexidade do modelo e a melhorar seu desempenho.

# Drop the 'car_ID' column as it does not contribute to price prediction
X.drop('car_ID', axis=1, inplace=True)

1 2	# Drop the 'car_ID' column as it does not contribute to price prediction X.drop('car_ID', axis=1, inplace=True)

Engenharia de Atributos

A engenharia de atributos envolve transformar dados brutos em atributos significativos que melhor representam o problema subjacente para os modelos preditivos.

Codificação de Variáveis Categóricas

Algoritmos de aprendizado de máquina requerem entrada numérica, então variáveis categóricas precisam ser codificadas. Utilizaremos a Codificação One-Hot para converter variáveis categóricas em uma matriz binária.

from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer

# Identify categorical columns by their indices
string_cols = list(np.where((X.dtypes == object))[0])

# Apply One-Hot Encoding
columnTransformer = ColumnTransformer(
    [('encoder', OneHotEncoder(), string_cols)],
    remainder='passthrough'
)
X = columnTransformer.fit_transform(X)

from sklearn.preprocessing import OneHotEncoder

from sklearn.compose import ColumnTransformer

# Identify categorical columns by their indices

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

# Apply One-Hot Encoding

columnTransformer = ColumnTransformer(

[('encoder', OneHotEncoder(), string_cols)],

remainder='passthrough'

)

X = columnTransformer.fit_transform(X)

Escalonamento de Atributos

O escalonamento garante que cada atributo contribua igualmente para o resultado, aprimorando o desempenho de certos algoritmos.

from sklearn.preprocessing import StandardScaler

# Initialize the StandardScaler
sc = StandardScaler(with_mean=False)

# Fit and transform the training data
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)

from sklearn.preprocessing import StandardScaler

# Initialize the StandardScaler

sc = StandardScaler(with_mean=False)

# Fit and transform the training data

sc.fit(X_train)

X_train = sc.transform(X_train)

X_test = sc.transform(X_test)

Construção de Modelos de Regressão

Construiremos e avaliaremos cinco modelos de regressão diferentes para prever preços de carros:

Regressor de Árvore de Decisão
Regressor de Floresta Aleatória
Regressor AdaBoost
Regressor XGBoost
Regressor de Vetor de Suporte (SVR)

Regressor de Árvore de Decisão

Um Regressor de Árvore de Decisão divide os dados em subconjuntos com base nos valores dos atributos, tornando-o fácil de interpretar.

from sklearn.tree import DecisionTreeRegressor

# Initialize the model
decisionTreeRegressor = DecisionTreeRegressor(max_depth=4)

from sklearn.tree import DecisionTreeRegressor

# Initialize the model

decisionTreeRegressor = DecisionTreeRegressor(max_depth=4)

Regressor de Floresta Aleatória

A Floresta Aleatória agrega as previsões de múltiplas Árvores de Decisão, reduzindo o sobreajuste e melhorando a precisão.

from sklearn.ensemble import RandomForestRegressor

# Initialize the model
randomForestRegressor = RandomForestRegressor(n_estimators=25, random_state=10)

from sklearn.ensemble import RandomForestRegressor

# Initialize the model

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

Regressor AdaBoost

O AdaBoost combina múltiplos aprendizes fracos para criar um modelo preditivo forte, focando em instâncias que foram previamente mal previstas.

from sklearn.ensemble import AdaBoostRegressor

# Initialize the model
adaBoostRegressor = AdaBoostRegressor(random_state=0, n_estimators=100)

from sklearn.ensemble import AdaBoostRegressor

# Initialize the model

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

Regressor XGBoost

O XGBoost é uma biblioteca otimizada de boosting de gradiente distribuído, projetada para desempenho e velocidade.

import xgboost as xgb

# Initialize the model
xgbRegressor = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)

import xgboost as xgb

# Initialize the model

xgbRegressor = xgb.XGBRegressor(

n_estimators=100,

reg_lambda=1,

gamma=0,

max_depth=3,

learning_rate=0.05

)

Regressor de Vetor de Suporte (SVR)

O SVR utiliza os princípios das Máquinas de Vetores de Suporte para tarefas de regressão, sendo eficaz em espaços de alta dimensão.

from sklearn.svm import SVR

# Initialize the model
svr = SVR()

from sklearn.svm import SVR

# Initialize the model

svr = SVR()

Implementação da Validação Cruzada K-Fold

A Validação Cruzada K-Fold particiona o conjunto de dados em k subconjuntos e, iterativamente, treina e valida o modelo k vezes, cada vez usando um subconjunto diferente como conjunto de validação.

from sklearn.model_selection import KFold
from sklearn.metrics import r2_score

# Define the K-Fold Cross Validator
kf = KFold(n_splits=10, random_state=42, shuffle=True)

# Function to build and evaluate the model
def build_model(X_train, X_test, y_train, y_test, model):
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    return r2_score(y_test, y_pred)

from sklearn.model_selection import KFold

from sklearn.metrics import r2_score

# Define the K-Fold Cross Validator

kf = KFold(n_splits=10, random_state=42, shuffle=True)

# Function to build and evaluate the model

def build_model(X_train, X_test, y_train, y_test, model):

model.fit(X_train, y_train)

y_pred = model.predict(X_test)

return r2_score(y_test, y_pred)

Executando a Validação Cruzada K-Fold

Avaliaremos o desempenho de cada modelo através dos K-Folds e calcularemos a média da pontuação R².

# Initialize score lists
decisionTreeRegressor_scores = []
randomForestRegressor_scores = []
adaBoostRegressor_scores = []
xgbRegressor_scores = []
svr_scores = []

# Perform K-Fold Cross-Validation
for train_index, test_index in kf.split(X):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    
    # Decision Tree
    decisionTreeRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, decisionTreeRegressor)
    )
    
    # Random Forest
    randomForestRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, randomForestRegressor)
    )
    
    # AdaBoost
    adaBoostRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, adaBoostRegressor)
    )
    
    # XGBoost
    xgbRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, xgbRegressor)
    )
    
    # SVR
    svr_scores.append(
        build_model(X_train, X_test, y_train, y_test, svr)
    )

# Initialize score lists

decisionTreeRegressor_scores = []

randomForestRegressor_scores = []

adaBoostRegressor_scores = []

xgbRegressor_scores = []

svr_scores = []

# Perform K-Fold Cross-Validation

for train_index, test_index in kf.split(X):

X_train, X_test = X[train_index], X[test_index]

y_train, y_test = y[train_index], y[test_index]

# Decision Tree

decisionTreeRegressor_scores.append(

build_model(X_train, X_test, y_train, y_test, decisionTreeRegressor)

)

# Random Forest

randomForestRegressor_scores.append(

build_model(X_train, X_test, y_train, y_test, randomForestRegressor)

)

# AdaBoost

adaBoostRegressor_scores.append(

build_model(X_train, X_test, y_train, y_test, adaBoostRegressor)

)

# XGBoost

xgbRegressor_scores.append(

build_model(X_train, X_test, y_train, y_test, xgbRegressor)

)

# SVR

svr_scores.append(

build_model(X_train, X_test, y_train, y_test, svr)

)

Avaliação do Desempenho do Modelo

Após executar a Validação Cruzada K-Fold, calcularemos a média da pontuação R² para cada modelo a fim de avaliar seu desempenho.

from statistics import mean

print('Decision Tree Regressor Mean R² Score: ', mean(decisionTreeRegressor_scores))
print('Random Forest Regressor Mean R² Score: ', mean(randomForestRegressor_scores))
print('AdaBoost Regressor Mean R² Score: ', mean(adaBoostRegressor_scores))
print('XGBoost Regressor Mean R² Score: ', mean(xgbRegressor_scores))
print('SVR Mean R² Score: ', mean(svr_scores))

from statistics import mean

print('Decision Tree Regressor Mean R² Score: ', mean(decisionTreeRegressor_scores))

print('Random Forest Regressor Mean R² Score: ', mean(randomForestRegressor_scores))

print('AdaBoost Regressor Mean R² Score: ', mean(adaBoostRegressor_scores))

print('XGBoost Regressor Mean R² Score: ', mean(xgbRegressor_scores))

print('SVR Mean R² Score: ', mean(svr_scores))

Saída de Amostra:

Decision Tree Regressor Mean R² Score:  0.8786768422448108
Random Forest Regressor Mean R² Score:  0.9070724684428952
AdaBoost Regressor Mean R² Score:  0.894756851083693
XGBoost Regressor Mean R² Score:  0.9049838393114154
SVR Mean R² Score:  -0.1510507928400266

Decision Tree Regressor Mean R² Score: 0.8786768422448108

Random Forest Regressor Mean R² Score: 0.9070724684428952

AdaBoost Regressor Mean R² Score: 0.894756851083693

XGBoost Regressor Mean R² Score: 0.9049838393114154

SVR Mean R² Score: -0.1510507928400266

Interpretação:

Regressor de Floresta Aleatória apresenta a maior média da pontuação R², indicando o melhor desempenho entre os modelos testados.
SVR obtém uma pontuação R² negativa, sugerindo um desempenho ruim neste conjunto de dados, possivelmente devido à sua incapacidade de capturar os padrões subjacentes de forma eficaz sem a ajuste de hiperparâmetros.

Conclusão

Implementar a Validação Cruzada K-Fold proporciona um método robusto para avaliar o desempenho de modelos de regressão, garantindo que os resultados sejam generalizáveis e não dependam de uma divisão específica entre treinamento e teste. Neste guia, demonstramos como pré-processar dados, codificar variáveis categóricas, escalar atributos, construir múltiplos modelos de regressão e avaliar seu desempenho usando a Validação Cruzada K-Fold sem o GridSearchCV.

Principais Pontos:

Pré-processamento de Dados: O correto tratamento de dados faltantes e a seleção de atributos são cruciais para o desempenho do modelo.
Engenharia de Atributos: A codificação de variáveis categóricas e o escalonamento de atributos podem impactar significativamente a capacidade do modelo de aprender padrões.
Avaliação do Modelo: A Validação Cruzada K-Fold oferece uma maneira confiável de avaliar quão bem seu modelo generaliza para dados não vistos.
Seleção de Modelo: Entre os modelos testados, métodos de conjunto como Floresta Aleatória e XGBoost superam modelos mais simples como Árvores de Decisão e SVR neste caso específico.

Para uma otimização adicional, integrar técnicas de ajuste de hiperparâmetros como GridSearchCV ou RandomizedSearchCV pode melhorar o desempenho do modelo ao encontrar o melhor conjunto de parâmetros para cada algoritmo.

—

Seguindo esta abordagem estruturada, você pode implementar efetivamente a Validação Cruzada K-Fold para várias tarefas de regressão, garantindo que seus modelos sejam precisos e robustos.