Random Forest usando rpart

El siguiente script hace un ensamble de iteraciones del algoritmo rpart usando los siguientes principios de Random Forest:

• 1. Selección de variables al azar en cada arbol, considerando la raíz cuadrada del total de variables como el tamaño de variables a remuestrear en cada iteracion. (el método original remuestrea variables en cada nodo del arbol).
• 2. Muestras con reemplazo en Iteraciones, y tamaño de muestra es igual al Train-Dataset
• 3. Arboles sin podar, dejando crecer (en reglas) el algoritmo en cada iteracion.

Esto puede ser util en data set con gran cantidad de nulos, ya que el package randomForest no tiene un metodo para manejar nulos, y rpart sí.  También puede servir para calibrar los parámetros propios del rpart en cada iteración. 
La tabla final donde se ensamblan las predicciones de cada árbol queda así:

Y los arboles creados en cada iteración quedan así (solo para ilustrar la profundidad en reglas de cada árbol):

Imputacion con RandomForest

Si se tiene un data set con NA (datos faltantes, missing, etc..), puede usarse la función rfImpute del package randomForest para completar los NA de todas las variables.


Conceptualmente seria así:

El scipt queda así:

# imputacion con rfImpute del package randomForest
 
 
library(randomForest);
# --------------------------------------------
## Crea valores NA aleatoriamente en data set iris.na
iris.na <- iris
for (i in 1:4) iris.na[sample(150, sample(50)), i] <- NA
 
# --------------------------------------------
## Imputa valores NA en nuevo data set
iris.imputed <- rfImpute(Species ~ ., iris.na)

NOTAS: 
La función rfImpute solo imputa variables numéricas y factores.
Para imputar solo una variable, ver método con regresión lineal publicado AQUI
El excel con imagenes se descarga AQUI

Referencia:
http://stackoverflow.com/questions/20537186/getting-predictions-after-rfimpute

Cantidad de variables en Random Forest

Para saber la cantidad optima de variables en algoritmo randomForest (ver ejemplo de randomForest AQUI), puede usarse la función tuneRF que viene incluida en este package. Esta función gráfica el error OOB en cada iteración, aumentando la cantidad de variables en cada paso (para función de OOB ver nota publicada AQUI).

En el siguiente gráfico se puede identificar que al llegar a 8 variables se estabiliza el error:

Mediciones del Random Forest

Para conocer la eficiencia de un modelo de Random Forest (ver detalle de randomForest AQUI), puede usarse las siguientes medidas, todas obtenidas con funciones incluidas en el package randomForest.

OOB error (out of bag error)

Cuando el algoritmo randomForest selecciona una muestra con reemplazo para crear un árbol en una iteración, algunas observaciones se quedan fuera (out of bag)  y no son usadas para crear el árbol. Para esas observaciones que quedaron fuera del árbol, se  hace una predicción y se calcula el error de la predicción. Esto se hace en cada iteración para calcular el error estimado, llamado OOB error.

La función print(modelo_rf) muestra el OOB del modelo:

Paralelizar Random Forest

Si se quiere disminuir el tiempo de ejecución del algoritmo randomForest, (ver ejemplo de randomForest AQUI) puede utilizarse el package foreach, que distribuye las ejecuciones de los diferentes arboles en distintos procesadores logrando una ejecución en paralelo.

El siguiente script distribuye 1000 arboles de un randomForest  en 4 procesadores, asignando 250  arboles a cada procesador y luego uniéndolos en un único modelo. En un procesador i7 el tiempo de ejecucion tarda 30 segundos sin paralelizar, luego de paralelizar tarda 6 segundo

Conceptualmente el package foreach hace esto:

El script queda así:

# CARGA LIBRERIA Y DATOS
#---------------------------------------------------
library(doParallel);library(foreach);library(C50);data(churn)
inicio    <- Sys.time()           
datos     <- churnTrain[sample(3333,10000,replace = T),]
 
 
# REGISTRO DE PARALLEL BACKEND
#---------------------------------------------------
cl <- makeCluster(detectCores())
registerDoParallel(cl)
getDoParWorkers()
 
 
#RANDOM FOREST
#---------------------------------------------------
modelo.rf <- foreach(ntree=rep(250, 4),         # 250 arboles x 4 nodo: 1000 arboles
                    # .combine      =  combine,  # creacion de arboles en paralelo
                     .multicombine = TRUE,      # creacion de resultados en paralelo
                     .packages     = 'randomForest') %dopar%  
   randomForest(churn ~.,data=datos, mtry = 6, ntree=ntree)
 
 
# STOP CLUSTER
#---------------------------------------------------
stopCluster(cl)
print(duracion<-Sys.time()-inicio)
 
 

Referencia:
1. http://stackoverflow.com/questions/14106010/parallel-execution-of-random-forest-in-r
2. http://cran.r-project.org/web/packages/foreach/vignettes/foreach.pdf
3. https://github.com/tobigithub/R-parallel/wiki/R-parallel-Errors

Ejemplo de Random Forest

Random Forest es un algoritmo predictivo que usa la técnica de Bagging para combinar diferentes arboles, donde cada árbol es construido con observaciones y variables aleatorias.

En forma resumida sigue este proceso:

1. Selecciona individuos al azar (usando muestreo con reemplazo) para crear diferentes set de datos.
2. Crea un árbol de decisión con cada set de datos, obteniendo diferentes arboles, ya que cada set contiene diferentes individuos y diferentes variables en cada nodo.
3. Al crear los arboles se eligen variables al azar en cada nodo del arbol, dejando crecer el arbol en profundidad (es decir, sin podar).
4. Predice los nuevos datos usando el "voto mayoritario", donde clasificará como "positivo" si la mayoría de los arboles predicen la observación como positiva.

Conceptualmente sería así: