Obțineți importanțele caracteristicilor pentru pădurile aleatorii cu Python și Scikit-Learn

Introducere

Pădurea întâmplătoare algoritmul este un algoritm de învățare supravegheată bazat pe arbore, care utilizează un ansamblu de predicții ale multor arbori de decizie, fie pentru a clasifica un punct de date, fie pentru a determina valoarea sa aproximativă. Aceasta înseamnă că poate fi folosit fie pentru clasificare, fie pentru regresie.

Când se aplică pentru clasificare, clasa punctului de date este aleasă pe baza clasei care a fost cel mai votată de arbori; iar atunci când este aplicată pentru regresie, valoarea punctului de date este media tuturor valorilor ieșite de arbori.

Un lucru important de reținut atunci când folosiți Random Forests este că numărul de copaci este un hiperparametru și va fi definit înainte de a rula modelul.

Când lucrați în știința datelor, unul dintre motivele pentru care a fost ales un model de pădure aleatorie pentru un anumit proiect ar putea avea de a face cu capacitatea de a privi copacii ansamblu și de a înțelege de ce s-a făcut o clasificare, sau de ce a fost dată o valoare – aceasta se numește explicabilitate.

Luând în considerare algoritmii bazați pe arbore, încercarea de a explica un model se poate face în mai multe moduri, prin afișarea și uitarea fiecărui arbore (poate fi dificil dacă modelul are 200 de arbori sau mai mult), folosind Valori Shapley (sau SHAP)., uitându-se la caracteristicile care au fost cele mai luate în considerare de model, folosind LĂMÂIE VERDE pentru a investiga relațiile dintre intrarea și ieșirea modelului etc. De obicei, se folosește o combinație a tuturor metodelor.

În acest ghid rapid, ne vom concentra pe crearea unei diagrame cu caracteristicile care au fost considerate importante pentru ca modelul să ia o decizie la clasificarea pinguinilor. Acest lucru este cunoscut sub numele de investigarea importanța caracteristicii, și poate fi transmis altor membri ai echipei (tehnici și non-tehnic) pentru a oferi o privire asupra modului în care sunt luate deciziile.

Pentru a face acest lucru, să importăm bibliotecile necesare, să încărcăm setul de date Palmer Penguins, să împărțim datele, să creăm modelul, să obținem importanțele caracteristicilor și să folosim Seaborn pentru a le trasa! Nu vom cerceta prea mult date, EDA sau modelul în sine - acestea sunt subiectul ghidului dedicat.

Notă: Puteți descărca setul de date de la GitHub sau direct din cod.

Importul bibliotecilor

Să începem prin a importa câteva biblioteci pe care le vom folosi:

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)

Împărțirea datelor

Să împărțim datele pentru antrenament și testare:

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)

Obținerea importanțelor caracteristicilor

În cele din urmă, putem antrena un model și exportăm importanța caracteristicilor cu:

rf = RandomForestClassifier()


rf.fit(X_train, y_train)


rf.feature_importances_

Acest rezultat:

array([0.41267633, 0.30107056, 0.28625311])

Acestea sunt valorile caracteristicilor, pentru a vedea numele caracteristicilor, rulați:

rf.feature_names_in_

Rezultă numele corespunzător fiecărei caracteristici:

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

Aceasta înseamnă că cea mai importantă caracteristică pentru a decide clasele de pinguini pentru acest model special a fost bill_length_mm!

Importanța este relativă la măsurarea cât de bine sunt separate datele în fiecare divizare de nod - în acest caz, măsura este dată de Indicele Gini – valoarea gini este apoi ponderată cu câte rânduri au fost împărțite când se folosește bill_length_mm caracteristică și media celor 100 de arbori din ansamblu. Rezultatul acelor pași contează 0.41267633, sau mai mult de 40% în acest caz.

Vizualizarea importanței caracteristicilor

O modalitate obișnuită de a reprezenta valorile importanței este utilizarea chat-urilor cu bare. Să creăm mai întâi un cadru de date cu numele caracteristicilor și importanțele lor corespunzătoare, apoi să le vizualizăm folosind 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);                          

Indicații: O bună practică atunci când prezentați informații este să ordonați valorile în ordine crescătoare sau descrescătoare. În acest caz, datele sunt deja ordonate, prima valoare fiind prima pe care vrem să o știm. Când nu este cazul, puteți comanda cadrul de date cu sort_values. Acest lucru se poate face pe orice coloană în ordine crescătoare sau descrescătoare: importances_df.sort_values(by="importances", ascending=False).

Când privim acest prim complot, este mai greu de interpretat valoarea importanței fiecărei caracteristici. Este evident că lungimea bancnotei este mai mare decât celelalte două bare, dar nu chiar așa bill_depth_mm este echivalent cu 0.30107056, și că flipper_length_mm este 0.28625311. Deci, acest prim grafic poate fi îmbunătățit prin afișarea valorii fiecărei bare. Acest lucru se poate face accesând Seaborn's containers obiect. Stochează informațiile fiecărei bare și transmite valorile ca etichete de bare:

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)

Acum, putem vedea fiecare valoare de importanță clar, sau aproape clar, pentru că bill_length_mm valoarea este tăiată de o linie verticală care face parte din marginea exterioară a graficelor. Bordurile sunt folosite pentru a închide o zonă ca mijloc de a concentra mai multă atenție asupra acesteia, dar în acest caz, nu este nevoie să închidem, deoarece există un singur grafic. Să eliminăm chenarul și să îmbunătățim lizibilitatea numerelor:

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)

Graficul pare mai ușor de citit, dar căpușele de pe axa X par să plutească și avem deja valorile împreună cu barele, așa că putem elimina 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)

Observați cum, după îndepărtarea căpușelor, etichetele Y și X sunt puțin greu de citit. Eticheta Y, feature_names, este verticală și în axa X, există doar importances. Deoarece titlul afirmă deja că graficul este de Importanțele caracteristicilor, putem elimina și etichetele axei:

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)

Puteți vedea cum acest grafic este mai curat, ușor de citit și de înțeles atunci când o comparați cu primul. Mai sunt unele lucruri pe care le putem face. Observați că numerele sunt foarte aproape de bare, ar fi mai ușor de citit dacă ar fi puțin mai mult spațiu între ele.

Un alt element din această intrigă sunt culorile, când se folosesc culori contrastante, transmite o idee de separare, pe de altă parte, când sunt folosite culori similare, ele comunică o idee de unitate, sau părți dintr-un întreg. Deoarece toate caracteristicile fac parte din pinguini, putem folosi o culoare care face fiecare bară distinctă, menținând în același timp unitatea:

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) 

Dacă doriți să faceți rezultatele și mai directe, puteți schimba titlul și adăuga concluzia. Ceea ce se știe este că lungimea facturii a fost considerată cea mai importantă caracteristică conform criteriilor pe care le-am discutat anterior. Aceasta poate fi prima informație pentru cineva care se uită la complot, am putea spune asta lungimea becului pinguinului a fost cea mai importantă caracteristică pentru clasificarea speciilor în modelul de bază Random Forest (RF). :

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)

Acesta este rezultatul final al diagramei cu importanța caracteristicilor:

Concluzie

În acest ghid – am construit un clasificator de pădure aleatoriu – și am inspectat importanța caracteristicilor care au fost folosite pentru a antrena modelul în încercarea de a explica ce a învățat un model și ce îi afectează raționamentul.