S16L01 – Template mestre de modelo de regressão – Criação de dados

html
Dominar a Regressão: Um Modelo Abrangente para Previsão de Preços de Carros

Desbloqueie todo o potencial da análise de regressão com nosso modelo elaborado por especialistas projetado para previsão de preços de carros. Seja experimentando diferentes modelos ou enfrentando vários problemas de regressão, este guia fornece uma abordagem passo a passo para simplificar seu fluxo de trabalho de aprendizado de máquina.

Índice

    Introdução à Regressão em Aprendizado de Máquina
    Compreendendo o Conjunto de Dados CarPrice
    Configurando Seu Ambiente
    
        Pré-processamento de Dados
        
            Tratamento de Dados Faltantes
            Seleção de Atributos
            Codificação de Variáveis Categóricas
        
    
    Escalonamento de Atributos
    Divisão do Conjunto de Dados
    
        Construção e Avaliação de Modelos
        
            Regressão Linear
            Regressão Polinomial
            Regressor de Árvore de Decisão
            Regressor de Floresta Aleatória
            Regressor AdaBoost
            Regressor XGBoost
            Regressão por Vetores de Suporte (SVR)
        
    
    Conclusão
    Acessando o Modelo de Regressão


Introdução à Regressão em Aprendizado de Máquina

A análise de regressão é um componente fundamental do aprendizado de máquina, permitindo prever resultados contínuos com base em atributos de entrada. Desde a precificação de imóveis até a previsão do mercado de ações, os modelos de regressão desempenham um papel essencial nos processos de tomada de decisão em diversas indústrias. Neste artigo, vamos explorar a criação de um modelo de regressão robusto usando Python, especificamente adaptado para prever preços de carros.

Compreendendo o Conjunto de Dados CarPrice

Nossa jornada começa com o conjunto de dados CarPrice, obtido de Kaggle. Este conjunto de dados compreende 25 campos e aproximadamente 206 registros, tornando-o gerenciável, porém suficientemente complexo para demonstrar técnicas de regressão.

Estrutura do Conjunto de Dados

Aqui está uma visão geral do conjunto de dados:


    
        car_ID
        symboling
        CarName
        fueltype
        aspiration
        doornumber
        carbody
        drivewheel
        enginelocation
        wheelbase
        ...
        price
    
    
        1
        3
        alfa-romero giulia
        gas
        std
        two
        convertible
        rwd
        front
        88.6
        ...
        13495.0
    
    
        2
        3
        alfa-romero stelvio
        gas
        std
        two
        convertible
        rwd
        front
        88.6
        ...
        16500.0
    
    
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
    


A variável alvo é price, representando o preço do carro em dólares.

Configurando Seu Ambiente

Antes de mergulhar nos dados, certifique-se de ter as bibliotecas Python necessárias instaladas. Usaremos pandas para manipulação de dados, numpy para operações numéricas, e scikit-learn juntamente com XGBoost para construir e avaliar modelos.





		
		
			
			
Java
			
			import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
from sklearn.preprocessing import PolynomialFeatures
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor
from sklearn.svm import SVR
import xgboost as xgb
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
from sklearn.preprocessing import PolynomialFeatures
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor
from sklearn.svm import SVR
import xgboost as xgb
					
				
			
		



Pré-processamento de Dados

Tratamento de Dados Faltantes

A limpeza dos dados é fundamental. Abordaremos valores faltantes separadamente para dados numéricos e categóricos.

Dados Numéricos

Para colunas numéricas, usaremos o SimpleImputer para preencher valores faltantes com a média de cada coluna.





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

# Initialize imputer for numerical data
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Fit and transform the data
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						# Identify numerical columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
 
# Initialize imputer for numerical data
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Fit and transform the data
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		



Dados Categóricos

Para colunas categóricas, preencheremos valores faltantes com a categoria mais frequente usando o SimpleImputer.





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

# Initialize imputer for categorical data
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform the data
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						# Identify categorical columns
string_cols = list(np.where((X.dtypes == object))[0])
 
# Initialize imputer for categorical data
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Fit and transform the data
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
					
				
			
		



Seleção de Atributos

Nem todos os atributos contribuem de maneira significativa para o modelo. Por exemplo, a coluna car_ID é meramente um identificador e não fornece valor preditivo. Vamos remover essas colunas irrelevantes.





		
		
			
			
Java
			
			# Drop the car_ID column
X.drop('car_ID', axis=1, inplace=True)
			
				
					
				
					1
2
				
						# Drop the car_ID column
X.drop('car_ID', axis=1, inplace=True)
					
				
			
		



Codificação de Variáveis Categóricas

Os modelos de aprendizado de máquina exigem entradas numéricas. Converteremos variáveis categóricas em formato numérico usando Codificação One-Hot.





		
		
			
			
Java
			
			# Initialize OneHotEncoder within ColumnTransformer
columnTransformer = ColumnTransformer(
    [('encoder', OneHotEncoder(), string_cols)],
    remainder='passthrough'
)

# Transform the data
X = columnTransformer.fit_transform(X)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Initialize OneHotEncoder within ColumnTransformer
columnTransformer = ColumnTransformer(
    [('encoder', OneHotEncoder(), string_cols)],
    remainder='passthrough'
)
 
# Transform the data
X = columnTransformer.fit_transform(X)
					
				
			
		



Após a codificação, a forma do conjunto de dados muda de (205, 24) para (205, 199), indicando a transformação bem-sucedida das variáveis categóricas.

Escalonamento de Atributos

O escalonamento garante que todos os atributos contribuam igualmente para o resultado, especialmente para algoritmos baseados em distância.





		
		
			
			
Java
			
			# Initialize 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)
			
				
					
				
					1
2
3
4
5
6
7
				
						# Initialize 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)
					
				
			
		



Divisão do Conjunto de Dados

Dividiremos o conjunto de dados em conjuntos de treinamento e teste para avaliar o desempenho do nosso modelo.





		
		
			
			
Java
			
			# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    X, Y, test_size=0.20, random_state=1
)
			
				
					
				
					1
2
3
4
				
						# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    X, Y, test_size=0.20, random_state=1
)
					
				
			
		




    Conjunto de Treinamento: 164 amostras
    Conjunto de Teste: 41 amostras


Construção e Avaliação de Modelos

Exploraremos vários modelos de regressão, avaliando cada um usando o score R².

1. Regressão Linear

Uma abordagem direta para prever valores contínuos.





		
		
			
			
Java
			
			model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.0974
			
				
					
				
					1
2
3
4
				
						model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.0974
					
				
			
		



O score R² indica que o modelo linear explica aproximadamente 9,74% da variância.

2. Regressão Polinomial

Captura relações não lineares introduzindo atributos polinomiais.





		
		
			
			
Java
			
			poly = PolynomialFeatures(degree=2)
X_train_poly = poly.fit_transform(X_train)
X_test_poly = poly.transform(X_test)

model = LinearRegression()
model.fit(X_train_poly, y_train)
y_pred = model.predict(X_test_poly)
print(r2_score(y_test, y_pred))  # Output: -0.4531
			
				
					
				
					1
2
3
4
5
6
7
8
				
						poly = PolynomialFeatures(degree=2)
X_train_poly = poly.fit_transform(X_train)
X_test_poly = poly.transform(X_test)
 
model = LinearRegression()
model.fit(X_train_poly, y_train)
y_pred = model.predict(X_test_poly)
print(r2_score(y_test, y_pred))  # Output: -0.4531
					
				
			
		



O score R² negativo sugere sobreajuste ou seleção de grau inadequada.

3. Regressor de Árvore de Decisão

Um modelo não linear que divide os dados em subconjuntos.





		
		
			
			
Java
			
			model = DecisionTreeRegressor(max_depth=4)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.8840
			
				
					
				
					1
2
3
4
				
						model = DecisionTreeRegressor(max_depth=4)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.8840
					
				
			
		



Score R² significativamente maior, indicando melhor desempenho.

4. Regressor de Floresta Aleatória

Um método de ensemble que constrói múltiplas árvores de decisão.





		
		
			
			
Java
			
			model = RandomForestRegressor(n_estimators=25, random_state=10)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.9108
			
				
					
				
					1
2
3
4
				
						model = RandomForestRegressor(n_estimators=25, random_state=10)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.9108
					
				
			
		



Um impressionante score R² de 91,08%, mostrando desempenho robusto.

5. Regressor AdaBoost

Técnica de boosting que combina aprendizes fracos para formar um preditor forte.





		
		
			
			
Java
			
			model = AdaBoostRegressor(random_state=0, n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.8807
			
				
					
				
					1
2
3
4
				
						model = AdaBoostRegressor(random_state=0, n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.8807
					
				
			
		



Alcança um score R² de 88,07%.

6. Regressor XGBoost

Uma implementação escalável e eficiente de gradient boosting.





		
		
			
			
Java
			
			model = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.8947
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						model = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: 0.8947
					
				
			
		



Entregue um score R² de 89,47%.

7. Regressão por Vetores de Suporte (SVR)

Efetivo em espaços de alta dimensão, o SVR utiliza truques de kernel para dados não lineares.





		
		
			
			
Java
			
			model = SVR()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: -0.0271
			
				
					
				
					1
2
3
4
				
						model = SVR()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))  # Output: -0.0271
					
				
			
		



O score R² negativo indica desempenho ruim, possivelmente devido à necessidade de ajuste de parâmetros.

Conclusão

Este modelo de regressão abrangente oferece uma abordagem sistemática para lidar com problemas de regressão, desde o pré-processamento de dados até a avaliação de modelos. Enquanto modelos simples como a Regressão Linear podem não ser satisfatórios, métodos de ensemble como Floresta Aleatória e XGBoost demonstram desempenho superior na previsão de preços de carros. Adaptar este modelo ao seu conjunto de dados específico pode aprimorar a precisão preditiva e simplificar seus projetos de aprendizado de máquina.

Acessando o Modelo de Regressão

Pronto para implementar este fluxo de trabalho de regressão? Acesse o Jupyter Notebook completo e o conjunto de dados CarPrice.csv aqui. Utilize esses recursos para iniciar seus projetos de aprendizado de máquina e alcançar modelos preditivos precisos com facilidade.

Aprimore suas habilidades em análise de regressão hoje e desbloqueie novas oportunidades na tomada de decisões baseada em dados!
car_ID	symboling	CarName	fueltype	aspiration	doornumber	carbody	drivewheel	enginelocation	wheelbase	...	price
1	3	alfa-romero giulia	gas	std	two	convertible	rwd	front	88.6	...	13495.0
2	3	alfa-romero stelvio	gas	std	two	convertible	rwd	front	88.6	...	16500.0
...	...	...	...	...	...	...	...	...	...	...	...