Cursos Empresas Blog Live Conf Eventos Precios

0:009:09

Recursos

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.

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

Curso Profesional de Machine Learning con scikit-learn

Clase 29 de 37

Clase 29 / 37

Elias Dudamel

Hace 4 años

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

Hace 4 años

que contienen las variables:

X_scaled, y_bal_df,

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

Comentarios (19)19 comentarios

David Jordan

Hace 6 años

Franco Manca

Excelente la implementacion

Joel Ibarra

Hace 5 años

Matias Alexander Ibarra Trujillo

Hace 7 años

no entiendo como interpretar el resultado de score

Gersonrpq

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

Rodrigo Urquizo Yepez

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

Hace 3 años

Excelente!

Miguel R Montilla

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

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

Que valor de neg_mean_squared_error es bueno?

Alberto Perdomo

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

Jhon Freddy Tavera Blandon

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

Hace 2 años

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

Emanuel Anchique Pautt

Claudio Chavarría Altamirano

Hace un año

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

¿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

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

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.

Tomas Dale

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

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

Recursos

Resumen

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

Progreso del curso

Aprender los conceptos clave

Iniciar un proyecto con sklearn

Optimización de features

Regresiones robustas

Métodos de ensamble aplicados a clasificación

Clustering

Optimización paramétrica

Salida a producción