Introduzione
I Foresta casuale algoritmo è un algoritmo di apprendimento supervisionato basato su albero che utilizza un insieme di previsioni di molti alberi decisionali, sia per classificare un punto dati sia per determinarne il valore approssimativo. Ciò significa che può essere utilizzato per la classificazione o la regressione.
Quando si richiede la classificazione, la classe del punto dati viene scelta in base alla classe più votata dagli alberi; e quando applicato per la regressione, il valore del punto dati è la media di tutti i valori emessi dagli alberi.
Una cosa importante da ricordare quando si utilizzano le foreste casuali è che il numero di alberi è un iperparametro e verrà definito prima di eseguire il modello.
Quando si lavora nella scienza dei dati, uno dei motivi per cui è stato scelto un modello Random Forest per un progetto specifico potrebbe avere a che fare con la capacità di guardare gli alberi raggruppati e comprendere perché è stata fatta una classificazione, o perché è stato dato un valore – questo è chiamato spiegabilità.
Considerando gli algoritmi basati sugli alberi, il tentativo di spiegare un modello può essere fatto in diversi modi, visualizzando e guardando ogni albero (può essere difficile se il modello ha 200 o più alberi), usando Valori Shapley (o SHAP)., guardando le caratteristiche che sono state maggiormente prese in considerazione dal modello, utilizzando LIME per indagare le relazioni tra input e output del modello, ecc. Di solito, viene impiegata una combinazione di tutti i metodi.
In questa guida rapida, ci concentreremo sulla creazione di un grafico delle caratteristiche che sono state considerate importanti affinché il modello prenda una decisione durante la classificazione dei pinguini. Questo è noto come indagare sul importanza della caratteristica, e può essere trasmesso ad altri membri del team (tecnici e non) per offrire uno sguardo su come vengono prese le decisioni.
Per fare ciò, importiamo le librerie necessarie, carichiamo il set di dati Palmer Penguins, dividiamo i dati, creiamo il modello, otteniamo l'importanza delle caratteristiche e usiamo Seaborn per tracciarli! Non approfondiremo molto i dati, l'EDA o il modello stesso: questi sono l'argomento della guida dedicata.
Nota: È possibile scaricare il set di dati da GitHub o direttamente dal codice.
Importazione di librerie
Iniziamo importando alcune librerie che utilizzeremo:
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)
Divisione dei dati
Dividiamo i dati per l'addestramento e il test:
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)
Ottenere l'importanza delle caratteristiche
Infine, possiamo addestrare un modello ed esportare l'importanza delle funzionalità con:
rf = RandomForestClassifier()
rf.fit(X_train, y_train)
rf.feature_importances_
Questo produce:
array([0.41267633, 0.30107056, 0.28625311])
Questi sono i valori delle funzionalità, per vedere i nomi delle funzionalità, eseguire:
rf.feature_names_in_
Ciò si traduce nel nome corrispondente di ciascuna caratteristica:
array(['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm'],
dtype=object)
Ciò significa che la caratteristica più importante per decidere le classi di pinguino per questo particolare modello era il bill_length_mm!
L'importanza è relativa alla misura di quanto bene i dati vengono separati in ogni divisione del nodo - in questo caso, la misura è data dal Indice Gini – il valore gini viene quindi ponderato in base a quante righe sono state suddivise quando si utilizza il bill_length_mm caratteristica e una media sui 100 alberi dell'insieme. Il risultato di questi passaggi rappresenta 0.41267633, o più del 40% in questo caso.
Visualizzazione dell'importanza delle funzionalità
Un modo comune per rappresentare i valori di importanza è utilizzare le chat a barre. Creiamo prima un dataframe con i nomi delle caratteristiche e la loro importanza corrispondente, quindi visualizziamoli usando 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);
Consigli: Una buona pratica quando si presentano le informazioni è ordinare i valori in ordine crescente o decrescente. In questo caso, i dati sono già ordinati, con il primo valore che è il primo che vogliamo conoscere. Quando questo non è il caso, puoi ordinare il dataframe con sort_values. Questo può essere fatto su qualsiasi colonna in ordine crescente o decrescente: importances_df.sort_values(by="importances", ascending=False).
Quando si guarda a questa prima trama, è più difficile interpretare il valore dell'importanza di ciascuna caratteristica. È ovvio che la lunghezza della banconota è maggiore rispetto alle altre due barre, ma non esattamente quella bill_depth_mm è equivalente 0.30107056e che il flipper_length_mm è 0.28625311. Quindi, questo primo grafico può essere migliorato visualizzando il valore di ogni barra. Questo può essere fatto accedendo a Seaborn's containers oggetto. Memorizza ogni informazione sulla barra e passa i valori come etichette della barra:
Dai un'occhiata alla nostra guida pratica e pratica per l'apprendimento di Git, con le migliori pratiche, gli standard accettati dal settore e il cheat sheet incluso. Smetti di cercare su Google i comandi Git e in realtà imparare esso!
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)
Ora possiamo vedere ogni valore di importanza chiaramente, o quasi chiaramente, perché bill_length_mm il valore viene tagliato da una linea verticale che fa parte del bordo esterno del grafico. I bordi vengono utilizzati per racchiudere un'area come mezzo per focalizzare maggiore attenzione su di essa, ma in questo caso non è necessario racchiudere, perché c'è solo un grafico. Rimuoviamo il bordo e miglioriamo la leggibilità dei numeri:
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)
Il grafico sembra più facile da leggere, ma i tick sull'asse X sembrano fluttuare e abbiamo già i valori insieme alle barre, quindi possiamo rimuovere il 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)
Nota come dopo aver rimosso i segni di spunta, le etichette Y e X sono un po' difficili da leggere. L'etichetta Y, feature_names, è verticale e nell'asse X, ci sono solo importances. Poiché il titolo afferma già che il grafico è di Importanza delle funzionalità, possiamo anche rimuovere le etichette degli assi:
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)
Puoi vedere come questo grafico sia più pulito, facile da leggere e capire confrontandolo con il primo. Ci sono ancora alcune cose che possiamo fare. Osserva che i numeri sono molto vicini alle barre, sarebbe più facile leggerli se ci fosse un po' più di spazio tra di loro.
Un altro elemento di questa trama sono i colori, quando si usano colori contrastanti si trasmette un'idea di separazione, viceversa quando si usano colori simili si comunica un'idea di unità, o di parti di un tutto. Poiché le caratteristiche fanno tutte parte dei pinguini, possiamo usare un colore che renda distinta ogni barra mantenendo l'unità:
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)
Se vuoi rendere i risultati ancora più diretti, puoi cambiare il titolo e aggiungere la conclusione. Quello che si sa è che la lunghezza della banconota era considerata la caratteristica più importante secondo i criteri che abbiamo discusso in precedenza. Questa può essere la prima informazione per chi guarda la trama, potremmo dire così la lunghezza del becco del pinguino era la caratteristica più importante per la classificazione delle specie nel modello base 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)
Questo è il risultato finale della tabella dell'importanza delle funzionalità:
Conclusione
In questa guida, abbiamo creato un classificatore di foreste casuali e analizzato l'importanza delle caratteristiche utilizzate per addestrare il modello nel tentativo di spiegare ciò che un modello ha appreso e ciò che influenza il suo ragionamento.
