Erhalten Sie mit Python und Scikit-Learn Feature Importances for Random Forests

Einleitung

Das Zufälliger Wald Algorithmus ist ein baumbasierter überwachter Lernalgorithmus, der ein Ensemble von Vorhersagen vieler Entscheidungsbäume verwendet, um entweder einen Datenpunkt zu klassifizieren oder seinen ungefähren Wert zu bestimmen. Dies bedeutet, dass es entweder zur Klassifizierung oder Regression verwendet werden kann.

Bei der Beantragung der Klassifizierung wird die Klasse des Datenpunkts basierend auf der Klasse gewählt, die von den Bäumen am meisten gewählt wurde; und wenn er für die Regression angewendet wird, ist der Wert des Datenpunkts der Durchschnitt aller von den Bäumen ausgegebenen Werte.

Bei der Verwendung von Random Forests ist zu beachten, dass die Anzahl der Bäume ein Hyperparameter ist und vor dem Ausführen des Modells definiert wird.

Bei der Arbeit in der Datenwissenschaft könnte einer der Gründe, warum ein Random-Forest-Modell für ein bestimmtes Projekt ausgewählt wurde, mit der Fähigkeit zu tun haben, Ensemblebäume zu betrachten und zu verstehen warum eine Klassifizierung vorgenommen wurde, oder warum ein Wert gegeben wurde – das nennt man Erklärbarkeit.

In Anbetracht baumbasierter Algorithmen kann der Versuch, ein Modell zu erklären, auf verschiedene Arten erfolgen, indem jeder Baum angezeigt und betrachtet wird (kann schwierig sein, wenn das Modell 200 Bäume oder mehr hat). Shapley (oder SHAP)-Werte, indem Sie sich die Merkmale ansehen, die am meisten vom Modell berücksichtigt wurden, indem Sie verwenden LIME B. um die Zusammenhänge zwischen Modellinput und -output zu untersuchen, etc. Üblicherweise wird eine Kombination aller Methoden eingesetzt.

In dieser Kurzanleitung konzentrieren wir uns auf die Erstellung eines Diagramms der Merkmale, die für das Modell als wichtig erachtet wurden, um eine Entscheidung bei der Klassifizierung von Pinguinen zu treffen. Dies wird als Untersuchung der bezeichnet Merkmal Bedeutung, und kann an andere Teammitglieder (technische und nichttechnische) weitergegeben werden, um einen Einblick in die Entscheidungsfindung zu geben.

Lassen Sie uns dazu die erforderlichen Bibliotheken importieren, den Palmer Penguins-Datensatz laden, die Daten aufteilen, das Modell erstellen, die Wichtigkeiten der Merkmale abrufen und Seaborn verwenden, um sie zu zeichnen! Wir werden nicht viel auf die Daten, EDA oder das Modell selbst eingehen – das ist das Thema des speziellen Leitfadens.

Hinweis: Sie können den Datensatz von herunterladen GitHub oder direkt aus dem Code.

Bibliotheken importieren

Beginnen wir mit dem Import einiger Bibliotheken, die wir verwenden werden:

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier


raw_data_url = "https://gist.githubusercontent.com/cassiasamp/197b4e070f5f4da890ca4d226d088d1f/raw/38c9d4906ed121481b4dc201fa2004f2b3d0065f/penguins.csv"
df = pd.read_csv(raw_data_url)

Daten teilen

Lassen Sie uns die Daten für Training und Test aufteilen:

df = df.dropna().drop("rowid", axis=1)


y = df["species"]
X = df[["bill_length_mm", "bill_depth_mm", "flipper_length_mm"]]


X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

Abrufen von Feature-Wichtigkeiten

Schließlich können wir ein Modell trainieren und die Wichtigkeit der Merkmale exportieren mit:

rf = RandomForestClassifier()


rf.fit(X_train, y_train)


rf.feature_importances_

Dies gibt aus:

array([0.41267633, 0.30107056, 0.28625311])

Das sind die Feature-Werte, um Feature-Namen zu sehen, führen Sie Folgendes aus:

rf.feature_names_in_

Daraus ergibt sich der entsprechende Name jedes Features:

array(['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm'],
      dtype=object)

Dies bedeutet, dass das wichtigste Merkmal für die Entscheidung über Peguin-Klassen für dieses spezielle Modell die war bill_length_mm!

Die Wichtigkeit ist relativ zu dem Maß, wie gut die Daten in jeder Knotenaufteilung getrennt werden – in diesem Fall wird das Maß durch die angegeben Gini-Index – Der Gini-Wert wird dann gewichtet, wie viele Zeilen bei Verwendung von aufgeteilt wurden bill_length_mm Merkmal und gemittelt über die 100 Bäume im Ensemble. Das Ergebnis dieser Schritte berücksichtigt 0.41267633, oder mehr als 40 % in diesem Fall.

Visualisieren der Feature-Bedeutung

Eine gängige Art, Wichtigkeitswerte darzustellen, ist die Verwendung von Bar-Chats. Lassen Sie uns zuerst einen Datenrahmen mit den Feature-Namen und ihren entsprechenden Wichtigkeiten erstellen und sie dann mit Seaborn visualisieren barplot():

importances_df = pd.DataFrame({"feature_names" : rf.feature_names_in_, 
                               "importances" : rf.feature_importances_})
                             

g = sns.barplot(x=importances_df["feature_names"], 
                y=importances_df["importances"])
g.set_title("Feature importances", fontsize=14);                          

Hinweis: Bei der Darstellung von Informationen empfiehlt es sich, Werte entweder in aufsteigender oder absteigender Reihenfolge zu ordnen. In diesem Fall sind die Daten bereits geordnet, wobei der erste Wert der erste ist, den wir wissen möchten. Wenn dies nicht der Fall ist, können Sie den Datenrahmen mitbestellen sort_values. Dies kann für jede Spalte in aufsteigender oder absteigender Reihenfolge erfolgen: importances_df.sort_values(by="importances", ascending=False).

Wenn Sie sich dieses erste Diagramm ansehen, ist es schwieriger, den Wert der Wichtigkeit jedes Merkmals zu interpretieren. Es ist offensichtlich, dass der Schein länger ist als die anderen beiden Balken, aber nicht genau das bill_depth_mm entspricht 0.30107056und dass die flipper_length_mm ist 0.28625311. Dieses erste Diagramm kann also verbessert werden, indem der Wert jedes Balkens angezeigt wird. Dies kann durch Zugriff auf Seaborn's erfolgen containers Objekt. Es speichert alle Balkeninformationen und übergibt die Werte als Balkenbeschriftungen:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names")
g.set_title("Feature importances", fontsize=14)
for value in g.containers:
    g.bar_label(value)

Jetzt können wir jeden Wichtigkeitswert deutlich oder fast deutlich sehen, weil bill_length_mm Der Wert wird durch eine vertikale Linie geschnitten, die Teil des äußeren Rands des Diagramms ist. Grenzen werden verwendet, um einen Bereich einzuschließen, um mehr Aufmerksamkeit darauf zu lenken, aber in diesem Fall müssen wir ihn nicht einschließen, da es nur einen Graphen gibt. Lassen Sie uns den Rahmen entfernen und die Lesbarkeit der Zahlen verbessern:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names")
                

sns.despine(bottom=True, left=True)
g.set_title("Feature importances", fontsize=14)
for value in g.containers:
    g.bar_label(value)

Das Diagramm scheint einfacher zu lesen, aber die Ticks auf der X-Achse scheinen zu schweben und wir haben bereits die Werte zusammen mit den Balken, also können wir die entfernen xticks:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names")
sns.despine(bottom=True, left=True)


g.set(xticks=[])
g.set_title("Feature importances", fontsize=14)
for value in g.containers:
    g.bar_label(value)

Beachten Sie, dass nach dem Entfernen der Häkchen die Y- und X-Beschriftungen etwas schwer zu lesen sind. Das Y-Etikett, feature_names, ist vertikal und in der X-Achse gibt es nur importances. Da der Titel bereits sagt, dass das Diagramm von ist Feature-Bedeutungen, können wir auch die Achsenbeschriftungen entfernen:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names")
sns.despine(bottom=True, left=True)
g.set_title("Feature importances", fontsize=14)
g.set(xticks=[])


g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
    g.bar_label(value)

Sie können sehen, wie sauberer, einfacher zu lesen und zu verstehen dieses Diagramm ist, wenn Sie es mit dem ersten vergleichen. Es gibt noch einige Dinge, die wir tun können. Beachten Sie, dass die Zahlen sehr nahe an den Balken stehen. Es wäre einfacher zu lesen, wenn zwischen ihnen etwas mehr Platz wäre.

Ein weiteres Element in dieser Handlung sind die Farben, wenn kontrastierende Farben verwendet werden, vermitteln sie eine Vorstellung von Trennung, umgekehrt, wenn ähnliche Farben verwendet werden, vermitteln sie eine Vorstellung von Einheit oder Teilen eines Ganzen. Da die Merkmale alle Teil von Pinguinen sind, können wir Farben verwenden, die jeden Balken voneinander unterscheiden und gleichzeitig die Einheit beibehalten:

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names",
                
                
                palette="mako")
sns.despine(bottom=True, left=True)
g.set_title("Feature importances", fontsize=14)
g.set(xticks=[])
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
    g.bar_label(value, 
                padding=2) 

Wenn Sie die Ergebnisse noch direkter gestalten möchten, können Sie den Titel ändern und das Fazit hinzufügen. Was bekannt ist, ist, dass die Banknotenlänge gemäß den zuvor diskutierten Kriterien als das wichtigste Merkmal angesehen wurde. Dies kann die erste Information für jemanden sein, der sich die Handlung ansieht, könnten wir so sagen Die Schnabellänge des Pinguins war das wichtigste Merkmal für die Artenklassifizierung im Random Forest (RF)-Basismodell :

g = sns.barplot(data=importances_df, 
                x="importances", 
                y="feature_names", 
                palette="mako")
sns.despine(bottom=True, left=True)
g.set_title("The penguin's bill length was the most important feature for species classification (RF base model)", fontsize=14)
g.set(xticks=[])
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
    g.bar_label(value, padding=2)

Dies ist das Endergebnis des Feature-Wichtigkeiten-Diagramms:

Zusammenfassung

In diesem Leitfaden haben wir einen Random Forest Classifier erstellt und die Wichtigkeiten der Features untersucht, die zum Trainieren des Modells verwendet wurden, um dies zu versuchen erklären was ein Modell gelernt hat und was seine Argumentation beeinflusst.