चौरसाई अनियमित नमूना समय डेटा

Question

एक मेज जहां पहले कॉलम एक निश्चित संदर्भ बिंदु अतीत सेकंड है और दूसरा एक एक मनमाना माप है यह देखते हुए:

6 0.738158581 
21 0.801697222 
39 1.797224596 
49 2.77920469 
54 2.839757536 
79 3.832232283 
91 4.676794376 
97 5.18244704 
100 5.521878863 
118 6.316630137 
131 6.778507504 
147 7.020395216 
157 7.331607129 
176 7.637492223 
202 7.848079136 
223 7.989456499 
251 8.76853608 
278 9.092367123 
    ... 

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

क्या कोई मेरी मदद कर सकता है?

संपादित रों

1. मैं प्रत्येक कच्चे पढ़ने के लिए एक सरल पढ़ने, और समतल पढ़ने चाहते कच्चे पढ़ने का समांतर माध्य और पिछले 100 (डेल्टा) सेकंड में किसी भी अन्य हो रहा है । (जॉन, आप सही हैं)

2. विशाल ~ 1E6 - 10E6 लाइनों + तंग रैम

3. के साथ काम करने की जरूरत है डेटा लगभग यादृच्छिक की पैदल दूरी पर

4. डेटा

क्रमबद्ध हो जाता है है

RESOLUTION

मैंने जे माचिन और याएचु द्वारा प्रस्तावित समाधानों का परीक्षण किया है। दोनों ने एक ही परिणाम दिए, हालांकि, मेरे डेटा सेट पर, जे माचिन का संस्करण तेजी से प्रदर्शन करता है, जबकि यैचु की रैखिक है। अनुसरण कर रहे हैं निष्पादन समय के रूप में IPython के % timeit द्वारा मापा (माइक्रोसेकंड में):

data size J Machin yairchu 
10  90.2  55.6 
50   930   258 
100   3080  514 
500   64700  2660 
1000  253000  5390 
2000  952000  11500 

मदद के लिए आप सभी को धन्यवाद।

Answer 1

मैं एक योग परिणाम उपयोग कर रहा हूँ जो मैं नए सदस्यों को जोड़ने और पुराने लोगों को घटाकर कर रहा हूँ करने के लिए। हालांकि इस तरह से कोई फ़्लोटिंग पॉइंट त्रुटियों को जमा कर सकता है।

इसलिए मैं एक सूची के साथ एक "Deque" को लागू। और जब भी मेरा डेक एक छोटे आकार में reallocates। मैं उसी अवसर पर राशि का पुनर्मूल्यांकन करता हूं।

अप सहित बिंदु एक्स एक्स बात करने के लिए तो वहाँ औसत करने के लिए कम से कम एक नमूना बिंदु मैं भी औसत की गणना कर रहा हूँ।

def getAvgValues(data, avgSampleTime): 
    lastTime = 0 
    prevValsBuf = [] 
    prevValsStart = 0 
    tot = 0 
    for t, v in data: 
    avgStart = t - avgSampleTime 
    # remove too old values 
    while prevValsStart < len(prevValsBuf): 
     pt, pv = prevValsBuf[prevValsStart] 
     if pt > avgStart: 
     break 
     tot -= pv 
     prevValsStart += 1 
    # add new item 
    tot += v 
    prevValsBuf.append((t, v)) 
    # yield result 
    numItems = len(prevValsBuf) - prevValsStart 
    yield (t, tot/numItems) 
    # clean prevVals if it's time 
    if prevValsStart * 2 > len(prevValsBuf): 
     prevValsBuf = prevValsBuf[prevValsStart:] 
     prevValsStart = 0 
     # recalculate tot for not accumulating float precision error 
     tot = sum(v for (t, v) in prevValsBuf) 

Answer 2

इस तरह के बारे में कुछ, आखिरी बार समय अंतर के साथ मूल्यों को संग्रहित रखें> 100, औसत और उपज ऐसे मूल्य उदा।

def getAvgValues(data): 
    lastTime = 0 
    prevValues = [] 
    avgSampleTime=100 

    for t, v in data: 
     if t - lastTime < avgSampleTime: 
      prevValues.append(v) 
     else: 
      avgV = sum(prevValues)/len(prevValues) 
      lastTime = t 
      prevValues = [v] 
      yield (t,avgV) 

for v in getAvgValues(data): 
    print v 

Answer 3

आपने आउटपुट को ठीक से नहीं कहा है। मुझे लगता है कि आप प्रत्येक कच्चे पढ़ने के लिए एक चिकना पढ़ना चाहते हैं, और चिकना पढ़ना कच्चे पढ़ने और पिछले 100 (डेल्टा) सेकंड में किसी भी अन्य के अंकगणितीय अर्थ होना है।

संक्षिप्त उत्तर: संग्रह.deque का उपयोग करें ... यह कभी भी रीडिंग के "डेल्टा" सेकंड से अधिक नहीं रखेगा। जिस तरह से मैंने इसे सेट अप किया है, आप डेक को एक सूची की तरह ही इलाज कर सकते हैं, और आसानी से मतलब या कुछ फैंसी गिज्मोइड की गणना कर सकते हैं जो हालिया रीडिंग्स को अधिक भार देता है।

लांग जवाब:

>>> the_data = [tuple(map(float, x.split())) for x in """\ 
... 6  0.738158581 
... 21  0.801697222 
[snip] 
... 251  8.76853608 
... 278  9.092367123""".splitlines()] 
>>> import collections 
>>> delta = 100.0 
>>> q = collections.deque() 
>>> for t, v in the_data: 
...  while q and q[0][0] <= t - delta: 
...   # jettison outdated readings 
...   _unused = q.popleft() 
...  q.append((t, v)) 
...  count = len(q) 
...  print t, sum(item[1] for item in q)/count, count 
... 
... 
6.0 0.738158581 1 
21.0 0.7699279015 2 
39.0 1.112360133 3 
49.0 1.52907127225 4 
54.0 1.791208525 5 
79.0 2.13137915133 6 
91.0 2.49500989771 7 
97.0 2.8309395405 8 
100.0 3.12993279856 9 
118.0 3.74976297144 9 
131.0 4.41385300278 9 
147.0 4.99420529389 9 
157.0 5.8325615685 8 
176.0 6.033109419 9 
202.0 7.15545189083 6 
223.0 7.4342562845 6 
251.0 7.9150342134 5 
278.0 8.4246097095 4 
>>> 

संपादित

वन-स्टॉप शॉप: अपनी कल्पना यहाँ gizmoid मिलता है।कोड यह रहा:

numerator = sum(item[1] * upsilon ** (t - item[0]) for item in q) 
denominator = sum(upsilon ** (t - item[0]) for item in q) 
gizmoid = numerator/denominator 

जहां upsilon, बस ऊपर शून्य थोड़ा समरेखण करता है, एक आप समांतर माध्य से अधिक बर्बाद CPU समय है, और एक से अधिक देता हो जाता है एक छोटे से कम से कम 1.0 (< = शून्य गैर कानूनी है होना चाहिए आपके उद्देश्य के विपरीत)।

Answer 4

आपका डाटा मोटे तौर पर रैखिक हो रहा है:

Plot of your data http://rix0r.nl/~rix0r/share/shot-20090621.144851.gif

समरेखण किस तरह आप के लिए देख रहे हैं? कम से कम वर्ग इस डेटा सेट के लिए एक लाइन के फिट फिट? कुछ प्रकार के कम-पास फ़िल्टर? या कुछ और?

कृपया हमें बताएं ताकि हम आप थोड़ा बेहतर सलाह दे सकते हैं आवेदन बताओ।

संपादित करें: उदाहरण के लिए, आवेदन के आधार पर, पहले और अंतिम बिंदु के बीच एक रेखा को अलग करना आपके उद्देश्यों के लिए पर्याप्त हो सकता है।

Answer 5

यह एक यह रेखीय बनाता है: जैसे आप एक सरल राउंडिंग सूत्र की जरूरत

def process_data(datafile): 
    previous_n = 0 
    previous_t = 0 
    for line in datafile: 
     t, number = line.strip().split() 
     t = int(t) 
     number = float(number) 
     delta_n = number - previous_n 
     delta_t = t - previous_t 
     n_per_t = delta_n/delta_t 
     for t0 in xrange(delta_t): 
      yield previous_t + t0, previous_n + (n_per_t * t0) 
     previous_n = n 
     previous_t = t 

f = open('datafile.dat') 

for sample in process_data(f): 
    print sample 

Answer 6

लग रहा है। एक मनमाना अंतराल के किसी भी संख्या के दौर के लिए:

दौर (संख्या/अंतराल) * अंतराल

आप "के लिए अग्रणी करने के लिए" या "के बाद से" को प्रभावित करता है के लिए फर्श या छत के साथ दौर स्थानापन्न कर सकते हैं। यह एसक्यूएल सहित किसी भी भाषा में काम कर सकता है।

Answer 7

ओ (1) स्मृति यदि आप एक से अधिक बार इनपुट को पुन: सक्रिय कर सकते हैं - तो आप "बाएं" और "दाएं" के लिए एक इटरेटर का उपयोग कर सकते हैं।

def getAvgValues(makeIter, avgSampleTime): 
    leftIter = makeIter() 
    leftT, leftV = leftIter.next() 
    tot = 0 
    count = 0 
    for rightT, rightV in makeIter(): 
    tot += rightV 
    count += 1 
    while leftT <= rightT - avgSampleTime: 
     tot -= leftV 
     count -= 1 
     leftT, leftV = leftIter.next() 
    yield rightT, tot/count 

Answer 8

जबकि यह एक तेजी से खस्ताहाल औसत है, बजाय एक कुल औसत देता है, मुझे लगता है कि आप मैं एक exponential moving average with varying alpha क्या कहा जाता है, जो वास्तव में एक एकल पोल कम पास फिल्टर है सकते हैं। अब उस प्रश्न का समाधान है, और यह डेटा बिंदुओं की संख्या के लिए समय रैखिक में चलता है। देखें कि यह आपके लिए काम करता है या नहीं।