Validación Cruzada con Scikit-learn

Introducción

En el aprendizaje automático (machine learning), a menudo dividimos nuestros datos en un conjunto de entrenamiento (training set) y un conjunto de prueba (testing set) para evaluar el rendimiento de un modelo. Sin embargo, esta evaluación puede depender en gran medida de qué puntos de datos terminan en el conjunto de entrenamiento frente al conjunto de prueba. Un método más robusto es la validación cruzada (cross-validation, CV).

¿Por qué validación cruzada?

• Reduce el riesgo de sobreajuste (overfitting): Prueba el modelo en múltiples divisiones de datos.
• Mejor estimación de generalización: Rendimiento más fiable en datos no vistos.
• Maximiza el uso de datos: Cada muestra se utiliza tanto para entrenamiento como para prueba.

La validación cruzada implica dividir el conjunto de datos en múltiples "pliegues" (folds) y luego entrenar y evaluar el modelo varias veces, utilizando un pliegue diferente para la prueba cada vez. Esto nos da una estimación más fiable del rendimiento del modelo en datos no vistos.

En este laboratorio, aprenderá a utilizar las potentes y convenientes funciones de scikit-learn para realizar validación cruzada en un clasificador utilizando el famoso conjunto de datos Iris. Aprenderá a usar cross_val_score para obtener puntuaciones de rendimiento y luego calcular su media y desviación estándar para comprender mejor la estabilidad y la precisión general del modelo.

Importar cross_val_score desde sklearn.model_selection

En este paso, comenzará importando la función necesaria para realizar la validación cruzada. La función cross_val_score es la herramienta principal en scikit-learn para este propósito. Simplifica el proceso de dividir los datos, entrenar el modelo y puntuarlo en múltiples pliegues (folds).

Primero, abra el archivo main.py ubicado en el directorio ~/project utilizando el explorador de archivos en el lado izquierdo de su IDE.

Ahora, agregue la declaración de importación para cross_val_score a su script main.py. Colóquela junto con las otras importaciones en la parte superior del archivo.

from sklearn.model_selection import cross_val_score

Su archivo main.py debería verse así ahora:

import numpy as np
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

## Load the iris dataset
iris = datasets.load_iris()
X, y = iris.data, iris.target

## Initialize a Support Vector Classifier (SVC)
## Parameters explained:
## - kernel='linear': Uses a linear kernel for linearly separable data like Iris
## - C=1: Regularization parameter (higher values = less regularization)
## - random_state=42: Ensures reproducible results across runs
clf = SVC(kernel='linear', C=1, random_state=42)

## --- Your code will go below this line ---

Puede ejecutar el script para asegurarse de que no haya errores de sintaxis. Abra una terminal en su IDE y ejecute el siguiente comando:

python3 main.py

No debería ver ninguna salida, lo cual es esperado ya que aún no hemos agregado ningún código para producir salida.

Inicializar KFold con n_splits=5 desde sklearn.model_selection

Si bien cross_val_score puede manejar automáticamente la división de datos, es una buena práctica comprender el mecanismo subyacente. La estrategia de validación cruzada más común es K-Fold, donde el conjunto de datos se divide en 'k' pliegues (folds). El modelo se entrena en k-1 pliegues y se prueba en el pliegue restante, repitiendo este proceso k veces.

Parámetros de KFold:

• n_splits=5: Divide los datos en 5 partes iguales (pliegues).
• shuffle=False (por defecto): Mantiene el orden original de los datos.
• random_state: Controla la aleatorización si shuffle=True.

La clase KFold en scikit-learn es un iterador de validación cruzada que proporciona índices de entrenamiento/prueba para dividir los datos. Aunque utilizaremos un atajo más simple en el siguiente paso, comprender KFold es fundamental.

Importemos KFold y veamos cómo inicializarlo. Agregue las siguientes líneas a su archivo main.py.

Primero, agregue la declaración de importación en la parte superior:

from sklearn.model_selection import KFold

Luego, puede inicializarlo. Sin embargo, para este laboratorio, nos basaremos en el parámetro cv de cross_val_score, que es un enfoque más directo. El propósito de este paso es introducirle el concepto de KFold. Por simplicidad y para seguir el flujo del laboratorio, no agregaremos el código de inicialización de KFold a nuestro script. Utilizaremos directamente cv=5 en el siguiente paso, que internamente utiliza una estrategia K-Fold. Esta es la forma más común y sencilla de realizar validación cruzada.

Avancemos al siguiente paso donde utilizaremos este concepto en la práctica. Dado que no se agregó código en este paso, puede hacer clic en "Continuar" para avanzar.

Realizar validación cruzada con cross_val_score(clf, X, y, cv=5)

Ahora es el momento de realizar la validación cruzada. Utilizaremos la función cross_val_score que importamos anteriormente. Esta función toma varios argumentos:

Parámetros de cross_val_score:

• estimator: El modelo a evaluar (nuestro clasificador clf).
• X: La matriz de datos de características.
• y: El array de etiquetas objetivo.
• cv=5: Estrategia de validación cruzada (un entero indica k-fold, o un objeto divisor de CV).
• scoring: Métrica de evaluación (por defecto utiliza el método score del estimador).
• n_jobs: Número de núcleos de CPU a utilizar (por defecto=1, -1 para todos los núcleos).

Al establecer cv=5, le estamos indicando a scikit-learn que realice una validación cruzada de 5 pliegues. Dividirá automáticamente los datos en 5 pliegues, luego entrenará y probará el modelo 5 veces, devolviendo un array que contiene la puntuación para cada ejecución.

Agregue el siguiente código al final de su archivo main.py, debajo de la línea de comentario:

## Perform 5-fold cross-validation
scores = cross_val_score(clf, X, y, cv=5)

## Print the array of scores
print("Scores:", scores)

Su archivo main.py completo debería verse así ahora:

import numpy as np
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

## Load the iris dataset
iris = datasets.load_iris()
X, y = iris.data, iris.target

## Initialize a Support Vector Classifier (SVC)
## Parameters explained:
## - kernel='linear': Uses a linear kernel for linearly separable data like Iris
## - C=1: Regularization parameter (higher values = less regularization)
## - random_state=42: Ensures reproducible results across runs
clf = SVC(kernel='linear', C=1, random_state=42)

## --- Your code will go below this line ---

## Perform 5-fold cross-validation
scores = cross_val_score(clf, X, y, cv=5)

## Print the array of scores
print("Scores:", scores)

Ahora, ejecute el script desde su terminal:

python3 main.py

Verá la salida que muestra un array de 5 puntuaciones, una para cada pliegue de la validación cruzada.

Scores: [0.96666667 1.         0.96666667 0.96666667 1.        ]
Mean score: 0.9800000000000001
Standard deviation: 0.016329931618554516

Sus puntuaciones pueden ser ligeramente diferentes dependiendo de la división exacta, pero deberían ser similares. Este array le ofrece una visión detallada de cómo se desempeñó el modelo en diferentes subconjuntos de los datos.

Calcular la puntuación media de CV con scores.mean()

Tener un array de puntuaciones es informativo, pero para un resumen rápido del rendimiento del modelo, solemos calcular la media de estas puntuaciones. Este único valor nos da una idea general de la precisión del modelo.

La función cross_val_score devuelve un array de NumPy, que viene con muchos métodos útiles, incluido .mean(). Podemos llamar a este método directamente en nuestra variable scores.

Agregue las siguientes líneas al final de su script main.py para calcular e imprimir la puntuación media:

## Compute and print the mean of the scores
mean_score = scores.mean()
print("Mean score:", mean_score)

Su archivo main.py ahora debería contener el siguiente código:

import numpy as np
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

## Load the iris dataset
iris = datasets.load_iris()
X, y = iris.data, iris.target

## Initialize a Support Vector Classifier (SVC)
## Parameters explained:
## - kernel='linear': Uses a linear kernel for linearly separable data like Iris
## - C=1: Regularization parameter (higher values = less regularization)
## - random_state=42: Ensures reproducible results across runs
clf = SVC(kernel='linear', C=1, random_state=42)

## --- Your code will go below this line ---

## Perform 5-fold cross-validation
scores = cross_val_score(clf, X, y, cv=5)

## Print the array of scores
print("Scores:", scores)

## Compute and print the mean of the scores
mean_score = scores.mean()
print("Mean score:", mean_score)

Ejecute el script de nuevo:

python3 main.py

La salida ahora incluirá la media de las 5 puntuaciones, proporcionándole una métrica de rendimiento única y representativa.

Scores: [0.96666667 1.         0.96666667 0.96666667 1.        ]
Mean score: 0.9800000000000001

Calcular la desviación estándar de las puntuaciones de CV con scores.std()

La puntuación media nos indica el rendimiento promedio, pero no nos dice cuán consistente es ese rendimiento. La desviación estándar de las puntuaciones nos da una medida de esta varianza.

Interpretación de la desviación estándar:

• Desviación estándar baja (< 0.05): El modelo rinde de manera consistente en todos los subconjuntos de datos.
• Desviación estándar media (0.05-0.15): Variación moderada, aceptable para la mayoría de los casos.
• Desviación estándar alta (> 0.15): Gran variación en el rendimiento, puede indicar problemas con los datos o inestabilidad del modelo.

Una desviación estándar baja indica que el rendimiento del modelo es estable en diferentes subconjuntos de los datos, mientras que una desviación estándar alta sugiere que el rendimiento es más variable.

Al igual que .mean(), los arrays de NumPy también tienen un método .std() para calcular la desviación estándar.

Agregue la última parte del código a su script main.py para calcular e imprimir la desviación estándar:

## Compute and print the standard deviation of the scores
std_dev = scores.std()
print("Standard deviation:", std_dev)

Su script main.py final está ahora completo y debería verse así:

import numpy as np
from sklearn import datasets
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

## Load the iris dataset
iris = datasets.load_iris()
X, y = iris.data, iris.target

## Initialize a Support Vector Classifier (SVC)
## Parameters explained:
## - kernel='linear': Uses a linear kernel for linearly separable data like Iris
## - C=1: Regularization parameter (higher values = less regularization)
## - random_state=42: Ensures reproducible results across runs
clf = SVC(kernel='linear', C=1, random_state=42)

## --- Your code will go below this line ---

## Perform 5-fold cross-validation
scores = cross_val_score(clf, X, y, cv=5)

## Print the array of scores
print("Scores:", scores)

## Compute and print the mean of the scores
mean_score = scores.mean()
print("Mean score:", mean_score)

## Compute and print the standard deviation of the scores
std_dev = scores.std()
print("Standard deviation:", std_dev)

Ejecute el script una última vez:

python3 main.py

La salida final mostrará el array de puntuaciones, su media y su desviación estándar, proporcionándole una evaluación completa del rendimiento de su modelo.

Scores: [0.96666667 1.         0.96666667 0.96666667 1.        ]
Mean score: 0.9800000000000001
Standard deviation: 0.016329931618554516

Resumen

¡Felicitaciones por completar este laboratorio! Ha aprendido con éxito a realizar e interpretar una validación cruzada k-fold utilizando scikit-learn.

En este laboratorio, usted:

• Comprendió la importancia de la validación cruzada para una evaluación robusta del modelo.
• Utilizó la función cross_val_score para realizar fácilmente una validación cruzada de 5-fold en un clasificador de vectores de soporte (Support Vector Classifier).
• Analizó los resultados calculando e imprimiendo la media y la desviación estándar de las puntuaciones de la validación cruzada.

Consejos prácticos para la validación cruzada:

• Utilice validación cruzada de 5 o 10 folds para la mayoría de los escenarios.
• Considere la validación cruzada estratificada (stratified CV) para conjuntos de datos desequilibrados.
• Utilice cross_validate en lugar de cross_val_score para métricas múltiples.
• Siempre establezca random_state para obtener resultados reproducibles.

Esta técnica es una parte fundamental del flujo de trabajo del aprendizaje automático, asegurando que el rendimiento de su modelo sea confiable y no solo el resultado de una división afortunada de entrenamiento-prueba. Ahora puede aplicar este conocimiento para evaluar sus propios modelos de aprendizaje automático con mayor confianza.