Få funktionsviktigheter för slumpmässiga skogar med Python och Scikit-Learn

Återutgiven av Platon

anhängare: 0

Beskrivning

Smakämnen Slumpmässig skog Algoritm är en trädbaserad övervakad inlärningsalgoritm som använder en ensemble av förutsägelser av många beslutsträd, antingen för att klassificera en datapunkt eller bestämma dess ungefärliga värde. Det betyder att den antingen kan användas för klassificering eller regression.

Vid ansökan om klassificering väljs klassen för datapunkten baserat på den klass som röstades mest fram av träden; och när den tillämpas för regression är värdet för datapunkten medelvärdet av alla värden som matas ut av träden.

En viktig sak att komma ihåg när du använder Random Forests är att antalet träd är en hyperparameter och det kommer att definieras innan modellen körs.

När man arbetar inom datavetenskap kan en av anledningarna till att en Random Forest-modell valdes för ett specifikt projekt ha att göra med förmågan att titta på sammansatta träd och förstå varför en klassificering gjordes, eller varför ett värde gavs – detta kallas förklarbarhet.

Med tanke på trädbaserade algoritmer kan man försöka förklara en modell på flera sätt, genom att visa och titta på varje träd (kan vara svårt om modellen har 200 träd eller fler), med Shapley (eller SHAP) värden, titta på de funktioner som mest beaktades av modellen, med hjälp av KALK för att undersöka sambanden mellan modellens input och output etc. Vanligtvis används en kombination av alla metoder.

I den här snabbguiden kommer vi att fokusera på att skapa ett diagram över de funktioner som ansågs viktiga för att modellen ska kunna fatta ett beslut när de klassificerar pingviner. Detta är känt som att undersöka egenskapens betydelse, och kan förmedlas till andra medlemmar i teamet (tekniska och icke-tekniska) för att ge en inblick i hur beslut fattas.

För att göra detta, låt oss importera de nödvändiga biblioteken, ladda Palmer Penguins dataset, dela upp data, skapa modellen, skaffa funktionernas betydelse och använda Seaborn för att plotta dem! Vi kommer inte att fördjupa oss mycket i data, EDA eller själva modellen – det är ämnet för den dedikerade guiden.

Notera: Du kan ladda ner datasatsen från GitHub eller direkt från koden.

Importerar bibliotek

Låt oss börja med att importera några bibliotek som vi kommer att använda:


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)

Dela upp data

Låt oss dela upp data för träning och testning:


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)

Att erhålla funktionsviktigheter

Slutligen – vi kan träna en modell och exportera funktionernas betydelse med:


rf = RandomForestClassifier()


rf.fit(X_train, y_train)


rf.feature_importances_

Denna utgångar:

array([0.41267633, 0.30107056, 0.28625311])

Det är funktionsvärdena, för att se funktionsnamn, kör:


rf.feature_names_in_

Detta resulterar i motsvarande namn på varje funktion:

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

Detta betyder att den viktigaste egenskapen för att bestämma pingvinklasser för just denna modell var bill_length_mm!

Vikten är i förhållande till måttet på hur väl data separeras i varje noduppdelning – i det här fallet ges måttet av Gini Index – gini-värdet viktas sedan med hur många rader som har delats vid användning av bill_length_mm inslag och i genomsnitt över de 100 träden i ensemblen. Resultatet av dessa steg står för 0.41267633, eller mer än 40 % i detta fall.

Visualisera funktionens betydelse

Ett vanligt sätt att representera viktiga värden är att använda barchattar. Låt oss först skapa en dataram med funktionsnamnen och deras motsvarande betydelser och sedan visualisera dem med Seaborns 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);

Råd: En bra praxis när du presenterar information är att ordna värden antingen i stigande eller fallande ordning. I det här fallet är uppgifterna redan beställda, med det första värdet som det första vi vill veta. När så inte är fallet kan du beställa dataramen med sort_values. Detta kan göras på valfri kolumn i stigande eller fallande ordning: importances_df.sort_values(by="importances", ascending=False).

När man tittar på den här första handlingen är det svårare att tolka värdet av varje funktions betydelse. Det är uppenbart att sedellängden är större än de andra två staplarna, men inte precis så bill_depth_mm är ekvivalent med 0.30107056, och att flipper_length_mm är 0.28625311. Så det här första diagrammet kan förbättras genom att visa värdet för varje stapel. Detta kan göras genom att komma åt Seaborn's containers objekt. Den lagrar varje stapelinformation och skickar värdena som stapeletiketter:

Kolla in vår praktiska, praktiska guide för att lära dig Git, med bästa praxis, branschaccepterade standarder och medföljande fuskblad. Sluta googla Git-kommandon och faktiskt lära Det!

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)