Validación Cruzada con Scikit-learn: Cruz Vales Cor y KFold

Clase 29 de 37 • Curso Profesional de Machine Learning con scikit-learn

Resumen

¿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

Pandas: Utilizado para la manipulación de datos.
NumPy: Ayuda en cálculos matemáticos complejos.
DecisionTreeRegressor: Un modelo de árbol de decisión para regresiones.
cross_val_score y KFold: Funciones de Scikit-Learn que facilitan la implementación de la validación cruzada.

¿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']

DataFrame data: Cargamos un CSV que contiene los datos.
Características X: Todas las columnas excepto el nombre del país y el score.
Objetivo 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.
Media y valor absoluto: Convertimos el valor medio del score negativo a su valor absoluto para mayor claridad.

¿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.
Partición y asignación: Divide los datos en conjuntos de entrenamiento y prueba.

¡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

student•

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

Franco Manca

student•

Excelente la implementacion

Joel Ibarra

student•

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

Matias Alexander Ibarra Trujillo

student•

no entiendo como interpretar el resultado de score

Gersonrpq

student•

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.

Matias Alexander Ibarra Trujillo

student•

Muchas gracias por la respuesta

Rodrigo Urquizo Yepez

student•

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.

Julián Cárdenas

student•

Excelente!

Miguel R Montilla

student•

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

Miguel Andres Alcazar Herrera

student•

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))}')

David fernando Pinzon suarez

student•

Que valor de neg_mean_squared_error es bueno?

Alberto Perdomo

student•

NMSE es una metrica contraintuitiva. El mejor valor es 0.0. Se refiere a que un 100% de valores 0% son erroneos.

Gabriel Ichcanziho Pérez Landa

student•

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

Jhon Freddy Tavera Blandon

student•

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.

K-Folds Cross Validation es una técnica útil para evaluar el rendimiento del modelo de manera más robusta y es especialmente útil cuando se tiene un conjunto de datos pequeño o se desea obtener una estimación más precisa del rendimiento del modelo.

Ricardo Gomez

student•

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.

Hugo Montoya Diaz

student•

Emanuel Anchique Pautt

student•

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)

Claudio Chavarría Altamirano

student•

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

Claudio Chavarría Altamirano

student•

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.

Gabriel Andrés Montiel Hermosa

student•

¿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:

Métricas para maximizar: como precisión, puntuación F1, o R², donde el modelo es mejor mientras el puntaje sea más alto.
Métricas para minimizar: como el error cuadrático medio (MSE), donde el modelo es mejor mientras el valor sea más bajo.

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í:

El MSE normal tiene valores positivos, y mientras más bajo, mejor.
Con neg_mean_squared_error, el MSE se multiplica por −1-1−1. Ahora:
- Un menor MSE (mejor modelo) se traduce en un puntaje más alto.
- Un mayor MSE (peor modelo) se traduce en un puntaje más bajo.

Por ejemplo:

Si el MSE real es 25, scikit-learn devuelve −25.0.
Si el MSE real es 10 (mejor modelo), scikit-learn devuelve −10, que es "más alto" en términos de puntaje.

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':

Los valores de la métrica serán negativos (ejemplo: −10.0, −25.0).
Un valor menos negativo (más cercano a 0) indica un mejor modelo:
- Ejemplo: −10.0 es mejor que −25.0.
Si necesitas el MSE real, simplemente invierte el signo de los resultados negativos:
- Ejemplo: Si obtienes −25, el MSE real es 25.

Antonio Demarco Bonino

student•

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)

Daniel Moreno

student•

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.

Daniel Moreno

student•

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

&#x20;   print("Índices de entrenamiento:", train)

&#x20;   print("Índices de prueba:", test)



&#x20;   \# Dividir el conjunto de datos en entrenamiento y prueba

&#x20;   X\_train, y\_train = X.iloc\[train], y.iloc\[train]

&#x20;   X\_test, y\_test = X.iloc\[test], y.iloc\[test]



&#x20;   \# Entrenar el modelo de árbol de decisión

&#x20;   model = DecisionTreeRegressor().fit(X\_train, y\_train)



&#x20;   \# Predecir utilizando el modelo entrenado

&#x20;   predict = model.predict(X\_test)



&#x20;   \# Calcular y guardar el error cuadrático medio

&#x20;   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))

Elias Dudamel

student•

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

Alfonso Andres Zapata Guzman

student•

que contienen las variables:

X_scaled, y_bal_df,

Supongo la primera fue escalada con StandardScaler(), pero y la segunda?

Tomas Dale

student•

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

César Pérez

student•

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