Szybko stapiane operacje na tabelach danych

Question

Poszukuję wzorów do manipulowania obiektami data.table, których struktura przypomina strukturę ramek danych utworzonych za pomocą melt z pakietu reshape2. Mam do czynienia z tabelami danych z milionami wierszy. Wydajność ma kluczowe znaczenie.

Uogólnioną formą pytania jest pytanie, czy istnieje sposób przeprowadzania grupowania w oparciu o podzbiór wartości w kolumnie i czy wynik operacji grupowania tworzy jedną lub więcej nowych kolumn.

Specyficzną formą pytanie może być, jak korzystać data.table osiągnąć równowartość co dcast działa w następujących przypadkach:

input <- data.table(
    id=c(1, 1, 1, 2, 2, 2, 3, 3, 3, 3), 
    variable=c('x', 'y', 'y', 'x', 'y', 'y', 'x', 'x', 'y', 'other'), 
    value=c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) 
dcast(input, 
    id ~ variable, sum, 
    subset=.(variable %in% c('x', 'y'))) 

którego wyjście jest

id x y 
1 1 1 5 
2 2 4 11 
3 3 15 9 

Answer 1

Szybka odpowiedź niesprawdzone: Wygląda szukasz by-bez-by, aka grouping- by-i:

setkey(input,variable) 
input[c("x","y"),sum(value)] 

To jest jak szybki HAVING w SQL. j jest oceniany dla każdego wiersza i. Innymi słowy, powyżej jest taki sam wynik, ale o wiele szybciej niż:

input[,sum(value),keyby=variable][c("x","y")] 

Ten ostatni podzbiorów i evals dla wszystkich grup (rozrzutnie) Przed wybraniem tylko grupy interesów. Ten pierwszy (przez-bez-przez) przechodzi bezpośrednio do podzbioru grup.

Wyniki grupy zostaną zwrócone w długim formacie, jak zawsze. Ale później przekształcenie na szeroką skalę (relatywnie małych) zagregowanych danych powinno być względnie natychmiastowe. I tak myślę.

Pierwszy setkey(input,variable) może odgryźć, jeśli input ma dużo niepotrzebnych kolumn. Jeśli tak, to być może warto podzbioru kolumn potrzebne:

DT = setkey(input[,c("variable","value"),with=FALSE], variable) 
DT[c("x","y"),sum(value)] 

W przyszłości, gdy klucze wtórne są realizowane że byłoby łatwiejsze:

set2key(input,variable)    # add a secondary key 
input[c("x","y"),sum(value),key=2] # syntax speculative 

Do grupy przez id także:

setkey(input,variable) 
input[c("x","y"),sum(value),by='variable,id'] 

i tym razem id w kluczu może być warta setkey w zależności od twoich danych:

setkey(input,variable,id) 
input[c("x","y"),sum(value),by='variable,id'] 

Jeśli połączysz opcję "by-without-by" z "by-by-by", jak wyżej, to by-without-by działa tak jak podzbiór; to znaczy, j jest uruchamiany tylko dla każdego wiersza z i, gdy go brakuje (stąd nazwa by-without-by). Musisz więc ponownie dodać variable w by, jak pokazano powyżej.

Alternatywnie, następujące powinny grupa przez id nad jednością „X” i „Y” zamiast (ale wyżej jest o co prosiliście w pytaniu, IIUC):

input[c("x","y"),sum(value),by=id] 

Answer 2

> setkey(input, "id") 
> input[ , list(sum(value)), by=id] 
    id V1 
1: 1 6 
2: 2 15 
3: 3 34 

> input[ variable %in% c("x", "y"), list(sum(value)), by=id] 
    id V1 
1: 1 6 
2: 2 15 
3: 3 24 

Ostatni:

> input[ variable %in% c("x", "y"), list(sum(value)), by=list(id, variable)] 
    id variable V1 
1: 1  x 1 
2: 1  y 5 
3: 2  x 4 
4: 2  y 11 
5: 3  x 15 
6: 3  y 9 

Answer 3

Nie jestem pewien, czy jest to najlepszy sposób, ale można spróbować:

input[, list(x = sum(value[variable == "x"]), 
      y = sum(value[variable == "y"])), by = "id"] 
# id x y 
# 1: 1 1 5 
# 2: 2 4 11 
# 3: 3 15 9