有效地检查data.table中其他行的值

Question

注意：这是我最初发布到data.table帮助组的问题。 Matt Dowle要求提供一个更详细的例子，我发布了这个例子，但我在电子邮件格式化方面遇到了麻烦。 我已经知道如何格式化SO，所以我想我会在这里发布它。

我基本上尝试做的是基于该行中的值以及前一行或后一行中的值来自data.table的子集行。 现在，我正在为将来和过去的行创建新列，然后在这些列上键入data.table，但这是资源密集型和繁琐的。

下面的例子说明了我现在使用的方法。 该示例使用文档中的单词（我使用数字索引）。 我想为特定单词进行子集化，但前提是它前面或后面跟着另一个单词或一组单词：

我首先创建一个包含十个包含一百万个单词的文档的虚拟数据集。 集合中有三个独特的单词。

library(data.table)
set.seed(1000)
DT<-data.table(wordindex=sample(1:3,1000000,replace=T),docindex=sample(1:10,1000000,replace=T))
setkey(DT,docindex)
DT[,position:=seq.int(1:.N),by=docindex]


          wordindex docindex position
      1:         1        1        1
      2:         1        1        2
      3:         3        1        3
      4:         3        1        4
      5:         1        1        5
    ---                            
 999996:         2       10    99811
 999997:         2       10    99812
 999998:         3       10    99813
 999999:         1       10    99814
1000000:         3       10    99815

请注意，简单地计算所有文档中第一个唯一单词的出现次数非常简单。

setkey(DT,wordindex)
count<-DT[J(1),list(count.1=.N),by=docindex]
count

    docindex count.1
 1:        1   33533
 2:        2   33067
 3:        3   33538
 4:        4   33053
 5:        5   33231
 6:        6   33002
 7:        7   33369
 8:        8   33353
 9:        9   33485
10:       10   33225

考虑到前面的位置会变得更加混乱。 这是一个查询，用于计算所有文档中第一个唯一单词的出现次数， 除非后面跟着第二个唯一单词。 首先，我创建一个新列，其中包含前面一个位置的单词，然后键入两个单词。

setkey(DT,docindex,position)
DT[,lead_wordindex:=DT[list(docindex,position+1)][,wordindex]]

         wordindex docindex position lead_wordindex
      1:         1        1        1              1
      2:         1        1        2              3
      3:         3        1        3              3
      4:         3        1        4              1
      5:         1        1        5              2
     ---                                           
 999996:         2       10    99811              2
 999997:         2       10    99812              3
 999998:         3       10    99813              1
 999999:         1       10    99814              3
1000000:         3       10    99815             NA

setkey(DT,wordindex,lead_wordindex)
countr2<-DT[J(c(1,1),c(1,3)),list(count.1=.N),by=docindex]
countr2

    docindex count.1
 1:        1   22301
 2:        2   21835
 3:        3   22490
 4:        4   21830
 5:        5   22218
 6:        6   21914
 7:        7   22370
 8:        8   22265
 9:        9   22211
10:       10   22190

我有一个非常大的数据集，上面的查询无法进行内存分配。 作为替代方案，我们可以通过过滤原始数据集然后将其连接回所需位置来仅为相关数据子集创建此新列：

setkey(DT,wordindex)
filter<-DT[J(1),list(wordindex,docindex,position)]
filter[,lead_position:=position+1]

        wordindex wordindex docindex position lead_position
     1:         1         1        2    99717         99718
     2:         1         1        3    99807         99808
     3:         1         1        4   100243        100244
     4:         1         1        1        1             2
     5:         1         1        1       42            43
    ---                                                    
332852:         1         1       10    99785         99786
332853:         1         1       10    99787         99788
332854:         1         1       10    99798         99799
332855:         1         1       10    99804         99805
332856:         1         1       10    99814         99815

setkey(DT,docindex,position)
filter[,lead_wordindex:=DT[J(filter[,list(docindex,lead_position)])][,wordindex]]

        wordindex wordindex docindex position lead_position lead_wordindex
     1:         1         1        2    99717         99718             NA
     2:         1         1        3    99807         99808             NA
     3:         1         1        4   100243        100244             NA
     4:         1         1        1        1             2              1
     5:         1         1        1       42            43              1
    ---                                                                   
332852:         1         1       10    99785         99786              3
332853:         1         1       10    99787         99788              3
332854:         1         1       10    99798         99799              3
332855:         1         1       10    99804         99805              3
332856:         1         1       10    99814         99815              3

setkey(filter,wordindex,lead_wordindex)
countr2.1<-filter[J(c(1,1),c(1,3)),list(count.1=.N),by=docindex]
countr2.1

    docindex count.1
 1:        1   22301
 2:        2   21835
 3:        3   22490
 4:        4   21830
 5:        5   22218
 6:        6   21914
 7:        7   22370
 8:        8   22265
 9:        9   22211
10:       10   22190

我觉得很难看。 另外，我可能想要提前看一个单词，需要创建另一个专栏。 简单但昂贵的方式是：

setkey(DT,docindex,position)
DT[,lead_lead_wordindex:=DT[list(docindex,position+2)][,wordindex]]

         wordindex docindex position lead_wordindex lead_lead_wordindex
      1:         1        1        1              1                   3
      2:         1        1        2              3                   3
      3:         3        1        3              3                   1
      4:         3        1        4              1                   2
      5:         1        1        5              2                   3
     ---                                                               
 999996:         2       10    99811              2                   3
 999997:         2       10    99812              3                   1
 999998:         3       10    99813              1                   3
 999999:         1       10    99814              3                  NA
1000000:         3       10    99815             NA                  NA

setkey(DT,wordindex,lead_wordindex,lead_lead_wordindex)
countr23<-DT[J(1,2,3),list(count.1=.N),by=docindex]
countr23

    docindex count.1
 1:        1    3684
 2:        2    3746
 3:        3    3717
 4:        4    3727
 5:        5    3700
 6:        6    3779
 7:        7    3702
 8:        8    3756
 9:        9    3702
10:       10    3744

但是，由于尺寸的原因，我目前不得不使用丑陋的过滤和连接方式。

所以问题是，是否有更简单，更美丽的方式？

更新 ：

感谢Arun和eddi提供了解决问题的简洁代码。 在我的~200M行数据上，这个解决方案可以在大约10秒内完成一个简单的单词组合，这非常好！

然而，我确实有一个额外的问题，它使矢量扫描方法不是最佳的。 虽然在示例中我只寻找一个单词组合，但实际上我可能在每个位置都有一个单词向量。 当我为此目的将“==”语句更改为“％in％”（100个字或更多的向量）时，查询需要更长的时间才能运行。 所以我仍然会对二进制搜索解决方案感兴趣（如果存在）。 但是，如果阿伦不知道一个，它可能不会，我很乐意接受他的回答。

Answer 1

这是我脑海中浮现的另一个想法。 它只需要创建一个列并使用二进制搜索作为子集。

在您从数据生成的DT ，首先我们将添加额外的列：

# the extra column:
DT[, I := .I]

我们需要这个，因为我们setkey上docindex 和 wordindex 。 这是我们可以在不创建额外列的情况下进行子集的唯一方法（至少我能想到的是这样）。 因此，我们需要一种方法来提取“原始”位置，以检查您的状况（因此是I ）。

添加额外列后，让我们在上面提到的两列上设置键：

setkey(DT, docindex, wordindex)

大！ 这里的想法是提取你想要的单词匹配的位置 - 这里的值是1L 。 然后，提取您可能（或可能不）想要在正确位置后出现此单词的所有其他单词。 然后，我们只保留（或删除）满足条件的索引。

这是一个可以解决这个问题的功能。 它绝不是完整的，但应该给你一个想法。

foo <- function(DT, doc_key, word_key, rest_key=NULL, match=FALSE) {
    ## note that I'm using 1.9.3, where this results in a vector
    ## if you're using 1.9.2, you'll have to change the joins accordingly
    idx1 = DT[J(doc_key, word_key), I]
    for (i in seq_along(rest_key)) {
        this_key = rest_key[i]
        idx2 = DT[J(doc_key, this_key), I]
        if (match) idx1 = idx1[which((idx1+i) %in% idx2)]
        else idx1 = idx1[which(!(idx1+i) %in% idx2)]
    }
    DT[idx1, .N, by=c(key(DT)[1L])]
}

这里， DT是data.table了I列的data.table ， 然后 setkey在两列上调用了setkey 。

doc_key基本上包含在所有的唯一值docindex -在这里1:10。 word_key基本上是1L。 rest_key是你要检查的值，不会出现在word_key位置之后的第i个位置。

首先，我们在idx1中为1L所有匹配提取I （直截了当）。 接下来，我们遍历rest_key每个值并将该位置添加到idx1 = idx1+i并检查该值是否出现在idx2 。 如果是这样，根据您是要提取匹配或不匹配的条目，我们将保留（或删除它们）。

在这个循环结束时， idx1应该只有所需的条目。 希望这可以帮助。 下面显示的是对另一个答案中已经讨论过的案例的演示。

---

让我们考虑你的第一个场景。 所有条目的计数，对于docindex中的每个组，其中第i个位置是1L而i+1 不是 2L。 这基本上是：

system.time(ans1 <- foo(DT, 1:10, 1L, 2L, FALSE))

#  user  system elapsed 
# 0.066   0.019   0.085 

# old method took 0.12 seconds

#     docindex     N
#  1:        1 22301
#  2:        2 21836
#  3:        3 22491
#  4:        4 21831
#  5:        5 22218
#  6:        6 21914
#  7:        7 22370
#  8:        8 22265
#  9:        9 22211
# 10:       10 22190

---

第二种情况怎么样？ 在这里，我们希望第i+1和第i+2位置为2L和3L，而不是前面的情况中的不相等情况。 所以，我们在这里设置match=TRUE 。

system.time(ans2 <- foo(DT, 1:10, 1L, 2:3,TRUE))
#  user  system elapsed 
# 0.080   0.011   0.090 

# old method took 0.22 seconds

#     docindex    N
#  1:        1 3684
#  2:        2 3746
#  3:        3 3717
#  4:        4 3727
#  5:        5 3700
#  6:        6 3779
#  7:        7 3702
#  8:        8 3756
#  9:        9 3702
# 10:       10 3744

扩展此功能很容易。 例如：如果您希望i+1等于2L但i+2 不等于 3L那么，您可以将match更改为指定相应逻辑值的vector = length(rest_key) 。

我希望这对你的实际情况来说很快 - 至少比其他版本更快。

HTH

Answer 2

听起来你只是想要：

DT[, sum(wordindex == 1 & c(tail(wordindex, -1), 2) != 2), by = docindex]

我没有看到通过连接使其复杂化的重点。

顺便说一下，在某些情况下，你会得到一个不同的答案，这可能是因为我不明白你想要什么，或者因为你的方法在某些边缘情况下失败了。 例如，尝试两种方法

DT = data.table(wordindex = c(1,1,2,1,1,2), docindex = c(1,1,2,2,3,3))

Answer 3

只需创建一个lead函数并在j-expression使用它：

lead <- function(x, n)
    if (n == 0) x else c(tail(x, -n), rep.int(NA, n))

如果您想获得第i个位置的wordindex为1L且i+1 不是 2L的计数，则：

DT[, sum(wordindex == 1L & lead(wordindex, 1L) != 2L, na.rm=TRUE), by=docindex]
#     docindex    V1
#  1:        1 22301
#  2:        2 21835
#  3:        3 22490
#  4:        4 21830
#  5:        5 22218
#  6:        6 21914
#  7:        7 22370
#  8:        8 22265
#  9:        9 22211
# 10:       10 22190

如果你想获得i wordindex是1L的计数， i+1是2L而i+2是3L，那么：

DT[, sum(wordindex == 1L & lead(wordindex, 1L) == 2L & 
          lead(wordindex, 2L) == 3L, na.rm=TRUE), by=docindex]
#     docindex   V1
#  1:        1 3684
#  2:        2 3746
#  3:        3 3717
#  4:        4 3727
#  5:        5 3700
#  6:        6 3779
#  7:        7 3702
#  8:        8 3756
#  9:        9 3702
# 10:       10 3744

请注意，这里不需要setkey .. adhoc-by应该很好用。

---

要发表评论：

此解决方案使用j的向量扫描而不是二进制搜索方法。 但这里有不同的权衡。 与二进制搜索版本相比，代码相对优雅，易于阅读，扩展到多个滞后和条件并维护（因为我无法想到没有创建额外列的方式）。 这需要少得多的内存，这也是你的情况的一个限制因素。

你说“大数据”，但不要再多说了。 对整个数据（比如2000万行或2亿行）的矢量扫描是昂贵的，是的。 但是，对每个组进行操作，即使它不能提供二进制搜索的性能，也不应该慢得多。 当然，这又取决于你的团体数量和每组的观察数量。 但最好对这些事情进行基准测试并弄清楚。

我会告诉你的。 祝好运 ：）。