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

Question

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

rdata.table

6

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

我基本上正在尝试根据行中的值以及上一行或下一行中的值来对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提供了干净简单的代码来解决这个问题。在我的约2亿行数据中，这个解决方案可以在大约10秒内完成简单词语组合的查找，效果相当不错！

然而，我还有一个额外的问题，使向量扫描方法不太理想。尽管在这个例子中，我只寻找一个词语组合，但在实践中，我可能需要在每个位置上查找一组词语。当我将“ == ”语句更改为“％in％”以实现这个目的（使用100个或更多单词的向量），查询所需时间会更长。因此，如果存在二进制搜索解决方案，我仍然对其感兴趣。但是，如果Arun不知道是否存在这种方式，那么可能就没有了，我很乐意接受他的答案。

- Matt

1

更新：也许你可以尝试一种混合策略，将其过滤到你感兴趣的单词集合（如果你已经有一个关键字集合，可以使用简单的连接），然后在其中运行向量扫描（你需要保存位置并进行差分）。 - eddi

谢谢Eddi，我也可以试一下。 - Matt

1

此外，对于字符向量，%chin% 比 %in% 更快。 - Arun

3个回答

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))

- eddi

2

只需要创建一个 lead 函数并在您的 j表达式 中使用它即可：

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亿行）是昂贵的。但是，即使在每个组上操作，即使不能提供二进制搜索的性能，速度也不会慢太多。当然，这又取决于您拥有的组数和每个组的观察次数。但最好对这些事情进行基准测试并找出答案。

祝你好运：)。

- Arun

这是一个适用于你和eddi的问题。我曾经考虑过类似的方法（尽管远不如此优雅），但我避免使用它，因为（我认为）这是一种向量扫描。在这里采取这种方法是否正确？ - Matt

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Arun · Accepted Answer

我有一个新想法。它只需要创建一个额外的列，并使用二分搜索来进行子集。

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

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

我们需要这个是因为我们将在docindex和wordindex上进行setkey。这是我们可以进行子集操作而不创建额外列的唯一方法（至少我所能想到的）。因此，我们需要一种方法来提取“原始”位置以后检查你的条件（因此是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是添加了I列的data.table，然后按照之前提到的两列调用了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 更改为一个向量 = length(rest_key)，指定相应的逻辑值。

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

希望有所帮助。