Tutorial de Random Forest en R: Algoritmo con ejemplo

¿Qué es el bosque aleatorio en R?

Los bosques aleatorios se basan en una idea simple: "la sabiduría de la multitud". La suma de los resultados de múltiples predictores da una mejor predicción que el mejor predictor individual. Un grupo de predictores se llama junto. Por eso esta técnica se llama Ensemble Learning.

En un tutorial anterior, aprendiste a usar árboles de decisión para hacer una predicción binaria. Para mejorar nuestra técnica, podemos entrenar a un grupo de Clasificadores de árbol de decisión, cada uno en un subconjunto aleatorio diferente del conjunto de entrenamiento. Para hacer una predicción, se recopilan las predicciones de todos los árboles individuales y se devuelve la clase que recibe la mayor cantidad de votos. Esta técnica se llama Bosque al azar.

Antes de escribir cualquier código, resulta útil ver exactamente cómo se forma el bosque a partir de esos árboles individuales.

¿Cómo funciona el algoritmo Random Forest en R?

Comprender la mecánica facilita el razonamiento sobre cada parámetro de ajuste. Un bosque aleatorio se construye en cuatro etapas.

1. Bootstrap toma de muestras. El algoritmo extrae una muestra aleatoria de filas. con reemplazo del conjunto de entrenamiento para cada árbol. Aproximadamente un tercio de las filas se dejan fuera de cada muestra; estas son las observaciones fuera de la bolsa (OOB).
2. Selección aleatoria de características. En cada división, solo se considera un subconjunto aleatorio de predictores. El tamaño de ese subconjunto es el mtry parámetro. Restringir la elección es lo que evita que todos los árboles se parezcan.
3. Crecimiento de árboles sin podar. Cada árbol crece hasta que llega a un punto muerto.ping regla como maxnodos or tamaño del nodoSe permite deliberadamente que los árboles individuales se sobreajusten, porque sus errores no están correlacionados.
4. Agregación. Para la clasificación, el bosque devuelve la clase con la mayor cantidad de votos; para la regresión, devuelve la predicción promedio. Este paso de promediado es lo que el término harpillera (agregación bootstrap) describe.

La clave está en combinar el muestreo por filas con el muestreo por columnas. Un único árbol profundo presenta un sesgo bajo y una varianza muy alta; promediar cientos de ellos mantiene el sesgo bajo a la vez que reduce la varianza.

Error de salida de la bolsa. Debido a que cada observación se excluye de aproximadamente un tercio de los árboles, R puede puntuar cada fila utilizando solo los árboles que nunca la vieron. El error OOB resultante es una estimación de validación integrada y gratuita que imprime randomForest():

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

El error OOB es una comprobación rápida y práctica, pero este tutorial utiliza validación cruzada de diez pliegues mediante caret, de modo que cada cuadrícula de ajuste se compara en pliegues idénticos.

Bosque aleatorio frente a árbol de decisión en R

Un bosque aleatorio es un conjunto de los mismos árboles de decisión Como ya se explicó en el tutorial anterior, conviene aclarar las diferencias antes de elegir entre ellos.

Elija un solo árbol cuando deba explicar el proceso de decisión a un público no técnico. Elija un bosque cuando la precisión predictiva sea más importante que un diagrama legible.

Ventajas y desventajas del algoritmo Random Forest

Saber dónde el algoritmo es fuerte y dónde es débil te indica cuándo merece la pena invertir tiempo en su optimización.

Ventajas

• Precisión sin recorte: El promedio de muchos árboles no correlacionados ofrece resultados sólidos con muy poca corrección manual.
• Resistente al sobreajuste: Agregar más árboles nunca aumenta el error de generalización, por lo que se puede aumentar el valor de ntree sin problemas.
• Maneja datos mixtos: Los predictores numéricos y factoriales funcionan conjuntamente, y no es necesario aplicar escalas.
• Validación y posicionamiento gratuitos: El error OOB y varImp() no conllevan ningún coste computacional adicional.

Desventajas

• Predicciones opacas: no se puede tracuna única vía de decisión, lo cual es importante en entornos regulados.
• Lento en bosques extensos: El tiempo de entrenamiento y predicción aumenta linealmente con el número de árboles.
• Puntuaciones de importancia sesgadas: Las variables categóricas con muchos niveles pueden parecer más importantes de lo que realmente son.
• Extrapolación débil: En el caso de la regresión, el bosque nunca puede predecir valores fuera del rango observado durante el entrenamiento.

Una vez establecidas la teoría y analizadas las ventajas y desventajas, los siguientes seis pasos consisten en construir, ajustar y evaluar un bosque aleatorio de extremo a extremo sobre el conjunto de datos de supervivencia del Titanic.

Paso 1) Importar los datos

Para asegurarse de tener el mismo conjunto de datos que en el tutorial para árboles de decisiónEl conjunto de trenes y el conjunto de pruebas están alojados en línea. Puedes importarlos sin realizar ningún cambio.

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)

Paso 2) Entrena el modelo

Una forma de evaluar el rendimiento de un modelo es entrenarlo en varios conjuntos de datos más pequeños y evaluarlos sobre otro conjunto de prueba más pequeño. Esto se llama k-fold validación cruzada. R Esta función divide aleatoriamente los datos en k subconjuntos de tamaño casi idéntico. Por ejemplo, si k = 10, el modelo se entrena con nueve particiones y se evalúa con la restante. Este proceso se repite hasta que se hayan evaluado todos los subconjuntos. Esta técnica se utiliza ampliamente para la selección de modelos, especialmente cuando el modelo requiere el ajuste de parámetros.

Ahora que tenemos una forma de evaluar nuestro modelo, necesitamos decidir qué parámetros se generalizan mejor a datos no vistos.

El bosque aleatorio elige un subconjunto aleatorio de características y construye muchos árboles de decisión. El modelo promedia todas las predicciones de los árboles de Decisiones.

El algoritmo Random Forest tiene algunos parámetros que se pueden modificar para mejorar la generalización de la predicción. Utilizarás la función randomForest() para entrenar el modelo.

La sintaxis para randomForest() es:

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

Nota: : El bosque aleatorio se puede entrenar con más parámetros. Puedes consultar el viñeta para ver los diferentes parámetros.

Ajustar un modelo es un trabajo tedioso. Existen muchas combinaciones posibles de parámetros. No necesariamente tienes tiempo para probarlas todas. Una buena alternativa es dejar que la máquina encuentre la mejor combinación por ti. Hay dos métodos disponibles:

• Búsqueda aleatoria
• Búsqueda de cuadrícula

Ambos métodos se definen a continuación, pero este tutorial entrena el modelo utilizando la búsqueda en cuadrícula.

Definición de búsqueda de cuadrícula

El método de búsqueda de cuadrícula es simple, el modelo se evaluará sobre todas las combinaciones que pase en la función, mediante validación cruzada.

Por ejemplo, desea probar el modelo con 10, 20, 30 árboles y cada árbol se probará durante un número de intentos igual a 1, 2, 3, 4, 5. Luego, la máquina probará 15 modelos diferentes:

    .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	

El algoritmo evaluará:

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

Cada combinación se evalúa mediante validación cruzada. La desventaja de la búsqueda en cuadrícula es la cantidad de experimentos: aumenta exponencialmente cuando el número de combinaciones es elevado. Para superar este problema, se puede utilizar la búsqueda aleatoria.

Definición de búsqueda aleatoria

La principal diferencia entre la búsqueda aleatoria y la búsqueda en cuadrícula radica en que la búsqueda aleatoria no evalúa todas las combinaciones de hiperparámetros en el espacio de búsqueda. En cambio, selecciona una combinación al azar en cada iteración. La ventaja reside en un coste computacional mucho menor.

Establecer el parámetro de control

Procederá de la siguiente manera para construir y evaluar el modelo:

• Evaluar el modelo con la configuración predeterminada.
• Encuentra el mejor número de mtry
• Encuentra el mejor número de maxnodes
• Encuentra el mejor número de ntrees
• Evaluar el modelo en el conjunto de datos de prueba.

Antes de comenzar con la exploración de parámetros, necesita instalar dos bibliotecas.

• caret: biblioteca de aprendizaje automático de R. Si usted tiene instalar R con r-esencial. ya esta en la biblioteca
  • Anaconda: conda instalar -c r r-caret
• e1071: biblioteca de aprendizaje automático R.
  • Anaconda: instalación de conda -c r r-e1071

Puedes importarlos junto con randomForest:

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

Configuración predeterminada

La validación cruzada K-fold está controlada por la función 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.

Puede intentar ejecutar el modelo con los parámetros predeterminados y ver la puntuación de precisión.

Nota: : Utilizarás los mismos controles durante todo el tutorial.

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

Utilizará la biblioteca de intercalación para evaluar su modelo. La biblioteca tiene una función llamada train() para evaluar casi todos aprendizaje automático Algoritmo. Dicho de otro modo, puedes usar esta función para entrenar otros algoritmos.

La sintaxis básica es:

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

Vamos a construir el modelo con los valores predeterminados.

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 Explicación

• trainControl(method=”cv”, number=10, search=”grid”): Evalúa el modelo con una búsqueda en cuadrícula sobre 10 pliegues.
• train(…): Entrena un modelo de bosque aleatorio. El modelo mejorado se elige con la medida de precisión.

Salida:

## 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.

El algoritmo utiliza 500 árboles y probó tres valores diferentes de mtry: 2, 6, 10.

El valor final utilizado para el modelo fue mtry = 2, con una precisión de validación cruzada de 0.792. Intentemos obtener una puntuación más alta.

Busca el mejor mtry

Puedes probar el modelo con valores de mtry del 1 al 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 Explicación

• tuneGrid <- expand.grid(.mtry = c(1:10)): Construye un vector con valores del 1 al 10.

Salida:

## 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.

El mejor valor de mtry es 4. Se almacena en:

rf_mtry$bestTune$mtry

Puede almacenarlo y utilizarlo cuando necesite ajustar otros parámetros.

max(rf_mtry$results$Accuracy)

Salida:

## [1] 0.8110729

best_mtry <- rf_mtry$bestTune$mtry 
best_mtry

Salida:

## [1] 4

Paso 3) Busca los mejores maxnodes

Debe crear un bucle para evaluar los diferentes valores de maxnodes. En el código siguiente, deberá:

• Crear una lista
• Cree una variable con el mejor valor del parámetro mtry; Obligatorio
• Crea el bucle
• Almacenar el valor actual de maxnode
• Resumir los resultados

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 explicación:

• store_maxnode <- list(): Los resultados del modelo se almacenarán en esta lista
• expand.grid(.mtry=best_mtry): utilice el mejor valor de mtry
• para (maxnodes en c(5:15)) { … }: Calcula el modelo con valores de maxnodes de 5 a 15.
• maxnodes = maxnodes: En cada iteración, maxnodes es igual al valor actual del bucle, es decir, 5, 6, 7, …
• current_iteration <- toString(maxnodes): Almacena el valor de maxnodes como una cadena.
• store_maxnode[[current_iteration]] <- rf_maxnode: Guarda el resultado del modelo en la lista.
• resamples (store_maxnode): organiza los resultados del modelo
• resumen (resultados_mtry): imprime el resumen de toda la combinación.

Salida:

## 
## 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 mayor precisión media en este rango (0.8099) corresponde a maxnodes = 14, en la parte superior del intervalo analizado. Dado que el mejor valor se encuentra en el borde de la cuadrícula, conviene ampliar la búsqueda hacia arriba.

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)

Salida:

## 
## 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 mayor precisión media, 0.8135, se obtiene con maxnodes = 24 (maxnodes = 27 empata en la media, pero tiene un tercer cuartil inferior). Por lo tanto, utilizará maxnodes = 24 para los pasos restantes.

Paso 4) Busca los mejores ntrees

Ahora que tiene el mejor valor de mtry y maxnode, puede ajustar la cantidad de árboles. El método es exactamente el mismo que el de 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)

Salida:

## 
## 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

Ya tienes tu modelo final. Puedes entrenar el bosque aleatorio con los siguientes parámetros:

• ntree = 800: Se entrenarán 800 árboles.
• mtry = 4: Se dibujan 4 características candidatas en cada división.
• maxnodes = 24: Cada árbol está limitado a 24 nodos terminales (hojas).

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

Paso 5) Evaluar el modelo

El cursor de la biblioteca tiene una función para hacer predicciones.

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

prediction <-predict(fit_rf, data_test)

Puede utilizar la predicción para calcular la matriz de confusión y ver la puntuación de precisión.

confusionMatrix(prediction, data_test$survived)

Salida:

## 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             
## 

El modelo alcanza una precisión de 0.7943, es decir, un 79.43 % en el conjunto de prueba no visto, superior a la configuración predeterminada. La sensibilidad es de 0.9091 y la especificidad de 0.6364, por lo que el modelo reconoce a los no supervivientes con mucha más fiabilidad que a los supervivientes.

Paso 6) Visualice el resultado

Por último, puedes consultar la importancia de las características con la función varImp(). Las características más importantes son el sexo y la edad. Esto no sorprende, ya que las características importantes suelen aparecer más cerca de la raíz del árbol, mientras que las menos importantes generalmente aparecen más cerca de las hojas.

varImp(fit_rf)

Salida:

## 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		

Bosque aleatorio en R: Referencia rápida de funciones

La tabla que aparece a continuación enumera todas las funciones utilizadas en los seis pasos, el paquete que las proporciona y los parámetros que esperan.

Apéndice: Modelos disponibles en caret

La función train() puede entrenar muchos más modelos que solo bosques aleatorios. Ejecute el siguiente comando para imprimir todos los identificadores de modelos que admite caret y, a continuación, pase cualquiera de ellos al argumento del método.

names(getModelInfo())

Salida:

##   [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"

Preguntas Frecuentes