Rapide en remplaçant les valeurs dans dataframe dans la R

J'ai un dataframe de 150 000 lignes de 2 000 colonnes contenant des valeurs, certains étant négatifs.
Je suis le remplaçant ces valeurs négatives par 0, mais il est très lent pour le faire (~60min ou plus).

df[df < 0] = 0

où df[,1441:1453] ressemble (toutes les colonnes/valeurs numériques):

  V1441 V1442 V1443 V1444 V1445 V1446 V1447 V1448 V1449 V1450 V1451 V1452 V1453
1     3     1     0     4     4    -2     0     3    12     5    17    34    27
2     0     1     0     7     0     0     0     1     0     0     0     0     0
3     0     2     0     1     2     3     6     1     2     1    -6     3     1
4     1     2     3     6     1     2     1    -6     3     1    -4     1     0
5     1     2     1    -6     3     1    -4     1     0     0     1     0     0
6     1     0     0     1     0     0     0     0     0     0     1     2     2

Est-il un moyen pour accélérer le processus, par exemple, la façon dont je le fais c'est tout à fait lent, et il est plus rapide pour cette approche ?
Merci.

  • De 150 000 lignes x 2000 colonnes : c'est correct
  • Pouvez vous s'il vous plaît nous montrer la façon dont vos données ressemble? Sont toutes les colonnes numériques?
InformationsquelleAutor Benoit B. | 2012-10-11
  1. 30

    Essayez de transformer votre df pour une matrice.

    df <- data.frame(a=rnorm(1000),b=rnorm(1000))
m <- as.matrix(df)
m[m<0] <- 0
df <- as.data.frame(m)
    • Vraiment vraiment plus rapide!
    InformationsquelleAutor Roland
  2. 22

    À la fois votre approche originale et la réponse actuelle de créer un objet de la même taille que m (ou df) lors de la création de m<0 (la méthode de la matrice est plus rapide, car il y a moins de copie interne avec [<- comparé avec [<-.data.frame

    Vous pouvez utiliser lapply et replace, alors vous êtes seulement à la recherche à un vecteur ou length (nrow(df)) à chaque fois
    et ne copie pas tellement

    df <- as.data.frame(lapply(df, function(x){replace(x, x <0,0)})

    Le code ci-dessus devrait être assez effiicent.

    Si vous utilisez data.table, la plupart de la mémoire (et) le temps de l'inefficacité de la data.frame approche est supprimé. Il serait idéal pour un ensemble important de données situation comme la vôtre.

    library(data.table)
# this really shouldn't be 
DT <- lapply(df, function(x){replace(x, x <0,0)})
# change to data.table
setattr(DT, 'class', c('data.table','data.frame'))
# or 
# DT <- as.data.table(df, function(x){replace(x, x <0,0)})

    Vous pouvez définir les touches sur toutes les colonnes et ensuite remplacer par référence à des valeurs de clé inférieure à 0

    InformationsquelleAutor mnel
  3. 0

    Un autre des données.table de réponse, peut-être plus rapide, et vraiment devrait consommer moins de mémoire. 

    library(data.table)
set.seed(108)
d = data.table(a=rnorm(1000),b=rnorm(1000))
set.colwise = function(x, i, j, value) {
  replace_dot_j = function(e, j) {
    if (is.symbol(e) && identical(e, as.symbol(".j"))) return(j)
    if (is.call(e)) {
      if (e[[1L]] == ".j") e[[1L]] = j
      for (i in seq_along(e)[-1L]) if (!is.null(e[[i]])) e[[i]] = replace_dot_j(e[[i]], j)
    }
    e
  }
  for (jj in j) eval(substitute(
    set(x, .i, .j, value),
    list(
      .i=replace_dot_j(substitute(i), jj),
      .j=jj
    )
  ))
  invisible(x)
}
d
set.colwise(d, i = which(d[[.j]] < 0), j = c("a","b"), value = 0)
d

    .j symbole utilisé dans i argument est répété et remplacées par les colonnes de j argument.

    InformationsquelleAutor jangorecki