Tracer les courbes d'apprentissage

Introduction

Le but de ce laboratoire est de montrer comment utiliser la classe LearningCurveDisplay de scikit-learn pour tracer des courbes d'apprentissage. Les courbes d'apprentissage montrent l'effet de l'ajout de plus nombreux échantillons au cours du processus d'entraînement. Nous allons analyser la courbe d'apprentissage d'un classifieur Naïf Bayes et d'un classifieur SVM avec noyau RBF en utilisant l'ensemble de données digits. De plus, nous examinerons la capacité à s'échelle de ces modèles prédictifs en considérant leur coût de calcul et non seulement leur précision statistique.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Charger l'ensemble de données

from sklearn.datasets import load_digits

X, y = load_digits(return_X_y=True)

Définir les modèles

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

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

Tracer les courbes d'apprentissage

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": "Accuracy",
}

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], ["Training Score", "Test Score"])
    ax[ax_idx].set_title(f"Learning Curve for {estimator.__class__.__name__}")

Analyser les courbes d'apprentissage

## Interpréter les courbes d'apprentissage

Nous pouvons analyser la courbe d'apprentissage du classifieur Naïf Bayes. Sa forme peut être trouvée très souvent dans des ensembles de données plus complexes : le score d'entraînement est très élevé lorsqu'on utilise peu d'échantillons pour l'entraînement et diminue lorsque le nombre d'échantillons augmente, tandis que le score de test est très bas au début et augmente ensuite lorsqu'on ajoute des échantillons. Les scores d'entraînement et de test deviennent plus réalistes lorsqu'on utilise tous les échantillons pour l'entraînement.

Nous voyons une autre courbe d'apprentissage typique pour le classifieur SVM avec noyau RBF. Le score d'entraînement reste élevé indépendamment de la taille de l'ensemble d'entraînement. D'un autre côté, le score de test augmente avec la taille de l'ensemble de données d'entraînement. En effet, il augmente jusqu'à un certain point où il atteint un plateau. L'observation d'un tel plateau est une indication qu'il peut ne pas être utile d'acquérir de nouvelles données pour entraîner le modèle puisque la performance de généralisation du modèle ne va plus augmenter.

Vérifier la capacité d'échelle des modèles

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
)

Tracer la capacité d'échelle des modèles

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],
    )
):
    ## capacité d'échelle concernant le temps d'ajustement
    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("Temps d'ajustement (s)")
    ax[0, ax_idx].set_title(
        f"Capacité d'échelle du classifieur {estimator.__class__.__name__}"
    )

    ## capacité d'échelle concernant le temps de score
    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("Temps de score (s)")
    ax[1, ax_idx].set_xlabel("Nombre d'échantillons d'entraînement")

Vérifier le compromis entre le temps d'entraînement accru et le score de validation croisée

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("Précision")
    ax[ax_idx].set_xlabel("Temps d'ajustement (s)")
    ax[ax_idx].set_title(
        f"Performance du classifieur {estimator.__class__.__name__}"
    )

plt.show()

Sommaire

Dans ce laboratoire, nous avons montré comment utiliser la classe LearningCurveDisplay de scikit - learn pour tracer les courbes d'apprentissage. Nous avons analysé la courbe d'apprentissage d'un classifieur Naïf Bayes et d'un classifieur SVM avec noyau RBF en utilisant l'ensemble de données digits. De plus, nous avons étudié la capacité d'échelle de ces modèles prédictifs en examinant leur coût computationnel et non seulement leur précision statistique. Nous avons vu que la capacité d'échelle des classifieurs SVM et Naïf Bayes est très différente. La complexité du classifieur SVM au moment de l'ajustement et du score augmente rapidement avec le nombre d'échantillons. En revanche, le classifieur Naïf Bayes s'échelle beaucoup mieux avec une complexité plus faible au moment de l'ajustement et du score. Nous avons également vérifié le compromis entre le temps d'entraînement accru et le score de validation croisée.