Guida definitiva all'algoritmo Random Forest con Python e Scikit-Learn

Introduzione

L'algoritmo Random Forest è uno degli algoritmi più flessibili, potenti e ampiamente utilizzati per classificazione e regressione, costruito come un insieme di alberi decisionali.

Se non hai familiarità con questi, non preoccuparti, tratteremo tutti questi concetti.

In questa guida pratica approfondita, costruiremo un intuizione su come funzionano gli alberi decisionali, in che modo l'ensemble potenzia i singoli classificatori e regressori, cosa sono le foreste casuali e costruisci un classificatore e un regressore di foreste casuali usando Python e Scikit-Learn, attraverso un mini-progetto end-to-end, e rispondi a una domanda di ricerca.

Considera che attualmente fai parte di un gruppo di ricerca che sta analizzando i dati sulle donne. Il gruppo ha raccolto 100 record di dati e vuole essere in grado di organizzare quei record iniziali dividendo le donne in categorie: essere o non essere incinta e vivere in aree rurali o urbane. I ricercatori vogliono capire quante donne ci sarebbero in ciascuna categoria.

Esiste una struttura computazionale che fa esattamente questo, è il albero struttura. Utilizzando una struttura ad albero, sarai in grado di rappresentare le diverse divisioni per ogni categoria.

Alberi decisionali

Come si popolano i nodi di un albero? Qui è dove alberi decisionali venire a fuoco.

Per prima cosa, possiamo dividere i record per gravidanza, dopodiché possiamo dividerli per vivere in aree urbane o rurali. Si noti che potremmo farlo in un ordine diverso, dividendo inizialmente per l'area in cui vivono le donne e successivamente per il loro stato di gravidanza. Da questo, possiamo vedere che l'albero ha una gerarchia intrinseca. Oltre a organizzare le informazioni, un albero organizza le informazioni in modo gerarchico: l'ordine in cui le informazioni appaiono è importante e di conseguenza porta a diversi alberi.

Di seguito è riportato un esempio dell'albero che è stato descritto:

Nell'immagine dell'albero ci sono 7 quadrati, quello in alto che rappresenta il totale di 100 donne, questo quadrato in alto è collegato con due quadrati in basso, che dividono le donne in base al loro numero di 78 non gravide e 22 gravide, e da entrambe le caselle precedenti ci sono quattro caselle; due collegate ad ogni quadrato soprastante che dividono le donne in base alla loro area, per le non gravide, 45 abitano in area urbana, 33 in area rurale e per le gestanti, 14 abitano in area rurale e 8 in area urbana. Solo guardando l'albero, è facile capire quelle divisioni e vedere come ogni "strato" è derivato da quelli precedenti, quegli strati sono l'albero livelli, i livelli descrivono il profondità dell'albero:

Osserva nell'immagine sopra che il primo livello dell'albero è livello 0 dove c'è solo un quadrato, seguito da livello 1 dove ci sono due quadrati, e livello 2 dove ci sono quattro quadrati. Questo è un profondità 2 albero.

Nel livello 0 c'è il quadrato che origina l'albero, il primo, chiamato nodo radice, questa radice ne ha due nodi figlio nel livello 1, cioè nodi genitori ai quattro nodi del livello 2. Vedi che i “quadrati” di cui abbiamo parlato finora, in realtà si chiamano nodi; e che ogni nodo precedente è genitore dei nodi successivi, che sono i suoi figli. Vengono chiamati i nodi figli di ogni livello che hanno lo stesso genitore fratelli, come si può vedere nella prossima immagine:

Nell'immagine precedente, mostriamo anche il livello 1 come il nodi interni, una volta che si trovano tra la radice e gli ultimi nodi, che sono i nodi fogliari. I nodi fogliari sono l'ultima parte di un albero, se dovessimo dire delle 100 donne iniziali, quante sono incinte e vivono in zone rurali, potremmo farlo guardando le foglie. Quindi il numero sulle foglie risponderebbe alla prima domanda di ricerca.

Se ci fossero nuove registrazioni di donne, e l'albero precedentemente utilizzato per classificarle, fosse ora utilizzato per decidere se una donna potesse o meno far parte della ricerca, funzionerebbe ancora? L'albero utilizzerebbe gli stessi criteri e una donna sarebbe idonea a partecipare se incinta e residente in una zona rurale.

Osservando l'immagine qui sopra, possiamo vedere che le risposte alle domande di ciascun nodo dell'albero – “è una partecipante?”, “è incinta?”, “vive in una zona rurale?”- sono sì, sì, e sì, quindi sembra che l'albero possa portare alla decisione, in questo caso, che la donna possa partecipare alla ricerca.

Questa è la essenza degli alberi decisionali in, fatto in modo manuale. Utilizzando il Machine Learning, possiamo costruire un modello che costruisce questo albero automaticamente per noi, in modo tale da massimizzare l'accuratezza delle decisioni finali.

Negli esempi precedenti, osserva come potrebbe farlo l'albero classificare nuovi dati come partecipante o non partecipante, oppure le domande potrebbero anche essere modificate in – “quanti partecipanti?”, “quante sono incinte?”, “quante vivono in una zona rurale?”- portandoci a trovare il quantità di partecipanti incinte che vivono in una zona rurale.

Quando i dati sono classificati, significa che l'albero sta eseguendo a classificazione compito, e quando viene trovata la quantità di dati, l'albero sta eseguendo a regressione compito. Ciò significa che l'albero decisionale può essere utilizzato per entrambi i compiti: classificazione e regressione.

Ora che comprendiamo cos'è un albero decisionale, come può essere utilizzato e quale nomenclatura viene utilizzata per descriverlo, possiamo interrogarci sui suoi limiti.

Capire le foreste casuali

Cosa succede alla decisione se qualche partecipante vive della divisione tra aree urbane e rurali? L'albero aggiungerebbe questo record a rurale o urbano? Sembra difficile adattare questi dati alla struttura che abbiamo attualmente, dal momento che è abbastanza chiaro.

Inoltre, se una donna che vive su una barca partecipasse alla ricerca, sarebbe considerata rurale o urbana? Analogamente al caso precedente, è un punto dati impegnativo da classificare considerando le opzioni disponibili nell'albero.

Pensando un po' di più all'esempio dell'albero decisionale, siamo in grado di vedere che può classificare correttamente i nuovi dati considerando che segue già uno schema che l'albero ha già, ma quando ci sono record che differiscono dai dati iniziali che hanno definito l'albero, il la struttura ad albero è troppo rigida, rendendo i record non classificabili.

Ciò significa che l'albero decisionale può essere rigoroso e limitato nelle sue possibilità. Un albero decisionale ideale sarebbe più flessibile e in grado di accogliere dati invisibili più sfumati.

Per quanto riguarda la risposta alla domanda iniziale, sappiamo già che sarà codificata nelle foglie degli alberi – ma cosa cambia quando abbiamo tanti alberi invece di uno?

Se gli alberi vengono combinati per una classificazione, il risultato sarà definito dalla maggioranza delle risposte, si chiama così voto a maggioranza; e nel caso di una regressione, sarà il numero dato da ciascun albero nella foresta media.

Ensemble Learning e ensemble di modelli

Questo metodo è noto come apprendimento dell'ensemble. Quando si utilizza l'apprendimento dell'ensemble, è possibile combinare insieme qualsiasi algoritmo, purché sia ​​possibile garantire che l'output possa essere analizzato e combinato con altri output (manualmente o utilizzando le librerie esistenti). In genere, si raggruppano più modelli dello stesso tipo, ad esempio più alberi decisionali, ma non si è limitati a unire solo insiemi dello stesso tipo di modello.

L'ensemble è un modo praticamente garantito per generalizzare meglio un problema e ottenere un leggero aumento delle prestazioni. In alcuni casi, l'insieme di modelli produce a significativa aumento del potere predittivo e, a volte, solo lieve. Questo dipende dal set di dati su cui stai addestrando e valutando, nonché dai modelli stessi.

Unire insieme gli alberi decisionali produce significativa aumenta le prestazioni rispetto ai singoli alberi. Questo approccio è stato reso popolare nelle comunità di ricerca e apprendimento automatico ed era così comune che l'insieme degli alberi decisionali è stato chiamato colloquialmente a foresta, e il tipo comune di foresta che veniva creata (una foresta di alberi decisionali su un sottoinsieme casuale di caratteristiche) rese popolare il nome foreste casuali.

Dato l'utilizzo su larga scala, librerie come Scikit-Learn hanno implementato wrapper per RandomForestRegressors e RandomForestClassifiers, costruito in cima alle proprie implementazioni dell'albero decisionale, per consentire ai ricercatori di evitare di costruire i propri ensemble.

Tuffiamoci in foreste casuali!

Come funziona l'algoritmo Random Forest?

Di seguito sono riportati i passaggi di base coinvolti durante l'esecuzione dell'algoritmo della foresta casuale:

1. Scegli un numero di record casuali, può essere qualsiasi numero, ad esempio 4, 20, 76, 150 o anche 2.000 dal set di dati (chiamato N registrazioni). Il numero dipenderà dalla larghezza del set di dati, più ampio, più grande N può essere. Questo è dove il casuale parte del nome dell'algoritmo viene da!
2. Costruisci un albero decisionale basato su quelli N registrazioni casuali;
3. In base al numero di alberi definito per l'algoritmo o al numero di alberi nella foresta, ripetere i passaggi 1 e 2. Questo genera più alberi da insiemi di record di dati casuali;
4. Dopo il passaggio 3, arriva il passaggio finale, che prevede i risultati:
   • In caso di classificazione: ogni albero della foresta predirà la categoria a cui appartiene il nuovo record. Successivamente, il nuovo primato viene assegnato alla categoria che ottiene il voto di maggioranza.
   • In caso di regressione: ogni albero nella foresta prevede un valore per il nuovo record e il valore di previsione finale sarà calcolato prendendo una media di tutti i valori previsti da tutti gli alberi nella foresta.

Ogni albero che rientra in un sottoinsieme casuale di caratteristiche non avrà necessariamente alcuna conoscenza di alcune altre caratteristiche, che vengono rettificate dall'insieme, pur mantenendo il costo computazionale inferiore.

Con un'intuizione su come funzionano gli alberi e una comprensione delle foreste casuali, l'unica cosa rimasta è esercitarsi a costruirli, addestrarli e sintonizzarli sui dati!

Costruzione e addestramento di modelli forestali casuali con Scikit-Learn

C'era una ragione per cui gli esempi usati finora riguardano la gravidanza, la vita e le donne.

Nel 2020, i ricercatori del Bangladesh hanno notato che la mortalità tra le donne incinte era ancora molto alta, soprattutto considerando quelle che vivono nelle zone rurali. Per questo motivo, hanno utilizzato un sistema di monitoraggio IOT per analizzare il rischio per la salute materna. Il sistema IOT ha raccolto dati da diversi ospedali, cliniche comunitarie e assistenza sanitaria materna delle aree rurali del Bangladesh.

I dati raccolti sono stati quindi organizzati in un file con valori separati da virgola (csv) e caricati in Repository di machine learning di UCI.

Questi sono i dati che useremo per esercitarci e cercare di capire se una donna incinta ha a Basso, medie or alto rischio di mortalità.

Utilizzo della foresta casuale per la classificazione

Dal momento che vogliamo sapere se la donna ha a Basso, medie or alto rischio di mortalità, ciò significa che eseguiremo una classificazione con tre classi. Quando un problema ha più di due classi, si chiama a multiclasse problema, al contrario di a binario problema (in cui si sceglie tra due classi, in genere 0 ed 1).

In questo primo esempio, implementeremo un modello di classificazione multiclasse con un classificatore Random Forest e Scikit-Learn di Python.

Seguiremo i soliti passaggi di apprendimento automatico per risolvere questo problema, che sono il caricamento delle librerie, la lettura dei dati, l'osservazione delle statistiche di riepilogo e la creazione di visualizzazioni dei dati per comprenderli meglio. Quindi, pre-elaborazione e suddivisione dei dati seguiti dalla generazione, addestramento e valutazione di un modello.

Importazione di librerie

Useremo Pandas per leggere i dati, Seaborn e Matplotlib per visualizzarli e NumPy per i grandi metodi di utilità:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

Importazione del set di dati

Il codice seguente importa il set di dati e lo carica in un python DataFrame:

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

Per esaminare le prime cinque righe dei dati, eseguiamo il file head() comando:

dataset.head()

Questo produce:

    Age SystolicBP  DiastolicBP BS      BodyTemp    HeartRate   RiskLevel
0   25  130         80          15.0    98.0        86          high risk
1   35  140         90          13.0    98.0        70          high risk
2   29  90          70          8.0     100.0       80          high risk
3   30  140         85          7.0     98.0        70          high risk
4   35  120         60          6.1     98.0        76          low risk

Qui possiamo vedere tutti gli attributi raccolti durante la ricerca.

• Età: età in anni.
• PA sistolica: valore massimo della pressione sanguigna in mmHg, un attributo significativo durante la gravidanza.
• DiastolicBP: valore più basso della pressione sanguigna in mmHg, un altro attributo significativo durante la gravidanza.
• BS: livelli di glucosio nel sangue in termini di concentrazione molare, mmol/L.
• Frequenza cardiaca: frequenza cardiaca a riposo in battiti al minuto.
• RiskLevel: livello di rischio durante la gravidanza.
• BodyTemp: la temperatura corporea.

Ora che comprendiamo di più su ciò che viene misurato, possiamo esaminare i tipi di dati con info():

dataset.info()

Questo risulta in:

RangeIndex: 1014 entries, 0 to 1013
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   Age          1014 non-null   int64  
 1   SystolicBP   1014 non-null   int64  
 2   DiastolicBP  1014 non-null   int64  
 3   BS           1014 non-null   float64
 4   BodyTemp     1014 non-null   float64
 5   HeartRate    1014 non-null   int64  
 6   RiskLevel    1014 non-null   object 
dtypes: float64(2), int64(4), object(1)
memory usage: 55.6+ KB

Dal guardare il RangeIndex line, possiamo vedere che ci sono 1014 record e la colonna Non-Null Count informa che i dati non presentano valori mancanti. Ciò significa che non avremo bisogno di effettuare alcun trattamento per i dati mancanti!

Nel Dtype colonna, possiamo vedere il tipo di ogni variabile. Attualmente, float64 colonne tali BS ed BodyTemp hanno valori numerici che possono variare in qualsiasi intervallo, come 15.0, 15.51, 15.76, 17.28, rendendoli numericamente continuo (puoi sempre aggiungere uno 0 a un numero in virgola mobile, ad infinitem). D'altra parte, variabili come Age, SystolicBP, DiastolicBPe HeartRate sono del tipo int64, questo significa che i numeri cambiano solo in base all'unità, come 11, 12, 13, 14 – non avremo una frequenza cardiaca di 77.78, è 77 o 78 – quelli sono numericamente discreto i valori. E abbiamo anche RiskLevel con una object tipo, questo di solito indica che la variabile è un testo e probabilmente dovremo trasformarlo in un numero. Poiché il livello di rischio cresce da basso ad alto, c'è un ordine implicito nelle categorie, questo indica che è a categoricamente ordinale variabile.

Dopo aver esaminato i tipi di dati, possiamo utilizzare describe() per dare un picco ad alcune statistiche descrittive, come i valori medi di ciascuna colonna, la deviazione standard, i quantili, i valori minimi e massimi dei dati:

dataset.describe().T 

Il codice sopra mostra:

            count   mean        std         min     25%     50%     75%     max
Age         1014.0  29.871795   13.474386   10.0    19.0    26.0    39.0    70.0
SystolicBP  1014.0  113.198225  18.403913   70.0    100.0   120.0   120.0   160.0
DiastolicBP 1014.0  76.460552   13.885796   49.0    65.0    80.0    90.0    100.0
BS          1014.0  8.725986    3.293532    6.0     6.9     7.5     8.0     19.0
BodyTemp    1014.0  98.665089   1.371384    98.0    98.0    98.0    98.0    103.0
HeartRate   1014.0  74.301775   8.088702    7.0     70.0    76.0    80.0    90.0
RiskLevel   1014.0  0.867850    0.807353    0.0     0.0     1.0     2.0     2.0

Si noti che per la maggior parte delle colonne, il significare i valori sono lontani dal deviazione standard (std) – questo indica che i dati non seguono necessariamente una distribuzione statistica corretta. Se così fosse, avrebbe aiutato il modello nella previsione del rischio. Quello che si può fare qui è preelaborare i dati per renderli più rappresentativi come se fossero dati dell'intera popolazione mondiale, o più normalizzato. Tuttavia, un vantaggio quando si utilizzano i modelli Random Forest per classificazione, è che la struttura ad albero intrinseca può gestire bene i dati che non sono stati normalizzati, una volta divisi per il valore in ogni livello dell'albero per ogni variabile.

Inoltre, poiché stiamo usando alberi e la classe risultante sarà ottenuta votando, non stiamo intrinsecamente confrontando tra valori diversi, solo tra stessi tipi di valori, quindi in questo caso non è necessario adattare le caratteristiche alla stessa scala . Ciò significa che il modello di classificazione Random Forest è invariante di scalae non è necessario eseguire il ridimensionamento delle funzionalità.

In questo caso, il passaggio nella preelaborazione dei dati che possiamo compiere è trasformare il categorico RiskLevel colonna in una numerica.

Visualizzazione dei dati

Prima di trasformare RiskLevel, visualizziamo anche rapidamente i dati osservando le combinazioni di punti per ogni coppia di caratteristiche con un grafico a dispersione e come i punti sono distribuiti visualizzando la curva dell'istogramma. Per farlo, useremo Seaborn's pairplot() che combina entrambe le trame. Genera entrambi i grafici per ciascuna combinazione di caratteristiche e visualizza i punti codificati a colori in base al loro livello di rischio con il hue proprietà:

g = sns.pairplot(dataset, hue='RiskLevel')
g.fig.suptitle("Scatterplot and histogram of pairs of variables color coded by risk level", 
               fontsize = 14, 
               y=1.05); 

Il codice precedente genera:

Osservando la trama, la situazione ideale sarebbe avere una netta separazione tra curve e punti. Come si vede, le tre tipologie di classi di rischio sono per lo più confuse, poiché gli alberi disegnano internamente delle linee quando delimitano gli spazi tra i punti, possiamo ipotizzare che più alberi nella foresta potrebbero essere in grado di delimitare più spazi e classificare meglio i punti.

Dopo aver eseguito l'analisi esplorativa di base dei dati, possiamo preelaborare il file RiskLevel colonna.

Preelaborazione dei dati per la classificazione

A dire il vero ci sono solo tre classi di RiskLevel nei nostri dati e che nessun altro valore è stato aggiunto erroneamente, possiamo utilizzare unique() per visualizzare i valori univoci della colonna:

dataset['RiskLevel'].unique()

Questo produce:

array(['high risk', 'low risk', 'mid risk'], dtype=object)

Le classi sono controllate, ora il passo successivo è trasformare ogni valore in un numero. Poiché esiste un ordine tra le classificazioni, possiamo usare i valori 0, 1 e 2 per indicare Basso, medie ed alto rischi. Esistono molti modi per modificare i valori delle colonne, seguendo quelli di Python semplice è meglio che complesso motto, useremo il .replace() metodo e sostituirli semplicemente con le loro rappresentazioni intere:

dataset['RiskLevel'] = dataset['RiskLevel'].replace('low risk', 0).replace('mid risk', 1).replace('high risk', 2)

Dopo aver sostituito i valori, possiamo suddividere i dati in ciò che verrà utilizzato per addestrare il modello, il Caratteristiche or X, e ciò che vogliamo prevedere, il etichette or y:

y = dataset['RiskLevel']
X = dataset.drop(['RiskLevel'], axis=1)

Una volta che il X ed y i set sono pronti, possiamo usare quelli di Scikit-Learn train_test_split() metodo per suddividerli ulteriormente nel treno e nei set di test:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

Qui utilizziamo il 20% dei dati per i test e l'80% per la formazione.

Addestrare un RandomForestClassifier

Scikit-Learn ha implementato ensemble sotto il formato sklearn.ensemble modulo. Un insieme di alberi decisionali utilizzati per la classificazione, in cui viene presa la maggioranza dei voti, viene implementato come the RandomForestClassifier.

Avendo il treno e i set di test, possiamo importare il file RandomForestClassifier class e creare il modello. Per iniziare, creiamo una foresta con tre alberi, ambientando n_estimators parametro come 3, e con ogni albero avente tre livelli, impostando max_deptha 2:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=3, 
                             max_depth=2,
                             random_state=SEED)

Per adattare il modello ai dati, chiamiamo il file fit() metodo, inserendo le caratteristiche formative e le etichette:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

Ora possiamo confrontare le etichette previste con le etichette reali per valutare quanto bene ha funzionato il modello! Prima di valutare il modello, diamo un'occhiata all'insieme.

Per esaminare un po' più a fondo il modello, possiamo visualizzare ciascuno degli alberi e come dividono i dati. Questo può essere fatto utilizzando il tree modulo integrato in Scikit-Learn, quindi scorrendo ciascuno degli stimatori nell'ensemble:

from sklearn import tree

features = X.columns.values 
classes = ['0', '1', '2'] 



for estimator in rfc.estimators_:
    print(estimator)
    plt.figure(figsize=(12,6))
    tree.plot_tree(estimator,
                   feature_names=features,
                   class_names=classes,
                   fontsize=8, 
                   filled=True, 
                   rounded=True)
    plt.show()

Il codice sopra mostra i grafici ad albero:

Nota come i tre alberi sono diversi. Il primo inizia con il BS caratteristica, la seconda con DiastolicBP, e il terzo con BS ancora. Sebbene il terzo esamini un numero diverso di campioni. Sul ramo destro, anche i primi due alberi decidono di utilizzare Age a livello fogliare, mentre il terzo albero termina con BS caratteristica. Con solo tre stimatori, è chiaro come lo scaling up fornisca una rappresentazione ricca e diversificata della conoscenza che può essere assemblata con successo in un modello altamente accurato.

Più alberi ci sono nella foresta, più vario può essere il modello. C'è un punto di rendimenti decrescenti, tuttavia, poiché molti alberi si adattano a un sottoinsieme casuale di caratteristiche, ci saranno un bel po' di alberi simili che non offrono molta diversità nell'insieme e che inizieranno ad avere troppo potere di voto e distorcere l'insieme per essere sovradimensionato sul set di dati di addestramento, danneggiando la generalizzazione al set di convalida.

In precedenza è stata fatta un'ipotesi sull'avere più alberi e su come potrebbe migliorare i risultati del modello. Diamo un'occhiata ai risultati, generiamo un nuovo modello e vediamo se l'ipotesi regge!

Valutazione di RandomForestClassifier

Scikit-Learn semplifica la creazione di linee di base fornendo a DummyClassifier, che restituisce le previsioni senza utilizzare le funzionalità di input (uscite totalmente casuali). Se il tuo modello è migliore del DummyClassifier, alcuni sta accadendo l'apprendimento! Per massimizzare l'apprendimento, puoi testare automaticamente vari iperparametri utilizzando a RandomizedSearchCV or GridSearchCV. Oltre ad avere una linea di base, puoi valutare le prestazioni del tuo modello dalla lente di diverse metriche.

Alcune metriche di classificazione tradizionali che possono essere utilizzate per valutare l'algoritmo sono la precisione, il richiamo, il punteggio f1, l'accuratezza e la matrice di confusione. Ecco una breve spiegazione su ciascuno di essi:

1. Precisione: quando il nostro obiettivo è capire quali valori di previsione corretti sono stati considerati corretti dal nostro classificatore. La precisione dividerà quei veri valori positivi per i campioni previsti come positivi;

$$
precisione = frac{testo{veri positivi}}{testo{veri positivi} + testo{falsi positivi}}
$$

2. Richiamo: comunemente calcolato insieme alla precisione per capire quanti dei veri positivi sono stati individuati dal nostro classificatore. Il richiamo viene calcolato dividendo i veri positivi per tutto ciò che avrebbe dovuto essere previsto come positivo.

$$
recall = frac{testo{veri positivi}}{testo{veri positivi} + testo{falsi negativi}}
$$

3. punteggio F1: è il bilanciato o media armonica di precisione e di richiamo. Il valore più basso è 0 e il più alto è 1. Quando f1-score è uguale a 1, significa che tutte le classi sono state previste correttamente – questo è un punteggio molto difficile da ottenere con dati reali (le eccezioni esistono quasi sempre).

$$
testo{f1-score} = 2* frac{testo{precision} * testo{recall}}{text{precision} + testo{recall}}
$$

4. Matrice di confusione: quando abbiamo bisogno di sapere quanti campioni abbiamo ottenuto giusto o sbagliato ogni classe. Vengono chiamati i valori che erano corretti e correttamente previsti veri positivi, vengono chiamati quelli previsti come positivi ma che non lo erano falsi positivi. La stessa nomenclatura di veri negativi ed falsi negativi è usato per valori negativi;

5. Precisione: descrive quante previsioni ha ottenuto il nostro classificatore. Il valore di precisione più basso è 0 e il più alto è 1. Tale valore viene solitamente moltiplicato per 100 per ottenere una percentuale:

$$
accuratezza = frac{testo{numero di previsioni corrette}}{testo{numero totale di previsioni}}
$$

È possibile eseguire il seguente script per importare le librerie necessarie e guardare i risultati:

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk)')

print(classification_report(y_test,y_pred))

L'output sarà simile a questo:

                precision    recall  f1-score   support

           0       0.53      0.89      0.66        80
           1       0.57      0.17      0.26        76
           2       0.74      0.72      0.73        47

    accuracy                           0.58       203
   macro avg       0.61      0.59      0.55       203
weighted avg       0.59      0.58      0.53       203

Nel rapporto di classificazione, osserva che il richiamo è alto, 0.89 per la classe 0, sia la precisione che il richiamo sono alti per la classe 2, 0.74, 0.72 – e per la classe 1, sono bassi, specialmente il richiamo di 0.17 e una precisione di 0.57 . La relazione tra il richiamo e la precisione per tutte e tre le classi individualmente è catturata nel file F1 punteggio, che è la media armonica tra richiamo e precisione – il modello sta facendo va bene per la classe 0, abbastanza male per la classe 1 e decente per la classe 2.

Il modello sta attraversando un periodo molto difficile nell'identificare il file casi a medio rischio.

La precisione raggiunta dal nostro classificatore forestale casuale con solo 3 alberi è di 0.58 (58%) – questo significa che sta ottenendo un po' più della metà dei risultati corretti. Questa è una precisione bassa e forse potrebbe essere migliorata aggiungendo più alberi.

Osservando la matrice di confusione, possiamo vedere che la maggior parte degli errori si verificano quando si classificano 52 record di rischio medio come rischio basso, ciò che fornisce ulteriori informazioni sul ricordo basso della classe 1. È prevenuto verso la classificazione di pazienti a rischio medio come basso- pazienti a rischio.

Un'altra cosa che può essere verificata per generare ancora più informazioni è quali caratteristiche vengono maggiormente prese in considerazione dal classificatore durante la previsione. Questo è un passo importante da compiere sistemi di apprendimento automatico spiegabilie aiuta a identificare e mitigare i bias nei modelli.

Per vederlo, possiamo accedere al file feature_importances_ proprietà del classificatore. Questo ci darà un elenco di percentuali, quindi possiamo anche accedere al file feature_names_in_ property per ottenere il nome di ciascuna caratteristica, organizzarle in un dataframe, ordinarle dal più alto al più basso e tracciare il risultato:

features_df = pd.DataFrame({'features': rfc.feature_names_in_, 'importances': rfc.feature_importances_ })


features_df_sorted = features_df.sort_values(by='importances', ascending=False)


g = sns.barplot(data=features_df_sorted, x='importances', y ='features', palette="rocket")
sns.despine(bottom = True, left = True)
g.set_title('Feature importances')
g.set(xlabel=None)
g.set(ylabel=None)
g.set(xticks=[])
for value in g.containers:
    g.bar_label(value, padding=2)

Si noti come il classificatore consideri principalmente il glicemia, quindi un po' di pressione diastolica, temperatura corporea e solo un po' di età per prendere una decisione, questo potrebbe anche avere a che fare con il basso richiamo sulla classe 1, forse i dati di rischio medio hanno a che fare con caratteristiche che non sono tenuto molto in considerazione dal modello. Puoi provare a giocare di più con l'importanza delle funzionalità per indagare su questo e vedere se le modifiche al modello influiscono sulle funzionalità utilizzate, anche se esiste una relazione significativa tra alcune delle funzionalità e le classi previste.

È finalmente giunto il momento di generare un nuovo modello con più alberi per vedere come influisce sui risultati. Creiamo il rfc_ foresta con 900 alberi, 8 livelli e lo stesso seme. I risultati miglioreranno?

rfc_ = RandomForestClassifier(n_estimators=900, 
                             max_depth=7,
                             random_state=SEED)
rfc_.fit(X_train, y_train)
y_pred = rfc_.predict(X_test)

Calcolo e visualizzazione delle metriche:

cm_ = confusion_matrix(y_test, y_pred)
sns.heatmap(cm_, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk) for 900 trees with 8 levels')

print(classification_report(y_test,y_pred))

Questo produce:

                precision    recall  f1-score   support

           0       0.68      0.86      0.76        80
           1       0.75      0.58      0.65        76
           2       0.90      0.81      0.85        47

    accuracy                           0.74       203
   macro avg       0.78      0.75      0.75       203
weighted avg       0.76      0.74      0.74       203

Questo mostra come l'aggiunta di più alberi e alberi più specializzati (livelli più alti) abbia migliorato le nostre metriche. Abbiamo ancora un richiamo basso per la classe 1, ma la precisione è ora del 74%. Il punteggio F1 quando si classificano i casi ad alto rischio è di 0.85, il che significa che i casi ad alto rischio sono ora più facilmente identificabili rispetto allo 0.73 del modello precedente!

In un progetto quotidiano, potrebbe essere più importante identificare i casi ad alto rischio, ad esempio con una metrica simile alla precisione, nota anche come sensibilità nelle statistiche. Prova a modificare alcuni dei parametri del modello e osserva i risultati.

Fino ad ora, abbiamo ottenuto una comprensione generale di come la foresta casuale può essere utilizzata per classificare i dati: nella sezione successiva, possiamo utilizzare lo stesso set di dati in un modo diverso per vedere come lo stesso modello prevede i valori con la regressione.

Utilizzo di foreste casuali per la regressione

In questa sezione studieremo come utilizzare un algoritmo Random Forest per risolvere problemi di regressione utilizzando Scikit-Learn. I passaggi seguiti per implementare questo algoritmo sono quasi identici ai passaggi eseguiti per la classificazione, oltre al tipo di modello e al tipo di dati previsti - che ora saranno valori continui - c'è solo una differenza nella preparazione dei dati.

Poiché la regressione è fatta per valori numerici – scegliamo un valore numerico dal set di dati. Abbiamo visto che lo zucchero nel sangue era importante nella classificazione, quindi dovrebbe essere prevedibile in base ad altre caratteristiche (poiché se è correlato a qualche caratteristica, anche quella caratteristica è correlata ad essa).

Seguendo quanto fatto per la classificazione, importiamo prima le librerie e lo stesso dataset. Se lo hai già fatto per il modello di classificazione, puoi saltare questa parte e passare direttamente alla preparazione dei dati per l'addestramento.

Importazione di librerie e dati

import pandas as pd
import numpy as np
import maplotlib.pyplot as plt
import seaborn as sns

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

Preelaborazione dei dati per la regressione

Questa è un'attività di regressione, quindi invece di prevedere le classi, possiamo prevedere una delle colonne numeriche del set di dati. In questo esempio, il BS colonna sarà prevista. Questo significa il y i dati conterranno dati sulla glicemiae X i dati conterranno tutte le caratteristiche oltre alla glicemia. Dopo aver separato il X ed y dati, possiamo dividere il treno e i set di test:

from sklearn.model_selection import train_test_split

SEED = 42

y = dataset['BS']
X = dataset.drop(['BS'], axis=1) 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

Addestrare un RandomForestRegressor

Ora che abbiamo ridimensionato il nostro set di dati, è tempo di addestrare il nostro algoritmo per risolvere questo problema di regressione, per modificarlo un po': creeremo un modello con 20 alberi nella foresta e ciascuno con 4 livelli. Per farlo, puoi eseguire il seguente codice:

from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators=20, 
                            max_depth=3, 
                            random_state=SEED)

rfr.fit(X_train, y_train)
y_pred = rfr.predict(X_test)

Puoi trovare i dettagli per tutti i parametri di RandomForestRegressor nella documentazione ufficiale.

Dal momento che tracciare e guardare 20 alberi richiederebbe un po' di tempo e dedizione, possiamo tracciare solo il primo per dare un'occhiata a come è diverso dall'albero di classificazione:

from sklearn import tree

features = X.columns

first_tree = rfr.estimators_[0]

plt.figure(figsize=(15,6))
tree.plot_tree(first_tree,
               feature_names=features,
               fontsize=8, 
               filled=True, 
               rounded=True);

Si noti che l'albero di regressione ha già un valore assegnato ai dati che ricade su ogni nodo. Questi sono i valori di cui verrà calcolata la media quando si combinano i 20 alberi. Seguendo ciò che abbiamo fatto con la classificazione, puoi anche tracciare l'importanza delle caratteristiche per vedere quali variabili il modello di regressione sta prendendo maggiormente in considerazione durante il calcolo dei valori.

È tempo di procedere all'ultimo e ultimo passaggio per risolvere un problema di apprendimento automatico e valutare le prestazioni dell'algoritmo!

Valutazione di un RandomForestRegressor

Per i problemi di regressione le metriche utilizzate per valutare un algoritmo sono l'errore medio assoluto (MAE), l'errore quadratico medio (MSE) e l'errore quadratico medio (RMSE).

1. Errore assoluto medio (MAE): quando sottraiamo i valori previsti dai valori effettivi, ottenendo gli errori, sommiamo i valori assoluti di quegli errori e otteniamo la loro media. Questa metrica fornisce un'idea dell'errore complessivo per ogni previsione del modello, più piccolo (vicino a 0) meglio è.

$$
mae = (frac{1}{n})sum_{i=1}^{n}sinistra | Attuale – Previsto giusto |
$$

2. Errore quadratico medio (MSE): è simile alla metrica MAE, ma eleva al quadrato i valori assoluti degli errori. Inoltre, come con MAE, più piccolo o più vicino a 0, meglio è. Il valore MSE è elevato al quadrato in modo da rendere ancora più grandi gli errori più grandi. Una cosa a cui prestare molta attenzione è che di solito è una metrica difficile da interpretare a causa della dimensione dei suoi valori e del fatto che non sono nella stessa scala dei dati.

$$
mse = sum_{i=1}^{D}(Attuale – Previsto)^2
$$

3. Errore quadratico medio della radice (RMSE): cerca di risolvere il problema interpretativo posto con il MSE ricavando la radice quadrata del suo valore finale, in modo da riportarlo alle stesse unità del dato. È più facile da interpretare e buono quando dobbiamo visualizzare o mostrare il valore effettivo dei dati con l'errore. Mostra quanto possono variare i dati, quindi, se abbiamo un RMSE di 4.35, il nostro modello può commettere un errore perché ha aggiunto 4.35 al valore effettivo o ha bisogno di 4.35 per arrivare al valore effettivo. Più vicino a 0, meglio è.

$$
rmse = sqrt{ sum_{i=1}^{D}(Attuale – Previsto)^2}
$$

Possiamo usare una di queste tre metriche per confrontare modelli (se dobbiamo sceglierne uno). Possiamo anche confrontare lo stesso modello di regressione con valori di argomenti diversi o con dati diversi e quindi considerare le metriche di valutazione. Questo è noto come messa a punto dell'iperparametro – mettere a punto gli iperparametri che influenzano un algoritmo di apprendimento e osservarne i risultati.

Quando si sceglie tra i modelli, quelli con gli errori più piccoli di solito hanno prestazioni migliori. Durante il monitoraggio dei modelli, se le metriche peggioravano, una versione precedente del modello era migliore o si verificava un'alterazione significativa nei dati per un rendimento del modello peggiore di quello che stava facendo.

È possibile il seguente codice per trovare questi valori:

from sklearn.metrics import mean_absolute_error, mean_squared_error

print('Mean Absolute Error:', mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(mean_squared_error(y_test, y_pred)))

L'output dovrebbe essere:

Mean Absolute Error: 1.127893702896059
Mean Squared Error: 3.0802988503933326
Root Mean Squared Error: 1.755078018320933

Con 20 alberi, l'errore quadratico medio della radice è 1.75 che è basso, ma anche così, aumentando il numero di alberi e sperimentando gli altri parametri, questo errore potrebbe probabilmente ridursi ulteriormente.

Vantaggi dell'utilizzo di Random Forest

Come con qualsiasi algoritmo, ci sono vantaggi e svantaggi nell'usarlo. Nelle prossime due sezioni daremo un'occhiata ai pro e ai contro dell'utilizzo di foreste casuali per la classificazione e la regressione.

1. L'algoritmo della foresta casuale non è distorto, poiché esistono più alberi e ogni albero viene addestrato su un sottoinsieme casuale di dati. Fondamentalmente, l'algoritmo della foresta casuale si basa sul potere della "folla"; pertanto il grado complessivo di distorsione dell'algoritmo è ridotto.
2. Questo algoritmo è molto stabile. Anche se viene introdotto un nuovo punto dati nel set di dati, l'algoritmo complessivo non ne risente molto poiché i nuovi dati possono avere un impatto su un albero, ma è molto difficile che abbiano un impatto su tutti gli alberi.
3. L'algoritmo della foresta casuale funziona bene quando si hanno caratteristiche sia categoriche che numeriche.
4. L'algoritmo della foresta casuale funziona bene anche quando i dati hanno valori mancanti o non sono stati ridimensionati.

Svantaggi dell'utilizzo di Random Forest

1. Il principale svantaggio delle foreste casuali risiede nella loro complessità. Richiedono molte più risorse computazionali, a causa del gran numero di alberi decisionali uniti insieme, durante l'addestramento di grandi insiemi. Tuttavia, con l'hardware moderno, l'addestramento anche di una grande foresta casuale non richiede molto tempo.

Andare oltre: progetto end-to-end portatile

La tua natura curiosa ti fa venire voglia di andare oltre? Ti consigliamo di dare un'occhiata al nostro Progetto guidato: "Previsione pratica dei prezzi delle abitazioni - Apprendimento automatico in Python".

In questo progetto guidato imparerai come creare potenti modelli di machine learning tradizionali e modelli di deep learning, utilizzare Ensemble Learning e formare meta-discenti per prevedere i prezzi delle case da un sacco di modelli Scikit-Learn e Keras.

Utilizzando Keras, l'API di deep learning basata su Tensorflow, sperimenteremo architetture, costruiremo un insieme di modelli impilati e addestreremo un meta-studente rete neurale (modello di livello 1) per determinare il prezzo di una casa.

Il deep learning è sorprendente, ma prima di ricorrere ad esso, si consiglia anche di tentare di risolvere il problema con tecniche più semplici, come con apprendimento superficiale algoritmi. La nostra performance di base sarà basata su a Regressione casuale della foresta algoritmo. Inoltre, esploreremo la creazione di insiemi di modelli attraverso Scikit-Learn tramite tecniche come insaccamento ed voto.

Questo è un progetto end-to-end e, come tutti i progetti di Machine Learning, inizieremo con – con Analisi dei dati esplorativi, Seguita da Pre-elaborazione dei dati e infine Edificio poco profondo ed Modelli di apprendimento profondo per adattarsi ai dati che abbiamo esplorato e ripulito in precedenza.