filas - filtrar datos en r

Idioma apropiado para agregar filas de cero en tidyr/dplyr

Question

Supongamos que tengo algunos datos de recuento que se parecen a esto:

library(tidyr)
library(dplyr)

X.raw <- data.frame(
    x = as.factor(c("A", "A", "A", "B", "B", "B")),
    y = as.factor(c("i", "ii", "ii", "i", "i", "i")),
    z = 1:6)
X.raw
#   x  y z
# 1 A  i 1
# 2 A ii 2
# 3 A ii 3
# 4 B  i 4
# 5 B  i 5
# 6 B  i 6

Me gustaría ordenar y resumir así:

X.tidy <- X.raw %>% group_by(x,y) %>% summarise(count=sum(z))
X.tidy
# Source: local data frame [3 x 3]
# Groups: x
#
#   x  y count
# 1 A  i     1
# 2 A ii     5
# 3 B  i    15

Sé que para x=="B" y y=="ii" hemos observado un conteo de cero, en lugar de un valor perdido. es decir, el trabajador de campo estaba realmente allí, pero como no había un recuento positivo, no se ingresó ninguna fila en los datos sin procesar. Puedo agregar explícitamente el conteo de cero haciendo esto:

X.fill <- X.tidy %>% spread(y, count, fill=0) %>% gather(y, count, -x)
X.fill
# Source: local data frame [4 x 3]
# 
#   x  y count
# 1 A  i     1
# 2 B  i    15
# 3 A ii     5
# 4 B ii     0

Pero eso parece una forma un tanto indirecta de hacer las cosas. ¿Es un lenguaje más limpio para esto?

Solo para aclarar: mi código ya hace lo que necesito que haga, usar spread luego gather , así que lo que me interesa es encontrar una ruta más directa dentro de tidyr y dplyr .

Answer 1

La función complete de tidyr está hecha solo para esta situación.

De la documentación:

Esta es una envoltura alrededor de expand (), left_join () y replace_na que es útil para completar combinaciones de datos faltantes.

Podrías usarlo de dos maneras. Primero, puede usarlo en el conjunto de datos original antes de resumir, "completar" el conjunto de datos con todas las combinaciones de x e y , y llenar z con 0 (puede usar el fill NA predeterminado y usar na.rm = TRUE en la sum ).

X.raw %>% 
    complete(x, y, fill = list(z = 0)) %>% 
    group_by(x,y) %>% 
    summarise(count = sum(z))

Source: local data frame [4 x 3]
Groups: x [?]

       x      y count
  <fctr> <fctr> <dbl>
1      A      i     1
2      A     ii     5
3      B      i    15
4      B     ii     0

También puede utilizar complete en su conjunto de datos pre-resumido. Ten en cuenta que complete agrupación de respetos. X.tidy está agrupado, por lo que puede ungroup y completar el conjunto de datos x e y o simplemente listar la variable que desea completar dentro de cada grupo, en este caso, y .

# Complete after ungrouping
X.tidy %>% 
    ungroup %>%
    complete(x, y, fill = list(count = 0))

# Complete within grouping
X.tidy %>% 
    complete(y, fill = list(count = 0))

El resultado es el mismo para cada opción:

Source: local data frame [4 x 3]

       x      y count
  <fctr> <fctr> <dbl>
1      A      i     1
2      A     ii     5
3      B      i    15
4      B     ii     0

Answer 2

Podrías hacer explícitamente todas las combinaciones posibles y luego unirlas con el resumen ordenado:

x.fill <- expand.grid(x=unique(x.tidy$x), x=unique(x.tidy$y)) %>%
    left_join(x.tidy, by=("x", "y")) %>%
    mutate(count = ifelse(is.na(count), 0, count)) # replace null values with 0''s

Answer 3

Puede usar la expand de tidyr para hacer todas las combinaciones de niveles de factores, y luego left_join :

X.tidy %>% expand(x, y) %>% left_join(X.tidy)

# Joining by: c("x", "y")
# Source: local data frame [4 x 3]
# 
#   x  y count
# 1 A  i     1
# 2 A ii     5
# 3 B  i    15
# 4 B ii    NA

Luego puede mantener los valores como NA o reemplazarlos por 0 o cualquier otro valor. De esa manera, tampoco es una solución completa al problema, pero es más rápido y más compatible con la memoria RAM que la spread y la gather .

Answer 4

plyr tiene la funcionalidad que está buscando, pero dplyr no (todavía), por lo que necesita un código adicional para incluir los grupos de cero, como lo muestra @momeara. También vea esta pregunta . En plyr::ddply simplemente agregas .drop=FALSE para mantener los grupos de cero en el resultado final. Por ejemplo:

library(plyr)

X.tidy = ddply(X.raw, .(x,y), summarise, count=sum(z), .drop=FALSE)

X.tidy
  x  y count
1 A  i     1
2 A ii     5
3 B  i    15
4 B ii     0