Få funksjonsbetydninger for tilfeldige skoger med Python og Scikit-Learn

Publisert av Platon

Følgere: 0

Introduksjon

De Tilfeldig skog Algoritme er en trebasert overvåket læringsalgoritme som bruker et ensemble av prediksjoner fra mange beslutningstrær, enten for å klassifisere et datapunkt eller bestemme dets omtrentlige verdi. Dette betyr at den enten kan brukes til klassifisering eller regresjon.

Når det søkes om klassifisering, velges klassen for datapunktet basert på den klassen som ble mest stemt av trærne; og når det brukes for regresjon, er verdien av datapunktet gjennomsnittet av alle verdiene som sendes ut av trærne.

En viktig ting å huske på når du bruker Random Forests er at antall trær er en hyperparameter og den vil bli definert før du kjører modellen.

Når du jobber med datavitenskap, kan en av grunnene til at en Random Forest-modell ble valgt for et spesifikt prosjekt ha å gjøre med evnen til å se på sammensatte trær og forstå hvorfor det ble foretatt en klassifisering, eller hvorfor en verdi ble gitt – dette kalles forklarbarhet.

Med tanke på trebaserte algoritmer, kan forsøk på å forklare en modell gjøres på flere måter, ved å vise og se på hvert tre (kan være vanskelig hvis modellen har 200 trær eller flere), ved å bruke Shapley (eller SHAP) verdier, ser på funksjonene som ble mest tatt i betraktning av modellen, ved å bruke LIME for å undersøke sammenhengene mellom modellens input og output, etc. Vanligvis brukes en kombinasjon av alle metoder.

I denne hurtigveiledningen vil vi fokusere på å lage et diagram over funksjonene som ble ansett som viktige for at modellen skal kunne ta en avgjørelse når de klassifiserer pingviner. Dette er kjent som å undersøke funksjonens betydning, og kan formidles til andre medlemmer av teamet (tekniske og ikke-tekniske) for å gi et innblikk i hvordan beslutninger tas.

For å gjøre dette, la oss importere de nødvendige bibliotekene, laste Palmer Penguins-datasettet, dele dataene, lage modellen, få tak i funksjonene og bruke Seaborn til å plotte dem! Vi vil ikke fordype oss mye i dataene, EDA eller selve modellen – det er temaet for den dedikerte veiledningen.

OBS: Du kan laste ned datasettet fra GitHub eller direkte fra koden.

Importerer biblioteker

La oss starte med å importere noen biblioteker som vi skal bruke:


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)

Splitting av data

La oss dele dataene for trening og testing:


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)

Innhenting av funksjoner

Til slutt – vi kan trene opp en modell og eksportere funksjonene med:


rf = RandomForestClassifier()


rf.fit(X_train, y_train)


rf.feature_importances_

Dette gir utganger:

array([0.41267633, 0.30107056, 0.28625311])

Dette er funksjonsverdiene. For å se funksjonsnavn, kjør:


rf.feature_names_in_

Dette resulterer i det tilsvarende navnet på hver funksjon:

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

Dette betyr at den viktigste funksjonen for å bestemme pingvinklasser for denne modellen var bill_length_mm!

Viktigheten er i forhold til målet for hvor godt dataene blir separert i hver nodedeling - i dette tilfellet er målet gitt av Gini-indeks – gini-verdien blir så vektet med hvor mange rader som er delt ved bruk av bill_length_mm funksjon og gjennomsnitt over de 100 trærne i ensemblet. Resultatet av disse trinnene står for 0.41267633, eller mer enn 40 % i dette tilfellet.

Visualisering av funksjonens betydning

En vanlig måte å representere viktige verdier på er å bruke barchatter. La oss først lage en dataramme med funksjonsnavnene og deres tilsvarende betydning, og deretter visualisere dem ved hjelp av 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 god praksis når du presenterer informasjon er å ordne verdier enten i stigende eller synkende rekkefølge. I dette tilfellet er dataene allerede bestilt, og den første verdien er den første vi vil vite. Når dette ikke er tilfelle, kan du bestille datarammen med sort_values. Dette kan gjøres på hvilken som helst kolonne i stigende eller synkende rekkefølge: importances_df.sort_values(by="importances", ascending=False).

Når du ser på dette første plottet, er det vanskeligere å tolke verdien av hver funksjons viktighet. Det er åpenbart at seddellengden er større enn de to andre stolpene, men ikke akkurat det bill_depth_mm tilsvarer 0.30107056, og at flipper_length_mm er 0.28625311. Så dette første diagrammet kan forbedres ved å vise verdien til hver stolpe. Dette kan gjøres ved å gå inn på Seaborn's containers gjenstand. Den lagrer informasjon om hver bar og sender verdiene som streketiketter:

Sjekk ut vår praktiske, praktiske guide for å lære Git, med beste praksis, bransjeaksepterte standarder og inkludert jukseark. Slutt å google Git-kommandoer og faktisk lære den!

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)