Uso di doParallel / doMC non solo con pacchetto foreach - r, elaborazione parallela, doparallel, domc

tutti i tutorial ufficiali doParallel, doParallel-Vignette, domc e domc-Vignette Finora ho scoperto solo come usare il calcolo parallelo in combinazione con foreach. C'è un modo per accelerare anche il codice "sequenziale"?

Immagina come dividere un file in più file ed eseguire ogni file con un'istanza diversa di R. Per esempio.

## <run on core1>
data1 <- getData1()
dataResult1 <- doComplexAlgorithm1(data1)
## </run on core1>

## <run on core2>
data2 <- getData2()
dataResult2 <- doComplexAlgorithm2(data2)
## </run on core2>

## <run on core3>
data3 <- getData3()
dataResult3 <- doComplexAntotherAlgorithm3(data3)
## </run on core3>

## <run on core4>
data4 <- getData4()
dataResult4 <- doComplexNotSoComplexAlgorithm4(data4)
## </run on core4>

Grazie in anticipo!

(R v.3.2.1, RStudio v.0.99.451)

risposte:

Nello scenario di base (a processo singolo), si utilizzerà mapply, passando un elenco delle tue funzioni:

mapply(function(getData, doAlg) {
dat <- getData()
doAlg(dat)
},
getData=list(getData1, getData2, getData3, getData4),
doAlg=list(algorithm1, algorithm2, algorithm3, algorithm4))

Nel caso di elaborazione parallela, è possibile utilizzare clusterMap:

library(parallel)
cl <- makeCluster()
clusterMap(cl, function(getData, doAlg) {
dat <- getData()
doAlg(dat)
},
getData=list(getData1, getData2, getData3, getData4),
doAlg=list(algorithm1, algorithm2, algorithm3, algorithm4))

Sembra che tu voglia fare quello che provo a fare con le immagini. Ho alcune immagini e alcuni calcoli su di esse, il che da solo richiede abbastanza tempo. Il modo in cui lo faccio è avere un elenco di file e:

foreach (i =1:length(fileList)) %dopar% {
- load data
- do something
- write result to disk
}

È proprio come dici tu, ogni set di dati (file), viene elaborato sul suo core purché il tuo sistema abbia memoria sufficiente per conservarli tutti in una volta.

Quindi non hai bisogno di alcuna condivisione di memoria o comunicazione tra ogni lavoro, o sono lavori indipendenti.

Il paradigma foreach o lapply è più progettato per dividere un ciclo o un processo vettoriale. Per lavori totalmente individuali, devi avvolgere un altro livello per trasformarlo in un ciclo.

Avvolgi ciascuna sezione in una funzione, inserisci tutte le funzioni in un elenco, quindi chiama ogni funzione in loop.

fun_list <- list(
fun_1 <- function() {
data1 <- getData1()
doComplexAlgorithm1(data1)
},
fun_2 <- function() {
data2 <- getData1()
doComplexAlgorithm2(data2)
},
...
)