Permutations-Wichtigkeit auf dem Breast-Cancer-Datensatz

Einführung

In diesem Lab wird gezeigt, wie die Permutations-Wichtigkeit auf dem Wisconsin Breast Cancer-Datensatz mithilfe der permutation_importance-Funktion aus sklearn.inspection verwendet wird. Der Random Forest Classifier wird verwendet, um die Daten zu klassifizieren und seine Genauigkeit auf einem Testset zu berechnen. Wir werden auch zeigen, wie die Multikollinearität in den Merkmalen mit Hilfe der hierarchischen Clusteranalyse behandelt werden kann.

VM-Tipps

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback ab, und wir werden das Problem für Sie prompt beheben.

Ein Random Forest Classifier trainieren

Wir laden zunächst den Wisconsin Breast Cancer-Datensatz und teilen ihn in Trainings- und Testsets auf. Anschließend trainieren wir einen Random Forest Classifier auf dem Trainingsset und evaluieren seine Genauigkeit auf dem Testset.

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)))

Feature-Wichtigkeit plotten

Wir plotten die baumbasierte Feature-Wichtigkeit und die Permutations-Wichtigkeit. Das Permutations-Wichtigkeit-Diagramm zeigt, dass das Permutieren eines Features die Genauigkeit um maximal 0,012 verringert, was darauf hindeuten würde, dass keine der Features wichtig ist. Dies steht im Widerspruch zur hohen Testgenauigkeit, die oben berechnet wurde: Es muss mindestens ein Feature wichtig sein. Die Permutations-Wichtigkeit wird auf dem Trainingsset berechnet, um zu zeigen, wie stark das Modell bei der Training auf jedes Feature angewiesen ist.

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()

Multikollineare Features behandeln

Wenn Features kollinear sind, hat das Permutieren eines Features nur wenig Auswirkung auf die Modellleistung, da es die gleiche Information aus einem korrelierten Feature erhalten kann. Ein Möglichkeit, um multikollineare Features zu behandeln, besteht darin, eine hierarchische Clusteranalyse auf den Spearman-Rangkorrelationen durchzuführen, einen Schwellenwert auszuwählen und aus jeder Cluster nur ein einziges Feature zu behalten. Zunächst plotten wir eine Heatmap der korrelierten Features.

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

## Stellen Sie sicher, dass die Korrelationsmatrix symmetrisch ist
corr = (corr + corr.T) / 2
np.fill_diagonal(corr, 1)

## Bevor wir die hierarchische Clusteranalyse mit Ward-Verknüpfung durchführen,
## konvertieren wir die Korrelationsmatrix in eine Distanzmatrix.
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()

Einen Schwellenwert auswählen, um Features in Cluster zu gruppieren

Wir wählen manuell einen Schwellenwert aus, indem wir das Dendrogramm visuell untersuchen, um unsere Features in Cluster zu gruppieren und aus jedem Cluster ein Feature auszuwählen, um zu behalten. Wir wählen diese Features aus unserem Datensatz und trainieren einen neuen Random Forest. Die Testgenauigkeit des neuen Random Forests hat im Vergleich zum auf dem vollständigen Datensatz trainierten Random Forest nicht viel geändert.

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)
    )
)

Zusammenfassung

In diesem Lab wurde gezeigt, wie die Permutations-Wichtigkeit verwendet werden kann, um die Feature-Wichtigkeit auf dem Wisconsin Breast Cancer-Datensatz mit einem Random Forest Classifier zu berechnen. Wir haben gezeigt, wie multikollineare Features mit hierarchischer Clusteranalyse behandelt werden können.