Création de visualisations avec des objets d'affichage

Introduction

Dans ce laboratoire, nous allons apprendre à créer des visualisations avec des objets d'affichage à l'aide de scikit-learn. Les objets d'affichage sont des classes qui nous permettent de créer des visualisations directement à partir de leurs métriques respectives. Dans ce laboratoire, nous utiliserons les objets d'affichage ConfusionMatrixDisplay, RocCurveDisplay et PrecisionRecallDisplay pour créer des visualisations pour un problème de classification binaire.

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 Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

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

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églerons rapidement le problème pour vous.

Skills Graph

Charger les données et entraîner le modèle

Pour cet exemple, nous utiliserons un ensemble de données de centre de services de transfusion sanguine provenant d'OpenML. La variable cible est de savoir si une personne a fait un don de sang. Tout d'abord, les données sont divisées en ensembles d'entraînement et de test, puis un modèle de régression logistique est ajusté avec l'ensemble d'entraînement.

from sklearn.datasets import fetch_openml
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

X, y = fetch_openml(data_id=1464, return_X_y=True, parser="pandas")
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y)

clf = make_pipeline(StandardScaler(), LogisticRegression(random_state=0))
clf.fit(X_train, y_train)

Créer ConfusionMatrixDisplay

Avec le modèle ajusté, nous calculons les prédictions du modèle sur l'ensemble de test. Ces prédictions sont utilisées pour calculer la matrice de confusion qui est tracée avec ConfusionMatrixDisplay.

from sklearn.metrics import confusion_matrix
from sklearn.metrics import ConfusionMatrixDisplay

y_pred = clf.predict(X_test)
cm = confusion_matrix(y_test, y_pred)

cm_display = ConfusionMatrixDisplay(cm).plot()

Créer RocCurveDisplay

La courbe ROC nécessite soit les probabilités soit les valeurs de décision non seuillées de l'estimateur. Étant donné que la régression logistique fournit une fonction de décision, nous l'utiliserons pour tracer la courbe ROC.

from sklearn.metrics import roc_curve
from sklearn.metrics import RocCurveDisplay

y_score = clf.decision_function(X_test)

fpr, tpr, _ = roc_curve(y_test, y_score, pos_label=clf.classes_[1])
roc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot()

Créer PrecisionRecallDisplay

De manière similaire, la courbe précision-rappel peut être tracée à l'aide de y_score de la section précédente.

from sklearn.metrics import precision_recall_curve
from sklearn.metrics import PrecisionRecallDisplay

prec, recall, _ = precision_recall_curve(y_test, y_score, pos_label=clf.classes_[1])
pr_display = PrecisionRecallDisplay(precision=prec, recall=recall).plot()

Combiner les objets d'affichage en un seul graphique

Les objets d'affichage stockent les valeurs calculées qui ont été passées en tant qu'arguments. Cela permet de combiner facilement les visualisations à l'aide de l'API de Matplotlib. Dans l'exemple suivant, nous plaçons les affichages côte à côte dans une ligne.

import matplotlib.pyplot as plt

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))

roc_display.plot(ax=ax1)
pr_display.plot(ax=ax2)
plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à créer des visualisations avec des objets d'affichage à l'aide de scikit-learn. Nous avons utilisé les objets d'affichage ConfusionMatrixDisplay, RocCurveDisplay et PrecisionRecallDisplay pour créer des visualisations pour un problème de classification binaire. Nous avons tout d'abord chargé les données et entraîné un modèle de régression logistique. Nous avons ensuite créé la matrice de confusion, la courbe ROC et la courbe précision-rappel à l'aide d'objets d'affichage. Enfin, nous avons combiné les objets d'affichage en un seul graphique à l'aide de l'API de Matplotlib.