Tracé avancé avec dépendance partielle

Introduction

Ce tutoriel vous guidera tout au long du processus de tracé de courbes de dépendance partielle pour plusieurs fonctionnalités. Les courbes de dépendance partielle sont utilisées pour analyser l'effet d'une fonctionnalité sur le résultat prédit d'un modèle de machine learning tout en maintenant toutes les autres fonctionnalités constantes. Ce tutoriel démontrera comment tracer des courbes de dépendance partielle pour un arbre de décision et un perceptron multicouche sur l'ensemble de données de diabète.

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 à 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 limites 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

Entraîner des modèles sur l'ensemble de données de diabète

Dans cette étape, nous allons entraîner un arbre de décision et un perceptron multicouche sur l'ensemble de données de diabète.

diabetes = load_diabetes()
X = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
y = diabetes.target

tree = DecisionTreeRegressor()
mlp = make_pipeline(
    StandardScaler(),
    MLPRegressor(hidden_layer_sizes=(100, 100), tol=1e-2, max_iter=500, random_state=0),
)
tree.fit(X, y)
mlp.fit(X, y)

Tracer la dépendance partielle pour deux fonctionnalités

Dans cette étape, nous allons tracer les courbes de dépendance partielle pour les fonctionnalités "âge" et "imc" (indice de masse corporelle) pour l'arbre de décision. Avec deux fonctionnalités, PartialDependenceDisplay.from_estimator s'attend à tracer deux courbes. Ici, la fonction de tracé place une grille de deux graphiques en utilisant l'espace défini par ax.

fig, ax = plt.subplots(figsize=(12, 6))
ax.set_title("Decision Tree")
tree_disp = PartialDependenceDisplay.from_estimator(tree, X, ["age", "bmi"], ax=ax)

Les courbes de dépendance partielle peuvent être tracées pour le perceptron multicouche. Dans ce cas, line_kw est passé à PartialDependenceDisplay.from_estimator pour changer la couleur de la courbe.

fig, ax = plt.subplots(figsize=(12, 6))
ax.set_title("Multi-layer Perceptron")
mlp_disp = PartialDependenceDisplay.from_estimator(
    mlp, X, ["age", "bmi"], ax=ax, line_kw={"color": "red"}
)

Tracer la dépendance partielle des deux modèles ensemble

Dans cette étape, nous allons tracer les courbes de dépendance partielle des deux modèles sur le même graphique.

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 10))
tree_disp.plot(ax=ax1)
ax1.set_title("Decision Tree")
mlp_disp.plot(ax=ax2, line_kw={"color": "red"})
ax2.set_title("Multi-layer Perceptron")

Une autre manière de comparer les courbes est de les superposer. Ici, nous créons une figure avec une ligne et deux colonnes. Les axes sont passés à la fonction PartialDependenceDisplay.plot sous forme de liste, qui dessinera les courbes de dépendance partielle de chaque modèle sur les mêmes axes. La longueur de la liste d'axes doit être égale au nombre de graphiques tracés.

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 6))
tree_disp.plot(ax=[ax1, ax2], line_kw={"label": "Decision Tree"})
mlp_disp.plot(
    ax=[ax1, ax2], line_kw={"label": "Multi-layer Perceptron", "color": "red"}
)
ax1.legend()
ax2.legend()

tree_disp.axes_ est un conteneur numpy des axes utilisés pour tracer les graphiques de dépendance partielle. Cela peut être passé à mlp_disp pour avoir le même effet de tracé des graphiques les uns sur les autres. De plus, mlp_disp.figure_ stocke la figure, ce qui permet de redimensionner la figure après avoir appelé plot. Dans ce cas, tree_disp.axes_ a deux dimensions, donc plot ne montrera que l'étiquette y et les graduations y sur le graphique le plus à gauche.

tree_disp.plot(line_kw={"label": "Decision Tree"})
mlp_disp.plot(
    line_kw={"label": "Multi-layer Perceptron", "color": "red"}, ax=tree_disp.axes_
)
tree_disp.figure_.set_size_inches(10, 6)
tree_disp.axes_[0, 0].legend()
tree_disp.axes_[0, 1].legend()
plt.show()

Tracer la dépendance partielle pour une fonctionnalité

Dans cette étape, nous allons tracer les courbes de dépendance partielle pour une seule fonctionnalité, "âge", sur les mêmes axes. Dans ce cas, tree_disp.axes_ est passé à la deuxième fonction de tracé.

tree_disp = PartialDependenceDisplay.from_estimator(tree, X, ["age"])
mlp_disp = PartialDependenceDisplay.from_estimator(
    mlp, X, ["age"], ax=tree_disp.axes_, line_kw={"color": "red"}
)

Sommaire

Ce tutoriel a démontré comment tracer des courbes de dépendance partielle pour plusieurs fonctionnalités à l'aide de l'objet PartialDependenceDisplay. Tout d'abord, nous avons entraîné un arbre de décision et un perceptron multicouche sur l'ensemble de données de diabète. Ensuite, nous avons tracé des courbes de dépendance partielle pour l'arbre de décision et le perceptron multicouche pour deux fonctionnalités. Ensuite, nous avons tracé les courbes de dépendance partielle des deux modèles sur le même graphique. Enfin, nous avons tracé les courbes de dépendance partielle pour une seule fonctionnalité sur les mêmes axes.