quel élément liste est en cours de traitement lors de l'utilisation des chutes de neige :: sfLapply?

Question

Supposons que nous ayons une liste (mylist) qui est utilisé comme objet d'entrée pour une fonction lapply. Y at-il un moyen de savoir quel élément de mylist est en cours d'évaluation? La méthode devrait fonctionner sur lapply et snowfall::sfApply (et d'autres possibles appliquent les membres de la famille) ainsi.

le chat , Gavin Simpson a suggéré la méthode suivante. Cela fonctionne très bien pour lapply mais pas tant pour sfApply. Je voudrais éviter de paquets supplémentaires ou de jongler avec la liste. Toutes les suggestions?

mylist <- list(a = 1:10, b = 1:10)
foo <- function(x) {
    deparse(substitute(x))
}
bar <- lapply(mylist, FUN = foo)

> bar
$a
[1] "X[[1L]]"

$b
[1] "X[[2L]]"

Ceci est la version parallèle qui est pas le couper.

library(snowfall)
sfInit(parallel = TRUE, cpus = 2, type = "SOCK") # I use 2 cores

sfExport("foo", "mylist")
bar.para <- sfLapply(x = mylist, fun = foo)

> bar.para
$a
[1] "X[[1L]]"

$b
[1] "X[[1L]]"

sfStop()

Answer 1

Je pense que vous allez avoir à utiliser la solution / suggestion de Shane dans cette session de chat. Conservez vos objets dans une liste de telle sorte que chaque composant de la liste supérieure contient un composant avec le nom ou l'ID ou expérience contenue dans ce composant de liste, plus un composant contenant l'objet que vous souhaitez traiter:

obj <- list(list(ID = 1, obj = 1:10), list(ID = 2, obj = 1:10), 
            list(ID = 3, obj = 1:10), list(ID = 4, obj = 1:10),
            list(ID = 5, obj = 1:10))

Nous avons donc la structure suivante:

> str(obj)
List of 5
 $ :List of 2
  ..$ ID : num 1
  ..$ obj: int [1:10] 1 2 3 4 5 6 7 8 9 10
 $ :List of 2
  ..$ ID : num 2
  ..$ obj: int [1:10] 1 2 3 4 5 6 7 8 9 10
 $ :List of 2
  ..$ ID : num 3
  ..$ obj: int [1:10] 1 2 3 4 5 6 7 8 9 10
 $ :List of 2
  ..$ ID : num 4
  ..$ obj: int [1:10] 1 2 3 4 5 6 7 8 9 10
 $ :List of 2
  ..$ ID : num 5
  ..$ obj: int [1:10] 1 2 3 4 5 6 7 8 9 10

ont quelque chose comme la première ligne de la fonction suivante, suivi de votre

foo <- function(x) {
    writeLines(paste("Processing Component:", x$ID))
    sum(x$obj)
}

Ce qui va faire ceci:

> res <- lapply(obj, foo)
Processing Component: 1
Processing Component: 2
Processing Component: 3
Processing Component: 4
Processing Component: 5

Ce qui pourrait travailler sur des chutes de neige.

Answer 2

Je pourrais aussi modifier les attributs souhaiterai.

mylist <- list(a = 1:10, b = 1:10)
attr(mylist[[1]], "seq") <- 1
attr(mylist[[2]], "seq") <- 2

foo <- function(x) {
    writeLines(paste("Processing Component:", attributes(x)))   
}
bar <- lapply(mylist, FUN = foo)

(et la version parallèle)

mylist <- list(a = 1:10, b = 1:10)
attr(mylist[[1]], "seq") <- 1
attr(mylist[[2]], "seq") <- 2

foo <- function(x) {
    x <- paste("Processing Component:", attributes(x))  
}
sfExport("mylist", "foo")
bar <- sfLapply(mylist, fun = foo)