एक चर दर से एक निश्चित दर पर फिर से नमूना करने के लिए एक एल्गोरिथ्म क्या है?

Question

मेरे पास एक सेंसर है जो एक टाइम स्टांप और एक मूल्य के साथ इसकी रीडिंग की रिपोर्ट करता है। हालाँकि, यह एक निश्चित दर पर रीडिंग उत्पन्न नहीं करता है।

मुझे लगता है कि परिवर्तनीय दर डेटा से निपटने के लिए मुश्किल है। अधिकांश फ़िल्टर एक निश्चित नमूना दर की अपेक्षा करते हैं। एक निश्चित नमूना दर के साथ-साथ रेखांकन भी आसान है।

वहाँ एक चर नमूना दर से एक निश्चित नमूना दर से फिर से शुरू करने के लिए एक एल्गोरिथ्म है?

Comments

यह प्रोग्रामर का एक क्रॉस पोस्ट है। मुझे बताया गया कि यह पूछने के लिए बेहतर जगह है। programmers.stackexchange.com/questions/193795/…

— FigBug

क्या निर्धारित करता है जब सेंसर एक रीडिंग की रिपोर्ट करेगा? क्या यह रीडिंग तभी भेजता है जब रीडिंग बदलती है? एक सरल दृष्टिकोण एक "आभासी नमूना अंतराल" (टी) चुनना होगा जो उत्पन्न रीडिंग के बीच कम से कम समय से छोटा हो। एल्गोरिथ्म इनपुट पर, केवल अंतिम रिपोर्ट किए गए रीडिंग (करंट रीडिंग) को स्टोर करें। एल्गोरिदम आउटपुट पर, करंट रीयरिंग को "नए सैंपल" के रूप में रिपोर्ट करें, हर T सेकंड ताकि फिल्टर या ग्राफिंग सर्विस एक स्थिर दर (हर T सेकंड) पर रीडिंग प्राप्त करे। कोई विचार नहीं अगर यह आपके मामले में पर्याप्त है।

— user2718

यह हर 5ms या 10ms का नमूना लेने की कोशिश करता है। लेकिन यह कम प्राथमिकता वाला काम है, इसलिए इसमें चूक या देरी हो सकती है। मेरे पास 1 एमएस के लिए सही समय है। प्रसंस्करण पीसी पर किया जाता है, वास्तविक समय में नहीं, इसलिए धीमी एल्गोरिथ्म ठीक है अगर इसे लागू करना आसान है।

— अंजीर

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

— mbaitoff

क्या आप अंतर्निहित संकेत की कोई विशेषता जानते हैं जो आप नमूना कर रहे हैं? यदि अनियमित रूप से फैला हुआ डेटा अभी भी मापा जा रहा सिग्नल की बैंडविड्थ की तुलना में एक उच्च नमूना दर पर है, तो समान-दूरी वाले समय ग्रिड के लिए बहुपद प्रक्षेप की तरह कुछ सरल ठीक काम कर सकता है।

— जेसन आर

Answer 1

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

चाल गैर-वर्दी नमूनों के आपके सेट पर विचार करने के लिए है क्योंकि पहले से ही सिनकोप प्रक्षेप के माध्यम से वर्दी नमूनों से पुनर्निर्माण किया गया है । कागज में संकेतन के बाद:

$$y(t) = \sum_{k=1}^{N}{y(kT)\frac{\sin(\pi(t - kT)/T)}{\pi(t - kT)/T}} = \sum_{k=1}^{N}{y(kT)\mathrm{sinc}(\frac{t - kT}{T})}.$$

ध्यान दें कि यह रेखीय समीकरणों का एक सेट प्रदान करता है, प्रत्येक गैर-वर्दी नमूना , जहां अज्ञात समान-समान नमूने , जैसे:y ( k T $y(t)$$y(kT)$

$$\begin{bmatrix} y(t_0) \\ y(t_1) \\ \cdots \\ y(t_m) \end{bmatrix} = \begin{bmatrix} \mathrm{sinc}(\frac{t_0 - T}{T}) & \mathrm{sinc}(\frac{t_0 - 2T}{T}) & \cdots & \mathrm{sinc}(\frac{t_0 - nT}{T}) \\ \mathrm{sinc}(\frac{t_1 - T}{T}) & \mathrm{sinc}(\frac{t_1 - 2T}{T}) & \cdots & \mathrm{sinc}(\frac{t_1 - nT}{T}) \\ \cdots & \cdots & \cdots &\cdots \\ \mathrm{sinc}(\frac{t_m - T}{T}) & \mathrm{sinc}(\frac{t_m - 2T}{T}) & \cdots & \mathrm{sinc}(\frac{t_m - nT}{T}) \end{bmatrix} \begin{bmatrix} y(T) \\ y(2T) \\ \cdots \\ y(nT) \end{bmatrix}.$$

उपरोक्त समीकरण में, अज्ञात वर्दी नमूनों की संख्या है, समान नमूना दर का व्युत्क्रम है, और गैर-समान नमूने (जो से अधिक हो सकता है ) की संख्या है। उस प्रणाली के कम से कम वर्गों के समाधान की गणना करके , समान नमूनों को फिर से संगठित किया जा सकता है। तकनीकी तौर पर, केवल असमान नमूने जरूरी हैं, लेकिन पर कैसे "बिखरे" निर्भर करता है कि वे कर रहे हैं समय में, प्रक्षेप मैट्रिक्स बुरी तरह हो सकता है बीमार वातानुकूलित । जब ऐसा होता है, तो अधिक गैर-समान नमूनों का उपयोग आमतौर पर मदद करता है।टी एम एन $n$$T$$m$$n$$n$

एक खिलौने के उदाहरण के रूप में, यहाँ उपरोक्त विधि और क्यूबिक स्पलाइन प्रक्षेप के बीच तुलनात्मक रूप से तुलनात्मक रूप से एक तुलना की जाती है :

(इस उत्तर के अंत में उपरोक्त कथानक को पुन: प्रस्तुत करने के लिए कोड शामिल किया गया है)

कहा जा रहा है कि उच्च गुणवत्ता वाले, मजबूत तरीकों के लिए, निम्नलिखित में से किसी एक पेपर में कुछ के साथ शुरू करना संभवतः अधिक उचित होगा:

ए। अल्डरौबी और कार्ल्हिन्ज ग्रोचिग, नॉनफिफॉर्म नमूना और शिफ्ट-इनवेरिएंट स्पेस में पुनर्निर्माण , SIAM Rev., 2001, सं। 4, 585-620। ( pdf लिंक )।

के। ग्रोचेन और एच। श्वाब, शिफ्ट-इनवेरिएंट रिक्त स्थान में गैर- वर्दी नमूनाकरण के लिए तेजी से स्थानीय पुनर्निर्माण के तरीके , सियाम जे मैट्रिक्स एनल। Appl।, 24 (2003), 899- 913।

-

import numpy as np
import pylab as py

import scipy.interpolate as spi
import numpy.random as npr
import numpy.linalg as npl

npr.seed(0)

class Signal(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def plot(self, title):
        self._plot(title)
        py.plot(self.x, self.y ,'bo-')
        py.ylim([-1.8,1.8])
        py.plot(hires.x,hires.y, 'k-', alpha=.5)

    def _plot(self, title):
        py.grid()
        py.title(title)
        py.xlim([0.0,1.0])

    def sinc_resample(self, xnew):
        m,n = (len(self.x), len(xnew))
        T = 1./n
        A = np.zeros((m,n))

        for i in range(0,m):
            A[i,:] = np.sinc((self.x[i] - xnew)/T)

        return Signal(xnew, npl.lstsq(A,self.y)[0])

    def spline_resample(self, xnew):
        s = spi.splrep(self.x, self.y)
        return Signal(xnew, spi.splev(xnew, s))

class Error(Signal):

    def __init__(self, a, b):
        self.x = a.x
        self.y = np.abs(a.y - b.y)

    def plot(self, title):
        self._plot(title)
        py.plot(self.x, self.y, 'bo-')
        py.ylim([0.0,.5])

def grid(n): return np.linspace(0.0,1.0,n)
def sample(f, x): return Signal(x, f(x))

def random_offsets(n, amt=.5):
    return (amt/n) * (npr.random(n) - .5)

def jittered_grid(n, amt=.5):
    return np.sort(grid(n) + random_offsets(n,amt))

def f(x):
    t = np.pi * 2.0 * x
    return np.sin(t) + .5 * np.sin(14.0*t)

n = 30
m = n + 1

# Signals
even   = sample(f, np.r_[1:n+1] / float(n))
uneven = sample(f, jittered_grid(m))
hires  = sample(f, grid(10*n))

sinc   = uneven.sinc_resample(even.x)
spline = uneven.spline_resample(even.x)

sinc_err   = Error(sinc, even)
spline_err = Error(spline, even)

# Plot Labels
sn = lambda x,n: "%sly Sampled (%s points)" % (x,n)
r  = lambda x: "%s Reconstruction" % x
re = lambda x: "%s Error" % r(x)

plots = [
    [even,       sn("Even", n)],
    [uneven,     sn("Uneven", m)],
    [sinc,       r("Sinc")],
    [sinc_err,   re("Sinc")],
    [spline,     r("Cubic Spline")],
    [spline_err, re("Cubic Spline")]
]

for i in range(0,len(plots)):
    py.subplot(3, 2, i+1)
    p = plots[i]
    p[0].plot(p[1])

py.show()

Comments

अच्छा तरीका और कोड। लेकिन कुछ साथ लिए (जैसे [0 1 - 3 4 5 - 7 8] T), जो मुझे लगता है कि ओपीएस प्रश्न है, मैट्रिक्स 0 में सभी sinc नहीं हैं? निश्चित रूप से इसे ठीक करने के तरीके हैं, लेकिन। $t_j = jT$

— डेनिस

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

— datageist

यदि सभी पूर्णांक (T = 1) हो तो क्या होगा ? मान लें कि हमारे पास लिए डेटा बिंदु [ ] हैं , गैर-शून्य पूर्णांक का एक सेट जैसे {-1 1} या {-2 -1 1 2}; प्रक्षेपित , भले ही की परवाह किए बिना - या मैंने कुछ याद किया है? $t_j$$j, y_j$$j \in J$$y_0 = 0$$y_j$

— डेनिस

यदि नमूना दरें बिल्कुल समान हैं (w / लापता अंक), तो प्रक्षेप मैट्रिक्स को विरल हो जाएगा (क्योंकि प्रत्येक आउटपुट केवल एक इनपुट पर निर्भर करता है)। सामान्य तौर पर, गैर-समान नमूनों की औसत नमूना दर समान पुनर्निर्माण दर से अधिक होनी चाहिए। दूसरे शब्दों में, आपको "अंतराल में भरने के लिए" (उदाहरण के लिए T> 1) कम दर पर पुनर्निर्माण करना होगा। मैं हालांकि आपकी बात देखता हूं।

— datageist

इस तरह के जवाब शुद्ध सोने हैं।

— अहमद फ़सीह

Answer 2

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

निरंतर समय संकेत की गणना प्रत्येक नमूने को एक सेंस फ़ंक्शन के साथ करके की जा सकती है। चूँकि sinc फंक्शन अनिश्चित काल तक जारी रहता है, हम कुछ अधिक प्रैक्टिकल का उपयोग करते हैं जैसे कि एक व्यावहारिक परिमित लम्बाई का sinc। मुश्किल हिस्सा यह है कि क्योंकि आपके नमूने समय के बारे में आगे बढ़ते हैं, एक अलग चरण के ऑफसेट के साथ एक सिनक को प्रत्येक नमूने के लिए उपयोग करने की आवश्यकता हो सकती है जब पुन: नमूना लिया जाता है।

नमूना संकेत से निरंतर समय संकेत:

$x(t) = \sum\limits_{n=-\infty}^\infty x[n]sinc({t-nT_s\over T_s})$

जहां आपका नमूना समय है। आपके मामले में, हालांकि, आपका नमूना समय निश्चित नहीं है। इसलिए मुझे लगता है कि आपको उस नमूने पर नमूना समय के साथ इसे बदलने की आवश्यकता है।$T_s$

$x(t) = \sum\limits_{n=-\infty}^\infty x[n]sinc({t-nT_s[n]\over T_s[n]})$

इससे आप सिग्नल को फिर से खोल सकते हैं:

$y[n] = x(nT_{ns}$ )

जहां वांछित नमूना समय है।$T_{ns}$

यह सब आप एक साथ लाना:

$y[m] = \sum\limits_{n=-\infty}^\infty x[n]sinc({mT_{ns}-nT_s[n]\over T_s[n]})$

चूंकि यह कारण या ट्रैक्टेबल नहीं है, इसलिए sinc फ़ंक्शन को परिमित समर्थन के एक फ़ंक्शन और तदनुसार समायोजित किए गए योग की सीमाओं के साथ बदला जा सकता है।

कर्नेल (t) एक खिड़की वाला sinc या अन्य समान कार्य लंबाई 2k का हो:

$y[m] = \sum\limits_{n=-k}^k x[n]kernel({mT_{ns}-nT_s[n]\over T_s[n]})$

मुझे आशा है कि यह मदद करता है ..., लेकिन मैंने रास्ते में एक गलती की है और यह थोड़ा गणित गहन हो सकता है। मैं अधिक जानकारी के लिए नमूना दर रूपांतरण पर शोध करने की सलाह दूंगा। हो सकता है कि यहां कोई और बेहतर स्पष्टीकरण या समाधान दे सके।

Comments

एक संकेत के निरंतर संस्करण को फिर से संगठित करने के लिए एक sinc फ़ंक्शन का उपयोग करने के लिए आवश्यक है कि नमूने समान रूप से दूरी पर हों, इसलिए sinc फ़ंक्शन को नमूना रिक्ति को मध्यस्थ करने के लिए अनुकूल होना होगा। लागू करना मुश्किल हो सकता है।

— user2718

हाँ, यह बिल्कुल कुशल नहीं होगा जैसा कि यहाँ देखा गया है। इसके लिए प्रत्येक अलग-अलग नमूना समय के लिए नए कर्नेल गुणांक की गणना करने की आवश्यकता होगी। हालांकि, कई गुठली के संग्रह की गणना की जा सकती है, और इनमें से एक को समय निर्धारित किया गया है। परिमाणीकरण त्रुटि के सापेक्ष एक प्रदर्शन हिट होगा।

— याकूब

आप एकल sinc लुकअप तालिका की पूर्व-गणना भी कर सकते हैं और उस लुकअप तालिका के बिंदुओं के बीच प्रक्षेप कर सकते हैं।

— JMS

Answer 3

मुझे लगता है कि जैकब का जवाब बहुत काम का है।

एक आसान तरीका जो संभवतः विकृति का परिचय देने के मामले में बहुत अच्छा नहीं है, बहुपद प्रक्षेप करना है। मैं अपने मनमाने समय के नमूनों से किसी भी समय नमूने का उत्पादन करने के लिए या तो रैखिक प्रक्षेप (आसान, अच्छा संकेत प्रदर्शन-वार नहीं) या क्यूबिक स्प्लीन (अभी भी बहुत कठिन, बेहतर सिग्नल प्रदर्शन नहीं) का उपयोग करूंगा।

Comments

आप जवाब देते हैं कि जैकब की तुलना में इसे लागू करना बहुत आसान है, इसलिए मैं इसके साथ पहले गया हूं। यह काम करने लगता है, लेकिन मैंने अभी तक परीक्षणों का एक पूरा सेट नहीं चलाया है।

— अंजीर

@FigBug- यदि आपके पास समय है, तो आप अंतिम समाधान के साथ एक टिप्पणी जोड़ें।

— user2718

Answer 4

(एक महीने बाद) किसी भी प्रक्षेप विधि के लिए दो मुख्य विकल्प हैं:
1) उपयोग करने के लिए लापता बिंदु के निकटतम डेटा बिंदुओं की संख्या, 2 4 6 ... 2) आधार कार्यों के वर्ग का उपयोग करने के लिए: रैखिक, बहुपद, साइन-कोसाइन (फूरियर), टुकड़े-टुकड़े क्यूबिक (बी-स्पलाइन या इंटरपोलिंग स्पलाइन), सिनक-लाइक ... (पसंद 0 यह है कि किसी और के तरीके और कोड का उपयोग करना है या क्या यह खुद करना है।)$Nnear$

अंक के लिए एक सीधी रेखा को आसान है: 2 अंक [-1, ], [1, ]: अनुमान अंक औसत : औसत सामान्य : देखें उदाहरण के लिए संख्यात्मक व्यंजनों p। 781: एक पंक्ति फिट करें और अनुमान । एक ही तरह से क्वाड्रैटिक्स, क्यूबिक्स, साइन-कोसाइन ... फिट कर सकते हैं।$Nnear$
$y_{-1}$$y_1$
$\qquad$[ एक्स मैं , y मैं ] एक्स मैं = $y_0 \sim (y_{-1} + y_1) / 2$
$[x_i, y_i]$$x_i = 0$
y i [ x i , y i$\qquad y_0 \sim$$y_i$
$[x_i, y_i]$
$\qquad$वाई 0 ~ $a + b x$$y_0 \sim a$
$\qquad$

मैं समझता हूं कि आपके पास कुछ बिंदुओं के साथ समान रूप से अंतरित डेटा गायब है, क्या यह सही है?
इस मामले के लिए रैखिक प्रक्षेप कितनी अच्छी तरह काम करता है?
ठीक है, चलो = 0.25: 1 0 -1 -1 0 0 -1 -1 0 ... 2 के किसी भी बिंदु औसत से 0, भयानक के साथ का प्रयास करें । 4 पड़ोसी: औसत [1 0 (लापता -1) 0 1] = 1/2, भयानक। (इस पर 4-पड़ोसी फ़िल्टर [-1 3 3 -1] / 4 आज़माएं।)$2 \pi f t$$f$

4 या 6 या 8 पड़ोसियों के साथ रैखिक अंतःक्रिया आपके डेटा के लिए पर्याप्त रूप से काम कर सकती है।
मैं एक ऐसी विधि के साथ शुरू करने का सुझाव दूंगा जिसे आप छींटे में डुबकी लगाने से पहले अच्छी तरह से समझते हैं, जैसे कि ... हालांकि वे मज़ेदार भी हो सकते हैं।

---

एक और, काफी अलग तरीका उलटा दूरी भार है । इसे लागू करना आसान है (देखें एसओ पर idw-interpolation-with-python ), 2d 3 डी और इसके बाद के संस्करण में भी काम करता है, लेकिन सैद्धांतिक रूप से विश्लेषण करना मुश्किल है।

(जाहिर है, NO एकल प्रक्षेप विधि संभवतः
[सिग्नल, शोर, त्रुटि मीट्रिक, परीक्षण फ़ंक्शन] के संयोजन के अरबों को फिट कर सकती है जो वास्तविकता में होती
हैं । दुनिया में और भी तरीके हैं, जो परीक्षण कार्यों की तुलना में अधिक knobs के साथ हैं।
फिर भी एक गैलरी। तरीकों और परीक्षण कार्यों के लिए उपयोगी हो सकता है।)

Answer 5

यदि आप matlab के साथ काम करते हैं तो आप इसे समय के साथ काम करके कर सकते हैं।

time  % is your starting vector of time

data % vector of data you want to resample 

data_TS = timeseries(data,time); % define the data as a timeseries 

new_time = time(0):dt:time(end); % new vector of time with fixed dt=1/fs

data_res = resample(data_TS,new_time); % data resampled at constant fs

Answer 6

इससे पहले कि आप कुछ विदेशी प्रसंस्करण कर सकते हैं आप इस तरह से कुछ सरल की कोशिश कर सकते हैं (छद्म कोड - कोई प्रक्षेप नहीं, लेकिन यह हो सकता है)

TimeStamp[]  //Array of Sensor TimeStamps -NULL terminated – TimeStamp[i] corresponds to Reading[i]
Reading[]      //Array of Sensor Readings       -NULL terminated

AlgorithmOut   //Delimited file of of readings in fixed sample time (5ms) 
CurrentSavedReading = Reading[0]

SampleTime=TimeStamp[0] //ms virtual sample time, 5ms fixed samples

i = 0 // loop index
While(TimeStamp[i] != NULL)
{
   FileWrite (CurrentSavedReading, AlgorithmOut)//write value to file
   SampleTime = SampleTime + 5//ms
   if(SampleTime > TimeStamp[i])
   {
      i++
      CurrentSavedReading = Reading[i]
   }
}

Answer 7

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

• समान नमूनाकरण मामले के लिए, सिनस फ़ंक्शन का सेट ऑर्थोगोनल है: यदि प्रत्येक शिफ्ट किए गए सिनस फ़ंक्शन को इनपुट नमूनों पर विवेकाधीन किया जाता है, तो वे एक अनंत पहचान मैट्रिक्स बनाते हैं। ऐसा इसलिए है क्योंकि n (0) को छोड़कर सभी n के लिए sin (n pi) / (n pi) शून्य है।
• हालाँकि, इस संपत्ति को गैर-वर्दी मामले में अतिरिक्त रूप से शामिल नहीं किया जा सकता है: एक समान सेट का कार्य, इनपुट नमूनों पर विवेकाधीन, एक nontrivial मैट्रिक्स निकलेगा। इसलिए, आसपास के नमूनों से योगदान शून्य नहीं होगा, और पुनर्निर्माण अब इनपुट नमूनों के माध्यम से प्रक्षेपित नहीं होगा।