data.table vs dplyr: can one do something well the other can't or does poorly? Ask Question

We need to cover at least these aspects to provide a comprehensive answer/comparison (in no particular order of importance): Speed, Memory usage, Syntax and Features.

My intent is to cover each one of these as clearly as possible from data.table perspective.

Note: unless explicitly mentioned otherwise, by referring to dplyr, we refer to dplyr's data.frame interface whose internals are in C++ using Rcpp.

The data.table syntax is consistent in its form - DT[i, j, by]. To keep i, j and by together is by design. By keeping related operations together, it allows to easily optimise operations for speed and more importantly memory usage, and also provide some powerful features, all while maintaining the consistency in syntax.

1. Speed

Quite a few benchmarks (though mostly on grouping operations) have been added to the question already showing data.table gets faster than dplyr as the number of groups and/or rows to group by increase, including benchmarks by Matt1000万行から20億行（RAM 100GB）のグループ化、1億～1000万グループとさまざまなグループ化列の比較pandas。更新されたベンチマーク、およびも含まれSparkますPolars。

ベンチマークでは、以下の残りの側面もカバーすると良いでしょう。

• 行のサブセットを含むグループ化操作、つまりDT[x > val, sum(y), by = z]型操作。

• 更新や結合などの他の操作をベンチマークします。

• また、実行時間に加えて、各操作のメモリ フットプリントもベンチマークします。

2. メモリ使用量

1. filter()dplyr 内のorを含む操作は、slice()メモリ効率が悪くなる可能性があります (data.frames と data.tables の両方で)。この投稿を見る。

   ご了承くださいハドリーのコメント速度について語っていますが(dplyr は彼にとって十分に高速です)、ここでの主な懸念はメモリです。

2. 現時点では、data.table インターフェースを使用すると、参照によって列を変更/更新できます(結果を変数に再割り当てする必要がないことに注意してください)。

    # sub-assign by reference, updates 'y' in-place
    DT[x >= 1L, y := NA]
   

   しかし、dplyr は参照によって更新されることはありません。dplyr の同等のものは次のようになります (結果を再割り当てする必要があることに注意してください)。

    # copies the entire 'y' column
    ans <- DF %>% mutate(y = replace(y, which(x >= 1L), NA))
   

   これに対する懸念は参照透明性関数内で参照によるdata.tableオブジェクトの更新は必ずしも望ましいとは限りません。しかし、これは非常に便利な機能です。これそしてこれ興味深い事例の投稿。そしてそれを維持したいと考えています。

   shallow()そのため、私たちは、ユーザーに両方の可能性を提供する data.table の関数をエクスポートすることに取り組んでいます。たとえば、関数内で入力 data.table を変更したくない場合は、次のようにします。

    foo <- function(DT) {
        DT = shallow(DT)          ## shallow copy DT
        DT[, newcol := 1L]        ## does not affect the original DT 
        DT[x > 2L, newcol := 2L]  ## no need to copy (internally), as this column exists only in shallow copied DT
        DT[x > 2L, x := 3L]       ## have to copy (like base R / dplyr does always); otherwise original DT will 
                                  ## also get modified.
    }
   

   を使用しないことでshallow()、古い機能が保持されます。

    bar <- function(DT) {
        DT[, newcol := 1L]        ## old behaviour, original DT gets updated by reference
        DT[x > 2L, x := 3L]       ## old behaviour, update column x in original DT.
    }
   

   を使用して浅いコピーを作成することでshallow()、元のオブジェクトを変更したくないということを理解しています。 を保証しながら、絶対に必要な場合にのみ変更する列をコピーするように、すべてを内部的に処理します。 これを実装すると、参照の透明性の問題が完全に解決され、ユーザーに両方の可能性が提供されます。

   また、一度shallow()エクスポートされると、dplyr の data.table インターフェースはほとんどすべてのコピーを回避するはずです。そのため、dplyr の構文を好む人は、それを data.tables で使用できます。

   しかし、参照による (サブ) 割り当てなど、data.table が提供する多くの機能がまだ欠けています。

3. 参加しながら集計:

   次のような 2 つの data.tables があるとします。

    DT1 = data.table(x=c(1,1,1,1,2,2,2,2), y=c("a", "a", "b", "b"), z=1:8, key=c("x", "y"))
    #    x y z
    # 1: 1 a 1
    # 2: 1 a 2
    # 3: 1 b 3
    # 4: 1 b 4
    # 5: 2 a 5
    # 6: 2 a 6
    # 7: 2 b 7
    # 8: 2 b 8
    DT2 = data.table(x=1:2, y=c("a", "b"), mul=4:3, key=c("x", "y"))
    #    x y mul
    # 1: 1 a   4
    # 2: 2 b   3
   

   そして、列で結合しながらsum(z) * mul各行を取得したいとします。次のいずれかの方法があります。DT2x,y

   • 1. aggregate DT1 to get sum(z), 2) perform a join and 3) multiply (or)

        data.table way

        DT1[, .(z = sum(z)), keyby = .(x,y)][DT2][, z := z*mul][]
        

        dplyr equivalent

        DF1 %>% group_by(x, y) %>% summarise(z = sum(z)) %>% 
           right_join(DF2) %>% mutate(z = z * mul)
        

   • 2. do it all in one go (using by = .EACHI feature):

        DT1[DT2, list(z=sum(z) * mul), by = .EACHI]
        

   What is the advantage?

   • We don't have to allocate memory for the intermediate result.

   • We don't have to group/hash twice (one for aggregation and other for joining).

   • And more importantly, the operation what we wanted to perform is clear by looking at j in (2).

   Check this post for a detailed explanation of by = .EACHI. No intermediate results are materialised, and the join+aggregate is performed all in one go.

   Have a look at this, this and this posts for real usage scenarios.

   In dplyr you would have to join and aggregate or aggregate first and then join, neither of which are as efficient, in terms of memory (which in turn translates to speed).

4. Update and joins:

   Consider the data.table code shown below:

    DT1[DT2, col := i.mul]
   

   adds/updates DT1's column col with mul from DT2 on those rows where DT2's key column matches DT1. I don't think there is an exact equivalent of this operation in dplyr, i.e., without avoiding a *_join operation, which would have to copy the entire DT1 just to add a new column to it, which is unnecessary.

   Check this post for a real usage scenario.

DT = data.table(x=1:10, y=11:20, z=rep(1:2, each=5))
DF = as.data.frame(DT)