注意：这是我最初发布到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个字或更多的向量）时，查询需要更长的时间才能运行。所以我仍然会对二进制搜索解决方案感兴趣（如果存在）。但是，如果Arun不知道一个，它可能不会，我很乐意接受他的答案。
答案 0 :(得分：3)
这是我想到的另一个想法。它只需要创建一个列，并使用二进制搜索作为子集。
在您从数据中生成的DT上，我们首先要添加额外的列：
# the extra column:
DT[, I := .I]
我们需要这样做，因为我们setkey 和 docindex wordindex。这是我们可以在不创建额外列的情况下进行子集的唯一方法（至少我能想到的是这样）。因此，我们需要一种方法来提取原始的＆＃34;稍后检查您的状况（因此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，已在两列上调用然后 setkey如前所述。
doc_key基本上包含docindex中的所有唯一值 - 这里1:10。 word_key基本上是1L。 rest_key是i位置之后word_key位置未发生的值。{/ 1}}。
首先，我们针对I中1L的所有匹配（直截了当）提取idx1。接下来，我们遍历 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
答案 1 :(得分：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))
答案 2 :(得分：2)
只需创建一个lead功能，然后在j-expression：
lead <- function(x, n)
if (n == 0) x else c(tail(x, -n), rep.int(NA, n))
如果您希望获得wordindex i位置为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
如果您希望获得wordindex i为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中的矢量扫描，而不是二进制搜索方法。但这里有不同的权衡。与二进制搜索版本相比，代码相对优雅，易于阅读，扩展到多个滞后和条件并进行维护（因为我无法想到一种不创建额外列的方法）。这需要很多较少的内存，这也是你的情况的限制因素。
您说＆＃34;大数据＆＃34;，但不要再说什么了。对整个数据（比如2000万行或2亿行）的矢量扫描是昂贵的，是的。但是，对每个组进行操作，即使它不能提供二进制搜索的性能，也不应该慢得多。当然，这又取决于您的团体数量和每组的观察数量。但最好对这些事情进行基准测试并找出答案。
我会告诉你的。祝你好运:)。