Trazar curvas de aprendizaje

Introducción

El propósito de este laboratorio es mostrar cómo utilizar la clase LearningCurveDisplay de scikit-learn para trazar curvas de aprendizaje. Las curvas de aprendizaje muestran el efecto de agregar más muestras durante el proceso de entrenamiento. Analizaremos la curva de aprendizaje de un clasificador Naive Bayes y un clasificador SVM con un kernel RBF utilizando el conjunto de datos de dígitos. Además, examinaremos la escalabilidad de estos modelos predictivos al analizar su costo computacional y no solo su precisión estadística.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje comentarios después de la sesión y resolveremos rápidamente el problema para usted.

Skills Graph

Cargar el conjunto de datos

from sklearn.datasets import load_digits

X, y = load_digits(return_X_y=True)

Definir los modelos

from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC

naive_bayes = GaussianNB()
svc = SVC(kernel="rbf", gamma=0.001)

Trazar las curvas de aprendizaje

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import LearningCurveDisplay, ShuffleSplit

fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10, 6), sharey=True)

common_params = {
    "X": X,
    "y": y,
    "train_sizes": np.linspace(0.1, 1.0, 5),
    "cv": ShuffleSplit(n_splits=50, test_size=0.2, random_state=0),
    "score_type": "both",
    "n_jobs": 4,
    "line_kw": {"marker": "o"},
    "std_display_style": "fill_between",
    "score_name": "Precisión",
}

for ax_idx, estimator in enumerate([naive_bayes, svc]):
    LearningCurveDisplay.from_estimator(estimator, **common_params, ax=ax[ax_idx])
    handles, label = ax[ax_idx].get_legend_handles_labels()
    ax[ax_idx].legend(handles[:2], ["Puntuación de Entrenamiento", "Puntuación de Prueba"])
    ax[ax_idx].set_title(f"Curva de Aprendizaje para {estimator.__class__.__name__}")

Analizar las curvas de aprendizaje

## Interpretar las curvas de aprendizaje

Podemos analizar la curva de aprendizaje del clasificador Naive Bayes. Su forma se puede encontrar con frecuencia en conjuntos de datos más complejos: la puntuación de entrenamiento es muy alta cuando se utilizan pocos ejemplos para el entrenamiento y disminuye al aumentar el número de muestras, mientras que la puntuación de prueba es muy baja al principio y luego aumenta al agregar muestras. Las puntuaciones de entrenamiento y prueba se vuelven más realistas cuando se utilizan todas las muestras para el entrenamiento.

Vemos otra curva de aprendizaje típica para el clasificador SVM con kernel RBF. La puntuación de entrenamiento permanece alta independientemente del tamaño del conjunto de entrenamiento. Por otro lado, la puntuación de prueba aumenta con el tamaño del conjunto de datos de entrenamiento. De hecho, aumenta hasta un punto en el que alcanza un piso. Observar tal piso es una indicación de que puede que no sea útil adquirir nuevos datos para entrenar el modelo ya que el rendimiento de generalización del modelo no aumentará más.

Comprobar la escalabilidad de los modelos

from sklearn.model_selection import learning_curve

common_params = {
    "X": X,
    "y": y,
    "train_sizes": np.linspace(0.1, 1.0, 5),
    "cv": ShuffleSplit(n_splits=50, test_size=0.2, random_state=0),
    "n_jobs": 4,
    "return_times": True,
}

train_sizes, _, test_scores_nb, fit_times_nb, score_times_nb = learning_curve(
    naive_bayes, **common_params
)
train_sizes, _, test_scores_svm, fit_times_svm, score_times_svm = learning_curve(
    svc, **common_params
)

Trazar la escalabilidad de los modelos

fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(16, 12), sharex=True)

for ax_idx, (fit_times, score_times, estimator) in enumerate(
    zip(
        [fit_times_nb, fit_times_svm],
        [score_times_nb, score_times_svm],
        [naive_bayes, svc],
    )
):
    ## escalabilidad en cuanto al tiempo de ajuste
    ax[0, ax_idx].plot(train_sizes, fit_times.mean(axis=1), "o-")
    ax[0, ax_idx].fill_between(
        train_sizes,
        fit_times.mean(axis=1) - fit_times.std(axis=1),
        fit_times.mean(axis=1) + fit_times.std(axis=1),
        alpha=0.3,
    )
    ax[0, ax_idx].set_ylabel("Tiempo de ajuste (s)")
    ax[0, ax_idx].set_title(
        f"Escalabilidad del clasificador {estimator.__class__.__name__}"
    )

    ## escalabilidad en cuanto al tiempo de puntuación
    ax[1, ax_idx].plot(train_sizes, score_times.mean(axis=1), "o-")
    ax[1, ax_idx].fill_between(
        train_sizes,
        score_times.mean(axis=1) - score_times.std(axis=1),
        score_times.mean(axis=1) + score_times.std(axis=1),
        alpha=0.3,
    )
    ax[1, ax_idx].set_ylabel("Tiempo de puntuación (s)")
    ax[1, ax_idx].set_xlabel("Número de muestras de entrenamiento")

Comprobar el equilibrio entre el aumento del tiempo de entrenamiento y la puntuación de validación cruzada

fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(16, 6))

for ax_idx, (fit_times, test_scores, estimator) in enumerate(
    zip(
        [fit_times_nb, fit_times_svm],
        [test_scores_nb, test_scores_svm],
        [naive_bayes, svc],
    )
):
    ax[ax_idx].plot(fit_times.mean(axis=1), test_scores.mean(axis=1), "o-")
    ax[ax_idx].fill_between(
        fit_times.mean(axis=1),
        test_scores.mean(axis=1) - test_scores.std(axis=1),
        test_scores.mean(axis=1) + test_scores.std(axis=1),
        alpha=0.3,
    )
    ax[ax_idx].set_ylabel("Precisión")
    ax[ax_idx].set_xlabel("Tiempo de ajuste (s)")
    ax[ax_idx].set_title(
        f"Rendimiento del clasificador {estimator.__class__.__name__}"
    )

plt.show()

Resumen

En este laboratorio, mostramos cómo utilizar la clase LearningCurveDisplay de scikit - learn para trazar curvas de aprendizaje. Analizamos la curva de aprendizaje de un clasificador Naive Bayes y un clasificador SVM con un kernel RBF utilizando el conjunto de datos de dígitos. Además, examinamos la escalabilidad de estos modelos predictivos mirando su costo computacional y no solo su precisión estadística. Vimos que la escalabilidad del clasificador SVM y del clasificador Naive Bayes es muy diferente. La complejidad del clasificador SVM en el tiempo de ajuste y de puntuación aumenta rápidamente con el número de muestras. En contraste, el clasificador Naive Bayes escala mucho mejor con una menor complejidad en el tiempo de ajuste y de puntuación. También comprobamos el equilibrio entre el aumento del tiempo de entrenamiento y la puntuación de validación cruzada.