S16L01 – Modelo de regresión de plantilla maestra – Creación de datos

html
Dominando la Regresión: Una Plantilla Integral para la Predicción de Precios de Automóviles

Desbloquea todo el potencial del análisis de regresión con nuestra plantilla diseñada por expertos específicamente para la predicción de precios de automóviles. Ya sea que estés experimentando con diferentes modelos o abordando diversos problemas de regresión, esta guía proporciona un enfoque paso a paso para optimizar tu flujo de trabajo de aprendizaje automático.

Tabla de Contenidos

    Introducción a la Regresión en el Aprendizaje Automático
    Comprendiendo el Conjunto de Datos CarPrice
    Configurando Tu Entorno
    
        Preprocesamiento de Datos
        
            Manejo de Datos Faltantes
            Selección de Características
            Codificación de Variables Categóricas
        
    
    Escalado de Características
    División del Conjunto de Datos
    
        Construcción y Evaluación de Modelos
        
            Regresión Lineal
            Regresión Polinómica
            Regresor de Árbol de Decisión
            Regresor de Bosque Aleatorio
            Regresor AdaBoost
            Regresor XGBoost
            Regresión de Vectores de Soporte (SVR)
        
    
    Conclusión
    Acceso a la Plantilla de Regresión


Introducción a la Regresión en el Aprendizaje Automático

El análisis de regresión es un componente fundamental del aprendizaje automático, que nos permite predecir resultados continuos basados en características de entrada. Desde la valoración de bienes raíces hasta la previsión del mercado de valores, los modelos de regresión desempeñan un papel crucial en los procesos de toma de decisiones en diversas industrias. En este artículo, profundizaremos en la creación de una plantilla de regresión sólida utilizando Python, específicamente diseñada para predecir precios de automóviles.

Comprendiendo el Conjunto de Datos CarPrice

Nuestra travesía comienza con el conjunto de datos CarPrice, obtenido de Kaggle. Este conjunto de datos comprende 25 campos y aproximadamente 206 registros, lo que lo hace manejable pero suficientemente complejo para demostrar técnicas de regresión.

Estructura del Conjunto de Datos

Aquí tienes una instantánea del conjunto de datos:


    
        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
    
    
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
    


La variable objetivo es price, que representa el precio del automóvil en dólares.

Configurando Tu Entorno

Antes de sumergirte en los datos, asegúrate de tener instaladas las bibliotecas de Python necesarias. Utilizaremos pandas para la manipulación de datos, numpy para operaciones numéricas, y scikit-learn junto con XGBoost para construir y evaluar 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
					
				
			
		



Preprocesamiento de Datos

Manejo de Datos Faltantes

La limpieza de datos es primordial. Abordaremos los valores faltantes por separado para datos numéricos y categóricos.

Datos Numéricos

Para las columnas numéricas, utilizaremos el SimpleImputer para llenar los valores faltantes con la media de cada columna.





		
		
			
			
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])
					
				
			
		



Datos Categóricos

Para las columnas categóricas, llenaremos los valores faltantes con la categoría más frecuente utilizando 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])
					
				
			
		



Selección de Características

No todas las características contribuyen de manera significativa al modelo. Por ejemplo, la columna car_ID es simplemente un identificador y no proporciona valor predictivo. Eliminaremos columnas irrelevantes de este tipo.





		
		
			
			
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)
					
				
			
		



Codificación de Variables Categóricas

Los modelos de aprendizaje automático requieren entradas numéricas. Convertiremos las variables categóricas en formato numérico utilizando Codificación 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)
					
				
			
		



Después de la codificación, la forma del conjunto de datos cambia de (205, 24) a (205, 199), lo que indica la transformación exitosa de las variables categóricas.

Escalado de Características

El escalado asegura que todas las características contribuyan de igual manera al resultado, especialmente para algoritmos basados en distancia.





		
		
			
			
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)
					
				
			
		



División del Conjunto de Datos

Dividiremos el conjunto de datos en conjuntos de entrenamiento y prueba para evaluar el rendimiento de nuestro 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 Entrenamiento: 164 muestras
    Conjunto de Prueba: 41 muestras


Construcción y Evaluación de Modelos

Exploraremos varios modelos de regresión, evaluando cada uno utilizando el puntaje R².

1. Regresión Lineal

Un enfoque sencillo para predecir valores continuos.





		
		
			
			
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
					
				
			
		



El puntaje R² indica que el modelo lineal explica aproximadamente el 9.74% de la varianza.

2. Regresión Polinómica

Captura relaciones no lineales al introducir características polinómicas.





		
		
			
			
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
					
				
			
		



El puntaje R² negativo sugiere sobreajuste o una selección de grado inapropiada.

3. Regresor de Árbol de Decisión

Un modelo no lineal que divide los datos en 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
					
				
			
		



Puntaje R² significativamente más alto, indicando mejor rendimiento.

4. Regresor de Bosque Aleatorio

Un método de ensamblaje que construye múltiples árboles de decisión.





		
		
			
			
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
					
				
			
		



Un impresionante puntaje R² de 91.08%, demostrando un rendimiento robusto.

5. Regresor AdaBoost

Técnica de boosting que combina aprendices débiles para formar un fuerte predictor.





		
		
			
			
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
					
				
			
		



Logra un puntaje R² de 88.07%.

6. Regresor XGBoost

Una implementación escalable y 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
					
				
			
		



Ofrece un puntaje R² de 89.47%.

7. Regresión de Vectores de Soporte (SVR)

Efectivo en espacios de alta dimensión, SVR utiliza trucos de kernel para datos no lineales.





		
		
			
			
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
					
				
			
		



El puntaje R² negativo indica un rendimiento deficiente, posiblemente debido a la necesidad de ajustar parámetros.

Conclusión

Esta plantilla de regresión integral ofrece un enfoque sistemático para manejar problemas de regresión, desde el preprocesamiento de datos hasta la evaluación del modelo. Mientras que modelos simples como la Regresión Lineal pueden quedarse cortos, métodos de ensamblaje como Random Forest y XGBoost demuestran un rendimiento superior en la predicción de precios de automóviles. Adaptar esta plantilla a tu conjunto de datos específico puede mejorar la precisión predictiva y optimizar tus proyectos de aprendizaje automático.

Acceso a la Plantilla de Regresión

¿Listo para implementar este flujo de trabajo de regresión? Accede al Jupyter Notebook completo y al conjunto de datos CarPrice.csv aquí. Utiliza estos recursos para iniciar tus proyectos de aprendizaje automático y lograr modelos predictivos precisos con facilidad.

¡Mejora tus habilidades en análisis de regresión hoy y desbloquea nuevas oportunidades en la toma de decisiones basada en datos!
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
...	...	...	...	...	...	...	...	...	...	...	...