如何使用data.table和lubridate更快地计算按组排列（日期）的排名？

Question

我需要按组计算日期的排名。 有许多小组。

library(data.table)
library(lubridate)
library(microbenchmark)
set.seed(1)
NN <- 1000000
EE <- 10   
# Just an example.
todo <- data.table(id=paste0("ID",rep(1:NN, each=EE)), 
          val=dmy("1/1/1980") + sample(1:14000,NN*EE,replace=T))
# I want to benchmark this:
todo[,ord := frank(val, ties.method="first"), by=id]  

为了进行比较，您可以尝试使用更小的NN，时间是线性的。

对于NN = 100万，需要560秒。

有没有更快的方法？
我一直在使用lubridate，但我可以使用您建议的任何库。
在我的实际问题中，每个ID中的行数不是恒定的。

- skan

---

我也有一个想法，即为每个ID添加大量、独特且逐渐增加的数字，将它们一起排名，然后撤销“转换”。但我需要双精度或某些特殊方法来防止舍入误差。 - skan

Answer 1

我认为这是由于多次调用frank以处理许多小组的开销所致（下面的内存使用情况应该能帮你找到瓶颈）。以下是另一个选择：

DT1[order(id, val), ord := rowid(id)]

代码计时：

library(data.table)
set.seed(1L)
NN <- 1e6
EE <- 10
todo <- data.table(id=paste0("ID",rep(1:NN, each=EE)),
    val=as.IDate("1980-01-01") + sample(1:14000,NN*EE,replace=T))
DT0 <- copy(todo)
DT1 <- copy(todo)

bench::mark(
    todo[, ord := frank(val, ties.method="first"), by=id],
    DT0[, ord := rank(unclass(val), ties.method = "first"), by = id],
    DT1[order(id, val), ord := rowid(id)])

all.equal(todo$ord, DT0$ord)  
# [1] TRUE
all.equal(todo$ord, DT1$ord)  
# [1] TRUE

时序：

  expression                                                             min median `itr/sec` mem_alloc `gc/sec` n_itr  n_gc total_time result memory time 
  <bch:expr>                                                           <bch> <bch:>     <dbl> <bch:byt>    <dbl> <int> <dbl>   <bch:tm> <list> <list> <lis>
1 todo[, `:=`(ord, frank(val, ties.method = "first")), by = id]        6.32m  6.32m   0.00264    15.7GB    0.177     1    67      6.32m <df[,~ <df[,~ <bch~
2 DT0[, `:=`(ord, rank(unclass(val), ties.method = "first")), by = id] 1.12m  1.12m   0.0149     99.3MB    0.969     1    65      1.12m <df[,~ <df[,~ <bch~
3 DT1[order(id, val), `:=`(ord, rowid(id))]                            7.85s  7.85s   0.127     236.8MB    0         1     0      7.85s <df[,~ <df[,~ <bch~

如果我们在order中删除id，速度甚至可以更快。

DT1[order(val), ord := rowid(id)]

计时代码:

bench::mark(DT0[order(id, val), ord := rowid(id)], 
    DT1[order(val), ord := rowid(id)])
all.equal(DT0$ord, DT1$ord)
# [1] TRUE

时间：

# A tibble: 2 x 13
  expression                                     min   median `itr/sec` mem_alloc `gc/sec` n_itr  n_gc total_time result                    memory            time     gc              
  <bch:expr>                                <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl> <int> <dbl>   <bch:tm> <list>                    <list>            <list>   <list>          
1 DT0[order(id, val), `:=`(ord, rowid(id))]    7.44s    7.44s     0.134     237MB        0     1     0      7.44s <df[,3] [10,000,000 x 3]> <df[,3] [15 x 3]> <bch:tm> <tibble [1 x 3]>
2 DT1[order(val), `:=`(ord, rowid(id))]        4.66s    4.66s     0.215     237MB        0     1     0      4.66s <df[,3] [10,000,000 x 3]> <df[,3] [14 x 3]> <bch:tm> <tibble [1 x 3]>

- chinsoon12

---

@Frank，感谢你的修复。我相信在 order 中不包含 id 也可以工作。午餐后测试一下。 - chinsoon12

事实上，在计算排名后，我也会执行 setorder(todo, id, ord)。也许我可以将两行代码压缩成一行。我使用这种方法来避免并列排名带来的问题。 - skan

现在我有点困惑了。我不知道是需要使用“order”还是“rank”。 - skan

如果您需要排名以进行后续计算，则应将其存储在一列中。如果您只希望对其进行排序，则使用setorder或setkey（如果您将其用于子集或连接，则使用后者）。 - chinsoon12

Answer 2

我尝试了几种设置并发现使用rank(unclass(val), ties.method = "first")可以获得最大的改进 - 这是frank()的基本R等效版本。由于某种原因，当涉及到分组时，它优于frank()。

# Output from microbenchmark::microbenchmark()
Unit: seconds
                                                       expr      min       lq     mean   median       uq      max neval
         todo[, frank(val, ties.method = "first"), by = id] 599.8309 599.8309 599.8309 599.8309 599.8309 599.8309     1
 todo[, rank(unclass(val), ties.method = "first"), by = id] 111.4396 111.4396 111.4396 111.4396 111.4396 111.4396     1

- s_baldur

---

我也尝试了frank（unclass（val）），但速度也较慢。 - skan

@skan，当你使用base::rank()时，你是否也能获得与我相同的改进？ - s_baldur

我的意思是，目前你的解决方案是最快的。问题不在于未分类，而是由于分组而引起的，与日期无关。frank似乎比其他方法慢6倍（在我的电脑上是10倍）。 - skan

我刚刚在 https://github.com/Rdatatable/data.table/issues/3988 上开了一个问题。 - skan

@skan，截至2023年，我仍然大约慢了6倍。 - MatthewR