S17L04 – Validación cruzada K-fold sin GridSearchCV continúa

html
Implementación de la Validación Cruzada K-Fold para la Predicción de Precios de Autos Sin GridSearchCV

Tabla de Contenidos

    Introducción
    Descripción del Conjunto de Datos
    
        Preprocesamiento de Datos
        
            Manejo de Datos Faltantes
            Selección de Características
        
    
    
        Ingeniería de Características
        
            Codificación de Variables Categóricas
            Escalado de Características
        
    
    
        Construcción de Modelos de Regresión
        
            Regresor de Árbol de Decisión
            Regresor de Bosque Aleatorio
            Regresor AdaBoost
            Regresor XGBoost
            Regresor de Soporte Vectorial (SVR)
        
    
    Implementación de la Validación Cruzada K-Fold
    Evaluación del Rendimiento del Modelo
    Conclusión


Introducción
Predecir los precios de los autos es un problema clásico de regresión que implica pronosticar el precio de un vehículo basado en diversas características como el tamaño del motor, la potencia, el tipo de combustible y más. Implementar la Validación Cruzada K-Fold mejora la confiabilidad de nuestro modelo al asegurar que generaliza bien a datos no vistos. Este artículo demuestra cómo preprocesar datos, diseñar características, construir múltiples modelos de regresión y evaluar su rendimiento utilizando la Validación Cruzada K-Fold en Python.

Descripción del Conjunto de Datos
Usaremos el conjunto de datos Predicción de Precio de Autos de Kaggle, que contiene especificaciones detalladas de diferentes modelos de autos junto con sus precios. El conjunto de datos incluye características como symboling, CarName, fueltype, aspiration, doornumber, carbody, y muchas más que influyen en el precio del auto.

Preprocesamiento de Datos
El preprocesamiento efectivo de datos es esencial para preparar el conjunto de datos para el modelado. Esto implica manejar valores faltantes, codificar variables categóricas y seleccionar características relevantes.

Manejo de Datos Faltantes

Datos Numéricos
Los valores faltantes en características numéricas pueden manejarse utilizando medidas estadísticas. Usaremos la estrategia de la media para imputar valores faltantes en columnas numéricas.




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

# Cargar el conjunto de datos
data = pd.read_csv('CarPrice.csv')
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Identificar columnas numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns

# Imputar valores faltantes con la media
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer
 
# Cargar el conjunto de datos
data = pd.read_csv('CarPrice.csv')
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# Identificar columnas numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
 
# Imputar valores faltantes con la media
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
					
				
			
		



Datos Categóricos
Para características categóricas, la estrategia del valor más frecuente es efectiva para imputar valores faltantes.




		
		
			
			
Java
			
			from sklearn.impute import SimpleImputer

# Identificar columnas categóricas
string_cols = X.select_dtypes(include=['object']).columns

# Imputar valores faltantes con el valor más frecuente
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_freq.fit_transform(X[string_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.impute import SimpleImputer
 
# Identificar columnas categóricas
string_cols = X.select_dtypes(include=['object']).columns
 
# Imputar valores faltantes con el valor más frecuente
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_freq.fit_transform(X[string_cols])
					
				
			
		



Selección de Características
Seleccionar características relevantes ayuda a reducir la complejidad del modelo y a mejorar su rendimiento.




		
		
			
			
Java
			
			# Eliminar la columna 'car_ID' ya que no contribuye a la predicción del precio
X.drop('car_ID', axis=1, inplace=True)
			
				
					
				
					1
2
				
						# Eliminar la columna 'car_ID' ya que no contribuye a la predicción del precio
X.drop('car_ID', axis=1, inplace=True)
					
				
			
		



Ingeniería de Características
La ingeniería de características implica transformar datos sin procesar en características significativas que representen mejor el problema subyacente para los modelos predictivos.

Codificación de Variables Categóricas
Los algoritmos de aprendizaje automático requieren entrada numérica, por lo que las variables categóricas necesitan ser codificadas. Usaremos la Codificación One-Hot para convertir variables categóricas en una matriz binaria.




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

# Identificar columnas categóricas por sus índices
string_cols = list(np.where((X.dtypes == object))[0])

# Aplicar Codificación One-Hot
columnTransformer = ColumnTransformer(
    [('encoder', OneHotEncoder(), string_cols)],
    remainder='passthrough'
)
X = columnTransformer.fit_transform(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
 
# Identificar columnas categóricas por sus índices
string_cols = list(np.where((X.dtypes == object))[0])
 
# Aplicar Codificación One-Hot
columnTransformer = ColumnTransformer(
    [('encoder', OneHotEncoder(), string_cols)],
    remainder='passthrough'
)
X = columnTransformer.fit_transform(X)
					
				
			
		



Escalado de Características
El escalado asegura que cada característica contribuya de manera equitativa al resultado, mejorando el rendimiento de ciertos algoritmos.




		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

# Inicializar el StandardScaler
sc = StandardScaler(with_mean=False)

# Ajustar y transformar los datos de entrenamiento
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn.preprocessing import StandardScaler
 
# Inicializar el StandardScaler
sc = StandardScaler(with_mean=False)
 
# Ajustar y transformar los datos de entrenamiento
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
					
				
			
		



Construcción de Modelos de Regresión
Construiremos y evaluaremos cinco diferentes modelos de regresión para predecir los precios de los autos:

    Regresor de Árbol de Decisión
    Regresor de Bosque Aleatorio
    Regresor AdaBoost
    Regresor XGBoost
    Regresor de Soporte Vectorial (SVR)


Regresor de Árbol de Decisión
Un Regresor de Árbol de Decisión divide los datos en subconjuntos basados en los valores de las características, lo que lo hace fácil de interpretar.




		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeRegressor

# Inicializar el modelo
decisionTreeRegressor = DecisionTreeRegressor(max_depth=4)
			
				
					
				
					1
2
3
4
				
						from sklearn.tree import DecisionTreeRegressor
 
# Inicializar el modelo
decisionTreeRegressor = DecisionTreeRegressor(max_depth=4)
					
				
			
		



Regresor de Bosque Aleatorio
Random Forest agrega las predicciones de múltiples Árboles de Decisión, reduciendo el sobreajuste y mejorando la precisión.




		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestRegressor

# Inicializar el modelo
randomForestRegressor = RandomForestRegressor(n_estimators=25, random_state=10)
			
				
					
				
					1
2
3
4
				
						from sklearn.ensemble import RandomForestRegressor
 
# Inicializar el modelo
randomForestRegressor = RandomForestRegressor(n_estimators=25, random_state=10)
					
				
			
		



Regresor AdaBoost
AdaBoost combina múltiples aprendices débiles para crear un modelo predictivo fuerte, enfocándose en instancias que fueron previamente mal predichas.




		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostRegressor

# Inicializar el modelo
adaBoostRegressor = AdaBoostRegressor(random_state=0, n_estimators=100)
			
				
					
				
					1
2
3
4
				
						from sklearn.ensemble import AdaBoostRegressor
 
# Inicializar el modelo
adaBoostRegressor = AdaBoostRegressor(random_state=0, n_estimators=100)
					
				
			
		



Regresor XGBoost
XGBoost es una biblioteca optimizada de gradient boosting distribuido diseñada para rendimiento y velocidad.




		
		
			
			
Java
			
			import xgboost as xgb

# Inicializar el modelo
xgbRegressor = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import xgboost as xgb
 
# Inicializar el modelo
xgbRegressor = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)
					
				
			
		



Regresor de Soporte Vectorial (SVR)
SVR utiliza los principios de las Máquinas de Soporte Vectorial para tareas de regresión, siendo efectivo en espacios de alta dimensión.




		
		
			
			
Java
			
			from sklearn.svm import SVR

# Inicializar el modelo
svr = SVR()
			
				
					
				
					1
2
3
4
				
						from sklearn.svm import SVR
 
# Inicializar el modelo
svr = SVR()
					
				
			
		



Implementación de la Validación Cruzada K-Fold
La Validación Cruzada K-Fold divide el conjunto de datos en k subconjuntos y entrena y valida el modelo k veces de manera iterativa, usando cada vez un subconjunto diferente como conjunto de validación.




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

# Definir el Validador Cruzado K-Fold
kf = KFold(n_splits=10, random_state=42, shuffle=True)

# Función para construir y evaluar el modelo
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)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						from sklearn.model_selection import KFold
from sklearn.metrics import r2_score
 
# Definir el Validador Cruzado K-Fold
kf = KFold(n_splits=10, random_state=42, shuffle=True)
 
# Función para construir y evaluar el modelo
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)
					
				
			
		



Ejecutando la Validación Cruzada K-Fold
Evaluaremos el rendimiento de cada modelo a través de los K-Folds y calcularemos la puntuación R² media.




		
		
			
			
Java
			
			# Inicializar listas de puntuaciones
decisionTreeRegressor_scores = []
randomForestRegressor_scores = []
adaBoostRegressor_scores = []
xgbRegressor_scores = []
svr_scores = []

# Realizar la Validación Cruzada K-Fold
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]
    
    # Árbol de Decisión
    decisionTreeRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, decisionTreeRegressor)
    )
    
    # Bosque Aleatorio
    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)
    )
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
				
						# Inicializar listas de puntuaciones
decisionTreeRegressor_scores = []
randomForestRegressor_scores = []
adaBoostRegressor_scores = []
xgbRegressor_scores = []
svr_scores = []
 
# Realizar la Validación Cruzada K-Fold
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]
    
    # Árbol de Decisión
    decisionTreeRegressor_scores.append(
        build_model(X_train, X_test, y_train, y_test, decisionTreeRegressor)
    )
    
    # Bosque Aleatorio
    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)
    )
					
				
			
		



Evaluación del Rendimiento del Modelo
Después de ejecutar la Validación Cruzada K-Fold, calcularemos la puntuación R² media para cada modelo para evaluar su rendimiento.




		
		
			
			
Java
			
			from statistics import mean

print('Puntuación R² Media del Regresor de Árbol de Decisión: ', mean(decisionTreeRegressor_scores))
print('Puntuación R² Media del Regresor de Bosque Aleatorio: ', mean(randomForestRegressor_scores))
print('Puntuación R² Media del Regresor AdaBoost: ', mean(adaBoostRegressor_scores))
print('Puntuación R² Media del Regresor XGBoost: ', mean(xgbRegressor_scores))
print('Puntuación R² Media del SVR: ', mean(svr_scores))
			
				
					
				
					1
2
3
4
5
6
7
				
						from statistics import mean
 
print('Puntuación R² Media del Regresor de Árbol de Decisión: ', mean(decisionTreeRegressor_scores))
print('Puntuación R² Media del Regresor de Bosque Aleatorio: ', mean(randomForestRegressor_scores))
print('Puntuación R² Media del Regresor AdaBoost: ', mean(adaBoostRegressor_scores))
print('Puntuación R² Media del Regresor XGBoost: ', mean(xgbRegressor_scores))
print('Puntuación R² Media del SVR: ', mean(svr_scores))
					
				
			
		


Salida de Muestra:




		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
				
						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
					
				
			
		


Interpretación:

    Regresor de Bosque Aleatorio muestra la puntuación R² media más alta, indicando el mejor rendimiento entre los modelos probados.
    SVR obtiene una puntuación R² negativa, lo que sugiere un rendimiento deficiente en este conjunto de datos, posiblemente debido a su incapacidad para capturar eficazmente los patrones subyacentes sin la afinación de hiperparámetros.


Conclusión
Implementar la Validación Cruzada K-Fold proporciona un método robusto para evaluar el rendimiento de los modelos de regresión, asegurando que los resultados sean generalizables y no dependan de una división particular de entrenamiento-prueba. En esta guía, demostramos cómo preprocesar datos, codificar variables categóricas, escalar características, construir múltiples modelos de regresión y evaluar su rendimiento utilizando la Validación Cruzada K-Fold sin GridSearchCV.

Conclusiones Clave:

    Preprocesamiento de Datos: El manejo adecuado de datos faltantes y la selección de características son cruciales para el rendimiento del modelo.
    Ingeniería de Características: La codificación de variables categóricas y el escalado de características pueden impactar significativamente la capacidad del modelo para aprender patrones.
    Evaluación del Modelo: La Validación Cruzada K-Fold ofrece una manera confiable de evaluar qué tan bien tu modelo generaliza a datos no vistos.
    Selección de Modelo: Entre los modelos probados, los métodos de ensamblaje como Bosque Aleatorio y XGBoost superan a modelos más simples como Árboles de Decisión y SVR en este caso particular.

Para una optimización adicional, integrar técnicas de afinación de hiperparámetros como GridSearchCV o RandomizedSearchCV puede mejorar el rendimiento del modelo al encontrar el mejor conjunto de parámetros para cada algoritmo.

---

Siguiendo este enfoque estructurado, puedes implementar efectivamente la Validación Cruzada K-Fold para diversas tareas de regresión, asegurando que tus modelos sean precisos y robustos.