Cómo optimizar mi script R para usar "multinúcleo"

Estoy usando GNU R en una PC Ubuntu-Lucid que tiene 4 CPU. Para utilizar las 4 CPU, instalé el paquete "r-cran-multicore". Como el manual del paquete carece de ejemplos prácticos que entiendo, necesito consejos sobre cómo optimizar mi script para utilizar las 4 CPU.

Mi conjunto de datos es un data.frame (llamado P1) que tiene 50,000 filas y 1600 cols. Para cada fila, me gustaría calcular el máximo, la suma y la media. Mi guión se ve de la siguiente manera:

p1max <- 0
p1mean <- 0
p1sum <-0
plength <- length(P1[,1])
for(i in 1:plength){
   p1max <- c(p1max, max(P1[i,]))
   p1mean <- c(p1mean, mean(P1[i,]))
   p1sum <- c(p1sum, sum(P1[i,]))
}

¿Podría alguien decirme cómo modificar y ejecutar el script para usar las 4 CPU?

Use foreach y doMC . La explicación detallada se puede encontrar aquí . Tu guión cambiará muy poco, la línea

for(i in 1:plength){

debe cambiarse a

foreach(i=1:plength) %dopar% { 

Los requisitos previos para cualquier script multitarea que use estos paquetes son

library(foreach)
library(doMC)
registerDoMC()

Nota de precaución. De acuerdo con la documentación, no puede usar esto en la GUI.

En cuanto a su problema, ¿realmente necesita multitarea? Su data.frame toma aproximadamente 1.2 GB de RAM, por lo que debe caber en su memoria. Entonces, simplemente puede usar apply:

p1smry <- apply(P1,1,summary)

El resultado será una matriz con resúmenes de cada fila.

También puede usar la función mclapply que se encuentra en el paquete multinúcleo. Entonces su script podría verse así:

loopfun <- function(i) {
     summary(P1[i,])
}

res <- mclapply(1:nrow(P1),loopfun)

Esto devolverá la lista, donde i-ésimo elemento será el resumen de la i-ésima fila. Puedes convertirlo a matriz usando sapply

mres <- sapply(res,function(x)x)

Ya tiene una respuesta sobre cómo usar más de un núcleo, pero el verdadero problema es la forma en que ha escrito sus bucles. Nunca extienda su vector / objeto de resultado en cada iteración de un bucle . Si haces esto, obligas a R a copiar tu vector / objeto de resultado y lo extiendes, lo que lleva tiempo. En su lugar, asigne previamente suficiente espacio de almacenamiento antes de comenzar el ciclo y complete a medida que avanza. Aquí hay un ejemplo:

set.seed(1)
p1 <- matrix(rnorm(10000), ncol=100)
system.time({
p1max <- p1mean <- p1sum <- numeric(length = 100)
for(i in seq_along(p1max)){
   p1max[i] <- max(p1[i,])
   p1mean[i] <- mean(p1[i,])
   p1sum[i ]<- sum(p1[i,])
}
})

   user  system elapsed 
  0.005   0.000   0.005

O puede hacer estas cosas a través de apply():

system.time({
p1max2 <- apply(p1, 1, max)
p1mean2 <- apply(p1, 1, mean)
p1sum2 <- apply(p1, 1, sum)
})
   user  system elapsed 
  0.007   0.000   0.006 

Pero tenga en cuenta que esto no es más rápido que hacer el bucle correctamente y, a veces, más lento.

Sin embargo, siempre esté atento al código vectorizado. Puede hacer sumas de filas y medios usando rowSums()y rowMeans()que son más rápidos que el bucle o las applyversiones:

system.time({
p1max3 <- apply(p1, 1, max)
p1mean3 <- rowMeans(p1)
p1sum3 <- rowSums(p1)
})

   user  system elapsed 
  0.001   0.000   0.002 

Si fuera un apostador, tendría dinero en el tercer enfoque que menciono golpear foreach()u otras opciones multinúcleo en una prueba de velocidad en su matriz porque tendrían que acelerar las cosas considerablemente para justificar los gastos generales incurridos al configurar el procesos separados que se cultivan en los diferentes núcleos de CPU.

Actualización: Siguiendo el comentario de @shabbychef, ¿es más rápido hacer las sumas una vez y reutilizarlas en el cálculo de la media?

system.time({
    p1max4 <- apply(p1, 1, max)
    p1sum4 <- rowSums(p1)
    p1mean4 <- p1sum4 / ncol(p1)
    })

   user  system elapsed 
  0.002   0.000   0.002

No en esta prueba, pero esto está lejos de ser exhaustivo ...

Echa un vistazo a los paquetes de nieve y nieve . Un montón de ejemplos con esos ...

Si desea acelerar ese código específico en lugar de aprender sobre R y el paralelismo, debe hacerlo

P1 = matrix(rnorm(1000), ncol=10, nrow=10
apply(P1, 1, max)
apply(P1, 1, mean)
apply(P1, 1, sum)