S17L03 – Validación cruzada K-fold sin GridSearchCV

html
Dominando la Validación Cruzada K-Fold sin GridSearchCV: Una Guía Completa
En el ámbito del aprendizaje automático, asegurar la robustez y confiabilidad de tus modelos es de suma importancia. Una de las técnicas fundamentales para lograr esto es la Validación Cruzada K-Fold. Mientras que bibliotecas populares como Scikit-Learn ofrecen herramientas como GridSearchCV para la optimización de hiperparámetros combinada con la validación cruzada, existen escenarios donde podrías querer implementar la Validación Cruzada K-Fold manualmente. Esta guía profundiza en la comprensión e implementación de la Validación Cruzada K-Fold sin depender de GridSearchCV, utilizando Python y Jupyter Notebooks.

Tabla de Contenidos

    Introducción a la Validación Cruzada K-Fold
    Comprensión del Conjunto de Datos
    Preprocesamiento de Datos
        
            Manejo de Datos Faltantes
            Selección de Características
            Codificación de Variables Categóricas
            Escalado de Características
        
    
    Construcción de Modelos de Aprendizaje Automático
    Implementación de la Validación Cruzada K-Fold sin GridSearchCV
    Mejores Prácticas y Consejos
    Conclusión



Introducción a la Validación Cruzada K-Fold
Validación Cruzada K-Fold es una técnica de remuestreo utilizada para evaluar modelos de aprendizaje automático en una muestra de datos limitada. El proceso implica dividir el conjunto de datos original en K subconjuntos no superpuestos (folds). El modelo se entrena en K-1 folds y se valida en el fold restante. Este procedimiento se repite K veces, con cada fold sirviendo como el conjunto de validación una vez. La métrica de rendimiento final suele ser el promedio de las K puntuaciones de validación.

¿Por Qué Usar la Validación Cruzada K-Fold?

    Evaluación Robusta: Proporciona una estimación más confiable del rendimiento del modelo en comparación con una única división de entrenamiento-prueba.
    Reducción del Sobreajuste: Al entrenar en múltiples subconjuntos, el modelo generaliza mejor a datos no vistos.
    Uso Eficiente de los Datos: Especialmente beneficioso al trabajar con conjuntos de datos limitados.

Mientras GridSearchCV integra la validación cruzada con la optimización de hiperparámetros, entender cómo implementar la Validación Cruzada K-Fold manualmente ofrece mayor flexibilidad e insights en el proceso de entrenamiento del modelo.


Comprensión del Conjunto de Datos
Para esta guía, utilizamos el conjunto de datos Predicción de Precios de Coches obtenido de Kaggle. Este conjunto de datos abarca varias características de los coches, con el objetivo de predecir sus precios de mercado.

Descripción General del Conjunto de Datos

    Características: 25 (excluyendo la variable objetivo)
        
            Numéricas: Tamaño del motor, potencia, RPM máxima, MPG en ciudad, MPG en carretera, etc.
            Categóricas: Marca del coche, tipo de combustible, aspiración, número de puertas, tipo de carrocería, configuración del eje motriz, etc.
        
    
    Variable Objetivo: price (valor continuo)


Inspección Inicial de los Datos
Antes de profundizar en el preprocesamiento de datos, es crucial inspeccionar el conjunto de datos:




		
		
			
			
Java
			
			import pandas as pd

# Load the dataset
data = pd.read_csv('CarPrice.csv')
print(data.head())
			
				
					
				
					1
2
3
4
5
				
						import pandas as pd
 
# Load the dataset
data = pd.read_csv('CarPrice.csv')
print(data.head())
					
				
			
		


Salida de Muestra:

    
        car_ID
        symboling
        CarName
        fueltype
        aspiration
        doornumber
        carbody
        
        highwaympg
        price
    
    
        1
        3
        alfa-romero giulia
        gas
        std
        two
        convertible
        
        27
        13495.0
    
    
        2
        3
        alfa-romero stelvio
        gas
        std
        two
        convertible
        
        27
        16500.0
    
    
        3
        1
        alfa-romero Quadrifoglio
        gas
        std
        two
        hatchback
        
        26
        16500.0
    
    
        4
        2
        audi 100 ls
        gas
        std
        four
        sedan
        
        30
        13950.0
    
    
        5
        2
        audi 100ls
        gas
        std
        four
        sedan
        
        22
        17450.0
    



Preprocesamiento de Datos
Un preprocesamiento de datos efectivo es vital para construir modelos de aprendizaje automático precisos y eficientes. Esta sección cubre el manejo de datos faltantes, la selección de características, la codificación de variables categóricas y el escalado de características.

Manejo de Datos Faltantes

Características Numéricas
Los valores faltantes en características numéricas pueden imputarse utilizando estrategias como la media, la mediana o el valor más frecuente:




		
		
			
			
Java
			
			import numpy as np
from sklearn.impute import SimpleImputer

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

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

# Fit and transform the numerical 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
10
11
12
				
						import numpy as np
from sklearn.impute import SimpleImputer
 
# Initialize imputer with mean strategy
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Identify numerical columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
 
# Fit and transform the numerical data
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		



Características Categóricas
Para datos categóricos, el valor más frecuente puede reemplazar las entradas faltantes:




		
		
			
			
Java
			
			from sklearn.impute import SimpleImputer

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

# Initialize imputer with most frequent strategy
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform the categorical 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
10
11
				
						from sklearn.impute import SimpleImputer
 
# Identify string columns
string_cols = list(np.where((X.dtypes == object))[0])
 
# Initialize imputer with most frequent strategy
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Fit and transform the categorical data
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
					
				
			
		



Selección de Características
Eliminar características irrelevantes o redundantes puede mejorar el rendimiento del modelo:




		
		
			
			
Java
			
			# Drop the 'car_ID' column as it's not a predictive feature
X.drop('car_ID', axis=1, inplace=True)
			
				
					
				
					1
2
				
						# Drop the 'car_ID' column as it's not a predictive feature
X.drop('car_ID', axis=1, inplace=True)
					
				
			
		



Codificación de Variables Categóricas
Los modelos de aprendizaje automático requieren entradas numéricas. Por lo tanto, las variables categóricas necesitan ser codificadas.

Codificación One-Hot
La codificación one-hot transforma variables categóricas en una matriz binaria:




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

# Identify string columns for encoding
string_cols = list(np.where((X.dtypes == object))[0])

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

# Apply transformation
X = columnTransformer.fit_transform(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
 
# Identify string columns for encoding
string_cols = list(np.where((X.dtypes == object))[0])
 
# Initialize ColumnTransformer with OneHotEncoder
columnTransformer = ColumnTransformer(
    [('encoder', OneHotEncoder(), string_cols)],
    remainder='passthrough'
)
 
# Apply transformation
X = columnTransformer.fit_transform(X)
					
				
			
		



Escalado de Características
El escalado asegura que las características numéricas contribuyan de manera equitativa al proceso de entrenamiento del modelo.

Estandarización
La estandarización escala las características para que tengan una media de 0 y una desviación estándar de 1:




		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

# 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
8
9
				
						from sklearn.preprocessing import StandardScaler
 
# 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)
					
				
			
		




Construcción de Modelos de Aprendizaje Automático
Con los datos preprocesados, se pueden construir y evaluar diversos modelos de regresión.

Regresor de Árbol de Decisión




		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import r2_score

# Initialize the model
model = DecisionTreeRegressor(max_depth=4)

# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import r2_score
 
# Initialize the model
model = DecisionTreeRegressor(max_depth=4)
 
# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
					
				
			
		


Puntuación R²: 0.884

Regresor de Bosque Aleatorio




		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestRegressor

# Initialize the model
model = RandomForestRegressor(n_estimators=25, random_state=10)

# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn.ensemble import RandomForestRegressor
 
# Initialize the model
model = RandomForestRegressor(n_estimators=25, random_state=10)
 
# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
					
				
			
		


Puntuación R²: 0.911

Regresor AdaBoost




		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostRegressor

# Initialize the model
model = AdaBoostRegressor(random_state=0, n_estimators=100)

# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn.ensemble import AdaBoostRegressor
 
# Initialize the model
model = AdaBoostRegressor(random_state=0, n_estimators=100)
 
# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
					
				
			
		


Puntuación R²: 0.881

Regresor XGBoost




		
		
			
			
Java
			
			import xgboost as xgb

# Initialize the model
model = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)

# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						import xgboost as xgb
 
# Initialize the model
model = xgb.XGBRegressor(
    n_estimators=100,
    reg_lambda=1,
    gamma=0,
    max_depth=3,
    learning_rate=0.05
)
 
# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
					
				
			
		


Puntuación R²: 0.895

Regresor de Vectores de Soporte (SVR)




		
		
			
			
Java
			
			from sklearn.svm import SVR

# Initialize the model
model = SVR()

# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn.svm import SVR
 
# Initialize the model
model = SVR()
 
# Train and evaluate
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(r2_score(y_test, y_pred))
					
				
			
		


Puntuación R²: -0.027
Nota: Una puntuación R² por debajo de 0 indica que el modelo funciona peor que una línea horizontal.


Implementación de la Validación Cruzada K-Fold sin GridSearchCV
Implementar la Validación Cruzada K-Fold manualmente proporciona un control granular sobre el proceso de entrenamiento y evaluación. Aquí hay una guía paso a paso:

Paso 1: Inicializar K-Fold




		
		
			
			
Java
			
			from sklearn.model_selection import KFold

# Initialize KFold with 5 splits, shuffling, and a fixed random state for reproducibility
kf = KFold(n_splits=5, random_state=42, shuffle=True)
			
				
					
				
					1
2
3
4
				
						from sklearn.model_selection import KFold
 
# Initialize KFold with 5 splits, shuffling, and a fixed random state for reproducibility
kf = KFold(n_splits=5, random_state=42, shuffle=True)
					
				
			
		



Paso 2: Definir una Función para Construir el Modelo
Encapsula el entrenamiento y la evaluación del modelo dentro de una función para su reutilización:




		
		
			
			
Java
			
			from sklearn.metrics import r2_score

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
				
						from sklearn.metrics import r2_score
 
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)
					
				
			
		



Paso 3: Ejecutar la Validación Cruzada K-Fold
Itera a través de cada fold, entrena el modelo y recopila las puntuaciones R²:




		
		
			
			
Java
			
			scores = []
for train_index, test_index in kf.split(X):
    X_train_fold, X_test_fold = X[train_index], X[test_index]
    y_train_fold, y_test_fold = y.iloc[train_index], y.iloc[test_index]
    score = build_model(X_train_fold, X_test_fold, y_train_fold, y_test_fold, model)
    scores.append(score)

print(scores)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						scores = []
for train_index, test_index in kf.split(X):
    X_train_fold, X_test_fold = X[train_index], X[test_index]
    y_train_fold, y_test_fold = y.iloc[train_index], y.iloc[test_index]
    score = build_model(X_train_fold, X_test_fold, y_train_fold, y_test_fold, model)
    scores.append(score)
 
print(scores)
					
				
			
		


Salida de Muestra:




		
		
			
			
Java
			
			[-0.10198885010286984, 
 -0.05769313782320418, 
 -0.1910165707884004, 
 -0.09880100338491071, 
 -0.260272529471554]
			
				
					
				
					1
2
3
4
5
				
						[-0.10198885010286984, 
 -0.05769313782320418, 
 -0.1910165707884004, 
 -0.09880100338491071, 
 -0.260272529471554]
					
				
			
		


Interpretación de las Puntuaciones: Las puntuaciones R² negativas indican un rendimiento deficiente del modelo en todos los folds. Esto sugiere problemas como sobreajuste, fuga de datos o selección inapropiada del modelo.

Paso 4: Analizando los Resultados
Un análisis completo de las puntuaciones de validación cruzada puede proporcionar insights sobre la estabilidad del modelo y sus capacidades de generalización.




		
		
			
			
Java
			
			import numpy as np

# Calculate mean and standard deviation
mean_score = np.mean(scores)
std_score = np.std(scores)

print(f"Mean R² Score: {mean_score}")
print(f"Standard Deviation: {std_score}")
			
				
					
				
					1
2
3
4
5
6
7
8
				
						import numpy as np
 
# Calculate mean and standard deviation
mean_score = np.mean(scores)
std_score = np.std(scores)
 
print(f"Mean R² Score: {mean_score}")
print(f"Standard Deviation: {std_score}")
					
				
			
		


Salida de Muestra:




		
		
			
			
Java
			
			Mean R² Score: -0.133554
Standard Deviation: 0.077'''
			
				
					
				
					1
2
				
						Mean R² Score: -0.133554
Standard Deviation: 0.077'''
					
				
			
		


Insights:

    La puntuación R² media negativa indica que el modelo está funcionando por debajo de lo esperado.
    Una alta desviación estándar sugiere una variabilidad significativa entre diferentes folds, lo que apunta a una inconsistencia en el poder predictivo del modelo.



Mejores Prácticas y Consejos

    K-Fold Estratificado para Clasificación: Aunque esta guía se centra en regresión, es esencial utilizar K-Fold Estratificado al tratar con tareas de clasificación para mantener la distribución de clases a través de los folds.
    Análisis de Importancia de Características: Después del entrenamiento del modelo, analizar la importancia de las características puede ayudar a entender cuáles características influyen más en la variable objetivo.
    Optimización de Hiperparámetros: Incluso sin GridSearchCV, puedes ajustar manualmente los hiperparámetros dentro de cada fold para encontrar las configuraciones óptimas para tus modelos.
    Manejo de Conjuntos de Datos Desequilibrados: Asegúrate de que las divisiones de entrenamiento y prueba mantengan el equilibrio de clases, especialmente en tareas de clasificación.
    Selección de Modelos: Siempre experimenta con múltiples modelos para identificar cuál se adapta mejor a las características de tu conjunto de datos.



Conclusión
La Validación Cruzada K-Fold es una técnica indispensable en el conjunto de herramientas de aprendizaje automático, ofreciendo un método robusto para evaluar el rendimiento del modelo. Al implementar manualmente la Validación Cruzada K-Fold, como se demuestra en esta guía, obtienes insights más profundos en el proceso de entrenamiento del modelo y mantienes un control total sobre cada paso de evaluación. Aunque herramientas automatizadas como GridSearchCV son convenientes, entender la mecánica subyacente te capacita para abordar escenarios más complejos y adaptar el proceso de validación a tus necesidades específicas.
Adopta el poder de la Validación Cruzada K-Fold para mejorar la confiabilidad y precisión de tus modelos predictivos, allanando el camino para decisiones más informadas y basadas en datos.


Palabras Clave: Validación Cruzada K-Fold, GridSearchCV, Aprendizaje Automático, Evaluación de Modelos, Python, Jupyter Notebook, Preprocesamiento de Datos, Modelos de Regresión, Técnicas de Validación Cruzada, Scikit-Learn
car_ID	symboling	CarName	fueltype	aspiration	doornumber	carbody	highwaympg	price
1	3	alfa-romero giulia	gas	std	two	convertible	27	13495.0
2	3	alfa-romero stelvio	gas	std	two	convertible	27	16500.0
3	1	alfa-romero Quadrifoglio	gas	std	two	hatchback	26	16500.0
4	2	audi 100 ls	gas	std	four	sedan	30	13950.0
5	2	audi 100ls	gas	std	four	sedan	22	17450.0