Random Forest in R: tutorial sull'algoritmo con esempio

Cos'è la foresta casuale in R?

Le foreste casuali si basano su un'idea semplice: "la saggezza della folla". L'aggregazione dei risultati di più predittori fornisce una previsione migliore rispetto al miglior predittore individuale. Un gruppo di predittori è chiamato an insieme. Quindi, questa tecnica viene chiamata Ensemble Learning.

In un tutorial precedente hai imparato come usare alberi decisionali per fare una previsione binaria. Per migliorare la nostra tecnica, possiamo allenare un gruppo di Classificatori dell'albero decisionale, ciascuno su un diverso sottoinsieme casuale del set di addestramento. Per fare una previsione, si raccolgono le previsioni di tutti i singoli alberi e si restituisce la classe che riceve il maggior numero di voti. Questa tecnica è chiamata Foresta casuale.

Prima di scrivere qualsiasi codice, è utile vedere esattamente come la foresta è composta dai singoli alberi.

Come funziona l'algoritmo Random Forest in R?

Comprendere i meccanismi rende più facile ragionare su ogni parametro di regolazione. Una foresta casuale viene costruita in quattro fasi.

1. Bootstrap campionamento. L'algoritmo seleziona un campione casuale di righe con sostituzione dal set di addestramento per ogni albero. Circa un terzo delle righe viene escluso da ciascun campione; queste sono le osservazioni out-of-bag (OOB).
2. Selezione casuale delle caratteristiche. Ad ogni suddivisione, viene considerato solo un sottoinsieme casuale di predittori. La dimensione di tale sottoinsieme è la mtry parametro. Limitare la scelta è ciò che impedisce che tutti gli alberi si assomiglino.
3. Crescita degli alberi non potata. Ogni albero cresce fino a fermarsiping regola come maxnodi or dimensione del nodoSi permette deliberatamente ai singoli alberi di sovradattarsi, perché i loro errori non sono correlati.
4. Aggregazione. Per la classificazione la foresta restituisce la classe con il maggior numero di voti; per la regressione restituisce la previsione media. Questo passaggio di media è ciò che il termine insaccamento (aggregazione bootstrap) descrive.

Il trucco sta nel campionamento per righe combinato con il campionamento per colonne. Un singolo albero profondo ha una bassa distorsione e una varianza molto elevata; la media di centinaia di alberi mantiene bassa la distorsione riducendo al contempo la varianza.

Errore out-of-bag. Poiché ogni osservazione viene esclusa da circa un terzo degli alberi, R può assegnare un punteggio a ciascuna riga utilizzando solo gli alberi che non l'hanno mai vista. L'errore OOB risultante è una stima di validazione gratuita e integrata, stampata da randomForest():

rf_oob <- randomForest(survived~., data = data_train, ntree = 800, mtry = 4)
print(rf_oob)   # reports the OOB estimate of error rate

L'errore OOB è un comodo controllo rapido, ma questo tutorial utilizza la convalida incrociata a dieci fold tramite caret, quindi ogni griglia di ottimizzazione viene confrontata su fold identici.

Random Forest vs Decision Tree in R

Una foresta casuale è un insieme dello stesso alberi decisionali Le differenze sono state trattate nel tutorial precedente, quindi vale la pena di enunciarle chiaramente prima di scegliere tra le due opzioni.

Scegli un singolo albero quando devi spiegare il percorso decisionale a un pubblico non tecnico. Scegli una foresta quando l'accuratezza predittiva è più importante della leggibilità del diagramma.

Vantaggi e svantaggi di Random Forest

Sapere quali sono i punti di forza e di debolezza dell'algoritmo ti permette di capire quando vale la pena dedicare tempo alla messa a punto.

Vantaggi

• Precisione senza potatura: La media di molti alberi non correlati fornisce risultati solidi con pochissime regolazioni manuali.
• Resistente all'overfitting: L'aggiunta di ulteriori alberi non aumenta mai l'errore di generalizzazione, quindi è possibile sollevare l'eccezione ntree in tutta sicurezza.
• Gestisce dati misti: I predittori numerici e fattoriali lavorano in parallelo e la scalatura non è necessaria.
• Validazione e classificazione gratuite: L'errore OOB e varImp() non comportano costi computazionali aggiuntivi.

Svantaggi

• Previsioni poco chiare: non puoi tracun unico percorso decisionale, aspetto fondamentale negli ambienti regolamentati.
• Andare piano nelle grandi foreste: I tempi di addestramento e di previsione scalano linearmente con il numero di alberi.
• Punteggi di importanza distorti: Le variabili categoriali con molti livelli possono sembrare più importanti di quanto non siano in realtà.
• Estrapolazione debole: Per la regressione, la foresta non può mai prevedere nulla al di fuori dell'intervallo osservato durante l'addestramento.

Una volta definiti la teoria e i compromessi, i successivi sei passaggi consistono nella costruzione, ottimizzazione e valutazione end-to-end di un algoritmo di random forest sul dataset relativo alla sopravvivenza del Titanic.

Passaggio 1) Importa i dati

Per assicurarti di avere lo stesso set di dati del tutorial per alberi decisionaliIl set di dati di addestramento e il set di dati di test sono ospitati online. È possibile importarli senza apportare alcuna modifica.

library(dplyr)
data_train <- read.csv("https://raw.githubusercontent.com/guru99-edu/R-Programming/master/train.csv")
glimpse(data_train)
data_test <- read.csv("https://raw.githubusercontent.com/guru99-edu/R-Programming/master/test.csv") 
glimpse(data_test)

Passaggio 2) Addestrare il modello

Un modo per valutare le prestazioni di un modello è addestrarlo su un certo numero di set di dati più piccoli e valutarli rispetto all'altro set di test più piccolo. Questo è chiamato convalida incrociata di k-fold. R Dispone di una funzione che suddivide casualmente i dati in k sottoinsiemi di dimensioni pressoché identiche. Ad esempio, se k = 10, il modello viene addestrato su nove fold e valutato sul fold rimanente. Questo processo viene ripetuto finché tutti i sottoinsiemi non sono stati valutati. Questa tecnica è ampiamente utilizzata per la selezione del modello, soprattutto quando il modello presenta parametri da ottimizzare.

Ora che abbiamo un modo per valutare il nostro modello, dobbiamo decidere quali parametri si generalizzano meglio a dati non visti in precedenza.

La foresta casuale sceglie un sottoinsieme casuale di funzionalità e costruisce molti alberi decisionali. Il modello calcola la media di tutte le previsioni degli alberi decisionali.

L'algoritmo Random Forest ha alcuni parametri che possono essere modificati per migliorare la generalizzazione della previsione. Utilizzerai la funzione randomForest() per addestrare il modello.

La sintassi per randomForest() è:

randomForest(formula, ntree=n, mtry=FALSE, maxnodes = NULL)
Arguments:
- Formula: Formula of the fitted model
- ntree: number of trees in the forest
- mtry: Number of candidate variables drawn at each split. By default, it is the square root of the number of predictors for classification.
- maxnodes: Set the maximum number of terminal nodes each tree can have
- importance=TRUE: Whether independent variables importance in the random forest be assessed

Note:: La foresta casuale può essere addestrata su più parametri. Puoi fare riferimento a vignette per vedere i diversi parametri.

La messa a punto di un modello è un lavoro tedioso. Esistono moltissime combinazioni possibili di parametri e non si ha necessariamente il tempo di provarle tutte. Una valida alternativa è lasciare che sia la macchina a trovare la combinazione ottimale. Sono disponibili due metodi:

• Ricerca casuale
• Grid Search

Entrambi i metodi sono descritti di seguito, ma questo tutorial addestra il modello utilizzando la ricerca a griglia.

Definizione della ricerca in griglia

Il metodo di ricerca della griglia è semplice, il modello verrà valutato su tutte le combinazioni passate nella funzione, utilizzando la convalida incrociata.

Ad esempio, vuoi provare il modello con 10, 20, 30 numeri di alberi e ogni albero verrà testato su un numero di metri pari a 1, 2, 3, 4, 5. Quindi la macchina testerà 15 modelli diversi:

    .mtry ntrees
 1      1     10
 2      2     10
 3      3     10
 4      4     10
 5      5     10
 6      1     20
 7      2     20
 8      3     20
 9      4     20
 10     5     20
 11     1     30
 12     2     30
 13     3     30
 14     4     30
 15     5     30	

L’algoritmo valuterà:

randomForest(formula, ntree=10, mtry=1)
randomForest(formula, ntree=10, mtry=2)
randomForest(formula, ntree=10, mtry=3)
randomForest(formula, ntree=20, mtry=2)
...

Ogni combinazione viene valutata tramite convalida incrociata. Il limite della ricerca a griglia è il numero di esperimenti: cresce esponenzialmente quando il numero di combinazioni è elevato. Per ovviare a questo problema, è possibile utilizzare la ricerca casuale.

Definizione di ricerca casuale

La principale differenza tra ricerca casuale e ricerca a griglia è che la ricerca casuale non valuta tutte le combinazioni di iperparametri nello spazio di ricerca. Al contrario, sceglie casualmente una combinazione a ogni iterazione. Il vantaggio è un costo computazionale molto inferiore.

Impostare il parametro di controllo

Si procederà come segue per costruire e valutare il modello:

• Valutare il modello con l'impostazione predefinita
• Trova il miglior numero di metri
• Trova il miglior numero di maxnodi
• Trova il miglior numero di nalberi
• Valutare il modello sul set di dati di test

Prima di iniziare con l'esplorazione dei parametri, è necessario installare due librerie.

• accento circonflesso: libreria di machine learning R. Se hai installa r con r-essenziale. È già in biblioteca
  • Anaconda: conda install -cr r-caret
• e1071: libreria di apprendimento automatico R.
  • Anaconda: conda install -cr r-e1071

È possibile importarli insieme a randomForest:

library(randomForest)
library(caret)
library(e1071)

Impostazione predefinita

La convalida incrociata K-fold è controllata dalla funzione trainControl()

trainControl(method = "cv", number = n, search ="grid")
arguments
- method = "cv": The method used to resample the dataset. 
- number = n: Number of folds to create
- search = "grid": Use the grid search method. For the randomized method, use "random"
Note: You can refer to the vignette to see the other arguments of the function.

Puoi provare a eseguire il modello con i parametri predefiniti e vedere il punteggio di precisione.

Note:: utilizzerai gli stessi controlli durante tutto il tutorial.

# Define the control
trControl <- trainControl(method = "cv",
    number = 10,
    search = "grid")

Utilizzerai la libreria di punti circonferenza per valutare il tuo modello. La libreria ha una funzione chiamata train() per valutare quasi tutti machine learning algoritmo. In altre parole, puoi utilizzare questa funzione per addestrare altri algoritmi.

La sintassi di base è:

train(formula, df, method = "rf", metric= "Accuracy", trControl = trainControl(), tuneGrid = NULL)
argument
- `formula`: Define the formula of the algorithm
- `method`: Define which model to train. Note, at the end of the tutorial, there is a list of all the models that can be trained
- `metric` = "Accuracy": Define how to select the optimal model
- `trControl = trainControl()`: Define the control parameters
- `tuneGrid = NULL`: Return a data frame with all the possible combination

Costruiamo il modello con i valori predefiniti.

set.seed(1234)
# Run the model
rf_default <- train(survived~.,
    data = data_train,
    method = "rf",
    metric = "Accuracy",
    trControl = trControl)
# Print the results
print(rf_default)

Code Spiegazione

• trainControl(method=”cv”, number=10, search=”grid”): Valuta il modello con una ricerca a griglia su 10 fold
• train(…): addestra un modello di foresta casuale. Il modello migliore viene scelto con la misura di accuratezza.

Produzione:

## Random Forest 
## 
## 836 samples
##   7 predictor
##   2 classes: 'No', 'Yes' 
## 
## No pre-processing
## Resampling: Cross-Validated (10 fold) 
## Summary of sample sizes: 753, 752, 753, 752, 752, 752, ... 
## Resampling results across tuning parameters:
## 
##   mtry  Accuracy   Kappa    
##    2    0.7919248  0.5536486
##    6    0.7811245  0.5391611
##   10    0.7572002  0.4939620
## 
## Accuracy was used to select the optimal model using  the largest value.
## The final value used for the model was mtry = 2.

L'algoritmo utilizza 500 alberi e testa tre diversi valori di mtry: 2, 6, 10.

Il valore finale utilizzato per il modello è stato mtry = 2, con un'accuratezza convalidata incrociata di 0.792. Proviamo a ottenere un punteggio più alto.

Cerca il miglior mtry

Puoi testare il modello con valori di mtry da 1 a 10

set.seed(1234)
tuneGrid <- expand.grid(.mtry = c(1: 10))
rf_mtry <- train(survived~.,
    data = data_train,
    method = "rf",
    metric = "Accuracy",
    tuneGrid = tuneGrid,
    trControl = trControl,
    importance = TRUE,
    nodesize = 14,
    ntree = 300)
print(rf_mtry)

Code Spiegazione

• tuneGrid <- expand.grid(.mtry = c(1:10)): Costruisci un vettore con valori da 1 a 10

Produzione:

## Random Forest 
## 
## 836 samples
##   7 predictor
##   2 classes: 'No', 'Yes' 
## 
## No pre-processing
## Resampling: Cross-Validated (10 fold) 
## Summary of sample sizes: 753, 752, 753, 752, 752, 752, ... 
## Resampling results across tuning parameters:
## 
##   mtry  Accuracy   Kappa    
##    1    0.7572576  0.4647368
##    2    0.7979346  0.5662364
##    3    0.8075158  0.5884815
##    4    0.8110729  0.5970664
##    5    0.8074727  0.5900030
##    6    0.8099111  0.5949342
##    7    0.8050918  0.5866415
##    8    0.8050918  0.5855399
##    9    0.8050631  0.5855035
##   10    0.7978916  0.5707336
## 
## Accuracy was used to select the optimal model using  the largest value.
## The final value used for the model was mtry = 4.

Il valore migliore di mtry è 4. Viene memorizzato in:

rf_mtry$bestTune$mtry

Puoi memorizzarlo e usarlo quando hai bisogno di regolare gli altri parametri.

max(rf_mtry$results$Accuracy)

Produzione:

## [1] 0.8110729

best_mtry <- rf_mtry$bestTune$mtry 
best_mtry

Produzione:

## [1] 4

Passaggio 3) Cerca i migliori maxnode

Devi creare un ciclo per valutare i diversi valori di maxnodes. Nel seguente codice, dovrai:

• Creare un elenco
• Crea una variabile con il miglior valore del parametro mtry; Obbligatorio
• Crea il ciclo
• Memorizza il valore corrente di maxnode
• Riassumi i risultati

store_maxnode <- list()
tuneGrid <- expand.grid(.mtry = best_mtry)
for (maxnodes in c(5: 15)) {
    set.seed(1234)
    rf_maxnode <- train(survived~.,
        data = data_train,
        method = "rf",
        metric = "Accuracy",
        tuneGrid = tuneGrid,
        trControl = trControl,
        importance = TRUE,
        nodesize = 14,
        maxnodes = maxnodes,
        ntree = 300)
    current_iteration <- toString(maxnodes)
    store_maxnode[[current_iteration]] <- rf_maxnode
}
results_mtry <- resamples(store_maxnode)
summary(results_mtry)

Code spiegazione:

• store_maxnode <- list(): i risultati del modello verranno archiviati in questo elenco
• expand.grid(.mtry=best_mtry): utilizza il miglior valore di mtry
• per (maxnodes in c(5:15)) { … }: Calcola il modello con valori di maxnodes da 5 a 15.
• maxnodes = maxnodes: Per ogni iterazione, maxnodes è uguale al valore corrente del ciclo, ovvero 5, 6, 7, …
• current_iteration <- toString(maxnodes): memorizza il valore di maxnodes come stringa.
• store_maxnode[[current_iteration]] <- rf_maxnode: Salva il risultato del modello nell'elenco.
• resamples(store_maxnode): organizza i risultati del modello
• summary(results_mtry): stampa il riepilogo di tutte le combinazioni.

Produzione:

## 
## Call:
## summary.resamples(object = results_mtry)
## 
## Models: 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 
## Number of resamples: 10 
## 
## Accuracy 
##         Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 5  0.6785714 0.7529762 0.7903758 0.7799771 0.8168388 0.8433735    0
## 6  0.6904762 0.7648810 0.7784710 0.7811962 0.8125000 0.8313253    0
## 7  0.6904762 0.7619048 0.7738095 0.7788009 0.8102410 0.8333333    0
## 8  0.6904762 0.7627295 0.7844234 0.7847820 0.8184524 0.8433735    0
## 9  0.7261905 0.7747418 0.8083764 0.7955250 0.8258749 0.8333333    0
## 10 0.6904762 0.7837780 0.7904475 0.7895869 0.8214286 0.8433735    0
## 11 0.7023810 0.7791523 0.8024240 0.7943775 0.8184524 0.8433735    0
## 12 0.7380952 0.7910929 0.8144005 0.8051205 0.8288511 0.8452381    0
## 13 0.7142857 0.8005952 0.8192771 0.8075158 0.8403614 0.8452381    0
## 14 0.7380952 0.7941050 0.8203528 0.8098967 0.8403614 0.8452381    0
## 15 0.7142857 0.8000215 0.8203528 0.8075301 0.8378873 0.8554217    0
## 
## Kappa 
##         Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 5  0.3297872 0.4640436 0.5459706 0.5270773 0.6068751 0.6717371    0
## 6  0.3576471 0.4981484 0.5248805 0.5366310 0.6031287 0.6480921    0
## 7  0.3576471 0.4927448 0.5192771 0.5297159 0.5996437 0.6508314    0
## 8  0.3576471 0.4848320 0.5408159 0.5427127 0.6200253 0.6717371    0
## 9  0.4236277 0.5074421 0.5859472 0.5601687 0.6228626 0.6480921    0
## 10 0.3576471 0.5255698 0.5527057 0.5497490 0.6204819 0.6717371    0
## 11 0.3794326 0.5235007 0.5783191 0.5600467 0.6126720 0.6717371    0
## 12 0.4460432 0.5480930 0.5999072 0.5808134 0.6296780 0.6717371    0
## 13 0.4014252 0.5725752 0.6087279 0.5875305 0.6576219 0.6678832    0
## 14 0.4460432 0.5585005 0.6117973 0.5911995 0.6590982 0.6717371    0
## 15 0.4014252 0.5689401 0.6117973 0.5867010 0.6507194 0.6955990    0

La massima accuratezza media in questo intervallo (0.8099) si ottiene con maxnodes = 14, nella parte superiore dell'intervallo testato. Poiché il valore migliore si trova al limite della griglia, è consigliabile estendere la ricerca verso l'alto.

store_maxnode <- list()
tuneGrid <- expand.grid(.mtry = best_mtry)
for (maxnodes in c(20: 30)) {
    set.seed(1234)
    rf_maxnode <- train(survived~.,
        data = data_train,
        method = "rf",
        metric = "Accuracy",
        tuneGrid = tuneGrid,
        trControl = trControl,
        importance = TRUE,
        nodesize = 14,
        maxnodes = maxnodes,
        ntree = 300)
    key <- toString(maxnodes)
    store_maxnode[[key]] <- rf_maxnode
}
results_node <- resamples(store_maxnode)
summary(results_node)

Produzione:

## 
## Call:
## summary.resamples(object = results_node)
## 
## Models: 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 
## Number of resamples: 10 
## 
## Accuracy 
##         Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 20 0.7142857 0.7821644 0.8144005 0.8075301 0.8447719 0.8571429    0
## 21 0.7142857 0.8000215 0.8144005 0.8075014 0.8403614 0.8571429    0
## 22 0.7023810 0.7941050 0.8263769 0.8099254 0.8328313 0.8690476    0
## 23 0.7023810 0.7941050 0.8263769 0.8111302 0.8447719 0.8571429    0
## 24 0.7142857 0.7946429 0.8313253 0.8135112 0.8417599 0.8690476    0
## 25 0.7142857 0.7916667 0.8313253 0.8099398 0.8408635 0.8690476    0
## 26 0.7142857 0.7941050 0.8203528 0.8123207 0.8528758 0.8571429    0
## 27 0.7023810 0.8060456 0.8313253 0.8135112 0.8333333 0.8690476    0
## 28 0.7261905 0.7941050 0.8203528 0.8111015 0.8328313 0.8690476    0
## 29 0.7142857 0.7910929 0.8313253 0.8087063 0.8333333 0.8571429    0
## 30 0.6785714 0.7910929 0.8263769 0.8063253 0.8403614 0.8690476    0
## 
## Kappa 
##         Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 20 0.3956835 0.5316120 0.5961830 0.5854366 0.6661120 0.6955990    0
## 21 0.3956835 0.5699332 0.5960343 0.5853247 0.6590982 0.6919315    0
## 22 0.3735084 0.5560661 0.6221836 0.5914492 0.6422128 0.7189781    0
## 23 0.3735084 0.5594228 0.6228827 0.5939786 0.6657372 0.6955990    0
## 24 0.3956835 0.5600352 0.6337821 0.5992188 0.6604703 0.7189781    0
## 25 0.3956835 0.5530760 0.6354875 0.5912239 0.6554912 0.7189781    0
## 26 0.3956835 0.5589331 0.6136074 0.5969142 0.6822128 0.6955990    0
## 27 0.3735084 0.5852459 0.6368425 0.5998148 0.6426088 0.7189781    0
## 28 0.4290780 0.5589331 0.6154905 0.5946859 0.6356141 0.7189781    0
## 29 0.4070588 0.5534173 0.6337821 0.5901173 0.6423101 0.6919315    0
## 30 0.3297872 0.5534173 0.6202632 0.5843432 0.6590982 0.7189781    0

La massima accuratezza media, pari a 0.8135, si ottiene con maxnodes = 24 (maxnodes = 27 presenta una media simile ma un terzo quartile inferiore). Pertanto, per i passaggi successivi si utilizzerà maxnodes = 24.

Passaggio 4) Cerca gli alberi migliori

Ora che hai il miglior valore di mtry e maxnode, puoi ottimizzare il numero di alberi. Il metodo è esattamente lo stesso di maxnode.

store_maxtrees <- list()
for (ntree in c(250, 300, 350, 400, 450, 500, 550, 600, 800, 1000, 2000)) {
    set.seed(5678)
    rf_maxtrees <- train(survived~.,
        data = data_train,
        method = "rf",
        metric = "Accuracy",
        tuneGrid = tuneGrid,
        trControl = trControl,
        importance = TRUE,
        nodesize = 14,
        maxnodes = 24,
        ntree = ntree)
    key <- toString(ntree)
    store_maxtrees[[key]] <- rf_maxtrees
}
results_tree <- resamples(store_maxtrees)
summary(results_tree)

Produzione:

## 
## Call:
## summary.resamples(object = results_tree)
## 
## Models: 250, 300, 350, 400, 450, 500, 550, 600, 800, 1000, 2000 
## Number of resamples: 10 
## 
## Accuracy 
##           Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 250  0.7380952 0.7976190 0.8083764 0.8087010 0.8292683 0.8674699    0
## 300  0.7500000 0.7886905 0.8024240 0.8027199 0.8203397 0.8452381    0
## 350  0.7500000 0.7886905 0.8024240 0.8027056 0.8277623 0.8452381    0
## 400  0.7500000 0.7886905 0.8083764 0.8051009 0.8292683 0.8452381    0
## 450  0.7500000 0.7886905 0.8024240 0.8039104 0.8292683 0.8452381    0
## 500  0.7619048 0.7886905 0.8024240 0.8062914 0.8292683 0.8571429    0
## 550  0.7619048 0.7886905 0.8083764 0.8099062 0.8323171 0.8571429    0
## 600  0.7619048 0.7886905 0.8083764 0.8099205 0.8323171 0.8674699    0
## 800  0.7619048 0.7976190 0.8083764 0.8110820 0.8292683 0.8674699    0
## 1000 0.7619048 0.7976190 0.8121510 0.8086723 0.8303571 0.8452381    0
## 2000 0.7619048 0.7886905 0.8121510 0.8086723 0.8333333 0.8452381    0
## 
## Kappa 
##           Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 250  0.4061697 0.5667400 0.5836013 0.5856103 0.6335363 0.7196807    0
## 300  0.4302326 0.5449376 0.5780349 0.5723307 0.6130767 0.6710843    0
## 350  0.4302326 0.5449376 0.5780349 0.5723185 0.6291592 0.6710843    0
## 400  0.4302326 0.5482030 0.5836013 0.5774782 0.6335363 0.6710843    0
## 450  0.4302326 0.5449376 0.5780349 0.5750587 0.6335363 0.6710843    0
## 500  0.4601542 0.5449376 0.5780349 0.5804340 0.6335363 0.6949153    0
## 550  0.4601542 0.5482030 0.5857118 0.5884507 0.6396872 0.6949153    0
## 600  0.4601542 0.5482030 0.5857118 0.5884374 0.6396872 0.7196807    0
## 800  0.4601542 0.5667400 0.5836013 0.5910088 0.6335363 0.7196807    0
## 1000 0.4601542 0.5667400 0.5961590 0.5857446 0.6343666 0.6678832    0
## 2000 0.4601542 0.5482030 0.5961590 0.5862151 0.6440678 0.6656337    0

Hai il tuo modello finale. Puoi addestrare la foresta casuale con i seguenti parametri:

• ntree = 800: verranno addestrati 800 alberi
• mtry = 4: 4 caratteristiche candidate vengono disegnate ad ogni divisione
• maxnodes = 24: Ogni albero è limitato a 24 nodi terminali (foglie)

fit_rf <- train(survived~.,
    data_train,
    method = "rf",
    metric = "Accuracy",
    tuneGrid = tuneGrid,
    trControl = trControl,
    importance = TRUE,
    nodesize = 14,
    ntree = 800,
    maxnodes = 24)

Passaggio 5) Valutare il modello

Il cursore della libreria ha una funzione per fare previsioni.

predict(model, newdata= df)
argument
- `model`: Define the model evaluated before. 
- `newdata`: Define the dataset to make prediction

prediction <-predict(fit_rf, data_test)

È possibile utilizzare la previsione per calcolare la matrice di confusione e visualizzare il punteggio di precisione

confusionMatrix(prediction, data_test$survived)

Produzione:

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction  No Yes
##        No  110  32
##        Yes  11  56
##                                          
##                Accuracy : 0.7943         
##                  95% CI : (0.733, 0.8469)
##     No Information Rate : 0.5789         
##     P-Value [Acc > NIR] : 3.959e-11      
##                                          
##                   Kappa : 0.5638         
##  Mcnemar's Test P-Value : 0.002289       
##                                          
##             Sensitivity : 0.9091         
##             Specificity : 0.6364         
##          Pos Pred Value : 0.7746         
##          Neg Pred Value : 0.8358         
##              Prevalence : 0.5789         
##          Detection Rate : 0.5263         
##    Detection Prevalence : 0.6794         
##       Balanced Accuracy : 0.7727         
##                                          
##        'Positive' Class : No             
## 

Il modello raggiunge un'accuratezza di 0.7943, ovvero il 79.43% sul set di test non visto, un valore superiore alla configurazione predefinita. La sensibilità è di 0.9091 e la specificità è di 0.6364, quindi il modello identifica i non sopravvissuti con molta più affidabilità rispetto ai sopravvissuti.

Passaggio 6) Visualizza il risultato

Infine, è possibile esaminare l'importanza delle caratteristiche con la funzione varImp(). Le caratteristiche più importanti sono il sesso e l'età. Ciò non sorprende, poiché le caratteristiche importanti tendono ad apparire più vicine alla radice dell'albero, mentre quelle meno importanti si trovano solitamente più vicine alle foglie.

varImp(fit_rf)

Produzione:

## rf variable importance
## 
##              Importance
## sexmale         100.000
## age              28.014
## pclassMiddle     27.016
## fare             21.557
## pclassUpper      16.324
## sibsp            11.246
## parch             5.522
## embarkedC         4.908
## embarkedQ         1.420
## embarkedS         0.000		

Random Forest in R: Guida rapida alle funzioni

La tabella seguente elenca tutte le funzioni utilizzate nei sei passaggi, il pacchetto che le fornisce e i parametri che si aspetta.

Appendice: Modelli disponibili nel carrello

La funzione train() può gestire molti più modelli rispetto alle foreste casuali. Esegui il comando seguente per stampare tutti gli identificatori di modello supportati da caret, quindi passane uno qualsiasi come argomento del metodo.

names(getModelInfo())

Produzione:

##   [1] "ada"                 "AdaBag"              "AdaBoost.M1"        ##   [4] "adaboost"            "amdai"               "ANFIS"              ##   [7] "avNNet"              "awnb"                "awtan"              ##  [10] "bag"                 "bagEarth"            "bagEarthGCV"        ##  [13] "bagFDA"              "bagFDAGCV"           "bam"                ##  [16] "bartMachine"         "bayesglm"            "binda"              ##  [19] "blackboost"          "blasso"              "blassoAveraged"     ##  [22] "bridge"              "brnn"                "BstLm"              ##  [25] "bstSm"               "bstTree"             "C5.0"               ##  [28] "C5.0Cost"            "C5.0Rules"           "C5.0Tree"           ##  [31] "cforest"             "chaid"               "CSimca"             ##  [34] "ctree"               "ctree2"              "cubist"             ##  [37] "dda"                 "deepboost"           "DENFIS"             ##  [40] "dnn"                 "dwdLinear"           "dwdPoly"            ##  [43] "dwdRadial"           "earth"               "elm"                ##  [46] "enet"                "evtree"              "extraTrees"         ##  [49] "fda"                 "FH.GBML"             "FIR.DM"             ##  [52] "foba"                "FRBCS.CHI"           "FRBCS.W"            ##  [55] "FS.HGD"              "gam"                 "gamboost"           ##  [58] "gamLoess"            "gamSpline"           "gaussprLinear"      ##  [61] "gaussprPoly"         "gaussprRadial"       "gbm_h3o"            ##  [64] "gbm"                 "gcvEarth"            "GFS.FR.MOGUL"       ##  [67] "GFS.GCCL"            "GFS.LT.RS"           "GFS.THRIFT"         ##  [70] "glm.nb"              "glm"                 "glmboost"           ##  [73] "glmnet_h3o"          "glmnet"              "glmStepAIC"         ##  [76] "gpls"                "hda"                 "hdda"               ##  [79] "hdrda"               "HYFIS"               "icr"                ##  [82] "J48"                 "JRip"                "kernelpls"          ##  [85] "kknn"                "knn"                 "krlsPoly"           ##  [88] "krlsRadial"          "lars"                "lars2"              ##  [91] "lasso"               "lda"                 "lda2"               ##  [94] "leapBackward"        "leapForward"         "leapSeq"            ##  [97] "Linda"               "lm"                  "lmStepAIC"          ## [100] "LMT"                 "loclda"              "logicBag"           ## [103] "LogitBoost"          "logreg"              "lssvmLinear"        ## [106] "lssvmPoly"           "lssvmRadial"         "lvq"                ## [109] "M5"                  "M5Rules"             "manb"               ## [112] "mda"                 "Mlda"                "mlp"                ## [115] "mlpKerasDecay"       "mlpKerasDecayCost"   "mlpKerasDropout"    ## [118] "mlpKerasDropoutCost" "mlpML"               "mlpSGD"             ## [121] "mlpWeightDecay"      "mlpWeightDecayML"    "monmlp"             ## [124] "msaenet"             "multinom"            "mxnet"              ## [127] "mxnetAdam"           "naive_bayes"         "nb"                 ## [130] "nbDiscrete"          "nbSearch"            "neuralnet"          ## [133] "nnet"                "nnls"                "nodeHarvest"        ## [136] "null"                "OneR"                "ordinalNet"         ## [139] "ORFlog"              "ORFpls"              "ORFridge"           ## [142] "ORFsvm"              "ownn"                "pam"                ## [145] "parRF"               "PART"                "partDSA"            ## [148] "pcaNNet"             "pcr"                 "pda"                ## [151] "pda2"                "penalized"           "PenalizedLDA"       ## [154] "plr"                 "pls"                 "plsRglm"            ## [157] "polr"                "ppr"                 "PRIM"               ## [160] "protoclass"          "pythonKnnReg"        "qda"                ## [163] "QdaCov"              "qrf"                 "qrnn"               ## [166] "randomGLM"           "ranger"              "rbf"                ## [169] "rbfDDA"              "Rborist"             "rda"                ## [172] "regLogistic"         "relaxo"              "rf"                 ## [175] "rFerns"              "RFlda"               "rfRules"            ## [178] "ridge"               "rlda"                "rlm"                ## [181] "rmda"                "rocc"                "rotationForest"     ## [184] "rotationForestCp"    "rpart"               "rpart1SE"           ## [187] "rpart2"              "rpartCost"           "rpartScore"         ## [190] "rqlasso"             "rqnc"                "RRF"                ## [193] "RRFglobal"           "rrlda"               "RSimca"             ## [196] "rvmLinear"           "rvmPoly"             "rvmRadial"          ## [199] "SBC"                 "sda"                 "sdwd"               ## [202] "simpls"              "SLAVE"               "slda"               ## [205] "smda"                "snn"                 "sparseLDA"          ## [208] "spikeslab"           "spls"                "stepLDA"            ## [211] "stepQDA"             "superpc"             "svmBoundrangeString"## [214] "svmExpoString"       "svmLinear"           "svmLinear2"         ## [217] "svmLinear3"          "svmLinearWeights"    "svmLinearWeights2"  ## [220] "svmPoly"             "svmRadial"           "svmRadialCost"      ## [223] "svmRadialSigma"      "svmRadialWeights"    "svmSpectrumString"  ## [226] "tan"                 "tanSearch"           "treebag"            ## [229] "vbmpRadial"          "vglmAdjCat"          "vglmContRatio"      ## [232] "vglmCumulative"      "widekernelpls"       "WM"                 ## [235] "wsrf"                "xgbLinear"           "xgbTree"            ## [238] "xyf"

DOMANDE FREQUENTI