Bagging en Paralelo con foreach+doParallel

Si se quiere entrenar un modelo usando la tecnica de bagging (ver concepto de bagging AQUI) y se tienen muchos datos, puede que el proceso demore mucho tiempo.

Una forma de reducir el tiempo es paralelizando los procesos, asignando a cada procesador una parte de los modelos a entrenar y luego unificar los resultados en un único modelo.

Conceptuelmente seria así:

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

Paralelizacion de Validacion Cruzada

Si se quiere saber qué tan eficiente es la predicción de un algoritmo, una forma es usar la tecnica de Validacion Cruzada (ver ejemplo AQUI). Esta técnica consiste en hacer varios modelos de forma iterada, usando diferentes arreglos del set de Entrenamiento y del set de Test en cada iteracion.

Cuando se tienen muchos datos, la Validación Cruzada puede tardar mucho tiempo de ejecución, y una forma de mejorar esto es paralelizando las iteraciones.

Conceptualmente seria algo como lo siguiente:

Paralelizando Iteraciones de K-Means

Si se hace una segmentacion con k-means en un set de datos muy grande, pueden obtenerse resultados significativamente diferentes en cada ejecucion. Una forma de obtener el mejor resultado es usando el parametro nstart para indicar cuantos set de datos se van a considerar al inicio del algoritmo para luego quedarse con el mejor.

Si al usar nstart se hace mas lenta la ejecución de k-means, puede paralelizarse este proceso y distribuir la tarea entre varios procesadores.

El siguiente scrip es una ejecución de k-means con nstart = 100. Tiene un tiempo de ejecucion de 1 minuto en un procesador i7

#-----------------------------------------------------------------------------

suppressWarnings(library(C50)); library(rpart); data(churn);

Datos<-churnTrain[,c(2,6:19)]

for (i in 1:4) Datos<-rbind(Datos,Datos)  # aumenta dataset duplicandolo

system.time(Madelo<-kmeans(Datos, centers = 5, iter.max = 100, nstart = 100))

#-----------------------------------------------------------------------------

Paralelizar una Optimizacion de K-Means

Si se quiere comparar las diferentes variaciones de k-means para luego usar el mejor (ver ejemplo con detalle publicado AQUI) , es posible que el tiempo de ejecución sea muy alto si existen muchos datos. Una de las causas de esto es que R no hace ejecución en paralelo por defecto.

Una forma de mejorar los tiempos de ejecución es "Paralelizando los Procesos", donde se asigna a cada núcleo del procesador una tarea distinta y luego se unen los diferentes resultado de cada proceso.

El siguiente script paraleliza 4 ejecuciones de k-means que corresponden a sus 4 variaciones (Hartigan-Wong, Lloyd, Forgy y MacQueen). Si se ejecuta este proceso sin paralelizar en un procesador i7, el tiempo aproximado es de 1 minuto. Luego de paralelizar, se el tiempo de ejecución es de 5 segundos.