Dominando a Previsão de Preços de Carros com Modelos de Regressão Avançados: Um Guia Abrangente
Índice
- Introdução
- Visão Geral do Conjunto de Dados
- Importação de Dados e Exploração Inicial
- Limpeza e Pré-processamento de Dados
- Seleção e Codificação de Características
- Divisão de Treino e Teste
- Escalonamento de Características
- Construção e Avaliação de Modelos de Regressão
- Comparação de Desempenho dos Modelos
- Conclusão
Introdução
A análise preditiva capacita as empresas a antecipar tendências futuras, otimizar operações e aprimorar processos de tomada de decisão. Previsão de preços de carros é um exemplo clássico onde modelos de machine learning podem prever os preços de veículos com base em atributos como marca, especificações do motor, tipo de combustível e mais. Este guia acompanha você na construção de um pipeline abrangente de modelos de regressão, desde o pré-processamento de dados até a avaliação de múltiplos algoritmos de regressão.
Visão Geral do Conjunto de Dados
O Conjunto de Dados de Previsão de Preços de Carros no Kaggle é um recurso rico contendo 205 entradas com 26 características cada. Essas características abrangem vários aspectos dos carros, como número de portas, tamanho do motor, potência, tipo de combustível e mais, todos os quais influenciam o preço de mercado do carro.
Características Principais:
CarName: Nome do carro (marca e modelo)FuelType: Tipo de combustível usado (por exemplo, gasolina, diesel)Aspiration: Tipo de aspiração do motorDoornumber: Número de portas (duas ou quatro)Enginesize: Tamanho do motorHorsepower: Potência do motorPrice: Preço de mercado do carro (variável alvo)
Importação de Dados e Exploração Inicial
Primeiro, importamos o conjunto de dados usando pandas e damos uma olhada preliminar na estrutura dos dados.
|
1 2 3 4 5 6 7 |
import pandas as pd # Load the dataset data = pd.read_csv('CarPrice.csv') # Display the first five rows print(data.head()) |
Exemplo de Saída:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
car_ID symboling CarName fueltype aspiration doornumber \ 0 1 3 alfa-romero giulia gas std two 1 2 3 alfa-romero stelvio gas std two 2 3 1 alfa-romero Quadrifoglio gas std two 3 4 2 audi 100 ls gas std four 4 5 2 audi 100ls gas std four carbody drivewheel enginelocation wheelbase ... horsepower peakrpm citympg \ 0 convertible rwd front 88.6 ... 111.0 5000 21 1 convertible rwd front 88.6 ... 111.0 5000 21 2 hatchback rwd front 94.5 ... 154.0 5000 19 3 sedan fwd front 99.8 ... 102.0 5500 24 4 sedan 4wd front 99.4 ... 115.0 5500 18 highwaympg price 0 27 13495.0 1 27 16500.0 2 26 16500.0 3 30 13950.0 4 22 17450.0 |
Limpeza e Pré-processamento de Dados
Tratamento de Dados Numéricos Faltantes
Valores ausentes podem distorcer significativamente o desempenho dos modelos de machine learning. Primeiro, tratamos os dados numéricos faltantes imputando com o valor médio.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
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 imputer imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') imp_mean.fit(X.iloc[:, numerical_cols]) # Impute missing numerical data X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols]) |
Tratamento de Dados Categóricos Faltantes
Para variáveis categóricas, valores ausentes são imputados usando a estratégia mais frequente.
|
1 2 3 4 5 6 7 8 9 |
# Identify categorical columns string_cols = list(np.where((X.dtypes == np.object))[0]) # Initialize imputer for categorical data imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent') imp_freq.fit(X.iloc[:, string_cols]) # Impute missing categorical data X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols]) |
Seleção e Codificação de Características
Removendo Características Irrelevantes
A coluna car_ID é um identificador único e não contribui para o poder preditivo do modelo. Portanto, ela é removida.
|
1 2 |
# Drop 'car_ID' column X.drop('car_ID', axis=1, inplace=True) |
Codificação One-Hot de Variáveis Categóricas
Algoritmos de machine learning exigem entrada numérica. Portanto, variáveis categóricas são transformadas usando Codificação One-Hot.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sklearn.preprocessing import OneHotEncoder from sklearn.compose import ColumnTransformer # Re-identify categorical columns after dropping 'car_ID' string_cols = list(np.where((X.dtypes == np.object))[0]) # Apply One-Hot Encoding columnTransformer = ColumnTransformer( [('encoder', OneHotEncoder(), string_cols)], remainder='passthrough' ) X = columnTransformer.fit_transform(X) |
Antes da Codificação:
- Forma: (205, 24)
Após a Codificação:
- Forma: (205, 199)
Divisão de Treino e Teste
Dividir o conjunto de dados em conjuntos de treino e teste é crucial para avaliar o desempenho do modelo.
|
1 2 3 4 5 6 7 8 9 |
from sklearn.model_selection import train_test_split # Perform train-test split X_train, X_test, y_train, y_test = train_test_split( X, Y, test_size=0.20, random_state=1 ) print(f"Training set shape: {X_train.shape}") print(f"Testing set shape: {X_test.shape}") |
Saída:
|
1 2 |
Training set shape: (164, 199) Testing set shape: (41, 199) |
Escalonamento de Características
O escalonamento de características garante que todas as características contribuam igualmente para o desempenho do modelo. Aqui, usamos Padronização.
|
1 2 3 4 5 6 7 8 9 |
from sklearn import preprocessing # Initialize StandardScaler sc = preprocessing.StandardScaler(with_mean=False) sc.fit(X_train) # Transform the data X_train = sc.transform(X_train) X_test = sc.transform(X_test) |
Construção e Avaliação de Modelos de Regressão
Exploraremos vários modelos de regressão, avaliando cada um com base na pontuação R².
1. Regressão Linear
A Regressão Linear serve como um modelo de referência.
|
1 2 3 4 5 6 7 8 9 10 11 |
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) r2 = r2_score(y_test, y_pred) print(f"Linear Regression R² Score: {r2:.2f}") |
Pontuação R²: 0.097
Interpretação: O modelo explica aproximadamente 9,7% da variância nos preços dos carros.
2. Regressão Linear Polinomial
Para capturar relações não lineares, introduzimos características polinomiais.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from sklearn.preprocessing import PolynomialFeatures # Initialize PolynomialFeatures poly = PolynomialFeatures(degree=2) X_train_poly = poly.fit_transform(X_train) X_test_poly = poly.transform(X_test) # Train the model model = LinearRegression() model.fit(X_train_poly, y_train) # Predict and evaluate y_pred = model.predict(X_test_poly) r2 = r2_score(y_test, y_pred) print(f"Polynomial Linear Regression R² Score: {r2:.2f}") |
Pontuação R²: -0.45
Interpretação: O modelo apresenta desempenho pior que o modelo de referência, explicando -45% da variância.
3. Regressão com Árvore de Decisão
Árvores de Decisão podem modelar relações complexas partitionando os dados.
|
1 2 3 4 5 6 7 8 9 10 |
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) r2 = r2_score(y_test, y_pred) print(f"Decision Tree Regression R² Score: {r2:.2f}") |
Pontuação R²: 0.88
Interpretação: Uma melhoria significativa, explicando 88% da variância.
4. Regressão com Floresta Aleatória
Floresta Aleatória agrega múltiplas Árvores de Decisão para aprimorar o desempenho e mitigar o overfitting.
|
1 2 3 4 5 6 7 8 9 10 |
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) r2 = r2_score(y_test, y_pred) print(f"Random Forest Regression R² Score: {r2:.2f}") |
Pontuação R²: 0.91
Interpretação: Desempenho excelente, explicando 91% da variância.
5. Regressão AdaBoost
AdaBoost combina aprendizes fracos para formar um preditor forte, focando nos erros.
|
1 2 3 4 5 6 7 8 9 10 |
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) r2 = r2_score(y_test, y_pred) print(f"AdaBoost Regression R² Score: {r2:.2f}") |
Pontuação R²: 0.88
Interpretação: Comparável à Regressão com Árvore de Decisão, explicando 88% da variância.
6. Regressão XGBoost
XGBoost é um poderoso framework de gradient boosting conhecido por sua eficiência e desempenho.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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) r2 = r2_score(y_test, y_pred) print(f"XGBoost Regression R² Score: {r2:.2f}") |
Pontuação R²: 0.89
Interpretação: Desempenho robusto, explicando 89% da variância.
7. Regressão por Vetores de Suporte (SVR)
SVR é eficaz em espaços de alta dimensão, mas pode ter desempenho inferior com conjuntos de dados maiores.
|
1 2 3 4 5 6 7 8 9 10 |
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) r2 = r2_score(y_test, y_pred) print(f"Support Vector Regression (SVR) R² Score: {r2:.2f}") |
Pontuação R²: -0.03
Interpretação: Desempenho ruim, explicando -3% da variância.
Comparação de Desempenho dos Modelos
| Modelo | Pontuação R² |
|---|---|
| Regressão Linear | 0.10 |
| Regressão Linear Polinomial | -0.45 |
| Regressão com Árvore de Decisão | 0.88 |
| Regressão com Floresta Aleatória | 0.91 |
| Regressão AdaBoost | 0.88 |
| Regressão XGBoost | 0.89 |
| Regressão por Vetores de Suporte (SVR) | -0.03 |
Insights:
- Regressão com Floresta Aleatória supera todos os outros modelos com uma pontuação R² de 0.91, indicando que ela explica 91% da variância nos preços dos carros.
- Regressão Linear Polinomial teve o pior desempenho, até pior que o modelo de referência, sugerindo overfitting ou transformação inadequada das características.
- Regressão por Vetores de Suporte (SVR) enfrentou dificuldades com este conjunto de dados, possivelmente devido à alta dimensionalidade após a codificação.
Conclusão
A modelagem preditiva para previsão de preços de carros ressalta a importância de selecionar o algoritmo certo e realizar um pré-processamento de dados completo. Em nossa exploração:
- Modelos de Árvore de Decisão e Floresta Aleatória demonstraram desempenho excepcional, com a Floresta Aleatória ligeiramente superando os demais.
- Métodos de ensemble como AdaBoost e XGBoost também apresentaram resultados fortes, destacando sua eficácia em lidar com conjuntos de dados complexos.
- Modelos lineares, especialmente quando estendidos para características polinomiais, nem sempre resultam em melhor desempenho e, às vezes, podem degradar a eficácia do modelo.
- Regressão por Vetores de Suporte (SVR) pode não ser a melhor opção para conjuntos de dados com alta dimensionalidade ou onde padrões não lineares são menos pronunciados.
Principais Lições:
- Pré-processamento de Dados: Tratar valores ausentes e codificar variáveis categóricas são etapas cruciais que influenciam significativamente o desempenho do modelo.
- Escalonamento de Características: Garante que todas as características contribuam igualmente, melhorando a eficiência de algoritmos baseados em gradiente.
- Seleção de Modelo: Métodos de ensemble como Florestas Aleatórias e XGBoost frequentemente proporcionam desempenho superior em tarefas de regressão.
- Avaliação de Modelo: A pontuação R² é uma métrica valiosa para avaliar quão bem as previsões se aproximam dos resultados reais.
Iniciar a previsão de preços de carros utilizando modelos de regressão avançados não apenas aprimora a precisão preditiva, mas também equipa os stakeholders com insights acionáveis sobre a dinâmica do mercado. Conforme o campo de machine learning continua a evoluir, manter-se atualizado com os últimos algoritmos e técnicas permanece essencial para entusiastas e profissionais de dados.