Wypełnianie brakujących dat w zgrupowanych szeregach czasowych - sposób tidyverse?

Question

Otrzymano obiekt data.frame zawierający szereg czasowy i jedno lub kilka pól grupujących. Mamy więc kilka szeregów czasowych - po jednej dla każdej kombinacji grupowania. Ale niektórych dat brakuje. A więc, co jest najłatwiejsze (w sensie najbardziej "tidyverse") dodawania tych dat z odpowiednimi wartościami grupowania?

Normalnie powiedziałbym, że generuję data.frame ze wszystkimi datami i wykonuję full_join z moją serią czasu. Ale teraz musimy to zrobić dla każdej kombinacji wartości grupowania - i wypełnić wartości grupowania.

Spójrzmy na przykład:

Najpierw tworzę data.frame z brakujących wartości:

library(dplyr) 
library(lubridate) 

set.seed(1234) 
# Time series should run vom 2017-01-01 til 2017-01-10 
date <- data.frame(date = seq.Date(from=ymd("2017-01-01"), to=ymd("2017-01-10"), by="days"), v = 1) 
# Two grouping dimensions 
d1 <- data.frame(d1 = c("A", "B", "C", "D"), v = 1) 
d2 <- data.frame(d2 = c(1, 2, 3, 4, 5), v = 1) 

# Generate the data.frame 
df <- full_join(date, full_join(d1, d2)) %>% 
    select(date, d1, d2) 
# and ad to value columns 
df$v1 <- runif(200) 
df$v2 <- runif(200) 

# group by the dimension columns 
df <- df %>% 
    group_by(d1, d2) 

# create missing dates 
df.missing <- df %>% 
    filter(v1 <= 0.8) 

# So now 2017-01-01 and 2017-01-10, A, 5 are missing now 
df.missing %>% 
    filter(d1 == "A" & d2 == 5) 

# A tibble: 8 x 5 
# Groups: d1, d2 [1] 
     date  d1 d2   v1  v2 
     <date> <fctr> <dbl>  <dbl>  <dbl> 
1 2017-01-02  A  5 0.21879954 0.1335497 
2 2017-01-03  A  5 0.32977018 0.9802127 
3 2017-01-04  A  5 0.23902573 0.1206089 
4 2017-01-05  A  5 0.19617465 0.7378315 
5 2017-01-06  A  5 0.13373890 0.9493668 
6 2017-01-07  A  5 0.48613541 0.3392834 
7 2017-01-08  A  5 0.35698708 0.3696965 
8 2017-01-09  A  5 0.08498474 0.8354756 

Tak aby dodać brakujące daty wygenerować data.frame ze wszystkimi datami:

start <- min(df.missing$date) 
end <- max(df.missing$date) 

all.dates <- data.frame(date=seq.Date(start, end, by="day")) 

Nie chcę zrobić coś podobnego (pamiętaj: df.missing jest group_by (d1, d2))

df.missing %>% 
    do(my_join()) 

Warto więc zdefiniować my_join():

my_join <- function(data) { 
    # get value of both dimensions 
    d1.set <- data$d1[[1]] 
    d2.set <- data$d2[[1]] 

    tmp <- full_join(data, all.dates) %>% 
    # First we need to ungroup. Otherwise we can't change d1 and d2 because they are grouping variables 
    ungroup() %>% 
    mutate(
     d1 = d1.set, 
     d2 = d2.set 
    ) %>% 
    group_by(d1, d2) 

    return(tmp) 
} 

Teraz możemy nazwać my_join() dla każdej kombinacji i spojrzeć na "A/5"

df.missing %>% 
    do(my_join(.)) %>% 
    filter(d1 == "A" & d2 == 5) 

# A tibble: 10 x 5 
# Groups: d1, d2 [1] 
     date  d1 d2   v1  v2 
     <date> <fctr> <dbl>  <dbl>  <dbl> 
1 2017-01-02  A  5 0.21879954 0.1335497 
2 2017-01-03  A  5 0.32977018 0.9802127 
3 2017-01-04  A  5 0.23902573 0.1206089 
4 2017-01-05  A  5 0.19617465 0.7378315 
5 2017-01-06  A  5 0.13373890 0.9493668 
6 2017-01-07  A  5 0.48613541 0.3392834 
7 2017-01-08  A  5 0.35698708 0.3696965 
8 2017-01-09  A  5 0.08498474 0.8354756 
9 2017-01-01  A  5   NA  NA 
10 2017-01-10  A  5   NA  NA 

Great! Tego właśnie szukaliśmy. Ale my my musimy zdefiniować d1 i d2 w my_join i to wydaje się trochę niezgrabne.

Czy istnieje jakieś tidyverse-way tego rozwiązania?

PS: Mam umieścić kod na GIST: https://gist.github.com/JerryWho/1bf919ef73792569eb38f6462c6d7a8e

Answer 1

tidyr ma kilka świetnych narzędzi do tego rodzaju problemów. Spójrz na complete.

library(dplyr) 
library(tidyr) 
library(lubridate) 

want <- df.missing %>% 
    ungroup() %>% 
    complete(nesting(d1, d2), date = seq(min(date), max(date), by = "day")) 

want %>% filter(d1 == "A" & d2 == 5) 

#> # A tibble: 10 x 5 
#> # Groups: d1 [1] 
#>  d1 d2  date   v1  v2 
#> <fctr> <dbl>  <date>  <dbl>  <dbl> 
#> 1  A  5 2017-01-01   NA  NA 
#> 2  A  5 2017-01-02 0.21879954 0.1335497 
#> 3  A  5 2017-01-03 0.32977018 0.9802127 
#> 4  A  5 2017-01-04 0.23902573 0.1206089 
#> 5  A  5 2017-01-05 0.19617465 0.7378315 
#> 6  A  5 2017-01-06 0.13373890 0.9493668 
#> 7  A  5 2017-01-07 0.48613541 0.3392834 
#> 8  A  5 2017-01-08 0.35698708 0.3696965 
#> 9  A  5 2017-01-09 0.08498474 0.8354756 
#> 10  A  5 2017-01-10   NA  NA 

Answer 2

Oto tidyverse sposób zaczynając df.missing

library(tidyverse) 
ans <- df.missing %>% 
      nest(date) %>% 
      mutate(data = map(data, ~seq.Date(start, end, by="day"))) %>% 
      unnest(data) %>% 
      rename(date = data) %>% 
      left_join(., df.missing, by=c("date","d1","d2")) 

ans %>% filter(d1 == "A" & d2 == 5) 

Output

 d1 d2  date   v1  v2 
    <fctr> <dbl>  <date>  <dbl>  <dbl> 
1  A  5 2017-01-01   NA  NA 
2  A  5 2017-01-02 0.21879954 0.1335497 
3  A  5 2017-01-03 0.32977018 0.9802127 
4  A  5 2017-01-04 0.23902573 0.1206089 
5  A  5 2017-01-05 0.19617465 0.7378315 
6  A  5 2017-01-06 0.13373890 0.9493668 
7  A  5 2017-01-07 0.48613541 0.3392834 
8  A  5 2017-01-08 0.35698708 0.3696965 
9  A  5 2017-01-09 0.08498474 0.8354756 
10  A  5 2017-01-10   NA  NA 

------ -------------------------------------------------- -----------------------------------------
Oto alternatywne podejście, które wykorzystuje expand.grid i dplyr czasowniki

with(df.missing, expand.grid(unique(date), unique(d1), unique(d2))) %>% 
    setNames(c("date", "d1", "d2")) %>% 
    left_join(., df.missing, by=c("date","d1","d2")) 

wyjściowych (głowa)

  date d1 d2   v1   v2 
1 2017-01-01 A 1 0.113703411 0.660754634 
2 2017-01-02 A 1 0.316612455 0.422330675 
3 2017-01-03 A 1 0.553333591 0.424109178 
4 2017-01-04 A 1   NA   NA 
5 2017-01-05 A 1   NA   NA 
6 2017-01-06 A 1 0.035456727 0.352998502 

Answer 3

Tutaj read.zoo tworzy szeroką obiekt forma zoo i że łączymy daty. Następnie przekształcamy ją z powrotem w długą ramkę danych przy użyciu fortify.zoo i rozkręcamy i v2 przy użyciu spread.

zauważyć, że:

• jeśli możemy założyć, że każda data pojawia się w co najmniej jednej kombinacji zmiennych dzielonych, czyli sort(unique(df.missing$date)) zawiera wszystkie daty, a następnie mogliśmy pominąć linię merge i nie dołącza byłoby w ogóle trzeba to zrobić. Wyniki badań df.missing pokazano na pytanie ma tę właściwość:

  all(all.dates$date %in% df.missing$date) 
  ## [1] TRUE 
  

• może się zatrzymać po merge (lub po read.zoo jeśli każda data jest obecny co najmniej jeden raz, jak we wcześniejszym punkcie) jeśli obiekt o szerokości formy zoo może być używany, ponieważ ma już wszystkie daty.

W kodzie poniżej linii oznaczonej ### może być pominięte z wersji rozwojowej Zoo (1.8.1):

library(dplyr) 
library(tidyr) 
library(zoo) 

split.vars <- c("d1", "d2") 
df.missing %>% 
    as.data.frame %>%  ### 
    read.zoo(split = split.vars) %>% 
    merge(zoo(, seq(start(.), end(.), "day"))) %>% 
    fortify.zoo(melt = TRUE) %>% 
    separate(Series, c("v", split.vars)) %>% 
    spread(v, Value) 

Aktualizacja: Uwaga uproszczenie w zoo 1.8.1 .