Biorąc pod uwagę dowolną listę nazw kolumn w data.table, chcę połączyć zawartość tych kolumn w pojedynczy łańcuch przechowywany w nowej kolumnie. Kolumny, które muszę konkatenować, nie zawsze są takie same, więc muszę wygenerować wyrażenie, aby to zrobić w locie.

Mam podejrzenie, że w ten sposób używam eval(parse(...)) wywołanie może zostać zastąpione czymś nieco bardziej eleganckim, ale metoda poniżej jest najszybsza, jaką udało mi się uzyskać do tej pory.

Z 10 milion wierszy, to trwa około 21.7 sekund na tej przykładowej danych (Baza R paste0 trwa nieco dłużej -- 23.6 sekund) . Moje rzeczywiste dane mają 18-20 kolumn konkatenowanych i do 100 milionów wierszy, więc spowolnienie staje się trochę bardziej niepraktyczne.

Jakieś pomysły, żeby to przyspieszyć?

Obecne metody

library(data.table)
library(stringi)

RowCount <- 1e7
DT <- data.table(x = "foo",
                 y = "bar",
                 a = sample.int(9, RowCount, TRUE),
                 b = sample.int(9, RowCount, TRUE),
                 c = sample.int(9, RowCount, TRUE),
                 d = sample.int(9, RowCount, TRUE),
                 e = sample.int(9, RowCount, TRUE),
                 f = sample.int(9, RowCount, TRUE))

## Generate an expression to paste an arbitrary list of columns together
ConcatCols <- c("x","a","b","c","d","e","f","y")
PasteStatement <- stri_c('stri_c(',stri_c(ConcatCols,collapse = ","),')')
print(PasteStatement)

Daje

[1] "stri_c(x,a,b,c,d,e,f,y)"

Który jest następnie używany do łączenia kolumn z następującymi wyrażenie:

DT[,State := eval(parse(text = PasteStatement))]

Próbka wyjścia:

     x   y a b c d e f        State
1: foo bar 4 8 3 6 9 2 foo483692bar
2: foo bar 8 4 8 7 8 4 foo848784bar
3: foo bar 2 6 2 4 3 5 foo262435bar
4: foo bar 2 4 2 4 9 9 foo242499bar
5: foo bar 5 9 8 7 2 7 foo598727bar

Wyniki Profilowania

Update 1: fread, fwrite, oraz sed

Podążając za sugestią @ Gregor, spróbowałem użyć sed, aby wykonać konkatenację na dysku. Dzięki data.table ' s blazing fast fread and fwrite functions, byłem w stanie wypisać kolumny na dysk, wyeliminować przecinki za pomocą sed ,a następnie odczytać z powrotem w post-przetworzonym wyjściu w o 18.3 sekund -- nie dość szybko, aby dokonać przełącznika, ale ciekawe tangent mimo wszystko!

ConcatCols <- c("x","a","b","c","d","e","f","y")
fwrite(DT[,..ConcatCols],"/home/xxx/DT.csv")
system("sed 's/,//g' /home/xxx/DT.csv > /home/xxx/DT_Post.csv ")
Post <- fread("/home/xxx/DT_Post.csv")
DT[,State := Post[[1]]]

• data.table::fwrite() - 0.5 sekundy
• sed - 14,8 sekundy
• data.table::fread() - 3.0 sekundy
• := - 0.0 sekundy

Jeśli nic innego, jest to świadectwo rozległej pracy danych.autorzy tabeli na optymalizacja wydajności dysków IO. (Używam wersji rozwojowej 1.10.5, która dodaje wielowątkowość do fread, fwrite jest wielowątkowy od jakiegoś czasu).

Jedno zastrzeżenie: jeśli istnieje obejście zapisu pliku za pomocą fwrite i pustego separatora, zgodnie z sugestią @Gregor w innym komentarzu poniżej, to ta metoda może być prawdopodobnie skrócona do ~3,5 sekundy!

Aktualizacja tej stycznej: rozwidlone dane.tabela i skomentował linię wymagającą separator większy niż długość 0, zamiast tego masz jakieś spacje? Po spowodowaniu kilku segfaultów próbujących zadzierać z wewnętrznymi C, umieściłem ten na razie w lodzie. Idealne rozwiÄ ... zanie nie wymagaĹ 'oby zapisu na dysk i zachowaĹ' oby wszystko w pamiÄ ™ ci.

Update 2: sprintf for Integer Specific Cases

Druga aktualizacja tutaj: podczas gdy dodałem ciągi w moim oryginalnym przykładzie użycia, mój rzeczywisty przypadek użycia łączy wyłącznie liczbę całkowitą wartości (które zawsze można przyjąć jako inne niż null na podstawie kroków czyszczenia).

Ponieważ przypadek użycia jest bardzo specyficzny i różni się od oryginalnego pytania, Nie będę bezpośrednio porównywał czasów do wcześniej opublikowanych. Jednak jednym z przykładów jest to, że chociaż stringi ładnie obsługuje wiele formatów kodowania znaków, mieszane typy wektorowe bez konieczności ich określania, i robi kilka błędów obsługi po wyjęciu z pudełka, to dodaje trochę czasu (co prawdopodobnie jest tego warte dla większości przypadki) .

Używając podstawowej funkcji R sprintf i informując z góry, że wszystkie wejścia będą liczbami całkowitymi, możemy zmniejszyć o około 30% Czas wykonania dla 5 milionów wierszy z 18 liczbami całkowitymi do obliczenia. (20,3 sekundy zamiast 28,9)

library(data.table)
library(stringi)
RowCount <- 5e6
DT <- data.table(x = "foo",
                 y = "bar",
                 a = sample.int(9, RowCount, TRUE),
                 b = sample.int(9, RowCount, TRUE),
                 c = sample.int(9, RowCount, TRUE),
                 d = sample.int(9, RowCount, TRUE),
                 e = sample.int(9, RowCount, TRUE),
                 f = sample.int(9, RowCount, TRUE))

## Generate an expression to paste an arbitrary list of columns together
ConcatCols <- list("a","b","c","d","e","f")
## Do it 3x as many times
ConcatCols <- c(ConcatCols,ConcatCols,ConcatCols)

## Using stringi::stri_c ---------------------------------------------------
stri_joinStatement <- stri_c('stri_join(',stri_c(ConcatCols,collapse = ","),', sep="", collapse=NULL, ignore_null=TRUE)')
DT[, State := eval(parse(text = stri_joinStatement))]

## Using sprintf -----------------------------------------------------------
sprintfStatement <- stri_c("sprintf('",stri_flatten(rep("%i",length(ConcatCols))),"', ",stri_c(ConcatCols,collapse = ","),")")
DT[,State_sprintf_i := eval(parse(text = sprintfStatement))]

Wygenerowane instrukcje są następujące:

> cat(stri_joinStatement)
stri_join(a,b,c,d,e,f,a,b,c,d,e,f,a,b,c,d,e,f, sep="", collapse=NULL, ignore_null=TRUE)
> cat(sprintfStatement)
sprintf('%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i', a,b,c,d,e,f,a,b,c,d,e,f,a,b,c,d,e,f)

Aktualizacja 3: R nie musi być powolna.

Na podstawie odpowiedzi @ Martin Modrák, dodałem razem jeden trick pony pakiet oparty na niektórych data.table wewnętrzne wyspecjalizowane dla wyspecjalizowanej" jednocyfrowej liczby całkowitej " przypadku: fastConcat. Nie szukaj go na CRAN, ale możesz go używać na własne ryzyko, instalując z github repo, msummersgill/fastConcat.)

To prawdopodobnie może być poprawione znacznie dalej przez kogoś, kto rozumie c lepiej, ale na razie działa to tak samo jak w aktualizacji 2 w 2.5 sekund -- około 8X szybciej niż sprintf() i 11,5 x szybciej niż metoda stringi::stri_c(), której używałem pierwotnie.

Dla mnie to podkreśla ogromną szansę na poprawę wydajności niektórych najprostszych operacji w R podobnie jak podstawowa konkatenacja strunowo-wektorowa Z lepiej dostrojonym c. Myślę, że ludzie tacy jak @ Matt Dowle widzieli to od lat. gdyby tylko miał czas na ponowne napisanie wszystkich R, a nie tylko data.rama.