Einführung
In der maschinellen Lernmethode werden Entscheidungsbäume häufig als Modelle eingesetzt. Entscheidungsbäume neigen jedoch dazu, die Trainingsdaten zu überanpassen, was dazu führen kann, dass sie bei den Testdaten schlecht performen. Ein Weg, um die Überanpassung zu vermeiden, besteht darin, den Entscheidungsbaum zu präunen. Die Kostkomplexitätspruning ist eine beliebte Methode zum Prüfen von Entscheidungsbäumen. In diesem Lab werden wir die Kostkomplexitätspruning für Entscheidungsbäume mit scikit-learn demonstrieren.
VM-Tipps
Nachdem die VM gestartet ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.
Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von 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.
Laden der Daten
Wir werden den Brustkrebs-Datensatz aus scikit-learn verwenden. Dieser Datensatz hat 30 Merkmale und eine binäre Zielvariable, die angibt, ob ein Patient bösartigen oder gutartigen Krebs hat.
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
Teilen der Daten
Wir werden die Daten in einen Trainingssatz und einen Testsatz aufteilen.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
Bestimmen der geeigneten Alpha-Werte
Wir möchten die geeigneten Alpha-Werte bestimmen, die für das Pruning des Entscheidungsbaums verwendet werden sollen. Wir können dies tun, indem wir die Gesamtunreinheit der Blätter gegen die effektiven Alphas des geprunten Baums aufzeichnen.
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
clf = DecisionTreeClassifier(random_state=0)
path = clf.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas, impurities = path.ccp_alphas, path.impurities
fig, ax = plt.subplots()
ax.plot(ccp_alphas[:-1], impurities[:-1], marker="o", drawstyle="steps-post")
ax.set_xlabel("effektive Alpha")
ax.set_ylabel("Gesamtunreinheit der Blätter")
ax.set_title("Gesamtunreinheit gegen effektive Alpha für den Trainingssatz")
Trainieren der Entscheidungsbäume
Als nächstes werden wir einen Entscheidungsbaum mit jeder der effektiven Alpha-Werte trainieren. Der letzte Wert in ccp_alphas ist der Alpha-Wert, der den gesamten Baum präunt und den Baum mit nur einem Knoten zurücklässt.
clfs = []
for ccp_alpha in ccp_alphas:
clf = DecisionTreeClassifier(random_state=0, ccp_alpha=ccp_alpha)
clf.fit(X_train, y_train)
clfs.append(clf)
print(
"Anzahl der Knoten im letzten Baum ist: {} mit ccp_alpha: {}".format(
clfs[-1].tree_.node_count, ccp_alphas[-1]
)
)
Entfernen von triviale Bäumen
Wir werden den triviale Baum mit nur einem Knoten aus der Liste der Entscheidungsbäume entfernen.
clfs = clfs[:-1]
ccp_alphas = ccp_alphas[:-1]
Zeichnen der Anzahl der Knoten und der Tiefe des Baums
Wir werden die Anzahl der Knoten und die Tiefe des Baums als Alpha zunimmt aufzeichnen.
node_counts = [clf.tree_.node_count for clf in clfs]
depth = [clf.tree_.max_depth for clf in clfs]
fig, ax = plt.subplots(2, 1)
ax[0].plot(ccp_alphas, node_counts, marker="o", drawstyle="steps-post")
ax[0].set_xlabel("alpha")
ax[0].set_ylabel("Anzahl der Knoten")
ax[0].set_title("Anzahl der Knoten gegen alpha")
ax[1].plot(ccp_alphas, depth, marker="o", drawstyle="steps-post")
ax[1].set_xlabel("alpha")
ax[1].set_ylabel("Tiefe des Baums")
ax[1].set_title("Tiefe gegen alpha")
fig.tight_layout()
Bestimmen des besten Alpha-Werts
Wir möchten den besten Alpha-Wert bestimmen, der für das Pruning des Entscheidungsbaums verwendet werden soll. Wir können dies tun, indem wir die Genauigkeit gegen Alpha für die Trainings- und Testsets aufzeichnen.
train_scores = [clf.score(X_train, y_train) for clf in clfs]
test_scores = [clf.score(X_test, y_test) for clf in clfs]
fig, ax = plt.subplots()
ax.set_xlabel("alpha")
ax.set_ylabel("Genauigkeit")
ax.set_title("Genauigkeit gegen alpha für Trainings- und Testsets")
ax.plot(ccp_alphas, train_scores, marker="o", label="train", drawstyle="steps-post")
ax.plot(ccp_alphas, test_scores, marker="o", label="test", drawstyle="steps-post")
ax.legend()
plt.show()
Zusammenfassung
In diesem Lab haben wir gezeigt, wie man mit scikit-learn kostenkomplexitätsbasiertes Pruning für Entscheidungsbäume durchführt. Wir haben die Daten in ein Trainings- und ein Testset unterteilt, die passenden Alpha-Werte für das Pruning bestimmt, Entscheidungsbäume mit den effektiven Alpha-Werten trainiert, die Anzahl der Knoten und die Tiefe des Baums geplottet und den besten Alpha-Wert für das Pruning basierend auf der Genauigkeit der Trainings- und Testsets bestimmt.