Contenido del curso
Validación Cruzada con Scikit-learn: Cruz Vales Cor y KFold
¿Cómo implementar la validación cruzada en Python?
La validación cruzada es una técnica esencial en el análisis de datos que te permite evaluar el rendimiento de un modelo de aprendizaje automático de manera efectiva. Este proceso implica dividir los datos en subconjuntos para probar el modelo varias veces y así asegurar su robustez. Gracias a bibliotecas como Scikit-Learn, esta técnica puede ser implementada de manera sencilla y eficaz. Vamos a explorar cómo hacerlo paso a paso.
¿Cuáles módulos y funciones necesitamos?
Para llevar a cabo la validación cruzada en Python, comenzaremos importando los módulos necesarios:
import pandas as pd import numpy as np from sklearn.tree import DecisionTreeRegressor from sklearn.model_selection import cross_val_score, KFold
¿Cómo preparar los datos?
Vamos a utilizar un dataset conocido para llevar a cabo nuestra validación cruzada. Puedes cargarlo y prepararlo como se muestra a continuación:
data = pd.read_csv('data/felicidad.csv') X = data.drop(['country', 'score'], axis=1) y = data['score']
data: Cargamos un CSV que contiene los datos.X: Todas las columnas excepto el nombre del país y el score.y: La columna que queremos predecir, en este caso, el 'score'.¿Cómo definir y evaluar el modelo?
En esta etapa, definimos nuestro modelo de árbol de decisión sin ajustes adicionales y procedemos a evaluarlo.
model = DecisionTreeRegressor() scores = cross_val_score( model, X, y, scoring='neg_mean_squared_error', cv=3 ) mean_score = np.mean(scores) abs_mean_score = np.abs(mean_score)
DecisionTreeRegressor: Se utiliza en su configuración predeterminada.cross_val_score: Calcula el error cuadrático medio negativo para validar cruzadamente.¿Cómo controlar las particiones de datos?
Usamos KFold para dividir los datos en subconjuntos específicos y controlar la aleatorización y consistencia de las particiones.
kf = KFold(n_splits=3, shuffle=True, random_state=42) for train_index, test_index in kf.split(X): X_train, X_test = X.iloc[train_index], X.iloc[test_index] y_train, y_test = y.iloc[train_index], y.iloc[test_index]
KFold: Permite definir el número de particiones (3 en nuestro caso), además de la opción de aleatorización.¡Así es como puedes implementar y controlar la validación cruzada de manera sencilla en Python! Experimentar con diferentes modelos y configuraciones te dará una profunda comprensión de la robustez y eficacia de tus modelos. Sigue explorando y aprendiendo, el único límite es tu curiosidad.
David Jordan
Estudiante
Franco Manca
Estudiante
Joel Ibarra
Estudiante
Matias Alexander Ibarra Trujillo
Estudiante
Gersonrpq
EstudianteMatias Alexander Ibarra Trujillo
Estudiante
Rodrigo Urquizo Yepez
Estudiante
Julián Cárdenas
Estudiante
Miguel R Montilla
EstudianteMiguel Andres Alcazar Herrera
EstudianteDavid fernando Pinzon suarez
Estudiante
Alberto Perdomo
Estudiante
Gabriel Ichcanziho Pérez Landa
Estudiante
Jhon Freddy Tavera Blandon
Estudiante
Ricardo Gomez
Estudiante
Hugo Montoya Diaz
EstudianteEmanuel Anchique Pautt
Estudiante
Claudio Chavarría Altamirano
EstudianteClaudio Chavarría Altamirano
Estudiante
Gabriel Andrés Montiel Hermosa
Estudiante
Antonio Demarco Bonino
Estudiante
Daniel Moreno
EstudianteDaniel Moreno
Estudiante
Elias Dudamel
Estudiante
Alfonso Andres Zapata Guzman
Estudiante
Tomas Dale
Estudiante
César Pérez
EstudianteAl final me parece que quedó muy en el aire esa información, asi que quise complementar. Aquí les dejo mi codigo de la implementación del Cross-Validation con KFold:
data = dataset.drop(["country","score"],axis=1) targets = dataset["score"] kf = KFold(n_splits=3,shuffle=True) mse_values = [] for train,test in kf.split(data): x_train = pd.DataFrame(columns=list(data),index=range(len(train))) x_test = pd.DataFrame(columns=list(data),index=range(len(test))) y_train = pd.DataFrame(columns=['score'],index=range(len(train))) y_test = pd.DataFrame(columns=['score'],index=range(len(test))) for i in range(len(train)): x_train.iloc[i] = data.iloc[train[i]] y_train.iloc[i] = targets.iloc[train[i]] for j in range(len(test)): x_test.iloc[j] = data.iloc[test[j]] y_test.iloc[j] = targets.iloc[test[j]] model = DecisionTreeRegressor().fit(x_train,y_train) predict = model.predict(x_test) mse_values.append(mean_squared_error(y_test,predict)) print("Los tres MSE fueron: ",mse_values) print("El MSE promedio fue: ", np.mean(mse_values))
Excelente la implementacion
Me parece que no es necesario todo lo que utilizas. Este es mi ejemplo usando tu codigo:
X = dataset.drop(['country', 'score'], axis=1) y = dataset['score'] print(dataset.shape) model = DecisionTreeRegressor() score = cross_val_score(model, X,y, cv=3, scoring='neg_mean_squared_error') # con cv podemos controlar el numOfFolds print(score) print(np.abs(np.mean(score))) kf = KFold(n_splits=3, shuffle=True, random_state=42) mse_values = [] for train, test in kf.split(dataset): print(train) print(test) X_train = X.iloc[train] y_train = y.iloc[train] X_test = X.iloc[test] y_test = y.iloc[test] model = DecisionTreeRegressor().fit(X_train, y_train) predict = model.predict(X_test) mse_values.append(mean_squared_error(y_test, predict)) print("Los tres MSE fueron: ", mse_values) print("El MSE promedio fue: ", np.mean(mse_values))
no entiendo como interpretar el resultado de score
El score es un arreglo de errores negativos medios cuadrados (es decir, cuanto mas pequeño en valor absoluto, mejor se ajusta el modelo a los datos) como salida del coss_val_score, este resultado se da ya que el modelo fue separado cv veces (en este caso 5 al principio y luego 3) en set de datos de entrenamiento y prueba, en lo que se puede notar que particiones fueron mas satisfactorias. Ahora al aplicar el promedio y el valor absoluto, puedes observar el error medio cuadrado promedio calculado a partir de las salidas score que evalúan la adaptación promedio del modelo a los datos.
Muchas gracias por la respuesta
En este caso al hacer tres splits, es decir al dividir nuestros datos en A,B,C, tenemos solo tres posibles combinaciones AB para training y C para test, luego AC con B, y por ultimo BC con A.
Excelente!
Dejo la implementación de los entrenamientos dentro del ciclo for de la última parte. Es decir, cómo usar los índices generados por KFold y usar una medida como la que veníamos usando antes para la pérdida (mean_squared_error):
# se importa adicional a las que ya se tienen from sklearn.metrics import mean_squared_error if __name__ == "__main__": dataset = pd.read_csv('./data/happiness.csv') X = dataset.drop(['country', 'score'], axis=1) y = dataset['score'] model = DecisionTreeRegressor() kf = KFold(n_splits=3, shuffle=True, random_state=42) losses = [] for train, test in kf.split(dataset): X_train = X.iloc[train] X_test = X.iloc[test] y_train = y[train] y_test = y[test] model.fit(X_train, y_train) predictions = model.predict(X_test) loss = mean_squared_error(y_test, predictions) losses.append(loss) print('Error para cada partición: ', losses) print('Promedio de los errores: ', np.mean(losses))
Implementación de cross validation con KFolds
X = dataset.drop(['country', 'score', 'rank'], axis=1) y = dataset['score'] model = DecisionTreeRegressor() kf = KFold(n_splits=10, shuffle=True, random_state=1) results = cross_val_score(model, X, y, cv=kf, scoring='neg_mean_squared_error') print(f'Promedio de los cross validation scores: {np.abs(np.mean(results))}')
Que valor de neg_mean_squared_error es bueno?
NMSE es una metrica contraintuitiva. El mejor valor es 0.0. Se refiere a que un 100% de valores 0% son erroneos.
Les dejo un código que hice bastante claro y escalable:
import pandas as pd import numpy as np from sklearn.tree import DecisionTreeRegressor from sklearn.model_selection import cross_val_score, KFold from sklearn.metrics import mean_squared_error def train_test_split_kf(data: np.array, target: np.array, train: np.array, test: np.array) -> np.array: x_train = data[train] x_test = data[test] y_train = target[train] y_test = target[test] return x_train, x_test, y_train, y_test def evaluate_model(model, metric, x_train, x_test, y_train, y_test): model.fit(x_train, y_train) y_pred = model.predict(x_test) score = metric(y_pred, y_test) return score def main(): dataset = pd.read_csv("../datasets/happines.csv") data = dataset.drop(["country", "score", "rank"], axis=1) target = dataset["score"] kf = KFold(n_splits=3, shuffle=True, random_state=42) models = {"DecisionTreeRegressor": DecisionTreeRegressor()} print('---- Easy Implementation ----') for name, model in models.items(): score = cross_val_score(model, data, target, cv=3, scoring='neg_mean_squared_error') print("Scores:", score) print("Mean score: ", np.abs(np.mean(score))) print("=" * 64) scores = [] print('---- Full Implementation ----') for name, model in models.items(): print(f"I'm evaluating: {name}") for n_fold, (train, test) in enumerate(kf.split(data)): print(f"\t-I'm running fold {n_fold + 1}") x_train, x_test, y_train, y_test = train_test_split_kf(data.values, target.values, train, test) score = evaluate_model(model, mean_squared_error, x_train, x_test, y_train, y_test) print("\t\t-score:", score) scores.append(score) print("="*64) print("Scores:", scores) print("Mean score: ", np.mean(scores)) if __name__ == '__main__': main()
- La validación cruzada de K-Folds (K-Folds Cross Validation) es una técnica que se utiliza para evaluar el rendimiento de un modelo de manera más robusta que simplemente dividir los datos en conjuntos de entrenamiento y prueba. En lugar de realizar una sola división de los datos, K-Folds divide los datos en K particiones o "pliegues" (folds) y entrena y prueba el modelo K veces, utilizando un fold diferente como conjunto de prueba en cada iteración. Luego, se promedian las métricas de rendimiento de todas las iteraciones para obtener una estimación más precisa del rendimiento del modelo.
La clase se centró en la implementación de K-Folds Cross Validation utilizando Scikit-Learn. Se explicó cómo importar las funciones necesarias y se mostró cómo aplicar la validación cruzada para evaluar un modelo de regresión de árboles de decisión. Se mencionó cómo ajustar los pliegues y calcular el score, destacando la importancia de obtener métricas como el error cuadrático medio. También se abordó la organización de los datos y la ejecución de pruebas rápidas para validar los modelos de manera eficiente.
Aquí les comparto mi implementación del KFold:
X = dataset.drop(['country','rank', 'score'], axis=1) y = dataset[['score']] k_fold = KFold(n_splits=3, shuffle=True, random_state=2) dtr = DecisionTreeRegressor() mse = [] for train_index, test_index in k_fold.split(X): # X_train X_train = pd.DataFrame(X.iloc[train_index, :], columns= list(X)) X_train = X_train.reset_index().drop('index', axis = 1) # X_test X_test = pd.DataFrame(X.iloc[test_index, :], columns= list(X)) X_test = X_test.reset_index().drop('index', axis = 1) # y_train y_train = pd.DataFrame(y.iloc[train_index, :], columns= list(y)) y_train = y_train.reset_index().drop('index', axis = 1) # y_test y_test = pd.DataFrame(y.iloc[test_index, :], columns= list(y)) y_test = y_test.reset_index().drop('index', axis = 1) dtr.fit(X_train, y_train) y_predit = dtr.predict(X_test) mse.append(mean_squared_error(y_test, y_predit)) print(mse)
Este codigo plotea las siguientes visuales:
import pandas as pd import numpy as np import matplotlib.pyplot as plt from sklearn.tree import DecisionTreeRegressor from sklearn.model_selection import cross_val_score, KFold from matplotlib.colors import ListedColormap if __name__ == "__main__": # Carga de datos data = pd.read_csv('./data/felicidad.csv') X = data.drop(['country','score'], axis=1) Y = data['score'] # Modelo y cross-validation model = DecisionTreeRegressor() kf = KFold(n_splits=5, shuffle=False)#, random_state=42) scores = cross_val_score(model, X, Y, cv=kf, scoring='neg_mean_squared_error') scores_abs = np.abs(scores) print("Scores por fold:", scores) print("Error medio absoluto:", np.mean(scores_abs)) # Visualización de folds en tonos de gris discretos n_samples = len(X) fold_matrix = np.zeros((5, n_samples)) for i, (train_idx, test_idx) in enumerate(kf.split(X)): fold_matrix[i, train_idx] = 1 # Train fold_matrix[i, test_idx] = 2 # Test cmap = ListedColormap(["white", "dimgray", "lightgray"]) plt.figure(figsize=(12, 5)) plt.imshow(fold_matrix, cmap=cmap, aspect="auto") plt.yticks(range(5), [f"Fold {i+1}" for i in range(5)]) plt.xticks([]) plt.colorbar(ticks=[0,1,2], label="0 = vacío | 1 = Train | 2 = Test") plt.title("División de datos en K-Fold Cross-Validation (escala de grises discreta)") plt.show() plt.figure(figsize=(8,5)) plt.bar(range(1, 6), scores_abs, color="gray", alpha=0.7) plt.plot(range(1, 6), scores_abs, "o-", color="black") plt.xlabel("Fold") plt.ylabel("Error cuadrático medio") plt.title("Error por fold en validación cruzada") plt.show()
El ver lo fold ordenados se debe a suffle = False, importante remover random_state = 42 para que funcione
La diferencia entre el mejor fold (3) y el peor (5) es grande. Eso indica que el modelo (árbol de decisión) es inestable con respecto a cómo se dividen los datos. Dicho de otro modo, depende bastante de qué ejemplos caigan en train y cuáles en test.
¿Por qué se utiliza un valor negativo para el error cuadrático medio (MSE) en scoring='neg_mean_squared_error' ?
1. El objetivo de las métricas de evaluación
En bibliotecas como scikit-learn, las métricas se dividen en dos categorías principales:
Sin embargo, las funciones de scikit-learn como cross_val_score están diseñadas para maximizar los puntajes, no minimizarlos. Esto presenta un problema con métricas como el MSE, que naturalmente debe minimizarse.
2. ¿Qué hace scikit-learn con el MSE?
Para que el MSE se ajuste al paradigma de "puntaje más alto = mejor modelo", scikit-learn invierte su signo. Así:
neg_mean_squared_error, el MSE se multiplica por −1-1−1. Ahora:
Por ejemplo:
3. ¿Por qué lo hacen negativo?
Esto es una convención de diseño en scikit-learn, porque las funciones como cross_val_score y GridSearchCV están pensadas para trabajar con métricas que crecen hacia valores más altos. Al usar el negativo, puedes seguir maximizando el puntaje sin necesidad de un tratamiento especial para métricas "de minimización".
4. Cómo interpretarlo en la práctica
Cuando usas scoring='neg_mean_squared_error':
Le hice unas pequeñas modificaciones al código para que se entienda más cuáles son las matrices de entrenamiento y cuáles las de prueba:
import pandas as pd import numpy as np from sklearn.tree import DecisionTreeRegressor from sklearn.model_selection import (cross_val_score, KFold) if __name__ == "__main__": data = pd.read_csv('./data/felicidad.csv') X = data.drop(['country','score'], axis=1) Y = data['score'] model = DecisionTreeRegressor() score = cross_val_score(model, X,Y, cv=3, scoring='neg_mean_squared_error') score_mean_abs = np.abs(np.mean(score)) print(score) print(score_mean_abs) kf = KFold(n_splits=3, shuffle=True, random_state=42) for train, test in kf.split(data): print("Training data:", train) print("Test data:", test)
El parámetro cv=3 en la función cross_val_score() indica el número de "folds" o divisiones que se utilizarán en la validación cruzada.
La validación cruzada es una técnica utilizada para evaluar el rendimiento de un modelo de machine learning. En este caso, al establecer cv=3, estamos utilizando la validación cruzada con 3 "folds" o divisiones.
En términos simples, esto significa que el conjunto de datos se divide en 3 partes iguales. Luego, el modelo se entrena y evalúa 3 veces, cada vez utilizando una de las partes como conjunto de prueba y las otras dos partes como conjunto de entrenamiento. Esto permite una evaluación más robusta del modelo, ya que se utiliza cada parte del conjunto de datos tanto para entrenamiento como para prueba en diferentes momentos. Luego, se calcula una métrica de rendimiento (en este caso, el error cuadrático medio) para cada fold y se informa el promedio de estas métricas como resultado final de la validación cruzada.
Aquí tienes el código optimizado y con comentarios explicativos:
from sklearn.model_selection import cross_val_score, KFold from sklearn.tree import DecisionTreeRegressor from sklearn.metrics import mean_squared_error import numpy as np # Seleccionar características y etiquetas X = dataset.drop(['country', 'score'], axis=1) y = dataset['score'] # Imprimir la forma del dataset original print("Forma del dataset original:", dataset.shape) # Crear un modelo de árbol de decisión model = DecisionTreeRegressor() # Validación cruzada para evaluar el modelo score = cross_val_score(model, X, y, cv=3, scoring='neg_mean_squared_error') print("Puntuaciones de validación cruzada:", score) # Calcular y imprimir el error cuadrático medio promedio absoluto print("Error cuadrático medio promedio absoluto:", np.abs(np.mean(score))) # Configurar validación cruzada KFold kf = KFold(n_splits=3, shuffle=True, random_state=42) # Inicializar una lista para almacenar los valores de error cuadrático medio mse_values = [] # Iterar a través de las divisiones de entrenamiento y prueba for train, test in kf.split(dataset): print("Índices de entrenamiento:", train) print("Índices de prueba:", test) # Dividir el conjunto de datos en entrenamiento y prueba X_train, y_train = X.iloc[train], y.iloc[train] X_test, y_test = X.iloc[test], y.iloc[test] # Entrenar el modelo de árbol de decisión model = DecisionTreeRegressor().fit(X_train, y_train) # Predecir utilizando el modelo entrenado predict = model.predict(X_test) # Calcular y guardar el error cuadrático medio mse_values.append(mean_squared_error(y_test, predict)) # Imprimir los valores de error cuadrático medio para cada fold print("Los tres MSE fueron:", mse_values) # Calcular y imprimir el MSE promedio print("El MSE promedio fue:", np.mean(mse_values)) ```from sklearn.model\_selection import cross\_val\_score, KFold from sklearn.tree import DecisionTreeRegressor from sklearn.metrics import mean\_squared\_error import numpy as np \# Seleccionar características y etiquetas X = dataset.drop(\['country', 'score'], axis=1) y = dataset\['score'] \# Imprimir la forma del dataset original print("Forma del dataset original:", dataset.shape) \# Crear un modelo de árbol de decisión model = DecisionTreeRegressor() \# Validación cruzada para evaluar el modelo score = cross\_val\_score(model, X, y, cv=3, scoring='neg\_mean\_squared\_error') print("Puntuaciones de validación cruzada:", score) \# Calcular y imprimir el error cuadrático medio promedio absoluto print("Error cuadrático medio promedio absoluto:", np.abs(np.mean(score))) \# Configurar validación cruzada KFold kf = KFold(n\_splits=3, shuffle=True, random\_state=42) \# Inicializar una lista para almacenar los valores de error cuadrático medio mse\_values = \[] \# Iterar a través de las divisiones de entrenamiento y prueba for train, test in kf.split(dataset):   print("Índices de entrenamiento:", train)   print("Índices de prueba:", test)   \# Dividir el conjunto de datos en entrenamiento y prueba   X\_train, y\_train = X.iloc\[train], y.iloc\[train]   X\_test, y\_test = X.iloc\[test], y.iloc\[test]   \# Entrenar el modelo de árbol de decisión   model = DecisionTreeRegressor().fit(X\_train, y\_train)   \# Predecir utilizando el modelo entrenado   predict = model.predict(X\_test)   \# Calcular y guardar el error cuadrático medio   mse\_values.append(mean\_squared\_error(y\_test, predict)) \# Imprimir los valores de error cuadrático medio para cada fold print("Los tres MSE fueron:", mse\_values) \# Calcular y imprimir el MSE promedio print("El MSE promedio fue:", np.mean(mse\_values))
Una forma de validar nuestro modelo a través de K-folds es importar la función cross_validate.
results = cross_validate(LinearSVC(dual=False), X_scaled, y_bal_df, return_train_score=True, cv=50)
Donde usa K-folds determinados por analista, ingresamos el modelo a usar, nuestros features, nuestra columna Target y podemos usar el parámetro return_train_score para que nos devuelva el score de cada uno de los modelos armados con cada K-fold.
Para este ejemplo, devuelve 50 resultados y se ve de esta manera:
{'fit_time': array([0.7657094 , 0.79296184, 0.78337979, 0.76587272, 0.77635145, 0.85032177, 0.81398034, 0.85498548, 0.83176494, 0.80038834, 0.77539325, 0.77279139, 0.77225327, 0.7791965 , 0.78038335, 0.80153918, 0.80040407, 0.79351783, 0.81560874, 0.80307364, 0.81683111, 0.82906723, 0.80062199, 0.82587028, 0.82564425, 0.82885957, 0.81278729, 0.8008554 , 0.79572654, 0.79565167, 0.79669046, 0.80218983, 0.80508876, 0.79961634, 0.81082296, 0.80319452, 0.77765465, 0.79044795, 0.8088398 , 0.77227616, 0.7737639 , 0.80028009, 0.77275562, 0.80092597, 0.83133173, 0.79332328, 0.82022905, 0.7792604 , 0.7991221 , 0.76032257]), 'score_time': array([0.00137734, 0.00085735, 0.00090194, 0.00089025, 0.00107074, 0.00088453, 0.00085354, 0.00089717, 0.00089884, 0.00094604, 0.00084925, 0.00099683, 0.00086522, 0.00086045, 0.00086689, 0.00135803, 0.00090003, 0.00088763, 0.00086021, 0.00089717, 0.00164509, 0.00086546, 0.00089502, 0.00087857, 0.00087142, 0.00086522, 0.00091124, 0.00086331, 0.00086379, 0.00085735, 0.00086927, 0.00086069, 0.00087881, 0.00088525, 0.00098681, 0.00091887, 0.00086212, 0.00087953, 0.00084734, 0.00087833, 0.00088882, 0.00086713, 0.0008862 , 0.00087786, 0.00107956, 0.00086331, 0.0008769 , 0.00088549, 0.00094199, 0.00087142]), 'test_score': array([0.77079108, 0.90365112, 0.90466531, 0.90567951, 0.92697769, 0.87423935, 0.92089249, 0.96044625, 0.96450304, 0.96653144, 0.96450304, 0.97360406, 0.96446701, 0.97360406, 0.9715736 , 0.97664975, 0.98375635, 0.97969543, 0.97360406, 0.97766497, 0.97055838, 0.97664975, 0.97766497, 0.97969543, 0.97360406, 0.97258883, 0.97969543, 0.96649746, 0.97664975, 0.97360406, 0.97664975, 0.97969543, 0.96649746, 0.97664975, 0.97360406, 0.98071066, 0.97969543, 0.93299492, 0.92791878, 0.92385787, 0.93401015, 0.93502538, 0.91269036, 0.9177665 , 0.92994924, 0.93299492, 0.91573604, 0.91573604, 0.91472081, 0.91979695]), 'train_score': array([0.95287416, 0.95154842, 0.95202486, 0.95127913, 0.95115484, 0.95206629, 0.95158985, 0.95171414, 0.95113413, 0.95127913, 0.95161056, 0.95111443, 0.95144585, 0.95115585, 0.95109371, 0.95113514, 0.95096943, 0.95082443, 0.95101085, 0.950928 , 0.95103157, 0.95113514, 0.95082443, 0.95090728, 0.95109371, 0.951363 , 0.95105228, 0.95134228, 0.95103157, 0.951073 , 0.95086585, 0.950928 , 0.95115585, 0.95111443, 0.95119728, 0.95088657, 0.95096943, 0.951073 , 0.95117657, 0.95144585, 0.95128014, 0.950928 , 0.95144585, 0.95179799, 0.95113514, 0.95088657, 0.95148728, 0.95123871, 0.951218 , 0.95159085])}
Un poco complejo de leer, no? En realidad es todo data que ya vimos en el curso, donde podemos ver los scores de cada modelo armado.
De acá en adelante solo nos queda sacar el promedio de nuestros scores en cada etapa (train y test) y ver si debemos ajustar algo para corregir un posible overfitting o un underfitting.
test_scores = results['test_score'] train_scores = results['train_score'] print(f'Train score : {np.mean(train_scores)}') print(f'Test score : {np.mean(test_scores)}')
Para cerrar este ejemplo, el resultado seria el siguiente: Train score : 0.9512525761353487 Test score : 0.9486281648665067
que contienen las variables:
X_scaled, y_bal_df,
Supongo la primera fue escalada con StandardScaler(), pero y la segunda?
COMPLETO
import pandas as pd import numpy as np
from sklearn.metrics import mean_squared_error
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import ( cross_val_score, KFold )
dataset = pd.read_csv('felicidad.csv') X = dataset.drop(['country', 'score'], axis=1) y = dataset['score']
model = DecisionTreeRegressor()
score = cross_val_score(model, X,y, cv=5, scoring='neg_mean_squared_error') print ("MSE para cv=5, 5 valores") print(score) print(np.abs(np.mean(score)))
print("")
kf = KFold(n_splits=3, shuffle=True, random_state=42) mse_values = []
for train, test in kf.split(dataset): X_train = X.iloc[train] X_test = X.iloc[test]
y_train = y[train] y_test = y[test] model = DecisionTreeRegressor().fit(X_train,y_train) predict = model.predict(X_test) mse = mean_squared_error(y_test,predict) mse_values.append(mse) #model.fit(X_train, y_train) #predictions = model.predict(X_test) #.append(mean_squared_error(y_test,predict))
print('Error para cada partición: ', mse_values) print('Promedio de los errores: ', np.mean(mse_values))
Mi implementación de K-Folds
lst = [] cv = 1 for train , test in kf.split(X,y= y): # datasets X_train = pd.DataFrame(X.iloc[train,:], columns=X.columns) y_train = pd.DataFrame(y.iloc[train,]) X_test = pd.DataFrame(X.iloc[test,:], columns=X.columns) y_test = pd.DataFrame(y.iloc[test,]) #Modelo dt = DecisionTreeRegressor().fit(X_train,y_train) y_predict = dt.predict(X_test) lst.append(mean_squared_error(y_predict, y_test)) print(f'The error for the folder number {cv} =',mean_squared_error(y_predict, y_test)) cv += 1 print(f'\nThe mean of ther erros is equal to {np.mean(lst)}')
Resultado
The error for the folder number 1 = 0.260119109314712 The error for the folder number 2 = 0.21976508857008575 The error for the folder number 3 = 0.23677062451690725 The error for the folder number 4 = 0.31030546626208927
The mean of ther erros is equal to 0.2567400721659486