Importance de permutation sur l'ensemble de données du cancer du sein

Introduction

Ce laboratoire montre comment utiliser l'importance de permutation sur l'ensemble de données du cancer du sein du Wisconsin à l'aide de la fonction permutation_importance de sklearn.inspection. Le classifieur Random Forest est utilisé pour classifier les données et calculer sa précision sur un ensemble de test. Nous montrerons également comment gérer la multicolinéarité dans les fonctionnalités en utilisant l'agrégation hiérarchique.

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 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 votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Entraîner un classifieur Random Forest

Nous commençons par charger l'ensemble de données du cancer du sein du Wisconsin et le divisons en ensembles d'entraînement et de test. Nous entraînons ensuite un classifieur Random Forest sur l'ensemble d'entraînement et évaluons sa précision sur l'ensemble de test.

data = load_breast_cancer()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)
print("Accuracy on test data: {:.2f}".format(clf.score(X_test, y_test)))

Tracer l'importance des fonctionnalités

Nous traçons l'importance des fonctionnalités basée sur l'arbre et l'importance de permutation. Le graphique d'importance de permutation montre que permuter une fonctionnalité diminue la précision d'au plus 0,012, ce qui laisserait croire que aucune des fonctionnalités n'est importante. Cela contredit la haute précision sur le test calculée ci-dessus : certaines fonctionnalités doivent être importantes. L'importance de permutation est calculée sur l'ensemble d'entraînement pour montrer jusqu'à quel point le modèle dépend de chaque fonctionnalité pendant l'entraînement.

result = permutation_importance(clf, X_train, y_train, n_repeats=10, random_state=42)
perm_sorted_idx = result.importances_mean.argsort()

tree_importance_sorted_idx = np.argsort(clf.feature_importances_)
tree_indices = np.arange(0, len(clf.feature_importances_)) + 0.5

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))
ax1.barh(tree_indices, clf.feature_importances_[tree_importance_sorted_idx], height=0.7)
ax1.set_yticks(tree_indices)
ax1.set_yticklabels(data.feature_names[tree_importance_sorted_idx])
ax1.set_ylim((0, len(clf.feature_importances_)))
ax2.boxplot(
    result.importances[perm_sorted_idx].T,
    vert=False,
    labels=data.feature_names[perm_sorted_idx],
)
fig.tight_layout()
plt.show()

Gérer les fonctionnalités multicolinéaires

Lorsque les fonctionnalités sont colinéaires, permuter une fonctionnalité aura peu d'effet sur les performances du modèle car il peut obtenir les mêmes informations à partir d'une fonctionnalité corrélée. Une manière de gérer les fonctionnalités multicolinéaires consiste à effectuer une agrégation hiérarchique sur les corrélations de classement de Spearman, à choisir un seuil et à conserver une seule fonctionnalité de chaque groupe. Tout d'abord, nous traçons une carte thermique des fonctionnalités corrélées.

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))
corr = spearmanr(X).correlation

## Ensure the correlation matrix is symmetric
corr = (corr + corr.T) / 2
np.fill_diagonal(corr, 1)

## We convert the correlation matrix to a distance matrix before performing
## hierarchical clustering using Ward's linkage.
distance_matrix = 1 - np.abs(corr)
dist_linkage = hierarchy.ward(squareform(distance_matrix))
dendro = hierarchy.dendrogram(
    dist_linkage, labels=data.feature_names.tolist(), ax=ax1, leaf_rotation=90
)
dendro_idx = np.arange(0, len(dendro["ivl"]))

ax2.imshow(corr[dendro["leaves"], :][:, dendro["leaves"]])
ax2.set_xticks(dendro_idx)
ax2.set_yticks(dendro_idx)
ax2.set_xticklabels(dendro["ivl"], rotation="vertical")
ax2.set_yticklabels(dendro["ivl"])
fig.tight_layout()
plt.show()

Choisir un seuil pour regrouper les fonctionnalités en clusters

Nous choisissons manuellement un seuil en examinant visuellement le dendrogramme pour regrouper nos fonctionnalités en clusters et choisir une fonctionnalité de chaque cluster à conserver, sélectionner ces fonctionnalités dans notre ensemble de données et entraîner un nouveau forêt aléatoire. La précision sur le test du nouveau forêt aléatoire n'a pas beaucoup changé par rapport à la forêt aléatoire entraînée sur l'ensemble de données complet.

cluster_ids = hierarchy.fcluster(dist_linkage, 1, criterion="distance")
cluster_id_to_feature_ids = defaultdict(list)
for idx, cluster_id in enumerate(cluster_ids):
    cluster_id_to_feature_ids[cluster_id].append(idx)
selected_features = [v[0] for v in cluster_id_to_feature_ids.values()]

X_train_sel = X_train[:, selected_features]
X_test_sel = X_test[:, selected_features]

clf_sel = RandomForestClassifier(n_estimators=100, random_state=42)
clf_sel.fit(X_train_sel, y_train)
print(
    "Accuracy on test data with features removed: {:.2f}".format(
        clf_sel.score(X_test_sel, y_test)
    )
)

Sommaire

Ce laboratoire a démontré comment utiliser l'importance de permutation pour calculer l'importance des fonctionnalités sur l'ensemble de données du cancer du sein du Wisconsin en utilisant un classifieur Random Forest. Nous avons montré comment gérer les fonctionnalités multicolinéaires en utilisant une agrégation hiérarchique.