¿Cómo reemplazo los valores de NA con ceros en un marco de datos R?

Respuestas:

880

Vea mi comentario en la respuesta @ gsk3. Un simple ejemplo:

> m <- matrix(sample(c(NA, 1:10), 100, replace = TRUE), 10)
> d <- as.data.frame(m)
   V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
1   4  3 NA  3  7  6  6 10  6   5
2   9  8  9  5 10 NA  2  1  7   2
3   1  1  6  3  6 NA  1  4  1   6
4  NA  4 NA  7 10  2 NA  4  1   8
5   1  2  4 NA  2  6  2  6  7   4
6  NA  3 NA NA 10  2  1 10  8   4
7   4  4  9 10  9  8  9  4 10  NA
8   5  8  3  2  1  4  5  9  4   7
9   3  9 10  1  9  9 10  5  3   3
10  4  2  2  5 NA  9  7  2  5   5

> d[is.na(d)] <- 0

> d
   V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
1   4  3  0  3  7  6  6 10  6   5
2   9  8  9  5 10  0  2  1  7   2
3   1  1  6  3  6  0  1  4  1   6
4   0  4  0  7 10  2  0  4  1   8
5   1  2  4  0  2  6  2  6  7   4
6   0  3  0  0 10  2  1 10  8   4
7   4  4  9 10  9  8  9  4 10   0
8   5  8  3  2  1  4  5  9  4   7
9   3  9 10  1  9  9 10  5  3   3
10  4  2  2  5  0  9  7  2  5   5

No hay necesidad de aplicar apply. =)

EDITAR

También deberías echar un vistazo al normpaquete. Tiene muchas características agradables para el análisis de datos faltantes. =)

aL3xa
fuente
2
Ya probé este código ayer antes de publicarlo y no funcionó. Porque esto publiqué la pregunta. Pero intenté saber y funcionó a la perfección. Creo que estaba haciendo algo mal.
Renato Dinhani
12
@ RenatoDinhaniConceição: si ya probaste algo, es útil compartir esa información cuando haces la pregunta; ayuda a reducir dónde puede estar el problema.
Aaron dejó Stack Overflow el
2
d [is.na (d)] <- 0 no tiene sentido para mí. Parece al revés? ¿Cómo procesa R esta declaración?
user798719
13
@ user798719 - "<-" es el operador de asignación de R, y se puede leer como: hacer algo en el lado derecho y luego asignarlo a la ubicación / nombre a la izquierda. En este caso, no estamos realmente "haciendo" nada, solo haciendo ceros. El lado izquierdo dice: mira el objeto d, dentro del objeto d (los corchetes), encuentra todos los elementos que devuelven VERDADERO (is.na (d) devuelve un lógico para cada elemento). Una vez que se encuentran, reemplácelos ("asígnelos") con el valor 0. Esto deja a todos los no NA como estaban, y solo reemplaza los que faltan.
Twitch_City
3
Y ... si tiene un marco de datos y solo desea aplicar el reemplazo a vectores numéricos específicos (dejando, por ejemplo, ... cadenas con NA):df[19:28][is.na(df[19:28])] <- 0
jtdoud
299

Las opciones hibridadas dplyr ahora son alrededor de un 30% más rápidas que las reasignaciones del subconjunto Base R. En un marco de datos de punto de datos de 100Mmutate_all(~replace(., is.na(.), 0)) ejecuta medio segundo más rápido que la d[is.na(d)] <- 0opción base R. Lo que uno quiere evitar específicamente es usar un ifelse()o un if_else(). (El análisis completo de 600 ensayos duró más de 4.5 horas debido principalmente a la inclusión de estos enfoques). Consulte los análisis de referencia a continuación para obtener los resultados completos.

Si está luchando con marcos de datos masivos, data.tablees la opción más rápida de todas: 40% más rápido que el enfoque estándar de Base R. También modifica los datos en el lugar, lo que le permite trabajar con casi el doble de datos a la vez.


Una agrupación de otros enfoques útiles de reemplazo tidyverse

Localmente:

  • índice mutate_at(c(5:10), ~replace(., is.na(.), 0))
  • referencia directa mutate_at(vars(var5:var10), ~replace(., is.na(.), 0))
  • arreglo mutate_at(vars(contains("1")), ~replace(., is.na(.), 0))
    • o en lugar de contains(), tratar ends_with(),starts_with()
  • coincidencia de patrones mutate_at(vars(matches("\\d{2}")), ~replace(., is.na(.), 0))

Condicionalmente:
(cambie solo un tipo y deje otros tipos solos).

  • enteros mutate_if(is.integer, ~replace(., is.na(.), 0))
  • números mutate_if(is.numeric, ~replace(., is.na(.), 0))
  • instrumentos de cuerda mutate_if(is.character, ~replace(., is.na(.), 0))

El análisis completo

Actualizado para dplyr 0.8.0: las funciones usan ~símbolos de formato purrr : reemplazando funs()argumentos obsoletos .

Enfoques probados:

# Base R: 
baseR.sbst.rssgn   <- function(x) { x[is.na(x)] <- 0; x }
baseR.replace      <- function(x) { replace(x, is.na(x), 0) }
baseR.for          <- function(x) { for(j in 1:ncol(x))
    x[[j]][is.na(x[[j]])] = 0 }

# tidyverse
## dplyr
dplyr_if_else      <- function(x) { mutate_all(x, ~if_else(is.na(.), 0, .)) }
dplyr_coalesce     <- function(x) { mutate_all(x, ~coalesce(., 0)) }

## tidyr
tidyr_replace_na   <- function(x) { replace_na(x, as.list(setNames(rep(0, 10), as.list(c(paste0("var", 1:10)))))) }

## hybrid 
hybrd.ifelse     <- function(x) { mutate_all(x, ~ifelse(is.na(.), 0, .)) }
hybrd.replace_na <- function(x) { mutate_all(x, ~replace_na(., 0)) }
hybrd.replace    <- function(x) { mutate_all(x, ~replace(., is.na(.), 0)) }
hybrd.rplc_at.idx<- function(x) { mutate_at(x, c(1:10), ~replace(., is.na(.), 0)) }
hybrd.rplc_at.nse<- function(x) { mutate_at(x, vars(var1:var10), ~replace(., is.na(.), 0)) }
hybrd.rplc_at.stw<- function(x) { mutate_at(x, vars(starts_with("var")), ~replace(., is.na(.), 0)) }
hybrd.rplc_at.ctn<- function(x) { mutate_at(x, vars(contains("var")), ~replace(., is.na(.), 0)) }
hybrd.rplc_at.mtc<- function(x) { mutate_at(x, vars(matches("\\d+")), ~replace(., is.na(.), 0)) }
hybrd.rplc_if    <- function(x) { mutate_if(x, is.numeric, ~replace(., is.na(.), 0)) }

# data.table   
library(data.table)
DT.for.set.nms   <- function(x) { for (j in names(x))
    set(x,which(is.na(x[[j]])),j,0) }
DT.for.set.sqln  <- function(x) { for (j in seq_len(ncol(x)))
    set(x,which(is.na(x[[j]])),j,0) }
DT.nafill        <- function(x) { nafill(df, fill=0)}
DT.setnafill     <- function(x) { setnafill(df, fill=0)}

El código para este análisis:

library(microbenchmark)
# 20% NA filled dataframe of 10 Million rows and 10 columns
set.seed(42) # to recreate the exact dataframe
dfN <- as.data.frame(matrix(sample(c(NA, as.numeric(1:4)), 1e7*10, replace = TRUE),
                            dimnames = list(NULL, paste0("var", 1:10)), 
                            ncol = 10))
# Running 600 trials with each replacement method 
# (the functions are excecuted locally - so that the original dataframe remains unmodified in all cases)
perf_results <- microbenchmark(
    hybrid.ifelse    = hybrid.ifelse(copy(dfN)),
    dplyr_if_else    = dplyr_if_else(copy(dfN)),
    hybrd.replace_na = hybrd.replace_na(copy(dfN)),
    baseR.sbst.rssgn = baseR.sbst.rssgn(copy(dfN)),
    baseR.replace    = baseR.replace(copy(dfN)),
    dplyr_coalesce   = dplyr_coalesce(copy(dfN)),
    tidyr_replace_na = tidyr_replace_na(copy(dfN)),
    hybrd.replace    = hybrd.replace(copy(dfN)),
    hybrd.rplc_at.ctn= hybrd.rplc_at.ctn(copy(dfN)),
    hybrd.rplc_at.nse= hybrd.rplc_at.nse(copy(dfN)),
    baseR.for        = baseR.for(copy(dfN)),
    hybrd.rplc_at.idx= hybrd.rplc_at.idx(copy(dfN)),
    DT.for.set.nms   = DT.for.set.nms(copy(dfN)),
    DT.for.set.sqln  = DT.for.set.sqln(copy(dfN)),
    times = 600L
)

Resumen de Resultados

> print(perf_results)
Unit: milliseconds
              expr       min        lq     mean   median       uq      max neval
      hybrd.ifelse 6171.0439 6339.7046 6425.221 6407.397 6496.992 7052.851   600
     dplyr_if_else 3737.4954 3877.0983 3953.857 3946.024 4023.301 4539.428   600
  hybrd.replace_na 1497.8653 1706.1119 1748.464 1745.282 1789.804 2127.166   600
  baseR.sbst.rssgn 1480.5098 1686.1581 1730.006 1728.477 1772.951 2010.215   600
     baseR.replace 1457.4016 1681.5583 1725.481 1722.069 1766.916 2089.627   600
    dplyr_coalesce 1227.6150 1483.3520 1524.245 1519.454 1561.488 1996.859   600
  tidyr_replace_na 1248.3292 1473.1707 1521.889 1520.108 1570.382 1995.768   600
     hybrd.replace  913.1865 1197.3133 1233.336 1238.747 1276.141 1438.646   600
 hybrd.rplc_at.ctn  916.9339 1192.9885 1224.733 1227.628 1268.644 1466.085   600
 hybrd.rplc_at.nse  919.0270 1191.0541 1228.749 1228.635 1275.103 2882.040   600
         baseR.for  869.3169 1180.8311 1216.958 1224.407 1264.737 1459.726   600
 hybrd.rplc_at.idx  839.8915 1189.7465 1223.326 1228.329 1266.375 1565.794   600
    DT.for.set.nms  761.6086  915.8166 1015.457 1001.772 1106.315 1363.044   600
   DT.for.set.sqln  787.3535  918.8733 1017.812 1002.042 1122.474 1321.860   600

Diagrama de caja de resultados

ggplot(perf_results, aes(x=expr, y=time/10^9)) +
    geom_boxplot() +
    xlab('Expression') +
    ylab('Elapsed Time (Seconds)') +
    scale_y_continuous(breaks = seq(0,7,1)) +
    coord_flip()

Comparación de diagrama de caja del tiempo transcurrido

Diagrama de dispersión codificado por color de ensayos (con eje y en una escala logarítmica)

qplot(y=time/10^9, data=perf_results, colour=expr) + 
    labs(y = "log10 Scaled Elapsed Time per Trial (secs)", x = "Trial Number") +
    coord_cartesian(ylim = c(0.75, 7.5)) +
    scale_y_log10(breaks=c(0.75, 0.875, 1, 1.25, 1.5, 1.75, seq(2, 7.5)))

Diagrama de dispersión de todos los tiempos de prueba

Una nota sobre los otros artistas de alto rendimiento.

Cuando los conjuntos de datos se hacen más grandes, Tidyr '' s replace_nase habían retirado históricamente hacia el frente. Con la colección actual de 100M puntos de datos para ejecutar, funciona casi exactamente tan bien como una Base R For Loop. Tengo curiosidad por ver qué sucede con los marcos de datos de diferentes tamaños.

Ejemplos adicionales para la mutatee summarize _aty _allvariantes de función se pueden encontrar aquí: https://rdrr.io/cran/dplyr/man/summarise_all.html Además, encontré manifestaciones votos y colecciones de ejemplos aquí: https: //blog.exploratory. io / dplyr-0-5-is-awesome-heres-why-be095fd4eb8a

Atribuciones y apreciaciones

Con especial agradecimiento a:

  • Tyler Rinker y Akrun por demostrar microbenchmark.
  • alexis_laz por trabajar en ayudarme a comprender el uso de local(), y (con la ayuda del paciente de Frank, también) el papel que juega la coerción silenciosa en acelerar muchos de estos enfoques.
  • ArthurYip para que el poke agregue la coalesce()función más nueva y actualice el análisis.
  • Gregor para que el empujón descubra las data.tablefunciones lo suficientemente bien como para finalmente incluirlas en la alineación.
  • Base R para bucle: alexis_laz
  • data.table Para bucles: Matt_Dowle
  • Roman por explicar lo que is.numeric()realmente prueba.

(Por supuesto, comuníquese y deles votos positivos también si considera que esos enfoques son útiles).

Nota sobre mi uso de Numerics: si tiene un conjunto de datos entero puro, todas sus funciones se ejecutarán más rápido. Consulte el trabajo de alexiz_laz para obtener más información. IRL, no recuerdo haber encontrado un conjunto de datos que contiene más del 10-15% de enteros, por lo que estoy ejecutando estas pruebas en marcos de datos totalmente numéricos.

Hardware utilizado CPU de 3.9 GHz con 24 GB de RAM

leerssej
fuente
2
@Frank - Gracias por encontrar esa discrepancia. Todas las referencias se limpian y los resultados se han vuelto a ejecutar por completo en una sola máquina y se han vuelto a publicar.
leerssej
OK gracias. Además, creo que df1[j][is.na(df1[j])] = 0está mal, debería serdf1[[j]][is.na(df1[[j]])] = 0
Frank
Oh, ahora veo que lo has escrito dos veces, de manera diferente en cada punto de referencia. De todos modos, forLp_Sbstno parece ser una forma de que nadie debe tener en cuenta que se acerca vsforLp_smplfSbst
Frank
1
@UweBlock: gran pregunta: me permitió realizar la operación de asignación de subconjuntos a la izquierda con todas las funciones trabajando exactamente en el mismo marco de datos. Como tenía que ajustar el local alrededor de esa función, entonces, en nombre de la ciencia [¡Un trabajo, tenías un trabajo!] Lo envolví en todos ellos para que el campo de juego estuviera inequívocamente nivelado. Para obtener más información, consulte aquí: stackoverflow.com/questions/41604711/... He recortado la respuesta anterior bastante larga, pero esa parte de la discusión sería buena para agregar nuevamente. ¡Gracias!
leerssej
1
@ArthurYip: agregué la coalesce()opción y la volví a ejecutar todas las veces. Gracias por el empujón para actualizar.
leerssej
128

Para un solo vector:

x <- c(1,2,NA,4,5)
x[is.na(x)] <- 0

Para un data.frame, haga una función de lo anterior, luego apply a las columnas.

Proporcione un ejemplo reproducible la próxima vez como se detalla aquí:

¿Cómo hacer un gran ejemplo reproducible de R?

Ari B. Friedman
fuente
18
is.naes una función genérica y tiene métodos para objetos de data.frameclase. así que este también funcionará en data.frames!
aL3xa
3
Cuando corrí methods(is.na)por primera vez, estaba como whaaa?!? . ¡Me encanta cuando suceden cosas así! =)
aL3xa
99
Suponga que tiene un marco de datos llamado df en lugar de un solo vector y solo desea reemplazar las observaciones faltantes en una sola columna llamada X3. Puede hacerlo con esta línea: df $ X3 [is.na (df $ X3)] <- 0
Mark Miller
8
Suponga que solo desea reemplazar NA con 0 en las columnas 4-6 de un marco de datos llamado my.df. Puede usar: my.df [, 4: 6] [is.na (my.df [, 4: 6])] <- 0
Mark Miller el
¿cómo es que pasas 'x' a is.na (x) ¿hay alguna manera de saber qué rutinas de biblioteca en R están vectorizadas?
uh_big_mike_boi
73

Ejemplo de dplyr:

library(dplyr)

df1 <- df1 %>%
    mutate(myCol1 = if_else(is.na(myCol1), 0, myCol1))

Nota: Estos trabajos por columna seleccionada, si tenemos que hacer esto para toda la columna, ver @reidjax 's respuesta usando mutate_each .

ianmunoz
fuente
57

Si intentamos reemplazar NAs al exportar, por ejemplo al escribir en csv, entonces podemos usar:

  write.csv(data, "data.csv", na = "0")
mrsoltys
fuente
47

Sé que la pregunta ya está respondida, pero hacerlo de esta manera podría ser más útil para algunos:

Defina esta función:

na.zero <- function (x) {
    x[is.na(x)] <- 0
    return(x)
}

Ahora, siempre que necesite convertir NA en un vector a cero, puede hacer:

na.zero(some.vector)
krishan404
fuente
22

Con dplyr0.5.0, puede usar la coalescefunción que se puede integrar fácilmente en la %>%tubería haciendo coalesce(vec, 0). Esto reemplaza todos los NA veccon 0:

Digamos que tenemos un marco de datos con NAs:

library(dplyr)
df <- data.frame(v = c(1, 2, 3, NA, 5, 6, 8))

df
#    v
# 1  1
# 2  2
# 3  3
# 4 NA
# 5  5
# 6  6
# 7  8

df %>% mutate(v = coalesce(v, 0))
#   v
# 1 1
# 2 2
# 3 3
# 4 0
# 5 5
# 6 6
# 7 8
Psidom
fuente
Probé coalesce y funciona casi igual que reemplazar. ¡el comando de fusión es el más simple hasta ahora!
Arthur Yip
Sería útil si presentara cómo aplicar eso en todas las columnas de 2+ columnas tibble.
Jangorecki
21

Enfoque más general del uso replace()en matriz o vector para reemplazar NAa0

Por ejemplo:

> x <- c(1,2,NA,NA,1,1)
> x1 <- replace(x,is.na(x),0)
> x1
[1] 1 2 0 0 1 1

Esta es también una alternativa al uso ifelse()endplyr

df = data.frame(col = c(1,2,NA,NA,1,1))
df <- df %>%
   mutate(col = replace(col,is.na(col),0))
Charleslmh
fuente
1
Mi columna fue un factor, así que tuve que agregar mi valor de reemplazolevels(A$x) <- append(levels(A$x), "notAnswered") A$x <- replace(A$x,which(is.na(A$x)),"notAnswered")
Climbs_lika_Spyder
1
whichno es necesario aquí, puedes usarlo x1 <- replace(x,is.na(x),1).
lmo
He intentado muchas formas que se proponen en este hilo para reemplazar NAa 0en sólo una columna específica de una trama de datos grande y esta función replace()trabajado la manera más eficaz a la vez que el más simple.
Duc
19

También es posible de usar tidyr::replace_na.

    library(tidyr)
    df <- df %>% mutate_all(funs(replace_na(.,0)))
Sasha
fuente
9

Otro ejemplo usando el paquete imputeTS :

library(imputeTS)
na.replace(yourDataframe, 0)
stats0007
fuente
9

Si desea reemplazar los NA en las variables de factor, esto podría ser útil:

n <- length(levels(data.vector))+1

data.vector <- as.numeric(data.vector)
data.vector[is.na(data.vector)] <- n
data.vector <- as.factor(data.vector)
levels(data.vector) <- c("level1","level2",...,"leveln", "NAlevel") 

Transforma un vector factorial en un vector numérico y agrega otro nivel de factor numérico artificial, que luego se transforma de nuevo en un vector factorial con un "nivel NA" adicional de su elección.

usuario6075957
fuente
8

Hubiera comentado en la publicación de @ ianmunoz pero no tengo suficiente reputación. Se pueden combinar dplyr's mutate_eachy replacecuidar de la NAde 0reemplazo. Usando el marco de datos de la respuesta de @ aL3xa ...

> m <- matrix(sample(c(NA, 1:10), 100, replace = TRUE), 10)
> d <- as.data.frame(m)
> d

    V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
1   4  8  1  9  6  9 NA  8  9   8
2   8  3  6  8  2  1 NA NA  6   3
3   6  6  3 NA  2 NA NA  5  7   7
4  10  6  1  1  7  9  1 10  3  10
5  10  6  7 10 10  3  2  5  4   6
6   2  4  1  5  7 NA NA  8  4   4
7   7  2  3  1  4 10 NA  8  7   7
8   9  5  8 10  5  3  5  8  3   2
9   9  1  8  7  6  5 NA NA  6   7
10  6 10  8  7  1  1  2  2  5   7

> d %>% mutate_each( funs_( interp( ~replace(., is.na(.),0) ) ) )

    V1 V2 V3 V4 V5 V6 V7 V8 V9 V10
1   4  8  1  9  6  9  0  8  9   8
2   8  3  6  8  2  1  0  0  6   3
3   6  6  3  0  2  0  0  5  7   7
4  10  6  1  1  7  9  1 10  3  10
5  10  6  7 10 10  3  2  5  4   6
6   2  4  1  5  7  0  0  8  4   4
7   7  2  3  1  4 10  0  8  7   7
8   9  5  8 10  5  3  5  8  3   2
9   9  1  8  7  6  5  0  0  6   7
10  6 10  8  7  1  1  2  2  5   7

Aquí estamos utilizando la evaluación estándar (SE), por lo que necesitamos el guión bajo en " funs_." También usamos lazyeval's interp/ ~y las .referencias "todo con lo que estamos trabajando", es decir, el marco de datos. ¡Ahora hay ceros!

reidjax
fuente
4

Puedes usar replace()

Por ejemplo:

> x <- c(-1,0,1,0,NA,0,1,1)
> x1 <- replace(x,5,1)
> x1
[1] -1  0  1  0  1  0  1  1

> x1 <- replace(x,5,mean(x,na.rm=T))
> x1
[1] -1.00  0.00  1.00  0.00  0.29  0.00 1.00  1.00
Zahra
fuente
66
Es cierto, pero solo práctico cuando conoce el índice de NAs en su vector. Está bien para vectores pequeños como en su ejemplo.
dardisco
44
@dardisco x1 <- replace(x,is.na(x),1)funcionará sin enumerar explícitamente los valores del índice.
lmo
4

Otra dplyropción compatible con tubería con tidyrmétodo replace_naque funciona para varias columnas:

require(dplyr)
require(tidyr)

m <- matrix(sample(c(NA, 1:10), 100, replace = TRUE), 10)
d <- as.data.frame(m)

myList <- setNames(lapply(vector("list", ncol(d)), function(x) x <- 0), names(d))

df <- d %>% replace_na(myList)

Puede restringir fácilmente, por ejemplo, a las columnas numéricas:

d$str <- c("string", NA)

myList <- myList[sapply(d, is.numeric)]

df <- d %>% replace_na(myList)
Antti
fuente
4

La función dedicada ( nafill/ setnafill) para ese propósito está en la data.tableversión reciente

install.packages("data.table", repos="https://Rdatatable.gitlab.io/data.table")
library(data.table)
ans_df = nafill(df, fill=0)
setnafill(df, fill=0) # this one updates in-place
jangorecki
fuente
Para aquellos que están votando negativamente, por favor envíe sus comentarios para que mi respuesta pueda ser mejorada.
Jangorecki
3

Esta simple función extraída de Datacamp podría ayudar:

replace_missings <- function(x, replacement) {
  is_miss <- is.na(x)
  x[is_miss] <- replacement

  message(sum(is_miss), " missings replaced by the value ", replacement)
  x
}

Entonces

replace_missings(df, replacement = 0)
Fábio
fuente
3

Una manera fácil de escribirlo es if_nadesde hablar:

library(dplyr)
library(hablar)

df <- tibble(a = c(1, 2, 3, NA, 5, 6, 8))

df %>% 
  mutate(a = if_na(a, 0))

que devuelve:

      a
  <dbl>
1     1
2     2
3     3
4     0
5     5
6     6
7     8
davsjob
fuente
2

Para reemplazar todas las NA en un marco de datos, puede usar:

df %>% replace(is.na(.), 0)

Oliver Oliver
fuente
esta no es una solución nueva
jogo
1

si desea asignar un nuevo nombre después de cambiar los NA en una columna específica en este caso la columna V3, use también puede hacer esto

my.data.frame$the.new.column.name <- ifelse(is.na(my.data.frame$V3),0,1)
Seyma Kalay
fuente