Introductie
De Willekeurig bos algoritme is een boomgebaseerd algoritme voor gesuperviseerd leren dat een geheel van voorspellingen van veel beslissingsbomen gebruikt om een gegevenspunt te classificeren of de geschatte waarde ervan te bepalen. Dit betekent dat het kan worden gebruikt voor classificatie of regressie.
Wanneer toegepast voor classificatie, wordt de klasse van het datapunt gekozen op basis van de klasse waarop de bomen het meest hebben gestemd; en wanneer toegepast voor regressie, is de waarde van het gegevenspunt het gemiddelde van alle waarden die door de bomen worden uitgevoerd.
Een belangrijk ding om te onthouden bij het gebruik van Random Forests is dat het aantal bomen een hyperparameter is en dat het zal worden gedefinieerd voordat het model wordt uitgevoerd.
Als je in de datawetenschap werkt, kan een van de redenen waarom voor een specifiek project voor een Random Forest-model is gekozen, te maken hebben met het vermogen om naar samengestelde bomen te kijken en te begrijpen Waarom een classificatie is gemaakt, of Waarom er is een waarde gegeven - dit wordt genoemd uitlegbaarheid.
Als we op boom gebaseerde algoritmen overwegen, kan een poging om een model uit te leggen op verschillende manieren worden gedaan, door elke boom weer te geven en te bekijken (kan moeilijk zijn als het model 200 bomen of meer heeft), met behulp van Shapley (of SHAP) waarden, kijkend naar de functies waarmee het model het meest rekening hield, met behulp van LIMOEN om de relaties tussen invoer en uitvoer van modellen te onderzoeken, enz. Meestal wordt een combinatie van alle methoden gebruikt.
In deze korte handleiding zullen we ons concentreren op het maken van een overzicht van de kenmerken die belangrijk werden geacht voor het model om een beslissing te nemen bij het classificeren van pinguïns. Dit staat bekend als het onderzoeken van de kenmerk belang, en kan worden overgedragen aan andere leden van het team (technisch en niet-technisch) om een glimp op te vangen van hoe beslissingen worden genomen.
Om dit te doen, importeren we de benodigde bibliotheken, laden we de gegevensset van Palmer Penguins, splitsen we de gegevens, maken we het model, verkrijgen we de belangrijkheid van de kenmerken en gebruiken we Seaborn om ze te plotten! We zullen niet veel uitweiden over de gegevens, EDA of het model zelf - dat is het onderwerp van de speciale gids.
Opmerking: U kunt de dataset downloaden van GitHub of rechtstreeks uit de code.
Bibliotheken importeren
Laten we beginnen met het importeren van enkele bibliotheken die we gaan gebruiken:
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)
De gegevens splitsen
Laten we de gegevens voor training en testen splitsen:
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)
Belangen van functies verkrijgen
Eindelijk - we kunnen een model trainen en de belangrijkheid van het kenmerk exporteren met:
rf = RandomForestClassifier()
rf.fit(X_train, y_train)
rf.feature_importances_
Dit levert op:
array([0.41267633, 0.30107056, 0.28625311])
Dat zijn de functiewaarden, om functienamen te zien, voert u uit:
rf.feature_names_in_
Dit resulteert in de overeenkomstige naam van elke functie:
array(['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm'],
dtype=object)
Dit betekent dat het belangrijkste kenmerk voor het bepalen van peguin-klassen voor dit specifieke model de was bill_length_mm!
Het belang is relatief aan de maatstaf van hoe goed de gegevens worden gescheiden in elke knooppuntsplitsing - in dit geval wordt de maatstaf gegeven door de Gini-index – de gini-waarde wordt vervolgens gewogen naar het aantal rijen dat is gesplitst bij gebruik van de bill_length_mm functie en gemiddeld over de 100 bomen in het ensemble. Het resultaat van die stappen is goed voor 0.41267633, of meer dan 40% in dit geval.
Het belang van functies visualiseren
Een gebruikelijke manier om belangrijkheidswaarden weer te geven, is door barchats te gebruiken. Laten we eerst een dataframe maken met de functienamen en hun overeenkomstige belang, en ze vervolgens visualiseren met behulp van Seaborn's 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);
Advies: Een goede gewoonte bij het presenteren van informatie is om waarden in oplopende of aflopende volgorde te ordenen. In dit geval zijn de gegevens al geordend, waarbij de eerste waarde de eerste is die we willen weten. Wanneer dit niet het geval is, kunt u de dataframe meebestellen sort_values. Dit kan op elke kolom in oplopende of aflopende volgorde worden gedaan: importances_df.sort_values(by="importances", ascending=False).
Als we naar deze eerste plot kijken, is het moeilijker om de waarde van het belang van elk kenmerk te interpreteren. Het is duidelijk dat de biljetlengte groter is dan de andere twee staven, maar niet precies dat de bill_depth_mm is gelijk aan 0.30107056en dat de flipper_length_mm bedraagt 0.28625311. Deze eerste grafiek kan dus worden verbeterd door de waarde van elke staaf weer te geven. Dit kan worden gedaan door toegang te krijgen tot Seaborn's containers object. Het slaat elke staafinformatie op en geeft de waarden door als staaflabels:
Bekijk onze praktische, praktische gids voor het leren van Git, met best-practices, door de industrie geaccepteerde normen en bijgevoegd spiekbriefje. Stop met Googlen op Git-commando's en eigenlijk leren het!
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)
Nu kunnen we elke belangrijkheidswaarde duidelijk zien, of bijna duidelijk, omdat bill_length_mm waarde wordt afgesneden door een verticale lijn die deel uitmaakt van de buitenrand van de grafiek. Grenzen worden gebruikt om een gebied te omsluiten om er meer aandacht op te vestigen, maar in dit geval hoeven we niet te omsluiten, omdat er maar één grafiek is. Laten we de rand verwijderen en de leesbaarheid van de cijfers verbeteren:
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)
De grafiek lijkt gemakkelijker te lezen, maar de vinkjes op de X-as lijken te zweven en we hebben de waarden al samen met de balken, dus we kunnen de 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)
Merk op hoe na het verwijderen van de vinkjes de Y- en X-labels een beetje moeilijk te lezen zijn. Het Y-label, feature_names, is verticaal en in de X-as zijn er alleen importances. Aangezien de titel al aangeeft dat de grafiek van is Belangen van functies, kunnen we ook de aslabels verwijderen:
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)
U kunt zien hoe deze grafiek overzichtelijker, gemakkelijk te lezen en te begrijpen is wanneer u deze vergelijkt met de eerste. Er zijn nog enkele dingen die we kunnen doen. Merk op dat de cijfers heel dicht bij de balken staan, het zou gemakkelijker te lezen zijn als er wat meer ruimte tussen zou zitten.
Een ander element in deze plot zijn de kleuren, wanneer contrasterende kleuren worden gebruikt, brengt het een idee van scheiding over, en omgekeerd, wanneer vergelijkbare kleuren worden gebruikt, communiceren ze een idee van eenheid of delen van een geheel. Omdat de kenmerken allemaal deel uitmaken van pinguïns, kunnen we een kleur gebruiken die elke balk onderscheidt terwijl de eenheid behouden blijft:
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)
Als u de resultaten nog directer wilt maken, kunt u de titel wijzigen en de conclusie toevoegen. Wat wel bekend is, is dat de rekeninglengte als het belangrijkste kenmerk werd beschouwd volgens de criteria die we eerder hebben besproken. Dit kan de eerste informatie zijn voor iemand die naar de plot kijkt, dat zouden we kunnen zeggen de snavellengte van de pinguïn was het belangrijkste kenmerk voor de classificatie van soorten in het Random Forest (RF) basismodel :
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)
Dit is het uiteindelijke resultaat van de functie-belangrijkheidsgrafiek:
Conclusie
In deze gids – we hebben een Random Forest Classifier gebouwd – en inspecteerden we de functiebelangen die werden gebruikt om het model te trainen in een poging om verklaren wat een model heeft geleerd en wat zijn redenering beïnvloedt.
