Data.table: रोलिंग फ़ंक्शंस, रोलिंग एग्रीगेट्स, स्लाइडिंग विंडो, मूविंग एवरेज

प्रस्तावित rollmean कार्यान्वयन, सरलीकृत।

x = data.table(v1=1:5, v2=1:5)
k = c(2, 3)

i - single column
j - single window
m - int referring to single row
w - current row's sum of rolling window
r - answer for each i, j



md5-be70673ef4a3bb883d4f334bd8fadec9



for i in x
  for j in k
  r = NA_real_
  w = 0
    for m in 1:length(i)
      w = w + i[m]
      w = w - i[m-j]
      r[m] = w / j

हां, और कई और लुढ़के हुए कार्य एक ही मूल विचार का पालन करते हैं (सहित
रोलिंग मानक विचलन/कोई अपेक्षा-आधारित क्षण, और कोई फ़ंक्शन
रोलप्रोडक्ट की तरह जो + के बजाय उलटा * का उपयोग करता है
खिड़की

मैंने हमेशा कई ओवरलैपिंग समूहों (विंडोज़) में डेटासेट को समूहीकृत करने के रूप में रोलिंग विंडो कार्यक्षमता की कल्पना की। तब एपीआई कुछ इस तरह दिखेगा:

DT[i, j,
   by = roll(width=5, align="center")]

फिर यदि j में mean(A) , तो हम इसे आंतरिक रूप से rollmean(A) - ठीक वैसे ही जैसे हम अभी gmean() साथ कर रहे हैं। या j में मनमाने ढंग से जटिल कार्यक्षमता हो सकती है (जैसे, प्रत्येक विंडो के लिए एक प्रतिगमन चलाएं), इस स्थिति में हम .SD डेटा की आपूर्ति करेंगे। ठीक उसी तरह जैसे हम समूहों के साथ करते हैं तुरंत।

इस तरह 10+ नए कार्यों को पेश करने की कोई आवश्यकता नहीं है, केवल एक। और यह data.table-y भावना में भी लगता है।

हाँ सहमत

शनिवार, अप्रैल २१, २०१८, ३:३८ अपराह्न पाशा स्टेट्सेंको नोटिफिकेशन @github.com . पर
लिखा था:

मैंने हमेशा रोलिंग विंडो कार्यक्षमता को समूहबद्ध करने के रूप में कल्पना की थी
एकाधिक अतिव्यापी समूहों (विंडो) में डेटासेट। तब एपीआई दिखेगा
कुछ इस तरह:

डीटी [मैं, जे,
द्वारा = रोल (चौड़ाई = 5, संरेखित करें = "केंद्र")]

फिर यदि j में, मान लीजिए, माध्य (A) है, तो हम इसे आंतरिक रूप से से बदल सकते हैं
Rollmean(A) -- ठीक वैसे ही जैसे हम अभी gmean() के साथ कर रहे हैं। या जे कैन
एक मनमाने ढंग से जटिल कार्यक्षमता शामिल है (कहते हैं, के लिए एक प्रतिगमन चलाएँ
प्रत्येक विंडो), जिस स्थिति में हम .SD data.table की आपूर्ति करेंगे - बिल्कुल
जैसे हम अभी समूहों के साथ करते हैं।

इस तरह 10+ नए कार्यों को पेश करने की कोई आवश्यकता नहीं है, केवल एक। और यह
data.table-y भावना में भी महसूस करता है।

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Rdatatable/data.table/issues/2778#issuecomment-383275134 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/AHQQdbADiE4aAI1qPxPnFXUM5gR-0w2Tks5tquH8gaJpZM4TeTQf
.

@ सेंट-पाशा दिलचस्प विचार, data.table-y भावना की तरह दिखता है, लेकिन यह कई सीमाएं लगाएगा, और इस श्रेणी के कार्यों के लिए वास्तव में उपयुक्त नहीं है।

• समूह द्वारा रोलमीन कैसे करें

DT[, rollmean(V1, 3), by=V2]

• विभिन्न स्तंभों के लिए विभिन्न विंडो आकारों की गणना कैसे करें

DT[, .(rollmean(V1, 3), rollmean(V2, 100))]

• [.data.table बाहर रोलमीन की गणना कैसे करें क्योंकि अब हम शिफ्ट की अनुमति देते हैं

rollmean(rnorm(10), 3)

• जैसे प्रश्नों का समर्थन कैसे करें

DT[, .(rollmean(list(V1, V2), c(5, 20)), rollmean(list(V2, V3), c(10, 30)))]

• एक ही j कॉल में mean और rollmean को कैसे कॉल करें

DT[, .(rollmean(V1, 3), mean(V1)), by=V2]

आमतौर पर by का उपयोग करते समय हम डेटा को छोटी पंक्तियों में एकत्रित करते हैं, जबकि रोलिंग फ़ंक्शन हमेशा इनपुट के समान लंबाई के वेक्टर लौटाते हैं। SQL में इस प्रकार के फ़ंक्शंस में निम्न शैली में API है:

SELECT AVG(value) OVER (ROWS BETWEEN 99 PRECEDING AND CURRENT ROW)
FROM tablename;

आप इसे अभी भी ग्रुप बाय के साथ इस प्रकार जोड़ सकते हैं:

SELECT AVG(value) OVER (ROWS BETWEEN 99 PRECEDING AND CURRENT ROW)
FROM tablename
GROUP BY group_columns;

तो SQL में वे फ़ंक्शन SELECT जो DT में j को संदर्भित करता है।
डीटी में हम इसके साथ ही हासिल कर सकते हैं:

DT[, rollmean(value, 100)]
DT[, rollmean(value, 100), group_columns]

रोलिंग फ़ंक्शंस फ़ंक्शन की एक ही श्रेणी में फिट बैठता है जैसे कि shift जो इनपुट पर प्राप्त पंक्तियों की समान संख्या भी देता है।
एसक्यूएल में शिफ्ट इस तरह दिखता है:

SELECT LAG(value, 1) OVER ()
FROM tablename;

mean और rollmean केवल अलग-अलग कार्य नहीं हैं, वे विभिन्न प्रकार के कार्य हैं। एक का मतलब समूह के अनुसार एकत्र होना था, दूसरा कुल मिलाकर नहीं। यह एसक्यूएल में आसानी से दिखाई देता है जहां हम रोलिंग फ़ंक्शन प्रकार के लिए GROUP BY उपयोग नहीं करते हैं, लेकिन हमें GROUP BY जैसे समुच्चय के लिए mean का उपयोग करने की आवश्यकता होती है (अंततः समूहीकरण करते समय कुल अनुदान प्राप्त करना) खंड मौजूद नहीं है)।
मुझे mean समान अनुकूलन नियमों को लागू करने का प्रयास करने के लिए मजबूत तर्क नहीं दिख रहा है, खासकर जब यह वास्तव में केस का उपयोग करने के लिए उपयुक्त नहीं है, और वह सब सिर्फ data.table-y के लिए आत्मा। वर्तमान प्रस्ताव data.table-y भावना भी है, इसे आसानी से := के साथ जोड़ा जा सकता है, जो shift । यह सिर्फ नए कार्यों का सेट जोड़ता है, वर्तमान में data.table में उपलब्ध नहीं है।

@jangorecki धन्यवाद, ये सभी मान्य विचार हैं। बेशक अलग-अलग लोगों के अलग-अलग अनुभव होते हैं, और अलग-अलग विचार होते हैं कि "स्वाभाविक" क्या माना जाना चाहिए।

समूह द्वारा रोलमीन करना संभव है: यह केवल 2-स्तरीय समूहीकरण है: DT[, mean(V1), by=.(V2, roll(3))] । हालांकि मैं नहीं देखता कि मेरे सिंटैक्स के साथ अलग-अलग कॉलम पर अलग-अलग विंडो आकार कैसे बनाएं ...

मुझे यह स्वीकार करना होगा कि मैंने पहले कभी भी रोलिंग जॉइन के लिए SQL सिंटैक्स नहीं देखा है। यह दिलचस्प है कि वे मानक एग्रीगेटर जैसे AVG फिर भी इसके लिए विंडोिंग विनिर्देश लागू करते हैं। ट्रांजैक्ट-एसक्यूएल दस्तावेज को देखते हुए वहां कुछ दिलचस्प विचार हैं, उदाहरण के लिए तार्किक/भौतिक पंक्ति चयन के बीच भेद। वे अलग-अलग कॉलम पर अलग-अलग "ओवर" ऑपरेटरों को अनुमति देते हैं, हालांकि उनके द्वारा दिए गए सभी उदाहरणों में, यह वही ओवर क्लॉज कई बार दोहराया जाता है। तो यह सुझाव देता है कि यह उपयोग-मामला बहुत अधिक सामान्य है, और इसलिए एकल roll() समूह का उपयोग करने से पुनरावृत्ति कम होगी।

साथ ही, यह SO प्रश्न एक दिलचस्प अंतर्दृष्टि प्रदान करता है कि SQL में ओवर सिंटैक्स क्यों पेश किया गया था:

आप Group BY SalesOrderID का उपयोग कर सकते हैं। अंतर यह है कि GROUP BY के साथ आपके पास केवल उन स्तंभों के लिए समेकित मान हो सकते हैं जो GROUP BY में शामिल नहीं हैं। इसके विपरीत, GROUP BY के बजाय विंडोड एग्रीगेट फ़ंक्शंस का उपयोग करके, आप समेकित और गैर-एकत्रित दोनों मान प्राप्त कर सकते हैं। यही है, हालांकि आप अपनी उदाहरण क्वेरी में ऐसा नहीं कर रहे हैं, आप एक ही SalesOrderIDs के समूहों पर अलग-अलग ऑर्डरक्यूटी मान और उनकी रकम, गणना, औसत इत्यादि दोनों पुनर्प्राप्त कर सकते हैं।

तो ऐसा प्रतीत होता है कि सिंटैक्स को मानक SQL की सीमा को दरकिनार करने के लिए डिज़ाइन किया गया है जहाँ समूह-दर परिणाम को असंगठित मानों के साथ नहीं जोड़ा जा सकता है (अर्थात एक ही अभिव्यक्ति में A और mean(A) दोनों का चयन करना)। हालाँकि data.table में ऐसी कोई सीमा नहीं है, इसलिए इसे वाक्य रचना के चुनाव में अधिक स्वतंत्रता है।

अब, यदि हम वास्तव में वक्र से आगे निकलना चाहते हैं, तो हमें व्यापक परिप्रेक्ष्य में सोचने की आवश्यकता है: "रोलिंग" फ़ंक्शन क्या हैं, उनका उपयोग किस लिए किया जाता है, उन्हें कैसे बढ़ाया जा सकता है, आदि। यहाँ मेरा यह है, आ रहा है एक सांख्यिकीविद् के दृष्टिकोण से:

कुछ शोर इनपुट को सुचारू करने के लिए "रोलिंग माध्य" फ़ंक्शन का उपयोग किया जाता है। मान लीजिए, यदि आपके पास समय के साथ अवलोकन हैं और आप "औसत मात्रा" की कुछ धारणा रखना चाहते हैं, जो कि समय के साथ बदलती रहती है, हालांकि बहुत धीरे-धीरे। इस मामले में "पिछले 100 अवलोकनों पर रोलिंग माध्य" या "सभी पिछली टिप्पणियों पर रोलिंग माध्य" पर विचार किया जा सकता है। इसी तरह, यदि आप इनपुट की एक सीमा पर निश्चित मात्रा का निरीक्षण करते हैं, तो आप "± 50 अवलोकनों से अधिक रोलिंग माध्य" लागू करके इसे आसान बना सकते हैं।

• तो, पहला विस्तार "चिकनी खिड़कियों" को देखना है: पिछले अवलोकनों पर एक औसत की कल्पना करें जहां अतीत में एक अवलोकन जितना अधिक होगा, उसका योगदान उतना ही कम होगा। या एक गाऊसी कर्नेल पर आस-पास के औसत अवलोकन।
• दूसरा अनुकूली खिड़कियां हैं। उदाहरण के लिए, यदि आपके पास अंतराल [0, 1] पर परिभाषित शोर इनपुट है, तो ±N विंडो का उपयोग करके इसे चिकना करना किनारों के पास एक पक्षपातपूर्ण परिणाम उत्पन्न करता है। एक निष्पक्ष अनुमानक किनारे से दूरी के आधार पर खिड़की के आकार को अनुकूलित करेगा।
• पुन: नमूना चौरसाई: स्रोत डेटा के रूप में कई अवलोकनों का उत्पादन करने के लिए प्रतिबंध बहुत सीमित है। यदि आप अपने डेटा को किसी अंतर्निहित फ़ंक्शन के शोर अवलोकन के रूप में सोचते हैं, तो उस फ़ंक्शन के चिकने मूल्यों की गणना करने के लिए पूछना पूरी तरह से उचित है जो मूल इनपुट की तुलना में मोटे/महीन है। या शायद मूल डेटा अनियमित रूप से फैला हुआ है और आप इसे नियमित ग्रिड पर फिर से नमूना देना चाहते हैं।
• जैकनाइफ: प्रत्येक अवलोकन के लिए आप वर्तमान को छोड़कर सभी अवलोकनों पर औसत/प्रतिगमन की गणना करना चाहते हैं।
• के-फोल्ड स्प्लिट: डेटा को कई समूहों के रूप में देखें जहां प्रत्येक समूह अवलोकनों के केवल एक छोटे हिस्से को बाहर करता है।

इन सभी को विस्तारित ग्रुपिंग ऑपरेटरों के रूप में लागू किया जा सकता है, जिसमें रोलिंग विंडो इस सूची के तत्वों में से एक है। कहा जा रहा है, मुझे नहीं पता कि हमारे पास यह दोनों तरीके क्यों नहीं हो सकते।

मुझे यह स्वीकार करना होगा कि मैंने पहले कभी भी रोलिंग जॉइन के लिए SQL सिंटैक्स नहीं देखा है।

मुझे लगता है कि आपका मतलब रोलिंग फ़ंक्शन है, इस मुद्दे का रोलिंग जॉइन से कोई लेना-देना नहीं है।

वे अलग-अलग कॉलम पर अलग-अलग "ओवर" ऑपरेटरों को अनुमति देते हैं, हालांकि उनके द्वारा दिए गए सभी उदाहरणों में, यह वही ओवर क्लॉज कई बार दोहराया जाता है। तो यह सुझाव देता है कि यह उपयोग-मामला बहुत अधिक सामान्य है, और इसलिए एकल रोल () समूह का उपयोग करने से पुनरावृत्ति कम होगी।

यह केवल उपयोग के मामले की बात है, यदि आप एक ही OVER() को कई बार कॉल कर रहे हैं तो आपको GROUP BY का उपयोग करने, लुकअप टेबल बनाने और अन्य प्रश्नों में पुन: उपयोग करने के लिए और अधिक प्रदर्शन करने वाला मिल सकता है। जो भी उदाहरण हैं, प्रदान किए गए प्रत्येक उपाय के लिए इलाके की विशेषता को बनाए रखने के लिए ओवर () को दोहराना आवश्यक है। मैं डेटा वेयरहाउस से मामलों का उपयोग करता हूं जहां माइक्रोसॉफ्ट डॉक्स से उतना आसान नहीं है।

इसके विपरीत, GROUP BY के बजाय विंडोड एग्रीगेट फ़ंक्शंस का उपयोग करके, आप समेकित और गैर-एकत्रित दोनों मान प्राप्त कर सकते हैं।

data.table में हम इसे प्राप्त करने के लिए एक प्रश्न में := और by करते हैं।

तो ऐसा प्रतीत होता है कि सिंटैक्स को मानक SQL की सीमा को दरकिनार करने के लिए डिज़ाइन किया गया है जहाँ समूह-दर परिणाम को असंगठित मानों के साथ नहीं जोड़ा जा सकता है (अर्थात एक ही अभिव्यक्ति में A और माध्य (A) दोनों का चयन करना)। हालाँकि data.table में ऐसी कोई सीमा नहीं है, इसलिए इसे वाक्य रचना के चुनाव में अधिक स्वतंत्रता है।

यह SQL की बहुत अधिक सीमा नहीं है, बल्कि GROUP BY का केवल डिज़ाइन है, कि यह समेकित होगा, वैसे ही जैसे हमारे by समुच्चय। नई विंडो कार्यात्मकताओं को कवर करने के लिए नए एपीआई की आवश्यकता थी। SQL विंडो फ़ंक्शन के लिए ग्रुपिंग FUN() OVER (PARTITION BY ...) का उपयोग करके प्रत्येक फ़ंक्शन कॉल के लिए प्रदान की जा सकती है जहां _partition by_ एकल माप के लिए स्थानीय समूह की तरह है। इसलिए SQL के लचीलेपन को प्राप्त करने के लिए हमें उस API को j में रखते हुए j = mean(V1, roll=5) या j = over(mean(V1), roll=5) का उपयोग करना होगा। फिर भी यह दृष्टिकोण ऊपर वर्णित सभी उपयोग मामलों का समर्थन करने की अनुमति नहीं देगा।

आप "±50 प्रेक्षणों से अधिक रोलिंग माध्य" लागू करके इसे सुचारू कर सकते हैं।

इसके लिए align तर्क का उपयोग किया जाता है।

तो, पहला विस्तार "चिकनी खिड़कियों" को देखना है: पिछले अवलोकनों पर एक औसत की कल्पना करें जहां अतीत में एक अवलोकन जितना अधिक होगा, उसका योगदान उतना ही कम होगा। या एक गाऊसी कर्नेल पर आस-पास के औसत अवलोकन।

मूविंग एवरेज के कई प्रकार (वस्तुतः असीमित संख्या) हैं, सबसे आम स्मूथिंग विंडो फंक्शन (रोलमीन/एसएमए के अलावा) एक्सपोनेंशियल मूविंग एवरेज (ईएमए) है। कौन सा शामिल किया जाना चाहिए, और कौन सा नहीं, निर्णय लेने के लिए तुच्छ नहीं है, और वास्तव में यह निर्णय उपयोगकर्ताओं से आने वाले फीचर अनुरोधों के अनुसार करना सबसे अच्छा है, अब तक इस तरह के किसी भी अनुरोध का अनुरोध नहीं किया गया था।

इन सभी को विस्तारित ग्रुपिंग ऑपरेटरों के रूप में लागू किया जा सकता है, जिसमें रोलिंग विंडो इस सूची के तत्वों में से एक है।

निश्चित रूप से वे कर सकते हैं, लेकिन यदि आप SO, और हमारे रेपो में बनाए गए मुद्दों को देखेंगे, तो आप देखेंगे कि यहां वे कुछ रोलिंग फ़ंक्शन उपयोगकर्ताओं के 95+% अनुरोधों के लिए जिम्मेदार हैं। मुझे ईएमए और अन्य एमए पर काम करने में खुशी हो रही है (हालांकि मुझे यकीन नहीं है कि डेटा टेबल उनके लिए सबसे अच्छी जगह है), लेकिन एक अलग मुद्दे के रूप में। कुछ उपयोगकर्ता, जिनमें मैं भी शामिल हूं, पहले से ही 4 साल से डेटा.टेबल में साधारण मूविंग एवरेज की प्रतीक्षा कर रहे हैं।

एक सांख्यिकीविद् के दृष्टिकोण से आते हुए, यह मेरा विचार है

मेरा दृष्टिकोण डेटा वेयरहाउसिंग (जहां मैंने सप्ताह में कम से कम एक बार विंडो फ़ंक्शन का उपयोग किया था) और मूल्य प्रवृत्ति विश्लेषण (जहां मैंने दसियों अलग-अलग चलती औसत का उपयोग किया था) से आता है।

rollmean ड्राफ्ट को roll शाखा में धकेल दिया गया है। मैंने पाया कि अधिकांश अन्य पैकेज जो रोलिंग माध्य को लागू करते हैं, वे इनपुट में मौजूद na.rm=FALSE और NA के साथ अच्छी तरह से निपटने में सक्षम नहीं हैं। यह कार्यान्वयन NA को लगातार mean संभालता है, जो ISNAN कॉल के कारण कुछ अतिरिक्त ओवरहेड लगाता है। हम एपीआई को तेज लेकिन कम सुरक्षित संस्करण की अनुमति दे सकते हैं यदि उपयोगकर्ता सुनिश्चित है कि इनपुट में कोई एनए नहीं है।
पीआर #2795 . में है

@mattdowle पीआर के सवालों का जवाब दे रहा है

हम इसे data.table के अंदर क्यों कर रहे हैं? हम मौजूदा पैकेजों में योगदान देने और data.table से उनका उपयोग करने के बजाय इसे एकीकृत क्यों कर रहे हैं?

1. डेटा.टेबल में उस कार्यक्षमता के लिए पूछकर 3 अलग-अलग मुद्दे बनाए गए थे। साथ ही कई SO प्रश्न data.table को टैग करते हैं। उपयोगकर्ता उम्मीद करते हैं कि डेटा.टेबल के दायरे में होना चाहिए।
2. data.table समय-श्रृंखला डेटा के लिए पूरी तरह से फिट बैठता है और रोलिंग एग्रीगेट वहां बहुत उपयोगी आंकड़े हैं।

मेरा अनुमान है कि यह सिंटैक्स के लिए नीचे आता है (डेटा में निर्मित होने पर ही संभव या सुविधाजनक सुविधाएँ। टेबल; जैसे अंदर [...] और अनुकूलित) और सी स्तर पर रोलिंग फ़ंक्शन में डेटा। टेबल इंटर्नल का निर्माण; उदाहरण के लिए फ्रोल* को जागरूक होना चाहिए और डेटा.टेबल इंडेक्स और कुंजी का उपयोग करना चाहिए। यदि हां, तो उस पर अधिक विशिष्टताओं की आवश्यकता है; उदाहरण के लिए एक साधारण संक्षिप्त उदाहरण।

मेरे लिए व्यक्तिगत रूप से यह गति और निर्भरता की श्रृंखला की कमी के बारे में है, आजकल हासिल करना आसान नहीं है।
कुंजी/सूचकांक फ्रोलमिन/फ्रोलमैक्स के लिए उपयोगी हो सकते हैं, लेकिन यह संभावना नहीं है कि उपयोगकर्ता माप चर पर अनुक्रमणिका बनाएगा। यह संभावना नहीं है कि उपयोगकर्ता माप चर पर अनुक्रमणिका बनाएगा, साथ ही हमने अभी तक न्यूनतम/अधिकतम के लिए यह अनुकूलन नहीं किया है। मुझे GForce अनुकूलन के लिए ज्यादा समझ नहीं है क्योंकि आवंटित स्मृति रोल * कॉल के बाद जारी नहीं की जाती है लेकिन उत्तर के रूप में वापस आती है (गैर-रोलिंग माध्य, योग, आदि के विपरीत)।

यदि एकीकरण के लिए कोई ठोस तर्क नहीं है, तो हमें इसके बजाय अन्य पैकेजों में योगदान देना चाहिए।

मैंने ऊपर कुछ सूचीबद्ध किए हैं, यदि आप आश्वस्त नहीं हैं तो मैं आपको डेटा.टेबल उपयोगकर्ताओं के लिए एक प्रश्न भरने, ट्विटर पर पूछने आदि के लिए प्रतिक्रिया की जांच करने की सलाह देता हूं। इस सुविधा का लंबे समय से अनुरोध किया गया था और कई उपयोगकर्ताओं द्वारा। अगर प्रतिक्रिया आपको आश्वस्त नहीं करती है तो आप इस मुद्दे को बंद कर सकते हैं।

मैंने पाया कि sparklyr बहुत बड़े पैमाने के डेटासेट में रोलिंग फ़ंक्शंस को बहुत अच्छी तरह से सपोर्ट कर सकता है।

@harryprince उदाहरण कोड प्रदान करके थोड़ा और प्रकाश डाल सकता है कि आप इसे स्पार्कलीर में कैसे करते हैं?
"विंडो फ़ंक्शंस" के अनुसार

रोलिंग समुच्चय एक निश्चित चौड़ाई वाली खिड़की में काम करते हैं। आप उन्हें आधार R या dplyr में नहीं पाएंगे, लेकिन RcppRoll जैसे अन्य पैकेजों में कई कार्यान्वयन हैं।

AFAIU आप स्पार्कलीर के माध्यम से कस्टम स्पार्क एपीआई का उपयोग करते हैं जिसके लिए dplyr इंटरफ़ेस लागू नहीं किया गया है, सही है?

यह मुद्दा रोलिंग एग्रीगेट्स के बारे में है, अन्य "प्रकार" विंडो फ़ंक्शंस पहले से ही data.table में लंबे समय से हैं।

कुछ उदाहरण प्रदान करना ताकि हम (इन-मेमोरी) प्रदर्शन बनाम sparklyr / SparkR तुलना कर सकें, यह भी सहायक होगा।

यह मेरे लिए अभी हुआ है कि यह प्रश्न:

विभिन्न स्तंभों के लिए विभिन्न विंडो आकारों की गणना कैसे करें?

वास्तव में एक व्यापक दायरा है, और केवल रोलिंग कार्यों पर लागू नहीं होता है।

उदाहरण के लिए, यह पूछना पूरी तरह से उचित प्रतीत होता है कि औसत उत्पाद मूल्य का चयन तिथि के अनुसार कैसे करें, और फिर सप्ताह के अनुसार, और फिर शायद सप्ताह + श्रेणी के अनुसार - सभी एक ही प्रश्न के भीतर। अगर हम कभी भी ऐसी कार्यक्षमता को लागू करते हैं, तो इसके लिए प्राकृतिक वाक्यविन्यास हो सकता है

DT[, .( mean(price, by=date), 
        mean(price, by=week), 
        mean(price, by=c(week, category)) )]

अब, यदि यह कार्यक्षमता पहले से ही लागू की गई थी, तो यह वहां से रोलिंग माध्यमों तक एक साधारण छलांग होती:

DT[, .( mean(price, roll=5), 
        mean(price, roll=20), 
        mean(price, roll=100) )]

यह नहीं कहना कि यह स्पष्ट रूप से rollmean(price, 5) से बेहतर है - बस विचार करने के लिए कुछ विकल्पों में फेंकना ...

@st-pasha

दिनांक के अनुसार औसत उत्पाद मूल्य का चयन कैसे करें, और फिर सप्ताह के अनुसार, और फिर शायद सप्ताह+श्रेणी के अनुसार -- सभी एक ही क्वेरी के भीतर।

AFAIU यह ?groupingsets का उपयोग करके पहले से ही संभव है, लेकिन अभी तक [.data.table जुड़ा नहीं है।

@jangorecki , @st-pasha, and Co. - इस पर आपके सभी कार्यों के लिए धन्यवाद! मैं उत्सुक हूं कि आंशिक विंडो समर्थन को दायरे से क्यों हटा दिया गया था, क्या उस कार्यक्षमता के लिए इसे रोडमैप पर वापस लाने की कोई संभावना है? कभी-कभी मेरे काम आएगा, और एक कार्यक्षमता अंतराल को भर देगा जो मेरी जानकारी में zoo या RcppRoll में नहीं भरा गया है।

यह स्टैक ओवरफ़्लो प्रश्न एक रोलिंग एप्लिकेशन का एक अच्छा उदाहरण है जो partial = TRUE तर्क से लाभान्वित हो सकता है।

@msummersgill प्रतिक्रिया के लिए धन्यवाद। पहली पोस्ट में मैंने स्पष्ट रूप से कमिट शा को लिंक किया है जहां आंशिक विंडो फीचर कोड पाया जा सकता है। जो कार्यान्वयन है, उसे बाद में कोड की जटिलता को कम करने के लिए हटा दिया गया था। यह उस सुविधा का उपयोग न करने पर भी छोटी प्रदर्शन लागत लगा रहा था। इस सुविधा को दूसरे तरीके से लागू किया जा सकता है (और शायद होना चाहिए), पहले जैसा है वैसा ही पूरा करें, और फिर 1:window_size अतिरिक्त लूप का उपयोग करके लापता आंशिक विंडो को भरें। तो जब आप इसका उपयोग करते हैं तो उस सुविधा का ऊपरी भाग केवल ध्यान देने योग्य होता है। फिर भी हम उस कार्यक्षमता को adaptive तर्क के माध्यम से प्रदान करते हैं, जहां partial सुविधा adaptive रोलिंग माध्य का एक विशेष मामला है। ?froll मैनुअल में adaptive का उपयोग करके partial प्राप्त करने का उदाहरण है। इसे यहाँ चिपकाना:

d = as.data.table(list(1:6/2, 3:8/4))
an = function(n, len) c(seq.int(n), rep(n, len-n))
n = an(3, nrow(d))
frollmean(d, n, adaptive=TRUE)

बेशक यह सिर्फ आंशिक विंडो को भरने के लिए अतिरिक्त लूप का उपयोग करके गैर-अनुकूली रोलिंग फ़ंक्शन जितना कुशल नहीं होगा।
AFAIK zoo में partial सुविधा है।

क्या आप लोगों के पास डेटा.टेबल में रोलिंग रिग्रेशन फ़ंक्शन जोड़ने की कोई योजना है?

@waynelapierre अगर उसकी मांग होगी, तो हाँ। आपके पास मेरा +1 . है

धन्यवाद यह बहुत अच्छा है। हालांकि सिर्फ एक सवाल। मुझे केवल रोलिंग माध्य या रोलिंग माध्यिका जैसे साधारण रोलिंग एग्रीगेट दिखाई देते हैं। क्या आप डीटी डेटाफ्रेम रोलिंग जैसे अधिक परिष्कृत रोलिंग फ़ंक्शन भी लागू कर रहे हैं? कहें, पिछले 10 अवलोकनों का उपयोग करके रोलिंग डीटी बनाएं और उस पर lm प्रतिगमन चलाएं।

धन्यवाद!

@randomgambit मैं कहूंगा कि यह दायरे से बाहर है, जब तक कि इसके लिए उच्च मांग न हो। सी में नेस्टेड लूप को हैंडल करके इसे बेस आर/चिड़ियाघर से तेज होना बहुत मुश्किल नहीं होगा। लेकिन हमें नेस्टेड लूप से बचने के लिए "ऑनलाइन" एल्गोरिदम का उपयोग करके इसे लागू करने का प्रयास करना चाहिए। यह अधिक कठिन है, और हम अंततः इसे किसी भी आँकड़ों के लिए कर सकते हैं, इसलिए हमें किसी बिंदु पर उन आँकड़ों को काटना होगा।

@jangorecki दिलचस्प धन्यवाद। इसका मतलब है कि मैं एम्बेड करने के लिए tsibble का उपयोग करता रहूंगा... DATA.TABLES एक tibble ! दिमाग चकरा गया :D

एक गैर-पैरामीट्रिक "लॉजिस्टिक कर्व" की गणना करने के लिए frollmean का उपयोग करने का प्रयास किया, जो P[y | x] बाइनरी y निकटतम पड़ोसियों का उपयोग करके x दिखाता है। आश्चर्यचकित था y को logical रूप में संग्रहीत किया गया था जो स्वचालित रूप से integer में नहीं डाला गया था:

DT = data.table(x = rnorm(1000), y = runif(1000) > .5)
DT[order(x), .(x, p_y = frollmean(y, 50L))]

फ्रोल में त्रुटि (मज़ा = "माध्य", x = x, n = n, भरण = भरण, algo = algo, align = align, :
x संख्यात्मक प्रकार का होना चाहिए

कैसे वेक्टरकृत x / n तर्क प्रदर्शन को प्रभावित कर सकते हैं इसका एक उदाहरण।
https://github.com/AdrianAntico/RemixAutoML/commit/d8370712591323be01d0c66f34a70040e2867636#r34784427
कम लूप, कोड पढ़ने में आसान, बहुत तेज (10x-36x स्पीडअप)।

फ्रोलअप्लाई के लिए तैयार: https://github.com/Rdatatable/data.table/pull/3600

    ### fun             mean     sum  median
    # rollfun          8.815   5.151  60.175
    # zoo::rollapply  34.373  27.837  88.552
    # zoo::roll[fun]   0.215   0.185      NA
    # frollapply       5.404   1.419  56.475
    # froll[fun]       0.003   0.002      NA

हाय दोस्तों, क्या FUN (उपयोगकर्ता परिभाषित) को फ्रोलएप्ली में पास किया जाएगा, R ऑब्जेक्ट या डेटा को वापस करने के लिए बदल दिया जाएगा। लेबल और फ़्रॉलाप्ली एक सूची लौटाते हैं? तब हम रोलिंग रिग्रेशन या रोलिंग परीक्षण कर सकते हैं जैसे बेनफोर्ड का परीक्षण या लेबल पर सारांश।

प्रतिलिपि प्रस्तुत करने योग्य उदाहरण प्रदान करना हमेशा उपयोगी होता है। स्पष्ट करने के लिए ... ऐसे परिदृश्य में आप frollapply(dt, 3, FUN) लंबाई की एक सूची nrow(dt) frollapply(dt, 3, FUN) वापस करना चाहेंगे जहां प्रत्येक सूची तत्व data.table द्वारा लौटाया जाएगा FUN(dt[window]) ?
frollapply(x=dt, n=3, fun=FUN)[[3]] बराबर FUN(dt[1:3])
frollapply(x=dt, n=3, FUN=FUN)[[4]] बराबर FUN(dt[2:4])
क्या वो सही है? @jerryfuyu0104

वर्तमान में हम पहले तर्क के लिए पारित कई स्तंभों का समर्थन करते हैं लेकिन हम उन्हें अलग से संसाधित करते हैं, लूपिंग। हमें शायद कुछ अतिरिक्त तर्क की आवश्यकता होगी multi.var=FALSE , जब सही पर सेट किया जाता है तो यह x से अधिक लूप नहीं करेगा (जैसा कि अब होता है: list(FUN(x[[1]]),FUN(x[[2]])) ) लेकिन सभी कॉलम FUN(x) ।

इसके लिए कोई अपडेट?

मैं उस पिछले अनुरोध को दूसरा करता हूं।

इसके अलावा, आंशिक खिड़कियों की अनुमति देने के लिए "आंशिक" तर्क का समर्थन करना संभव होगा?

@eliocamp क्या आप विस्तार से partial विंडो क्या है?

@eliocamp "आंशिक" तर्क का समर्थन करना संभव होगा। आप जानते होंगे कि इस कार्यक्षमता के लिए पहले से ही समर्थन है, adaptive=TRUE तर्क का उपयोग करते हुए, विवरण के लिए उदाहरण देखें।

इसका मतलब होगा कि आधे-विंडो बिंदु के बजाय शुरुआत से अंत तक फ़ंक्शन की गणना करना।
उदाहरण के लिए, ११ चौड़ाई के रोलिंग माध्य के लिए, लौटाया गया पहला तत्व १ से ६ तक के तत्वों का माध्य होगा। दूसरा, १ से ७वें तक का माध्य, इत्यादि।

@jangorecki ओह, धन्यवाद, मुझे यह नहीं पता था! मैं इसे देख लूँगा।

सहमत हूं, हमें न केवल सुविधाजनक बल्कि गति के लिए भी आंशिक तर्क की आवश्यकता है। adaptive=TRUE एक ओवरहेड जोड़ता है।
और हाँ हमें रोलिंग रिग्रेशन की भी आवश्यकता है, इसलिए एक ही बार में कई वेरिएबल्स की आपूर्ति करना और उन पर रोल करना, प्रत्येक को अलग से नहीं।
इनकी स्थिति के बारे में कोई अपडेट नहीं है।

मुझे मदद करना अच्छा लगेगा लेकिन मेरे सी ++ कौशल पूरी तरह मौजूद नहीं हैं। :पसीना: क्या आपको लगता है कि यह पूरी तरह से नए शौक के लिए उपयुक्त हो सकता है?

हम सी ++ में कोड नहीं करते हैं लेकिन सी में। हां यह शुरू करने के लिए अच्छी जगह है। मैंने ठीक वैसा ही फ्रोलमीन पर किया था।

मैं कोड को देखता हूं और यह कठिन लगता है। लेकिन मैं आपको किसी भी मामले में अपडेट करूंगा।

लेकिन अब, एक और अनुरोध के लिए: फ्रोलमीन (.SD) को नामों को संरक्षित करना चाहिए। आम तौर पर, अगर इनपुट नामों के साथ एक सूची जैसा है, तो फ्रोल* को नामों को संरक्षित करना चाहिए।

data.table के लगातार उपयोगकर्ता के रूप में, मुझे "समय जागरूक" सुविधाओं के लिए यह बेहद उपयोगी लगता है, जैसा कि वर्तमान में पैकेज tsibble । दुर्भाग्य से यह पैकेज dplyr आसपास विकसित किया गया है। मुझे आश्चर्य है कि क्या data.table कार्यान्वयन संभव हो सकता है। इस अंक में प्रस्तावित विंडो फ़ंक्शंस उन सुविधाओं का एक सबसेट हैं।

@ywhcuhk प्रतिक्रिया के लिए धन्यवाद, मैं वास्तव में सोच रहा था कि यह मुद्दा पहले से ही बहुत अधिक मांग रहा था। उनमें से अधिकांश अभी भी हल्के पैकेज रोल द्वारा अच्छी तरह से कवर किया गया है जो बहुत तेज़ है। अन्य सुविधाओं के लिए, मेरा सुझाव है कि आप जिस सुविधा में रुचि रखते हैं, उसके लिए नया मुद्दा बनाएं, इसलिए चर्चा करें कि क्या हम लागू करना/बनाए रखना चाहते हैं, प्रत्येक के लिए अलग से निर्णय लिया जा सकता है। बस tstibble के रीडमी को देखने से मुझे इसमें कुछ भी नया नहीं दिखता ...
इसका शीर्षक "टिडी टेम्पोरल डेटा फ्रेम्स" है, लेकिन यह टेम्पोरल जॉइन की पेशकश भी नहीं करता है।

प्रतिक्रिया के लिए @jangorecki धन्यवाद। शायद यह एक संदर्भ निर्भर मुद्दा है। मैं जिस डेटा संरचना से सबसे अधिक बार निपटता हूं, उसे "पैनल डेटा" के रूप में जाना जाता है, जिसमें एक आईडी और समय होता है। यदि प्रोग्राम इस डेटा सुविधा के बारे में "जागरूक" है, तो बहुत सारे संचालन, विशेष रूप से समय-श्रृंखला संचालन, बहुत आसान हो जाएंगे। किसी ऐसे व्यक्ति के लिए जो STATA को जानता है, यह tsset और xtset पर आधारित संचालन है, जैसे लीड, लैग, फिल गैप, आदि। मुझे लगता है कि डेटा.टेबल में "इंडेक्स" को बढ़ाया जा सकता है किसी तरह इस तरह के संचालन को सक्षम करने के लिए।

बेशक, ये ऑपरेशन डेटा.टेबल फ़ंक्शंस जैसे shift और by । मैंने अभी सोचा था कि data.table में index खोज करने की बहुत संभावनाएं हैं। मैं सहमत हूं कि यह एक अलग मुद्दे से संबंधित होना चाहिए। लेकिन मुझे नहीं पता कि ऊपर की चर्चाओं को खोए बिना इसे कैसे आगे बढ़ाया जाए ...