Come ottimizzare il mio script R per utilizzare il "multicore"

Sto usando GNU R su un PC Ubuntu-Lucid che ha 4 CPU. Per utilizzare tutte e 4 le CPU, ho installato il pacchetto "r-cran-multicore". Dato che nel manuale del pacchetto mancano esempi pratici che capisco, ho bisogno di consigli su come ottimizzare il mio script al fine di utilizzare tutte e 4 le CPU.

Il mio set di dati è un data.frame (chiamato P1) con 50.000 righe e 1600 cols. Per ogni riga, vorrei calcolare il massimo, la somma e la media. La mia sceneggiatura ha il seguente aspetto:

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,]))
}

Qualcuno potrebbe dirmi come modificare ed eseguire lo script per utilizzare tutte e 4 le CPU?

Usa foreach e doMC . La spiegazione dettagliata può essere trovata qui . La tua sceneggiatura cambierà molto poco, la linea

for(i in 1:plength){

dovrebbe essere cambiato in

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

I prerequisiti per qualsiasi script multitasking che utilizza questi pacchetti sono

library(foreach)
library(doMC)
registerDoMC()

Nota di attenzione. Secondo la documentazione non è possibile utilizzarlo nella GUI.

Per quanto riguarda il tuo problema, hai davvero bisogno del multitasking? Il tuo data.frame richiede circa 1,2 GB di RAM, quindi dovrebbe adattarsi alla tua memoria. Quindi puoi semplicemente usare applicare:

p1smry <- apply(P1,1,summary)

Il risultato sarà una matrice con i riassunti di ogni riga.

Puoi anche usare la funzione mclapply che si trova nel pacchetto multicore. Quindi il tuo script potrebbe apparire così:

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

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

Ciò restituirà l'elenco, in cui l'i-esimo elemento sarà il riepilogo dell'i-esima riga. Puoi convertirlo in matrice usando sapply

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

Hai già una risposta su come utilizzare più di un core, ma il vero problema è con il modo in cui hai scritto i tuoi loop. Non estendere mai il vettore / oggetto del risultato ad ogni iterazione di un ciclo . Se lo fai, imponi a R di copiare il tuo vettore / oggetto risultato e di estenderlo, il che richiede tempo. Invece, preallocate abbastanza spazio di archiviazione prima di avviare il ciclo e compilare mentre procedete. Ecco un esempio:

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

Oppure puoi fare queste cose tramite 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 

Ma nota che questo non è più veloce del fare il loop correttamente e talvolta più lentamente.

Tuttavia, cerca sempre il codice vettoriale. Puoi fare somme di riga e significa usare rowSums()e rowMeans()che sono più veloci del ciclo o delle applyversioni:

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

   user  system elapsed 
  0.001   0.000   0.002 

Se fossi un uomo di scommesse, avrei denaro sul terzo approccio che menziono battendo foreach()o le altre opzioni multi-core in un test di velocità sulla tua matrice perché dovrebbero accelerare notevolmente le cose per giustificare il sovraccarico sostenuto nell'impostare il processi separati che vengono estrapolati dai diversi core della CPU.

Aggiornamento: seguendo il commento di @shabbychef è più veloce fare le somme una volta e riutilizzarle nel calcolo della media?

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

   user  system elapsed 
  0.002   0.000   0.002

Non in questo test, ma questo è lungi dall'essere esaustivo ...

Dai un'occhiata ai pacchetti neve e nevicate . Un sacco di esempi con quelli ...

Se vuoi velocizzare quel codice specifico piuttosto che imparare a conoscere R e il parallelismo, dovresti farlo

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