Uzyskaj znaczenie funkcji dla losowych lasów za pomocą Pythona i Scikit-Learn

Wprowadzenie

Połączenia Losowy las Algorytm jest opartym na drzewach algorytmem uczenia nadzorowanego, który wykorzystuje zespół predykcji wielu drzew decyzyjnych, aby sklasyfikować punkt danych lub określić jego przybliżoną wartość. Oznacza to, że może być używany do klasyfikacji lub regresji.

Podczas składania wniosku o klasyfikację klasa punktu danych jest wybierana na podstawie klasy, na którą drzewa głosowały najczęściej; a po zastosowaniu do regresji wartość punktu danych jest średnią wszystkich wartości wyprowadzanych przez drzewa.

Ważną rzeczą do zapamiętania podczas korzystania z losowych lasów jest to, że liczba drzew jest hiperparametrem i zostanie zdefiniowana przed uruchomieniem modelu.

Podczas pracy w data science jednym z powodów, dla których wybrano model lasu losowego dla konkretnego projektu, może być umiejętność patrzenia na drzewa zespołowe i rozumienia dlaczego dokonano klasyfikacji lub dlaczego została podana wartość – to tzw wyjaśnialność.

Biorąc pod uwagę algorytmy oparte na drzewach, próbę wyjaśnienia modelu można wykonać na kilka sposobów, wyświetlając i przeglądając każde drzewo (może to być trudne, jeśli model ma 200 lub więcej drzew), używając wartości Shapleya (lub SHAP)., patrząc na cechy, które były najczęściej brane pod uwagę przez model, używając LIME w celu zbadania relacji między danymi wejściowymi i wyjściowymi modelu itp. Zwykle stosuje się kombinację wszystkich metod.

W tym krótkim przewodniku skupimy się na stworzeniu wykresu cech, które zostały uznane za ważne dla modelu przy podejmowaniu decyzji podczas klasyfikacji pingwinów. Jest to znane jako badanie znaczenie funkcjii mogą być przekazywane innym członkom zespołu (technicznym i nietechnicznym), aby dać wgląd w sposób podejmowania decyzji.

Aby to zrobić, zaimportujmy niezbędne biblioteki, załadujmy zestaw danych Palmer Penguins, podzielmy dane, utwórzmy model, uzyskajmy ważność funkcji i użyjmy Seaborn do ich wykreślenia! Nie będziemy się zbytnio zagłębiać w dane, EDA czy sam model – to temat dedykowanego poradnika.

Uwaga: Możesz pobrać zbiór danych z GitHub lub bezpośrednio z kodu.

Importowanie bibliotek

Zacznijmy od zaimportowania kilku bibliotek, których będziemy używać:

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)

Dzielenie danych

Podzielmy dane na trening i testowanie:

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)

Uzyskiwanie ważności funkcji

Wreszcie – możemy wytrenować model i wyeksportować ważność funkcji za pomocą:

rf = RandomForestClassifier()


rf.fit(X_train, y_train)


rf.feature_importances_

To daje:

array([0.41267633, 0.30107056, 0.28625311])

To są wartości funkcji, aby zobaczyć nazwy funkcji, uruchom:

rf.feature_names_in_

Powoduje to odpowiednią nazwę każdej funkcji:

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

Oznacza to, że najważniejszą cechą decydującą o klasach peguin dla tego konkretnego modelu była bill_length_mm!

Znaczenie zależy od miary tego, jak dobrze dane są rozdzielane w każdym podziale węzła — w tym przypadku miarę podaje Indeks Giniego – wartość Gini jest następnie ważona przez liczbę wierszy, które zostały podzielone podczas korzystania z bill_length_mm cechy i uśrednione dla 100 drzew w zespole. Wynik tych kroków stanowi 0.41267633lub więcej niż 40% w tym przypadku.

Wizualizacja znaczenia funkcji

Powszechnym sposobem przedstawiania wartości ważności jest używanie czatów na pasku. Najpierw stwórzmy ramkę danych z nazwami funkcji i odpowiadającymi im ważnościami, a następnie zwizualizujmy je za pomocą Seaborn 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);                          

Rada: Dobrą praktyką przy prezentowaniu informacji jest porządkowanie wartości w porządku rosnącym lub malejącym. W tym przypadku dane są już uporządkowane, a pierwsza wartość jest pierwszą, którą chcemy poznać. Jeśli tak nie jest, możesz zamówić ramkę danych z sort_values. Można to zrobić na dowolnej kolumnie w porządku rosnącym lub malejącym: importances_df.sort_values(by="importances", ascending=False).

Patrząc na ten pierwszy wykres, trudniej jest zinterpretować wartość ważności każdej cechy. Oczywiste jest, że długość dzioba jest większa niż w przypadku pozostałych dwóch słupków, ale nie do końca bill_depth_mm odpowiada 0.30107056i że flipper_length_mm wynosi 0.28625311. Tak więc ten pierwszy wykres można ulepszyć, wyświetlając wartość każdego słupka. Można to zrobić, uzyskując dostęp do Seaborn's containers obiekt. Przechowuje informacje o każdym słupku i przekazuje wartości jako etykiety słupków:

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)

Teraz możemy zobaczyć każdą wartość ważności wyraźnie lub prawie wyraźnie, ponieważ bill_length_mm wartość jest przecinana przez pionową linię, która jest częścią zewnętrznej krawędzi wykresów. Granice są używane do otaczania obszaru w celu skupienia na nim większej uwagi, ale w tym przypadku nie musimy otaczać, ponieważ jest tylko jeden wykres. Usuńmy obramowanie i poprawmy czytelność liczb:

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)

Wykres wydaje się łatwiejszy do odczytania, ale tiki na osi X wydają się pływające i mamy już wartości wraz ze słupkami, więc możemy usunąć 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)

Zwróć uwagę, że po usunięciu znaczników etykiety Y i X są nieco trudne do odczytania. Etykieta Y, feature_names, jest pionowa, a na osi X są tylko importances. Ponieważ tytuł już mówi, że wykres jest z Znaczenie funkcji, możemy również usunąć etykiety osi:

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)

Możesz zobaczyć, jak ten wykres jest czystszy, łatwiejszy do odczytania i zrozumienia w porównaniu z pierwszym. Wciąż jest kilka rzeczy, które możemy zrobić. Zwróć uwagę, że liczby są naprawdę blisko kresek, łatwiej byłoby je odczytać, gdyby było między nimi trochę więcej miejsca.

Kolejnym elementem tej fabuły są kolory, gdy stosowane są kolory kontrastowe, przekazuje to ideę separacji, odwrotnie, gdy używane są podobne kolory, komunikują ideę jedności lub części całości. Ponieważ wszystkie cechy są częścią pingwinów, możemy użyć kolorów, które wyróżnią każdy słupek, zachowując jedność:

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) 

Jeśli chcesz, aby wyniki były jeszcze bardziej bezpośrednie, możesz zmienić tytuł i dodać wniosek. Wiadomo, że długość dzioba została uznana za najważniejszą cechę zgodnie z wcześniej omówionymi kryteriami. To może być pierwsza informacja dla kogoś, kto patrzy na fabułę, można tak powiedzieć długość dzioba pingwina była najważniejszą cechą klasyfikacji gatunków w modelu podstawowym 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)

Oto końcowy wynik wykresu ważności funkcji:

Wnioski

W tym przewodniku — zbudowaliśmy losowy klasyfikator lasu — i sprawdziliśmy ważność funkcji, które zostały użyte do wytrenowania modelu w celu wyjaśniać czego nauczył się model i co wpływa na jego rozumowanie.