Pandas: चरण आकार के साथ रोलिंग विंडो

यदि आप 'मानक' फ़ंक्शन का उपयोग कर रहे हैं, तो ये वेक्टरकृत हैं, और इसलिए तेज़ हैं ( ts.rolling(5).max().dropna()[::2] )।

IIUC यहां बचत केवल फ़ंक्शन को समय के एक अंश को लागू करने से होगी (उदाहरण के लिए प्रत्येक nth मान)। लेकिन क्या ऐसा कोई मामला है जहां इससे व्यावहारिक फर्क पड़ता है?

यह किया जा सकता है, लेकिन मैं एक उपयोगकेस देखना चाहता हूं जहां यह मायने रखता है। यह 'इनपुट के समान आकार की वापसी' एपीआई को भी तोड़ देगा। हालांकि मुझे नहीं लगता कि इसे लागू करना वास्तव में कठिन है (हालांकि कार्यान्वयन में कई बदलाव शामिल होंगे)। हम सीमांत खिड़कियों का उपयोग करते हैं (IOW, खिड़की की गणना करें और जैसे-जैसे आप आगे बढ़ते हैं उन बिंदुओं को छोड़ दें और उन बिंदुओं को जोड़ें जिन्हें आप प्राप्त कर रहे हैं)। तो अभी भी कुछ भी गणना करना होगा, लेकिन आप इसे आउटपुट नहीं करेंगे।

आपके उत्तरों के लिए धन्यवाद!

IIUC यहां बचत केवल फ़ंक्शन को समय के एक अंश को लागू करने से होगी (उदाहरण के लिए प्रत्येक nth मान)। लेकिन क्या ऐसा कोई मामला है जहां इससे व्यावहारिक फर्क पड़ता है?

मेरा उपयोग मामला कुछ बड़े समय डेटाफ्रेम पर एकत्रीकरण कार्य (केवल अधिकतम नहीं) चला रहा है - 400 कॉलम, 5-25 हर्ट्ज पर डेटा के घंटे। मैंने 20kHz तक के डेटा के साथ अतीत में भी इसी तरह का काम किया है (सेंसर डेटा पर फीचर इंजीनियरिंग)। 5 सेकंड के चरण के साथ 30 सेकंड की विंडो चलाने से प्रसंस्करण का एक बड़ा हिस्सा बचता है - उदाहरण के लिए 25 हर्ट्ज पर 5s चरण के साथ यह 1/125 वां काम है, जो 1 मिनट या 2 घंटे में चलने के बीच का अंतर बनाता है।

मैं स्पष्ट रूप से वापस सुन्न हो सकता हूं, लेकिन यह अच्छा होगा यदि ऐसा करने के लिए उच्च स्तरीय एपीआई हो। मैंने सोचा कि यह सुझाव के लायक था अगर दूसरों को भी यह उपयोगी लगेगा - मुझे उम्मीद नहीं है कि आप सिर्फ मेरे लिए एक सुविधा का निर्माण करेंगे!

आप पहले उच्च आवृत्ति अंतराल पर फिर से शुरू करने की कोशिश कर सकते हैं, फिर रोलिंग

कुछ इस तरह

df = df.resample ('30s')
df.rolling(..).max() (या जो भी फ़ंक्शन)

अरे @jreback , सुझाव के लिए धन्यवाद।

यह काम करेगा अगर मैं सिर्फ अपने डेटा पर max चला रहा था (पुनर्मूल्यांकन को कमी फ़ंक्शन की आवश्यकता है, अन्यथा यह mean डिफ़ॉल्ट है, है ना?):

df.resample('1s').max().rolling(30).max()

हालांकि मैं 30 सेकंड के डेटा पर अपना कमी फ़ंक्शन चलाने के लिए चाहता हूं, फिर 1 सेकंड आगे बढ़ें, और इसे अगले 30 सेकंड डेटा आदि पर चलाएं। ऊपर दी गई विधि डेटा के 1 सेकंड पर एक फ़ंक्शन लागू करती है, और फिर दूसरा पहले फ़ंक्शन के 30 परिणामों पर कार्य करें।

यहां एक त्वरित उदाहरण दिया गया है - चोटी से चोटी की गणना चलाने से दो बार चलने का काम नहीं होता है (जाहिर है):

# 10 minutes of data at 5Hz
n = 5 * 60 * 10
rng = pandas.date_range('1/1/2017', periods=n, freq='200ms')
np.random.seed(0)
d = np.cumsum(np.random.randn(n), axis=0)
s = pandas.Series(d, index=rng)

# Peak to peak
def p2p(d):
    return d.max() - d.min()

def p2p_arr(d):
    return d.max(axis=1) - d.min(axis=1)

def rolling_with_step(s, window, step, func):
    # See https://ga7g08.github.io/2015/01/30/Applying-python-functions-in-moving-windows/
    vert_idx_list = np.arange(0, s.size - window, step)
    hori_idx_list = np.arange(window)
    A, B = np.meshgrid(hori_idx_list, vert_idx_list)
    idx_array = A + B
    x_array = s.values[idx_array]
    idx = s.index[vert_idx_list + int(window/2.)]
    d = func(x_array)
    return pandas.Series(d, index=idx)

# Plot data
ax = s.plot(figsize=(12, 8), legend=True, label='Data')

# Plot resample then rolling (obviously does not work)
s.resample('1s').apply(p2p).rolling(window=30, center=True).apply(p2p).plot(ax=ax, label='1s p2p, roll 30 p2p', legend=True)

# Plot rolling window with step
rolling_with_step(s, window=30 * 5, step=5, func=p2p_arr).plot(ax=ax, label='Roll 30, step 1s', legend=True)

@alexlouden आपके मूल विवरण से मुझे कुछ ऐसा लगता है

df.resample('5s').max().rolling('30s').mean() (या जो भी कटौती) आप जो चाहते हैं उसके अनुरूप अधिक है

IOW, 5s बिन में जो कुछ भी है उसे लें, फिर इसे एक बिंदु तक कम करें, फिर उन डिब्बे पर रोल करें। यह सामान्य विचार यह है कि आपके पास बहुत सारा डेटा है जिसे संक्षेप में संक्षिप्त किया जा सकता है, लेकिन आप वास्तव में इसे उच्च स्तर पर रोल करना चाहते हैं।

अरे @jreback , मैं वास्तव में हर 5 सेकंड में 30 सेकंड के डेटा पर एक फ़ंक्शन चलाना चाहता हूं। मेरे पिछले उदाहरण में रोलिंग_विथ_स्टेप फ़ंक्शन देखें। अधिकतम/माध्य का अतिरिक्त चरण मेरे उपयोग के मामले में काम नहीं करता है।

@jreback , स्टेप फंक्शन की वास्तविक आवश्यकता है जिसे अभी तक इस चर्चा में नहीं लाया गया है। मैं वह सब कुछ दूसरा करता हूं जो

मान लीजिए कि हम लगभग 3 से 10 मिलीसेकंड के नमूने वाले इनपुट डेटा के साथ समय-श्रृंखला विश्लेषण कर रहे हैं। हम फ़्रीक्वेंसी डोमेन सुविधाओं में रुचि रखते हैं। उनके निर्माण में पहला कदम Nyquist आवृत्ति का पता लगाना होगा। मान लीजिए कि डोमेन ज्ञान से हम जानते हैं कि 10 हर्ट्ज (प्रत्येक 100 एमएस में एक बार) है। इसका मतलब है, अगर सुविधाओं को इनपुट सिग्नल को अच्छी तरह से पकड़ना चाहिए, तो हमें कम से कम 20 हर्ट्ज (प्रत्येक 50 एमएस में एक बार) की आवृत्ति वाले डेटा की आवश्यकता होती है। हम उससे कम आवृत्ति के लिए पुन: नमूना नहीं कर सकते। अंतत: यहाँ वे गणनाएँ हैं जो हम करते हैं:

df.resample('50ms').mean().rolling(window=32).aggregate(power_spectrum_coeff)

यहां हमने 8 के गुणकों में एक विंडो का आकार चुना है, और 32 को चुनने से विंडो का आकार 1.6 सेकंड हो जाता है। कुल फ़ंक्शन एकल-पक्षीय आवृत्ति डोमेन गुणांक देता है और पहले माध्य घटक के बिना (fft फ़ंक्शन सममित है और 0 वें तत्व पर माध्य मान के साथ)। नमूना कुल कार्य निम्नलिखित है:

def power_spectrum_coeff():
    def power_spectrum_coeff_(x):
        return np.fft.fft(x)[1 : int(len(x) / 2 + 1)]

    power_spectrum_coeff_.__name__ = 'power_spectrum_coeff'
    return power_spectrum_coeff_

अब, हम इसे हर 0.4 सेकंड या हर 0.8 सेकंड की स्लाइडिंग विंडो में दोहराना चाहेंगे। गणनाओं को बर्बाद करने और इसके बजाय हर 50 एमएस में एफएफटी की गणना करने और फिर बाद में टुकड़ा करने का कोई मतलब नहीं है। इसके अलावा, 400 ms तक पुन: नमूनाकरण एक विकल्प नहीं है, क्योंकि 400 ms सिर्फ 2.5 हर्ट्ज है, जो कि Nyquist आवृत्ति से बहुत कम है और ऐसा करने से सभी जानकारी सुविधाओं से खो जाएगी।

यह फ़्रीक्वेंसी डोमेन विशेषताएँ थीं, जिनके कई समय-श्रृंखला संबंधी वैज्ञानिक प्रयोगों में अनुप्रयोग हैं। हालांकि, मानक विचलन जैसे सरल टाइम-डोमेन कुल कार्यों को भी पुन: नमूनाकरण द्वारा प्रभावी ढंग से समर्थित नहीं किया जा सकता है।

हालांकि मुझे नहीं लगता कि इसे लागू करना वास्तव में कठिन है (हालांकि कार्यान्वयन में कई बदलाव शामिल होंगे)। हम सीमांत खिड़कियों का उपयोग करते हैं (IOW, खिड़की की गणना करें और जैसे-जैसे आप आगे बढ़ते हैं, उन बिंदुओं को छोड़ दें जो छोड़ रहे हैं और उन बिंदुओं को जोड़ते हैं जो आप प्राप्त कर रहे हैं)। तो अभी भी सब कुछ गणना करना होगा, लेकिन आप इसे आउटपुट नहीं करेंगे।

'स्टेप' पैरामीटर होना और इसका उपयोग करके वास्तविक गणनाओं को कम करने में सक्षम होना पंडों का भविष्य का लक्ष्य होना चाहिए। यदि चरण पैरामीटर केवल कम अंक देता है, तो यह करने योग्य नहीं है, क्योंकि हम किसी भी तरह आउटपुट को स्लाइस कर सकते हैं। शायद ऐसा करने में शामिल काम को देखते हुए, हम सिर्फ उन सभी परियोजनाओं की सिफारिश कर सकते हैं जिनमें नम्पी का उपयोग करने की आवश्यकता है।

@Murmuria ऐसा करने के लिए पुल-अनुरोध सबमिट करने के लिए आपका स्वागत है। यह वास्तव में उतना मुश्किल नहीं है।

जबकि मैं step पैरामीटर के लिए rolling() दूसरा अनुरोध करता हूं, मैं यह बताना चाहता हूं कि base पैरामीटर के साथ वांछित परिणाम प्राप्त करना संभव है resample() , यदि चरण आकार विंडो आकार का एक पूर्णांक अंश है । @alexlouden के उदाहरण का उपयोग करना:

pandas.concat([
    s.resample('30s', label='left', loffset=pandas.Timedelta(15, unit='s'), base=i).agg(p2p) 
    for i in range(30)
]).sort_index().plot(ax=ax, label='Solution with resample()', legend=True, style='k:')

हमें एक ही परिणाम मिलता है (ध्यान दें कि रेखा दोनों तरफ 30 सेकंड तक फैली हुई है):

एकत्रीकरण के प्रकार के आधार पर यह अभी भी कुछ हद तक बेकार है। पीक-टू-पीक गणना के विशेष मामले के लिए जैसा कि @alexlouden के उदाहरण में है, p2p_arr() लगभग 200x तेज है क्योंकि यह श्रृंखला को 2-डी मैट्रिक्स में पुनर्व्यवस्थित करता है और फिर max() लिए एकल कॉल का उपयोग करता है min() ।

रोलिंग में चरण पैरामीटर बिना डेटाटाइम इंडेक्स के इस सुविधा का उपयोग करने की अनुमति देगा। क्या कोई पहले से ही इस पर काम कर रहा है?

@alexlouden ऊपर ने यह कहा:

मैं स्पष्ट रूप से वापस सुन्न हो सकता हूं, लेकिन यह अच्छा होगा यदि ऐसा करने के लिए उच्च स्तरीय एपीआई हो।

क्या @alexlouden या कोई और जो जानता है कृपया कुछ अंतर्दृष्टि साझा करें कि इसे numpy के साथ कैसे करें? मेरे अब तक के शोध से, ऐसा लगता है कि ऐसा करना तुच्छ नहीं है। वास्तव में, यहाँ इसके बारे में एक खुला मुद्दा है https://github.com/numpy/numpy/issues/7753

धन्यवाद

हाय @tsando - क्या फ़ंक्शन rolling_with_step मैंने ऊपर उपयोग किया था जो आपके लिए काम नहीं करता है?

@alexlouden धन्यवाद, बस उस समारोह की जाँच की और यह अभी भी पांडा पर निर्भर करता है (एक इनपुट के रूप में एक श्रृंखला लेता है और श्रृंखला सूचकांक का भी उपयोग करता है)। मैं सोच रहा था कि क्या इस पर विशुद्ध रूप से सुन्न दृष्टिकोण है। धागे में मैंने https://github.com/numpy/numpy/issues/7753 का उल्लेख किया है, वे एक फ़ंक्शन का प्रस्ताव देते हैं जो numpy स्ट्राइड्स का उपयोग करता है, लेकिन उन्हें विंडो और स्टेप इनपुट को समझना और अनुवाद करना कठिन होता है।

@tsando यहां ब्लॉग पोस्ट अपनी साइट को फिर से नहीं रखा है। (मैंने इसे पीडीएफ में बदलने के लिए इसे स्थानीय रूप से चलाया)।

ऊपर मेरा कार्य यह था कि मैं पंडों के साथ काम करने के लिए उनके अंतिम उदाहरण को परिवर्तित कर रहा था - यदि आप सीधे numpy का उपयोग करना चाहते हैं तो आप ऐसा कुछ कर सकते हैं: https://gist.github.com/alexlouden/e42f1d96982f7f005e62ebb737dcd987

उम्मीद है ये मदद करेगा!

@alexlouden धन्यवाद! मैंने इसे (13, 1313) आकार की एक सरणी पर आज़माया लेकिन इसने मुझे यह त्रुटि दी:

"यह किया जा सकता है, लेकिन मैं एक उपयोगकेस देखना चाहता हूं जहां यह मायने रखता है।"

पांडा का उपयोग करने पर मैंने जो भी प्रोजेक्ट काम किया, मैंने लगभग हमेशा इस सुविधा को याद किया, यह हर बार उपयोगी होता है जब आपको केवल एक बार आवेदन की गणना करने की आवश्यकता होती है, लेकिन फिर भी प्रत्येक विंडो के अंदर अच्छे रिज़ॉल्यूशन की आवश्यकता होती है।

मैं सहमत हूं और इस सुविधा का भी समर्थन करता हूं

समय श्रृंखला से निपटने के दौरान लगभग हर बार इसकी आवश्यकता होती है, यह सुविधा विज़ुअलाइज़ेशन और विश्लेषण दोनों के लिए समय श्रृंखला सुविधाओं को उत्पन्न करने के लिए बेहतर नियंत्रण दे सकती है। इस विचार का पुरजोर समर्थन करें!

सहमत हैं और इस सुविधा का भी समर्थन करते हैं

यह अभी भी एक अच्छा विंडो रिज़ॉल्यूशन रखते हुए कंप्यूटिंग समय को कम करने में बहुत मददगार होगा।

मैं एक समाधान कोड प्रदान करता हूं, जिसे आपके विशेष लक्ष्य के अनुरूप और अधिक समायोजित किया जा सकता है।

def average_smoothing(signal, kernel_size, stride):
    sample = []
    start = 0
    end = kernel_size
    while end <= len(signal):
        start = start + stride
        end = end + stride
        sample.append(np.mean(signal[start:end]))
    return np.array(sample)

मैं सहमत हूं और इस सुविधा का समर्थन करता हूं। मैं देख रहा हूँ अभी स्टॉप मोशन में है।

जब आपके पास डेटा का टीबी हो तो गणना करना और फिर डाउनसैंपलिंग कोई विकल्प नहीं है।

मैं जो करता हूं उसमें भी यह बहुत मददगार होगा। मेरे पास डेटा के टीबी हैं जहां मुझे स्थानीय परिस्थितियों को समझने के लिए गैर-अतिव्यापी विंडो के विभिन्न आंकड़ों की आवश्यकता है। मेरा वर्तमान "फिक्स" सिर्फ एक जनरेटर बनाना है जो डेटा फ्रेम और उपज के आंकड़ों को स्लाइस करता है। यह सुविधा होने से काफी मदद मिलेगी।

समय श्रृंखला शामिल होने पर यह सुविधा वास्तव में होनी चाहिए!

सहमत हूं, निश्चित रूप से इस सुविधा को जोड़ने की जरूरत है। स्टॉक की कीमतों के बीच विंडो सहसंबंध चलाने की कोशिश कर रहा है और इसके लिए अपना खुद का कार्य बनाना है

विश्वास नहीं हो रहा है कि ऐसी बुनियादी सुविधा अभी तक नहीं है!
यह मसला कब सुलझेगा?
धन्यवाद

'आगे की चर्चा' में योगदान करने के लिए:
मेरा उपयोग मामला 1 सेकंड के संकल्प के साथ डेटा के एक महीने के लिए प्रति घंटे एक मिनट/अधिकतम/औसत मान की गणना करना है। यह ऊर्जा उपयोग डेटा है और 1-2 सेकंड के लिए चोटियां हैं जिन्हें मैं पुन: नमूनाकरण के साथ खो दूंगा। इसके अलावा, उदाहरण के लिए 5 सेकंड/1 मिनट का पुन: नमूनाकरण इस तथ्य को नहीं बदलेगा कि मुझे अभी भी प्रति दिन 4k/1k विंडो की गणना करनी है, जिन्हें केवल आवश्यक 24 विंडो प्रति दिन की गणना करने में सक्षम होने के बजाय फेंकने की आवश्यकता है। .

ग्रुपबी एसो का उपयोग करके इसके आसपास काम करना संभव होगा, लेकिन यह न तो सहज ज्ञान युक्त और न ही रोलिंग कार्यान्वयन के रूप में तेज़ लगता है (सॉर्टिंग के साथ 2.5 मिलियन घंटे लंबी विंडो के लिए 2 सेकंड)। यह प्रभावशाली रूप से तेज़ और उपयोगी है, लेकिन हमें इसकी शक्ति का पूरी तरह से उपयोग करने के लिए वास्तव में एक विस्तृत तर्क की आवश्यकता है।

मैंने समस्या का जायजा लिया। यह अपेक्षाकृत तुच्छ है, हालांकि जिस तरह से कोड लागू किया गया है, एक सरसरी नज़र से मुझे लगता है कि इसके लिए किसी को सभी रोलिंग रूटीन को मैन्युअल रूप से संपादित करने के लिए नारा लगाना होगा। उनमें से कोई भी अनुक्रमणिका वर्गों द्वारा दी गई खिड़की की सीमाओं का सम्मान नहीं करता है। अगर उन्होंने ऐसा किया, तो यह अनुरोध और #11704 दोनों ही बहुत आसानी से हल किए जा सकते हैं। किसी भी मामले में, मुझे लगता है कि यह किसी के लिए भी प्रबंधनीय है जो चीजों को स्प्रूस करने में कुछ समय बिताना चाहता है। मैंने एक अर्ध-बेक्ड पीआर (केवल एक एमवीपी के लिए अस्वीकार किए जाने की उम्मीद) की शुरुआत की, यह प्रदर्शित करने के लिए कि मैं समस्या से कैसे निपटूंगा।

दौड़ना:

import numpy as np
import pandas as pd

data = pd.Series(
    np.arange(100),
    index=pd.date_range('2020/05/12 12:00:00', '2020/05/12 12:00:10', periods=100))

print('1s rolling window every 2s')
print(data.rolling('1s', step='2s').apply(np.mean))

data.sort_index(ascending=False, inplace=True)

print('1s rolling window every 500ms (and reversed)')
print(data.rolling('1s', step='500ms').apply(np.mean))

पैदावार

1s rolling window every 2s
2020-05-12 12:00:00.000000000     4.5
2020-05-12 12:00:02.020202020    24.5
2020-05-12 12:00:04.040404040    44.5
2020-05-12 12:00:06.060606060    64.5
2020-05-12 12:00:08.080808080    84.5
dtype: float64
1s rolling window every 500ms (and reversed)
2020-05-12 12:00:10.000000000    94.5
2020-05-12 12:00:09.494949494    89.5
2020-05-12 12:00:08.989898989    84.5
2020-05-12 12:00:08.484848484    79.5
2020-05-12 12:00:07.979797979    74.5
2020-05-12 12:00:07.474747474    69.5
2020-05-12 12:00:06.969696969    64.5
2020-05-12 12:00:06.464646464    59.5
2020-05-12 12:00:05.959595959    54.5
2020-05-12 12:00:05.454545454    49.5
2020-05-12 12:00:04.949494949    44.5
2020-05-12 12:00:04.444444444    39.5
2020-05-12 12:00:03.939393939    34.5
2020-05-12 12:00:03.434343434    29.5
2020-05-12 12:00:02.929292929    24.5
2020-05-12 12:00:02.424242424    19.5
2020-05-12 12:00:01.919191919    14.5
2020-05-12 12:00:01.414141414     9.5
2020-05-12 12:00:00.909090909     4.5
dtype: float64

कार्यान्वयन विवरण के लिए पीआर पर एक नज़र डालें (या यहां: https://github.com/anthonytw/pandas/tree/rolling-window-step)

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

क्या यह get_window_bounds() दृष्टिकोण का उपयोग करके एक कस्टम विंडो के लिए भी काम करेगा?

नमस्ते वहाँ, मैं दूसरा भी सुझाव कृपया। यह वास्तव में उपयोगी विशेषता होगी।

यदि आप 'मानक' फ़ंक्शन का उपयोग कर रहे हैं, तो ये वेक्टरकृत हैं, और इसलिए तेज़ हैं ( ts.rolling(5).max().dropna()[::2] )।

IIUC यहां बचत केवल फ़ंक्शन को समय के एक अंश को लागू करने से होगी (उदाहरण के लिए प्रत्येक nth मान)। लेकिन क्या ऐसा कोई मामला है जहां इससे व्यावहारिक फर्क पड़ता है?

मेरे पास यहाँ ऐसा ही एक उदाहरण है: https://stackoverflow.com/questions/63729190/pandas-resample-daily-data-to-annual-data-with-overlap-and-offset

प्रत्येक एनएच प्रत्येक 365वां होगा। विंडो का आकार प्रोग्राम के जीवनकाल में परिवर्तनशील है और चरण विंडो आकार के पूर्णांक अंश होने की गारंटी नहीं है।

मुझे मूल रूप से एक सेट विंडो आकार की आवश्यकता है जो "वर्ष में # दिनों को देख रहा है" जो इस मुद्दे के लिए अब तक मिले हर समाधान के साथ असंभव है।

मुझे निम्नलिखित संदर्भ के साथ भी इसी तरह की आवश्यकता है (वास्तविक और व्यावसायिक आवश्यकता से अनुकूलित):

• मेरे पास टाइमस्टैम्प कॉलम और एक मान कॉलम वाला कालानुक्रमिक डेटाफ़्रेम है, जो अनियमित घटनाओं का प्रतिनिधित्व करता है। उस टाइमस्टैम्प की तरह जब एक कुत्ता मेरी खिड़की के नीचे से गुजरा और उसे पास होने में कितने सेकंड लगे। मेरे पास किसी दिए गए दिन के लिए 6 ईवेंट हो सकते हैं और फिर अगले 2 दिनों के लिए कोई भी ईवेंट नहीं हो सकता है
• मैं 365 दिनों की रोलिंग विंडो के साथ एक मीट्रिक की गणना करना चाहता हूं (मान लें कि मेरी खिड़की के सामने कुत्तों द्वारा बिताया गया औसत समय), जो हर 30 दिनों में रोल करेगा

जहां तक ​​मैं समझता हूं, dataframe.rolling() API मुझे 365 दिनों की अवधि निर्दिष्ट करने की अनुमति देता है, लेकिन अगले माध्य की गणना करने के लिए 30 दिनों के मानों (जो पंक्तियों की एक गैर-स्थिर संख्या है) को छोड़ने की आवश्यकता नहीं है। 365 दिनों के मूल्यों का चयन।

जाहिर है, परिणामी डेटाफ्रेम मुझे उम्मीद है कि प्रारंभिक 'कुत्ते की घटनाओं' डेटाफ्रेम की तुलना में पंक्तियों की एक (बहुत) छोटी संख्या होगी।

एक साधारण उदाहरण के साथ इस अनुरोध के बारे में अधिक स्पष्टता प्राप्त करने के लिए।

अगर हमारे पास यह श्रृंखला है:

In [1]: s = pd.Series(range(5))

In [2]: s
Out[2]:
0    0
1    1
2    2
3    3
4    4
dtype: int64

और हम की एक खिड़की आकार 2 और के कदम आकार 1 । इंडेक्स 0 पर इस पहली विंडो का मूल्यांकन किया जाएगा, इंडेक्स 1 पर विंडो पर कदम, इंडेक्स 2 आदि पर विंडो का मूल्यांकन करें?

In [3]: s.rolling(2, step=1, min_periods=0).max()

Out[3]:
0    0.0
1    NaN # step over this observation
2    2.0
3    NaN # step over this observation
4    4.0
dtype: float64

इसी तरह अगर हमारे पास यह समय आधारित श्रृंखला है

In [1]: s = pd.Series(range(5), index=pd.DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-06', '2020-01-09']))

In [2]: s
Out[2]:
2020-01-01    0
2020-01-02    1
2020-01-03    2
2020-01-06    3
2020-01-09    4
dtype: int64

और हम की एक खिड़की आकार '3D' और के कदम आकार '3D' । क्या यह सही परिणाम होगा?

In [3]: s.rolling('3D', step='3D', min_periods=0).max()

Out[3]:
2020-01-01    0.0       # evaluate this window
2020-01-02    NaN    # step over this observation (2020-01-01 + 3 days > 2020-01-02)
2020-01-03    NaN    # step over this observation (2020-01-01 + 3 days > 2020-01-03)
2020-01-06    3.0      # evaluate this window ("snap back" to this observation)
2020-01-09    4.0      # evaluate this window (2020-01-06 + 3 days = 2020-01-09)
dtype: float64

पहले उदाहरण के लिए @mroeschke wrt ([3]), परिणाम वे नहीं हैं जिनकी मैं अपेक्षा करता हूँ। मुझे लगता है कि यह एक अनुगामी खिड़की है (उदाहरण के लिए, सूचकांक = 0 पर यह -1 और 0 पर अधिकतम तत्व होंगे, इसलिए केवल अधिकतम ([0]), फिर इसे "1" अनुक्रमणिका, अनुक्रमणिका = 0 पर आगे बढ़ना चाहिए + चरण = 1, और अगली गणना अधिकतम ([0,1]), फिर अधिकतम ([1,2]), आदि होगी। ऐसा लगता है कि आपके पास दो का एक चरण आकार था, इसलिए आप करेंगे इंडेक्स = 0 से इंडेक्स = 0 + 2 = 2 (इंडेक्स 1 को छोड़ना), और इसी तरह जारी रखना। इस मामले में यह लगभग सही है, लेकिन कोई NaN नहीं होना चाहिए। हालांकि यह "केवल" आकार में दोगुना हो सकता है मामले में, अन्य मामलों में यह पर्याप्त है। उदाहरण के लिए, मेरे पास एक मरीज के लिए लगभग एक घंटे का 500 हर्ट्ज ईसीजी डेटा है, जो कि 1.8 मिलियन नमूने हैं। अगर मुझे हर दो मिनट में 5 मिनट की चलती औसत चाहिए, तो यह एक सरणी होगी 30 मान्य संगणनाओं के साथ 1.8 मिलियन तत्व और 1.8 मिलियन NaN से थोड़ा कम। :-)

अनुक्रमण के लिए, चरण आकार = 1 वर्तमान व्यवहार है, अर्थात, विंडो में डेटा का उपयोग करके रुचि की विशेषता की गणना करें, विंडो को एक से स्थानांतरित करें, फिर दोहराएं। इस उदाहरण में, मैं विंडो में डेटा का उपयोग करके रुचि की विशेषता की गणना करना चाहता हूं, फिर 60,000 सूचकांकों द्वारा शिफ्ट करें, फिर दोहराएं।

समय के लिए इसी तरह की टिप्पणी। इस मामले में, इस प्रकार की विंडो को लागू करने के सही तरीके के बारे में कुछ असहमति हो सकती है, लेकिन मेरी राय में "सर्वश्रेष्ठ" (टीएम) तरीका समय t0 से शुरू करना है, सीमा में सभी तत्वों को ढूंढें (टी0-विंडो , t0], सुविधा की गणना करें, फिर चरण आकार से आगे बढ़ें। ऐसी किसी भी विंडो को फेंक दें जिसमें तत्वों की न्यूनतम संख्या से कम हो (कॉन्फ़िगर करने योग्य, डिफ़ॉल्ट 1 के लिए)। वह उदाहरण पिछली विंडो के लिए है, लेकिन आप संशोधित कर सकते हैं किसी भी विंडो कॉन्फ़िगरेशन को फिट करने के लिए। इसमें बड़े अंतराल में समय बर्बाद करने का नुकसान है, लेकिन अंतराल को समझदारी से संभाला जा सकता है और भले ही आप भोले तरीके से गणना करें (क्योंकि आप मेरी तरह आलसी हैं) मुझे अभी तक इस मामले को व्यवहार में देखना है , चूंकि अंतराल आमतौर पर वास्तविक डेटा में मायने रखने के लिए पर्याप्त बड़े नहीं होते हैं।

शायद यह अधिक स्पष्ट है? ऊपर मेरे उदाहरण + कोड पर एक नज़र डालें, जो इसे बेहतर तरीके से समझा सकता है।

@anthonytw स्पष्टीकरण के लिए धन्यवाद। दरअसल, ऐसा लगता है कि मुझे step को "कदम से बिंदु" के रूप में व्याख्या करने की आवश्यकता है।

जहां तक ​​NaN का संबंध है, मैं आउटपुट परिणाम में NaN को स्वचालित रूप से छोड़ने की भावनाओं को समझता हूं, लेकिन जैसा कि https://github.com/pandas-dev/pandas/issues/15354#issuecomment -278676420 by @jreback में उल्लेख किया गया है, वहां है आउटपुट के लिए एक एपीआई स्थिरता विचार इनपुट के समान लंबाई है। ऐसे उपयोगकर्ता हो सकते हैं जो NaN को भी रखना चाहते हैं (शायद?), और dropna rolling(..., step=...).func() ऑपरेशन के बाद भी उपलब्ध होगा।

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

ध्यान दें कि एक गणना मूल्यों की एक सरणी उत्पन्न कर सकती है। मैं ईसीजी तरंग के साथ क्या करना चाहता हूं? खैर, निश्चित रूप से पावर स्पेक्ट्रम की गणना करें! इसलिए मुझे 1 पूर्ण PSD वेक्टर (150,000 तत्व) 1.8 मिलियन बार (2TB डेटा) के लिए पर्याप्त स्थान आवंटित करने की आवश्यकता है, फिर उन टुकड़ों को प्राप्त करने के लिए फ़िल्टर करें जिनकी मुझे परवाह है (34MB)। सभी श्रृंखलाओं के लिए। सभी रोगियों के लिए। मुझे लगता है कि मुझे और रैम खरीदने की जरूरत है!

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

जबकि मैं एपीआई को बनाए रखने की इच्छा को समझता हूं, यह एक ऐसी सुविधा नहीं है जो किसी भी मौजूदा कोड को तोड़ देगी (क्योंकि यह एक नई सुविधा है जो पहले मौजूद नहीं थी), और कार्यक्षमता को देखते हुए कोई कारण नहीं है कि कोई भी इसे प्राप्त करने की उम्मीद करेगा। एक ही आकार का आउटपुट। और यहां तक ​​कि अगर उन्होंने किया, तो चरण आकार के लिए दस्तावेज़ीकरण में एक नोट पर्याप्त होगा। नुकसान "सुसंगत" एपीआई होने के किसी भी लाभ से कहीं अधिक है (ऐसी सुविधा के लिए जो पहले मौजूद नहीं थी, आपको याद है)। इस तरह से आगे नहीं बढ़ना सुविधा को पंगु बना देगा, यह उस मामले में लागू करने लायक भी नहीं है (मेरे अनुभव में अंतरिक्ष लागत लगभग हमेशा बड़ा कारक है)।