Le moyen le plus rapide de remplacer les NA dans une table de données volumineuse.

J'ai une grande table data.table , avec de nombreuses valeurs manquantes dispersées dans ses ~ 200k lignes et 200 colonnes. Je voudrais recoder ces valeurs NA en zéros aussi efficacement que possible.

Je vois deux options:
1: Convertir en data.frame et utiliser quelque chose comme ceci
2: Une sorte de commande de sous-paramétrage data.table cool

Je serai satisfait d'une solution de type 1 assez efficace. La conversion en data.frame puis en data.table ne prendra pas trop de temps.

Voici une solution utilisant l' opérateur de data.table:= , s'appuyant sur les réponses d'Andrie et Ramnath.

require(data.table)  # v1.6.6
require(gdata)       # v2.8.2

set.seed(1)
dt1 = create_dt(2e5, 200, 0.1)
dim(dt1)
[1] 200000    200    # more columns than Ramnath's answer which had 5 not 200

f_andrie = function(dt) remove_na(dt)

f_gdata = function(dt, un = 0) gdata::NAToUnknown(dt, un)

f_dowle = function(dt) {     # see EDIT later for more elegant solution
  na.replace = function(v,value=0) { v[is.na(v)] = value; v }
  for (i in names(dt))
    eval(parse(text=paste("dt[,",i,":=na.replace(",i,")]")))
}

system.time(a_gdata = f_gdata(dt1)) 
   user  system elapsed 
 18.805  12.301 134.985 

system.time(a_andrie = f_andrie(dt1))
Error: cannot allocate vector of size 305.2 Mb
Timing stopped at: 14.541 7.764 68.285 

system.time(f_dowle(dt1))
  user  system elapsed 
 7.452   4.144  19.590     # EDIT has faster than this

identical(a_gdata, dt1)   
[1] TRUE

Notez que f_dowle a mis à jour dt1 par référence. Si une copie locale est requise, un appel explicite à la copyfonction est nécessaire pour créer une copie locale de l'ensemble de données. de data.table setkey, key<-et :=ne pas copier-on-write.

Ensuite, voyons où f_dowle passe son temps.

Rprof()
f_dowle(dt1)
Rprof(NULL)
summaryRprof()
$by.self
                  self.time self.pct total.time total.pct
"na.replace"           5.10    49.71       6.62     64.52
"[.data.table"         2.48    24.17       9.86     96.10
"is.na"                1.52    14.81       1.52     14.81
"gc"                   0.22     2.14       0.22      2.14
"unique"               0.14     1.36       0.16      1.56
... snip ...

Là, je me concentrerais sur na.replaceet is.na, où il y a quelques copies vectorielles et numérisations vectorielles. Ceux-ci peuvent être assez facilement éliminés en écrivant une petite fonction C na.replace qui se met NAà jour par référence dans le vecteur. Cela réduirait au moins de moitié les 20 secondes, je pense. Une telle fonction existe-t-elle dans un package R?

La raison f_andrieéchoue peut être parce qu'il copie la totalité de dt1, ou crée une matrice logique aussi grande que l'ensemble de dt1, plusieurs fois. Les 2 autres méthodes fonctionnent sur une colonne à la fois (même si je n'ai regardé que brièvement NAToUnknown).

EDIT (solution plus élégante comme demandé par Ramnath dans les commentaires):

f_dowle2 = function(DT) {
  for (i in names(DT))
    DT[is.na(get(i)), (i):=0]
}

system.time(f_dowle2(dt1))
  user  system elapsed 
 6.468   0.760   7.250   # faster, too

identical(a_gdata, dt1)   
[1] TRUE

J'aurais aimé le faire de cette façon pour commencer!

EDIT2 (plus d'un an plus tard, maintenant)

Il y a aussi set(). Cela peut être plus rapide s'il y a beaucoup de colonnes en boucle, car cela évite la (petite) surcharge de l'appel [,:=,]dans une boucle. setest une boucle :=. Voir ?set.

f_dowle3 = function(DT) {
  # either of the following for loops

  # by name :
  for (j in names(DT))
    set(DT,which(is.na(DT[[j]])),j,0)

  # or by number (slightly faster than by name) :
  for (j in seq_len(ncol(DT)))
    set(DT,which(is.na(DT[[j]])),j,0)
}

Voici le plus simple que je puisse proposer:

dt[is.na(dt)] <- 0

C'est efficace et pas besoin d'écrire des fonctions et autres codes de glue.

Des fonctions dédiées ( nafillet setnafill) à cet effet sont disponibles dans le data.tablepackage (version> = 1.12.4):

Il traite les colonnes en parallèle si bien pour répondre aux repères précédemment publiés, en dessous de ses délais par rapport à l'approche la plus rapide jusqu'à présent, et également mis à l'échelle, en utilisant une machine à 40 cœurs.

library(data.table)
create_dt <- function(nrow=5, ncol=5, propNA = 0.5){
  v <- runif(nrow * ncol)
  v[sample(seq_len(nrow*ncol), propNA * nrow*ncol)] <- NA
  data.table(matrix(v, ncol=ncol))
}
f_dowle3 = function(DT) {
  for (j in seq_len(ncol(DT)))
    set(DT,which(is.na(DT[[j]])),j,0)
}

set.seed(1)
dt1 = create_dt(2e5, 200, 0.1)
dim(dt1)
#[1] 200000    200
dt2 = copy(dt1)
system.time(f_dowle3(dt1))
#   user  system elapsed 
#  0.193   0.062   0.254 
system.time(setnafill(dt2, fill=0))
#   user  system elapsed 
#  0.633   0.000   0.020   ## setDTthreads(1) elapsed: 0.149
all.equal(dt1, dt2)
#[1] TRUE

set.seed(1)
dt1 = create_dt(2e7, 200, 0.1)
dim(dt1)
#[1] 20000000    200
dt2 = copy(dt1)
system.time(f_dowle3(dt1))
#   user  system elapsed 
# 22.997  18.179  41.496
system.time(setnafill(dt2, fill=0))
#   user  system elapsed 
# 39.604  36.805   3.798 
all.equal(dt1, dt2)
#[1] TRUE

library(data.table)

DT = data.table(a=c(1,"A",NA),b=c(4,NA,"B"))

DT
    a  b
1:  1  4
2:  A NA
3: NA  B

DT[,lapply(.SD,function(x){ifelse(is.na(x),0,x)})]
   a b
1: 1 4
2: A 0
3: 0 B

Juste pour référence, plus lent par rapport à gdata ou data.matrix, mais utilise uniquement le package data.table et peut traiter des entrées non numériques.

Voici une solution utilisant NAToUnknowndans le gdatapackage. J'ai utilisé la solution d'Andrie pour créer un énorme tableau de données et j'ai également inclus des comparaisons de temps avec la solution d'Andrie.

# CREATE DATA TABLE
dt1 = create_dt(2e5, 200, 0.1)

# FUNCTIONS TO SET NA TO ZERO   
f_gdata  = function(dt, un = 0) gdata::NAToUnknown(dt, un)
f_Andrie = function(dt) remove_na(dt)

# COMPARE SOLUTIONS AND TIMES
system.time(a_gdata  <- f_gdata(dt1))

user  system elapsed 
4.224   2.962   7.388 

system.time(a_andrie <- f_Andrie(dt1))

 user  system elapsed 
4.635   4.730  20.060 

identical(a_gdata, g_andrie)  

TRUE

Par souci d'exhaustivité, une autre façon de remplacer les NA par 0 consiste à utiliser

f_rep <- function(dt) {
dt[is.na(dt)] <- 0
return(dt)
}

Pour comparer les résultats et les temps, j'ai intégré toutes les approches mentionnées jusqu'à présent.

set.seed(1)
dt1 <- create_dt(2e5, 200, 0.1)
dt2 <- dt1
dt3 <- dt1

system.time(res1 <- f_gdata(dt1))
   User      System verstrichen 
   3.62        0.22        3.84 
system.time(res2 <- f_andrie(dt1))
   User      System verstrichen 
   2.95        0.33        3.28 
system.time(f_dowle2(dt2))
   User      System verstrichen 
   0.78        0.00        0.78 
system.time(f_dowle3(dt3))
   User      System verstrichen 
   0.17        0.00        0.17 
system.time(res3 <- f_unknown(dt1))
   User      System verstrichen 
   6.71        0.84        7.55 
system.time(res4 <- f_rep(dt1))
   User      System verstrichen 
   0.32        0.00        0.32 

identical(res1, res2) & identical(res2, res3) & identical(res3, res4) & identical(res4, dt2) & identical(dt2, dt3)
[1] TRUE

La nouvelle approche est donc légèrement plus lente f_dowle3mais plus rapide que toutes les autres approches. Mais pour être honnête, cela va à l'encontre de mon Intuition de la syntaxe data.table et je n'ai aucune idée de pourquoi cela fonctionne. Quelqu'un peut-il m'éclairer?

Je crois comprendre que le secret des opérations rapides dans R est d'utiliser des vecteurs (ou des tableaux, qui sont des vecteurs sous le capot.)

Dans cette solution, j'utilise un data.matrixqui est un arraymais se comporte un peu comme un data.frame. Comme il s'agit d'un tableau, vous pouvez utiliser une substitution vectorielle très simple pour remplacer le NAs:

Une petite fonction d'aide pour supprimer le NAs. L'essence est une seule ligne de code. Je ne fais cela que pour mesurer le temps d'exécution.

remove_na <- function(x){
  dm <- data.matrix(x)
  dm[is.na(dm)] <- 0
  data.table(dm)
}

Une petite fonction d'aide pour créer un data.tabled'une taille donnée.

create_dt <- function(nrow=5, ncol=5, propNA = 0.5){
  v <- runif(nrow * ncol)
  v[sample(seq_len(nrow*ncol), propNA * nrow*ncol)] <- NA
  data.table(matrix(v, ncol=ncol))
}

Démonstration sur un petit échantillon:

library(data.table)
set.seed(1)
dt <- create_dt(5, 5, 0.5)

dt
            V1        V2        V3        V4        V5
[1,]        NA 0.8983897        NA 0.4976992 0.9347052
[2,] 0.3721239 0.9446753        NA 0.7176185 0.2121425
[3,] 0.5728534        NA 0.6870228 0.9919061        NA
[4,]        NA        NA        NA        NA 0.1255551
[5,] 0.2016819        NA 0.7698414        NA        NA

remove_na(dt)
            V1        V2        V3        V4        V5
[1,] 0.0000000 0.8983897 0.0000000 0.4976992 0.9347052
[2,] 0.3721239 0.9446753 0.0000000 0.7176185 0.2121425
[3,] 0.5728534 0.0000000 0.6870228 0.9919061 0.0000000
[4,] 0.0000000 0.0000000 0.0000000 0.0000000 0.1255551
[5,] 0.2016819 0.0000000 0.7698414 0.0000000 0.0000000

Pour généraliser à de nombreuses colonnes, vous pouvez utiliser cette approche (en utilisant des exemples de données précédents mais en ajoutant une colonne):

z = data.table(x = sample(c(NA_integer_, 1), 2e7, TRUE), y = sample(c(NA_integer_, 1), 2e7, TRUE))

z[, names(z) := lapply(.SD, function(x) fifelse(is.na(x), 0, x))]

Je n'ai pas testé la vitesse

> DT = data.table(a=LETTERS[c(1,1:3,4:7)],b=sample(c(15,51,NA,12,21),8,T),key="a")
> DT
   a  b
1: A 12
2: A NA
3: B 15
4: C NA
5: D 51
6: E NA
7: F 15
8: G 51
> DT[is.na(b),b:=0]
> DT
   a  b
1: A 12
2: A  0
3: B 15
4: C  0
5: D 51
6: E  0
7: F 15
8: G 51
> 

Utilisation de la fifelsefonction du plus récentdata.table versions 1.12.6, il est même 10 fois plus rapide que NAToUnknowndans le gdatapackage:

z = data.table(x = sample(c(NA_integer_, 1), 2e7, TRUE))
system.time(z[,x1 := gdata::NAToUnknown(x, 0)])

#   user  system elapsed 
#  0.798   0.323   1.173 

system.time(z[,x2:= fifelse(is.na(x), 0, x)])

#   user  system elapsed 
#  0.172   0.093   0.113