6.2 Proyecto 2: Predicción de Precios de Automóviles Usados con Regresión Lineal

En este proyecto, desarrollaremos un modelo predictivo para estimar los precios de automóviles usados basándonos en diversas características como kilometraje, año, marca, modelo y otros factores relevantes. Este proyecto tiene aplicaciones significativas en la industria automotriz, especialmente para concesionarios de autos, compañías de seguros y mercados en línea que manejan vehículos usados.

La regresión lineal es adecuada para esta tarea, ya que nuestro objetivo es predecir un valor continuo (precio del automóvil) basado en múltiples características de entrada. A lo largo de este proyecto, realizaremos las siguientes tareas:

Exploraremos y preprocesaremos un conjunto de datos de automóviles usados.
Aplicaremos la regresión lineal para predecir los precios de los automóviles.
Evaluaremos el rendimiento del modelo utilizando varias métricas.
Optimizaremos el modelo a través de la ingeniería y selección de características.
Compararemos nuestro modelo de regresión lineal con otros algoritmos.
Analizaremos la importancia de las características y la interpretabilidad del modelo.

6.2.1 Cargar y Explorar el Conjunto de Datos

Comenzaremos cargando y explorando nuestro completo conjunto de datos de automóviles usados. Este paso crucial forma la base de nuestro análisis, permitiéndonos obtener una visión profunda de la estructura y las características de nuestros datos.

A través de un examen cuidadoso, podemos identificar posibles problemas, como valores faltantes o atípicos, y descubrir patrones significativos que puedan influir en el rendimiento de nuestro modelo.

Esta exploración inicial no solo nos ayuda a comprender la naturaleza de nuestro conjunto de datos, sino que también guía nuestras decisiones posteriores de preprocesamiento e ingeniería de características, lo que finalmente conducirá a un modelo de predicción de precios de automóviles más robusto y preciso.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.feature_selection import RFE
from sklearn.ensemble import RandomForestRegressor

# Load the dataset
url = 'https://example.com/used_car_data.csv'  # Replace with actual URL
car_df = pd.read_csv(url)

# Display basic information about the dataset
print(car_df.info())
print(car_df.describe())

# Visualize the distribution of car prices
plt.figure(figsize=(12, 6))
sns.histplot(car_df['price'], bins=50, kde=True)
plt.title('Distribution of Car Prices')
plt.xlabel('Price')
plt.ylabel('Frequency')
plt.show()

# Correlation heatmap
plt.figure(figsize=(12, 10))
sns.heatmap(car_df.corr(), annot=True, cmap='coolwarm')
plt.title('Correlation Heatmap of Numerical Features')
plt.show()

# Scatter plot of price vs. mileage
plt.figure(figsize=(10, 6))
sns.scatterplot(x='mileage', y='price', data=car_df)
plt.title('Price vs. Mileage')
plt.xlabel('Mileage')
plt.ylabel('Price')
plt.show()

Descargue el archivo CSV aquí: https://files.cuantum.tech/csv/used_car_data.csv

Este es el desglose de sus principales componentes:

Importación de las bibliotecas necesarias: pandas, numpy, matplotlib, seaborn y varios módulos de scikit-learn para la manipulación de datos, visualización y tareas de machine learning.
Carga del conjunto de datos: Lee un archivo CSV desde una URL en un DataFrame de pandas llamado car_df.
Muestra de información básica: Imprime la información del conjunto de datos y estadísticas descriptivas utilizando los métodos info() y describe().
Visualización de la distribución de precios de automóviles: Crea un histograma con una estimación de densidad de núcleo (KDE) para mostrar la distribución de los precios.
Creación de un mapa de calor de correlación: Visualiza las correlaciones entre las características numéricas en el conjunto de datos.
Trazado de un gráfico de dispersión: Muestra la relación entre el kilometraje y el precio.

Este código es parte de la fase de exploración de datos, que es crucial para comprender las características del conjunto de datos, identificar patrones potenciales y guiar el preprocesamiento y las decisiones de modelado posteriores.

6.2.2 Preprocesamiento de Datos

Antes de construir nuestro modelo de regresión, es crucial preprocesar los datos para garantizar su calidad y adecuación para el análisis.

Este paso esencial involucra varios procesos clave:

Manejo de valores faltantes: Necesitamos abordar cualquier vacío en nuestro conjunto de datos, ya sea imputando valores o eliminando registros incompletos.
Codificación de variables categóricas: Dado que nuestro modelo trabaja con datos numéricos, debemos convertir la información categórica (como las marcas y modelos de automóviles) en un formato que el algoritmo pueda procesar.
Escalado de características numéricas: Para asegurar que todas las características contribuyan de manera equitativa al modelo, estandarizaremos o normalizaremos las variables numéricas a una escala común.
Ingeniería de características: Podemos crear nuevas características o transformar las existentes para captar relaciones importantes en los datos.

Estos pasos de preprocesamiento son vitales para construir un modelo de predicción de precios de automóviles robusto y preciso.

# Handle missing values
car_df.dropna(subset=['price'], inplace=True)
car_df['mileage'].fillna(car_df['mileage'].median(), inplace=True)
car_df['year'].fillna(car_df['year'].mode()[0], inplace=True)

# Encode categorical variables
car_df = pd.get_dummies(car_df, columns=['make', 'model'], drop_first=True)

# Feature engineering
car_df['age'] = 2023 - car_df['year']  # Assuming current year is 2023
car_df['miles_per_year'] = car_df['mileage'] / car_df['age']

# Scale numerical features
scaler = StandardScaler()
numerical_features = ['mileage', 'year', 'age', 'miles_per_year']
car_df[numerical_features] = scaler.fit_transform(car_df[numerical_features])

# Display the updated dataset
print(car_df.head())

Desglosémoslo paso a paso:

Manejo de valores faltantes: El código elimina las filas con valores faltantes en el precio y rellena los valores faltantes en el kilometraje y el año utilizando la mediana y la moda, respectivamente.
Codificación de variables categóricas: Utiliza one-hot encoding para convertir variables categóricas (marca y modelo) en formato numérico.
Ingeniería de características: Se crean dos nuevas características:
- age: calculada restando el año del automóvil de 2023 (suponiendo que es el año actual).
- miles_per_year: derivada dividiendo el kilometraje entre la edad.
Escalado de características numéricas: El código usa StandardScaler para normalizar las características numéricas (kilometraje, año, edad y miles_per_year), asegurando que estén en la misma escala.
Muestra de resultados: Finalmente, imprime las primeras filas del conjunto de datos actualizado para mostrar los cambios.

Estos pasos de preprocesamiento son fundamentales para preparar los datos para los modelos de machine learning, garantizar la calidad de los datos y mejorar potencialmente el rendimiento del modelo.

6.2.3 Selección de Características

En este paso crucial del proceso de desarrollo de nuestro modelo, emplearemos la Eliminación Recursiva de Características (RFE) para identificar y seleccionar las características más influyentes para nuestro modelo de predicción de precios de automóviles.

RFE es una técnica avanzada de selección de características que elimina de manera recursiva las características menos importantes mientras se construye el modelo, lo que nos permite centrarnos en las variables que tienen el mayor impacto en nuestra variable objetivo.

Al implementar RFE, podemos optimizar nuestro modelo, mejorar su rendimiento y obtener valiosas ideas sobre cuáles son los factores más importantes en la determinación de los precios de automóviles usados.

# Prepare features and target
X = car_df.drop('price', axis=1)
y = car_df['price']

# Perform RFE
rfe = RFE(estimator=LinearRegression(), n_features_to_select=10)
rfe = rfe.fit(X, y)

# Get selected features
selected_features = X.columns[rfe.support_]
print("Selected features:", selected_features)

# Update X with selected features
X = X[selected_features]

Este es el desglose de lo que hace el código:

Primero, separa las características (X) y la variable objetivo (y) del conjunto de datos. La columna price se establece como la variable objetivo, mientras que las demás columnas se consideran características.
Luego, inicializa el objeto RFE con un estimador de LinearRegression y establece el número de características a seleccionar en 10.
Se ajusta el RFE a los datos, lo que realiza el proceso de eliminación recursiva de características.
Después de ajustarlo, el código recupera las características seleccionadas usando rfe.support_ y las imprime.
Finalmente, actualiza el conjunto de características X para incluir solo las características seleccionadas.

Este proceso ayuda a identificar las características más importantes para predecir los precios de los automóviles, lo que potencialmente mejora el rendimiento y la interpretabilidad del modelo.

6.2.4 Dividir los Datos y Construir el Modelo

Con los datos preprocesados y las características seleccionadas, estamos listos para avanzar en el desarrollo del modelo. En este paso crucial, dividiremos nuestro conjunto de datos en subconjuntos de entrenamiento y prueba, una práctica que nos permite construir nuestro modelo de regresión lineal en una parte de los datos y evaluar su rendimiento en otra. Este enfoque asegura que nuestro modelo pueda generalizarse bien a datos nuevos y no vistos.

Al dividir los datos, creamos un marco robusto para evaluar las capacidades predictivas de nuestro modelo. El conjunto de entrenamiento se usará para enseñar al algoritmo de regresión lineal los patrones subyacentes en los precios de los automóviles, mientras que el conjunto de prueba servirá como un proxy de datos del mundo real, lo que nos permitirá evaluar qué tan bien funciona el modelo con ejemplos no vistos previamente.

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create and train the linear regression model
model = LinearRegression()
model.fit(X_train, y_train)

# Make predictions
y_pred = model.predict(X_test)

# Evaluate the model
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print(f"Mean Squared Error: {mse}")
print(f"Root Mean Squared Error: {rmse}")
print(f"R-squared Score: {r2}")

Este es el desglose de lo que hace cada parte:

División de Datos: Los datos se dividen en conjuntos de entrenamiento y prueba utilizando train_test_split(). El 80% de los datos se utiliza para entrenamiento (test_size=0.2) y el 20% restante para prueba.
Creación y Entrenamiento del Modelo: Se instancia un modelo de LinearRegression y se entrena con los datos de entrenamiento usando el método fit().
Predicción: El modelo entrenado se utiliza para hacer predicciones sobre los datos de prueba.
Evaluación del Modelo: El rendimiento del modelo se evalúa utilizando tres métricas:
- Error Cuadrático Medio (MSE): Mide la diferencia cuadrática promedio entre los valores predichos y los reales.
- Raíz del Error Cuadrático Medio (RMSE): La raíz cuadrada del MSE, que proporciona una medida de error en la misma unidad que la variable objetivo.
- Puntuación R-cuadrado: Indica la proporción de la varianza en la variable dependiente que es predecible a partir de las variables independientes.

Estas métricas ayudan a evaluar qué tan bien está funcionando el modelo en la predicción de precios de automóviles basándose en las características seleccionadas.

6.2.5 Interpretación del Modelo

Ahora, profundicemos en los coeficientes de nuestro modelo de regresión lineal para obtener una comprensión completa de cómo cada característica influye en los precios de los automóviles. Al examinar estos coeficientes, podemos discernir qué factores tienen el impacto más significativo en la determinación del valor de un vehículo, proporcionando información valiosa tanto para compradores como para vendedores en el mercado de automóviles usados.

# Display feature coefficients
coefficients = pd.DataFrame({'Feature': X.columns, 'Coefficient': model.coef_})
coefficients = coefficients.sort_values(by='Coefficient', key=abs, ascending=False)
print(coefficients)

# Visualize feature importance
plt.figure(figsize=(12, 6))
sns.barplot(x='Coefficient', y='Feature', data=coefficients)
plt.title('Feature Importance in Linear Regression Model')
plt.show()

Desglosémoslo:

Mostrar los coeficientes de las características:
- Crea un DataFrame llamado coefficients con dos columnas: Feature (de X.columns) y Coefficient (de model.coef_).
- Los coeficientes se ordenan por sus valores absolutos en orden descendente.
- Este DataFrame ordenado se imprime, mostrando qué características tienen el mayor impacto en la predicción.
Visualizar la importancia de las características:
- Se crea un gráfico de barras usando seaborn (sns.barplot).
- El eje x representa los valores de los coeficientes y el eje y muestra los nombres de las características.
- Esta visualización ayuda a identificar rápidamente qué características tienen el impacto más significativo, ya sea positivo o negativo, en los precios de los automóviles.

Este código es crucial para entender cómo cada característica en el modelo contribuye a la predicción de los precios de los automóviles, lo que permite una mejor interpretación del proceso de toma de decisiones del modelo.

6.2.6 Análisis de Errores

Para obtener una visión más profunda del rendimiento de nuestro modelo e identificar áreas potenciales de mejora, realizaremos un análisis exhaustivo de sus errores. Este paso es crucial para descubrir patrones sistemáticos o valores atípicos notables en nuestras predicciones, lo que nos permitirá refinar nuestro enfoque y mejorar la precisión de nuestras estimaciones de precios de automóviles.

Al examinar las discrepancias entre los precios predichos y los reales, podemos identificar escenarios específicos donde nuestro modelo sobresale o tiene dificultades, lo que conducirá a un sistema de predicción más robusto y confiable.

# Calculate residuals
residuals = y_test - y_pred

# Plot residuals
plt.figure(figsize=(10, 6))
sns.scatterplot(x=y_test, y=residuals)
plt.axhline(y=0, color='r', linestyle='--')
plt.title('Residual Plot')
plt.xlabel('Actual Price')
plt.ylabel('Residuals')
plt.show()

# Plot actual vs predicted prices
plt.figure(figsize=(10, 6))
sns.scatterplot(x=y_test, y=y_pred)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.title('Actual vs Predicted Prices')
plt.xlabel('Actual Price')
plt.ylabel('Predicted Price')
plt.show()

Este código realiza un análisis de errores para un modelo de regresión lineal utilizado para predecir los precios de automóviles. Consta de dos partes principales:

Gráfico de residuos:
- Calcula los residuos (diferencias entre los precios reales y los predichos).
- Crea un gráfico de dispersión de precios reales vs. residuos.
- Añade una línea discontinua roja horizontal en y=0 para destacar la línea base.
- Este gráfico ayuda a identificar posibles patrones o heterocedasticidad en los errores.
Gráfico de precios reales vs. predichos:
- Crea un gráfico de dispersión de precios reales vs. precios predichos.
- Añade una línea diagonal discontinua roja que representa predicciones perfectas.
- Este gráfico ayuda a visualizar qué tan bien se alinean las predicciones del modelo con los precios reales.

Estas visualizaciones son cruciales para comprender el rendimiento del modelo e identificar posibles áreas de mejora en el modelo de predicción de precios de automóviles.

6.2.7 Comparación de Modelos

Para mejorar nuestras capacidades predictivas y obtener una comprensión más profunda de los factores que influyen en los precios de los automóviles, ahora compararemos nuestro modelo de regresión lineal con un algoritmo de machine learning más complejo: el Random Forest Regressor.

Esta comparación nos permitirá evaluar si podemos lograr una mayor precisión en nuestras predicciones y, potencialmente, descubrir relaciones no lineales en nuestros datos que el modelo lineal podría haber pasado por alto.

Al implementar este modelo adicional, podremos evaluar las fortalezas y debilidades de ambos enfoques, proporcionando valiosas ideas sobre el método más efectivo para estimar los precios de automóviles usados en diferentes escenarios.

# Create and train a Random Forest model
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)

# Make predictions with Random Forest
rf_pred = rf_model.predict(X_test)

# Evaluate Random Forest model
rf_mse = mean_squared_error(y_test, rf_pred)
rf_rmse = np.sqrt(rf_mse)
rf_r2 = r2_score(y_test, rf_pred)

print("Random Forest Performance:")
print(f"Mean Squared Error: {rf_mse}")
print(f"Root Mean Squared Error: {rf_rmse}")
print(f"R-squared Score: {rf_r2}")

# Compare feature importance
rf_importance = pd.DataFrame({'Feature': X.columns, 'Importance': rf_model.feature_importances_})
rf_importance = rf_importance.sort_values('Importance', ascending=False)

plt.figure(figsize=(12, 6))
sns.barplot(x='Importance', y='Feature', data=rf_importance)
plt.title('Feature Importance in Random Forest Model')
plt.show()

Este es el desglose de lo que hace el código:

Crea y entrena un modelo de Bosque Aleatorio con 100 árboles.
Utiliza el modelo entrenado para hacer predicciones en los datos de prueba.
Evalúa el rendimiento del modelo de Bosque Aleatorio utilizando tres métricas:
- Error Cuadrático Medio (MSE)
- Raíz del Error Cuadrático Medio (RMSE)
- Puntuación R-cuadrado
Imprime las métricas de rendimiento para facilitar la comparación con el modelo de regresión lineal.
Analiza la importancia de las características en el modelo de Bosque Aleatorio:
- Crea un DataFrame con las características y sus puntuaciones de importancia.
- Ordena las características por importancia.
- Visualiza la importancia de las características usando un gráfico de barras.

Este código permite una comparación integral entre los modelos de regresión lineal y Bosque Aleatorio, ayudando a identificar qué enfoque podría ser más efectivo para predecir los precios de automóviles en este escenario específico.

6.2.8 Conclusión

En este proyecto, hemos construido un modelo integral de predicción de precios de automóviles utilizando regresión lineal. Hemos incorporado técnicas avanzadas de exploración de datos, ingeniería de características e interpretación de modelos. Al comparar nuestro modelo de regresión lineal con un modelo de Bosque Aleatorio, obtuvimos información sobre las fortalezas y limitaciones de diferentes enfoques.

Principales conclusiones de este proyecto:

La importancia de una exploración y visualización de datos exhaustiva.
El impacto de la ingeniería de características en el rendimiento del modelo.
El valor de modelos interpretables como la regresión lineal para entender la importancia de las características.
El potencial de los métodos de ensamblado como el Bosque Aleatorio para captar relaciones no lineales y mejorar las predicciones.

Este proyecto demuestra el poder del machine learning para resolver problemas del mundo real y proporciona una base sólida para seguir explorando el campo del modelado predictivo.