valores - replace na with 0 in r

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

Question

Tengo un marco de datos y algunas columnas tienen valores de NA .

¿Cómo puedo reemplazar estos valores de NA con ceros?

Answer 1

Con dplyr 0.5.0, puede usar la función coalesce que puede integrarse fácilmente en %>% pipeline haciendo coalesce(vec, 0) . Esto reemplaza todas las NA en vec con 0:

Digamos que tenemos un marco de datos con NA s:

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

Answer 2

Enfoque más general del uso de replace() en matriz o vector para reemplazar NA a 0

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 de ifelse() en dplyr

df = data.frame(col = c(1,2,NA,NA,1,1))
df <- df %>%
mutate(col = replace(col,is.na(col),0))

Answer 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)

Answer 4

Hubiera comentado en la publicación de @ianmunoz pero no tengo suficiente reputación. Puede combinar dplyr y replace mutate_each para ocuparse del replace de NA a 0 . 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

Estamos utilizando la evaluación estándar (SE) aquí, por lo que necesitamos el guión bajo en " funs_ ". También usamos el interp / ~ interp y el . hace referencia a "todo con lo que estamos trabajando", es decir, el marco de datos. Ahora hay ceros!

Answer 5

La opción híbrida dplyr / Base R : mutate_all(funs(replace(., is.na(.), 0)))) es más del doble de rápida que la base R d[is.na(d)] <- 0 opción. (Consulte los análisis de referencia a continuación.)

Si tiene dificultades con los marcos de datos masivos, data.table es la opción más rápida de todas: un 30% menos que dplyr y 3 veces más rápido de lo que se aproxima a la Base R. También modifica los datos en su lugar, lo que le permite trabajar con casi el doble de datos a la vez.

Un agrupamiento de otros enfoques útiles de reemplazo tidyverse

Ubicación:

• index mutate_at(c(5:10), funs(replace(., is.na(.), 0)))
• referencia directa mutate_at(vars(var5:var10), funs(replace(., is.na(.), 0)))
• coincidencia fija mutate_at(vars(contains("1")), funs(replace(., is.na(.), 0)))
  • o en lugar de contains() , pruebe ends_with() , starts_with()
• patrón coincidencia mutate_at(vars(matches("//d{2}")), funs(replace(., is.na(.), 0)))

Condicionalmente
(cambie solo numérico (columnas) y deje la cadena (columnas) solo).

• enteros mutate_if(is.integer, funs(replace(., is.na(.), 0)))
• duplica mutate_if(is.numeric, funs(replace(., is.na(.), 0)))
• cadenas mutate_if(is.character, funs(replace(., is.na(.), 0)))

El análisis completo -

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
library(tidyverse)
dplyr_if_else <- function(x) { mutate_all(x, funs(if_else(is.na(.), 0, .))) }
dplyr_coalesce <- function(x) { mutate_all(x, funs(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, funs(ifelse(is.na(.), 0, .))) }
hybrd.rplc_all <- function(x) { mutate_all(x, funs(replace(., is.na(.), 0))) }
hybrd.rplc_at.idx<- function(x) { mutate_at(x, c(1:10), funs(replace(., is.na(.), 0))) }
hybrd.rplc_at.nse<- function(x) { mutate_at(x, vars(var1:var10), funs(replace(., is.na(.), 0))) }
hybrd.rplc_at.stw<- function(x) { mutate_at(x, vars(starts_with("var")), funs(replace(., is.na(.), 0))) }
hybrd.rplc_at.ctn<- function(x) { mutate_at(x, vars(contains("var")), funs(replace(., is.na(.), 0))) }
hybrd.rplc_at.mtc<- function(x) { mutate_at(x, vars(matches("//d+")), funs(replace(., is.na(.), 0))) }
hybrd.rplc_if <- function(x) { mutate_if(x, is.numeric, funs(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) }

El código para este análisis:

library(microbenchmark)
# 20% NA filled dataframe of 5 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)), 5e6*10, replace = TRUE),
dimnames = list(NULL, paste0("var", 1:10)),
ncol = 10))
# Running 250 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)),
baseR.sbst.rssgn = baseR.sbst.rssgn(copy(dfN)),
baseR.replace = baseR.replace(copy(dfN)),
dplyr_coalesce = dplyr_coalesce(copy(dfN)),
hybrd.rplc_at.nse= hybrd.rplc_at.nse(copy(dfN)),
hybrd.rplc_at.stw= hybrd.rplc_at.stw(copy(dfN)),
hybrd.rplc_at.ctn= hybrd.rplc_at.ctn(copy(dfN)),
hybrd.rplc_at.mtc= hybrd.rplc_at.mtc(copy(dfN)),
hybrd.rplc_at.idx= hybrd.rplc_at.idx(copy(dfN)),
hybrd.rplc_if = hybrd.rplc_if(copy(dfN)),
tidyr_replace_na = tidyr_replace_na(copy(dfN)),
baseR.for = baseR.for(copy(dfN)),
DT.for.set.nms = DT.for.set.nms(copy(dfN)),
DT.for.set.sqln = DT.for.set.sqln(copy(dfN)),
times = 250L
)

Resumen de Resultados

> perf_results
Unit: milliseconds
expr min lq mean median uq max neval
hybrid.ifelse 5250.5259 5620.8650 5809.1808 5759.3997 5947.7942 6732.791 250
dplyr_if_else 3209.7406 3518.0314 3653.0317 3620.2955 3746.0293 4390.888 250
baseR.sbst.rssgn 1611.9227 1878.7401 1964.6385 1942.8873 2031.5681 2485.843 250
baseR.replace 1559.1494 1874.7377 1946.2971 1920.8077 2002.4825 2516.525 250
dplyr_coalesce 949.7511 1231.5150 1279.3015 1288.3425 1345.8662 1624.186 250
hybrd.rplc_at.nse 735.9949 871.1693 1016.5910 1064.5761 1104.9590 1361.868 250
hybrd.rplc_at.stw 704.4045 887.4796 1017.9110 1063.8001 1106.7748 1338.557 250
hybrd.rplc_at.ctn 723.9838 878.6088 1017.9983 1063.0406 1110.0857 1296.024 250
hybrd.rplc_at.mtc 686.2045 885.8028 1013.8293 1061.2727 1105.7117 1269.949 250
hybrd.rplc_at.idx 696.3159 880.7800 1003.6186 1038.8271 1083.1932 1309.635 250
hybrd.rplc_if 705.9907 889.7381 1000.0113 1036.3963 1083.3728 1338.190 250
tidyr_replace_na 680.4478 973.1395 978.2678 1003.9797 1051.2624 1294.376 250
baseR.for 670.7897 965.6312 983.5775 1001.5229 1052.5946 1206.023 250
DT.for.set.nms 496.8031 569.7471 695.4339 623.1086 861.1918 1067.640 250
DT.for.set.sqln 500.9945 567.2522 671.4158 623.1454 764.9744 1033.463 250

Diagrama de caja de resultados (en una escala de registro)

# adjust the margins to prepare for better boxplot printing
par(mar=c(8,5,1,1) + 0.1)
# generate boxplot
boxplot(opN, las = 2, xlab = "", ylab = "log(time)[milliseconds]")

Diagrama de dispersión codificado por colores de ensayos (en una escala de registro)

qplot(y=time/10^9, data=opN, colour=expr) +
labs(y = "log10 Scaled Elapsed Time per Trial (secs)", x = "Trial Number") +
scale_y_log10(breaks=c(1, 2, 4))

Una nota sobre los otros artistas de alto rendimiento.

Cuando los conjuntos de datos se hacen más grandes, el reemplazo de Tidyr ''históricamente se había retirado al frente. Con la colección actual de 50M puntos de datos para ejecutar, se desempeña casi exactamente igual que la Base R For Loop. Tengo curiosidad por ver qué sucede con los marcos de datos de diferentes tamaños.

_all se pueden encontrar ejemplos adicionales para las variantes de función mutate y summarize _at y _all : https://rdrr.io/cran/dplyr/man/summarise_all.html Además, encontré demostraciones y colecciones de ejemplos útiles aquí: https://blog.exploratory.io/dplyr-0-5-is-awesome-heres-why-be095fd4eb8a

Atribuciones y apreciaciones

Con un agradecimiento especial a:

• Tyler Rinker y Akrun por demostrar microbenchmark.
• alexis_laz por trabajar para ayudarme a entender el uso de local() y (con la ayuda del paciente de Frank también) el papel que desempeña la coacción silenciosa en la aceleración de muchos de estos enfoques.
• ArthurYip para el empuje para agregar la nueva función coalesce() y actualizar el análisis.
• Gregor por el empujón para averiguar la data.table funciona lo suficientemente bien como para incluirlos finalmente en la alineación.
• Base R Para loop: alexis_laz
• data.table For Loops: Matt_Dowle

(Por supuesto, acércate y dales el voto positivo, también si encuentras útiles esos enfoques).

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

Answer 6

Otra opción compatible con dplyr pipe con el método replace_na que 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 columnas numéricas:

d$str <- c("string", NA)
myList <- myList[sapply(d, is.numeric)]
df <- d %>% replace_na(myList)

Answer 7

Otro ejemplo usando el paquete imputeTS :

library(imputeTS)
na.replace(yourDataframe, 0)

Answer 8

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?

Answer 9

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

Answer 10

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

Define esta función:

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

Ahora, cuando necesites convertir NA en un vector a cero, puedes hacer:

na.zero(some.vector)

Answer 11

Si desea reemplazar NA en 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 nuevamente en un vector factorial con un "nivel de NA" adicional de su elección.

Answer 12

Si intentamos reemplazar los NA al exportar, por ejemplo, al escribir en csv, podemos usar:

 write.csv(data, "data.csv", na = "0")

Answer 13

Ver mi comentario en @ gsk3 respuesta. Un ejemplo simple:

> 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 apply . =)

EDITAR

También deberías echarle un vistazo al paquete norm . Tiene muchas características interesantes para el análisis de datos faltantes. =)

Answer 14

ejemplo dplyr

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

Nota: Esto funciona para cada columna seleccionada, si necesitamos hacer esto para todas las columnas, vea la respuesta de mutate_each usando mutate_each .