Data.table: Keyby/सबसेटिंग के साथ अद्वितीय समूहों को वापस नहीं करके

सहमत हूँ कि यह एक बग है।

रिकॉर्ड के लिए, इस मामले में अनुशंसित कोड है:

dat[Group == "All", lapply(.SD, sum, na.rm = TRUE), .SDcols= c("count"), keyby = ID]

जो सही उत्तर देता है क्योंकि यह संस्करण GForce को सक्रिय करेगा और उस स्थिति में बग मौजूद नहीं है।

बेशक यह कोई मदद नहीं है अगर आपका वास्तविक कोड इस तरह से नहीं लगाया जा सकता है।

दिलचस्प बात यह है कि अगर हम सबसेट पंक्तियों को सीधे पास करते हैं तो कोड काम करता है:

dat[c(1, 3, 5, 7),
    lapply(.SD, function(x) sum(x, na.rm = TRUE)),
    .SDcols= "count", keyby = ID, verbose = TRUE]
# i clause present and columns used in by detected, only these subset: ID 
# Finding groups using forderv ... 0.000sec 
# Finding group sizes from the positions (can be avoided to save RAM) ... 0.000sec 
# lapply optimization changed j from 'lapply(.SD, function(x) sum(x, na.rm = TRUE))' to 'list(..FUN1(count))'
# GForce is on, left j unchanged
# Old mean optimization is on, left j unchanged.
# Making each group and running j (GForce FALSE) ... 
#   collecting discontiguous groups took 0.000s for 2 groups
#   eval(j) took 0.000s for 2 calls
# 0.000sec 
#    ID count
# 1:  1     4
# 2:  2    12

मुझे verbose आउटपुट में निम्न अंतर दिखाई देता है:

अनुक्रमणिका 'समूह' के साथ अनुकूलित उपसमुच्चय

इसने मुझे सीआरएएन से स्थापित करने के लिए प्रेरित किया; कोड 1.10.4-3 पर त्रुटि के बिना चलता है।

तो मुझे लगता है कि यह सबसेट ऑप्टिमाइज़ेशन पर @MarkusBonsch के काम से कुछ है?

अगर हम शामिल होने को स्पष्ट करते हैं तो मुझे भी वही त्रुटि दिखाई देती है:

dat[.('All'), on = 'Group',
    lapply(.SD, function(x) sum(x, na.rm = TRUE)),
    .SDcols= "count", keyby = ID]
#    ID count
# 1:  1     4
# 2:  1    12

लेकिन कुंजी संस्करण ठीक है:

setkey(dat, Group)
dat[.('All'), 
    lapply(.SD, function(x) sum(x, na.rm = TRUE)),
    .SDcols= "count", keyby = ID]#    ID count
# 1:  1     4
# 2:  2    12

रिपोर्टिंग के लिए @cathine और जांच के लिए @MichaelChirico को धन्यवाद।
मूल कारण माइकल द्वारा बताए गए संस्करण में शामिल होने का छोटा व्यवहार है:
dat[.('All'), on = 'Group', lapply(.SD, function(x) sum(x, na.rm = TRUE)), .SDcols= "count", keyby = ID]

जब यह समस्या #2591 हल हो जाएगी, तो शायद सुलझ जाएगी।
नए उपसमुच्चय अनुकूलन में, उपसमुच्चय को data.table सम्मिलित भाग पर पुनर्निर्देशित किया जाता है, इसलिए यह बग अब उपसमुच्चय के साथ-साथ जुड़ने को भी प्रभावित करता है। अगर मैं समस्या का समाधान कर सकता हूं तो मैं ASAP की जांच करने की कोशिश करूंगा।
तब तक, आप इसका सहारा ले सकते हैं
उदाहरण के लिए dat[Group == "All"][ ,lapply(.SD, function(x) sum(x, na.rm = TRUE)), .SDcols= c("count"), keyby = ID, verbose = TRUE] ।
असुविधा के लिए खेद है।

धन्यवाद @ कैथिन! पुष्टि की गई कि यह केवल-देव है और इसे options(datatable.optimize=2) साथ कम किया जा सकता है क्योंकि समस्या स्तर 3 अनुकूलन में प्रतीत होती है। मैं सोच रहा हूँ कि यह कैसे परीक्षणों के माध्यम से फिसलने में कामयाब रहा!
एक अन्य संपर्क से और भी सरल उदाहरण जिन्होंने रिपोर्ट भी की:

> DT = data.table(
    id = c("a","a","a","b","b","c","c","d","d"),
    group = c(1,1,1,1,1,2,2,2,2),
    num = 1)
> DT[, uniqueN(id), by=group]          # ok 
   group    V1
   <num> <int>
1:     1     2
2:     2     2
> DT[num==1, uniqueN(id), by=group]    # group column wrong
   group    V1
   <num> <int>
1:     1     2
2:     1     2
> options(datatable.optimize=2)
> DT[num==1, uniqueN(id), by=group]    # ok
   group    V1
   <num> <int>
1:     1     2
2:     2     2
> options(datatable.optimize=3)        # not ok
> DT[num==1, uniqueN(id), by=group]
   group    V1
   <num> <int>
1:     1     2
2:     1     2
> DT[num==1, sum(num), by=group]       # ok
   group    V1
   <num> <num>
1:     1     7
2:     2     4
> DT[num==1, length(num), by=group]    # not ok
   group    V1
   <num> <int>
1:     1     7
2:     1     4
> options(datatable.optimize=2)        # ok
> DT[num==1, length(num), by=group]
   group    V1
   <num> <int>
1:     1     7
2:     2     4
> 

यह परीक्षणों के माध्यम से क्यों फिसल गया? क्योंकि यह तभी होता है जब ग्रुपिंग कॉलम को सॉर्ट किया जाता है (नीचे कोड देखें)! मैंने विशेष रूप से सॉर्ट किए गए कॉलम पर ग्रुपिंग की जांच नहीं की।

library(data.table)
DT = data.table(
  id = c("a","a","a","b","b","c","c","d","d"),
  group = c(1,1,1,1,1,2,2,2,2),
  group2 = c(1,1,1,1,1,2,2,2,1),
  num = 1)
DT[, uniqueN(id), by=group]          # ok 
# group    V1
# <num> <int>
# 1:     1     2
# 2:     2     2
DT[num==1, uniqueN(id), by=group]    # group column wrong
# group    V1
# <num> <int>
# 1:     1     2
# 2:     1     2
DT[num==1, uniqueN(id), by=group2]    # ok with other group column that is not sorted
# group2 V1
# 1:      1  3
# 2:      2  2

setkey(DT, group2)
DT[num==1, uniqueN(id), by=group2]    # not ok anymore since the group column is sorted now
# group2 V1
# 1:      1  3
# 2:      1  2