อัลกอริทึมในการสุ่มตัวอย่างใหม่จากอัตราตัวแปรเป็นอัตราคงที่คืออะไร

ฉันมีเซ็นเซอร์ที่รายงานการอ่านด้วยการประทับเวลาและค่า อย่างไรก็ตามจะไม่สร้างการอ่านในอัตราคงที่

ฉันพบว่าข้อมูลอัตราตัวแปรนั้นยากที่จะจัดการ ตัวกรองส่วนใหญ่คาดว่าอัตราตัวอย่างคงที่ กราฟการวาดง่ายขึ้นด้วยอัตราตัวอย่างคงที่เช่นกัน

มีอัลกอริธึมที่จะสุ่มตัวอย่างจากอัตราตัวอย่างแปรไปเป็นอัตราตัวอย่างคงที่หรือไม่?

วิธีที่ง่ายที่สุดคือการแก้ไขแบบอิสระเช่นJim Clay แนะนำ (เชิงเส้นหรืออื่น ๆ ) อย่างไรก็ตามหากคุณมีความหรูหราของการประมวลผลแบบแบทช์และโดยเฉพาะอย่างยิ่งถ้าคุณมีตัวอย่างที่ไม่ได้กำหนดจำนวนมากเกินไปมันมีอัลกอริทึม "การสร้างใหม่ที่สมบูรณ์แบบ" ซึ่งสง่างามที่สุด สำหรับเหตุผลที่เป็นตัวเลขอาจไม่สามารถใช้ได้ในทุกกรณี แต่อย่างน้อยก็ควรรู้เกี่ยวกับแนวคิด ก่อนอื่นฉันอ่านเกี่ยวกับเรื่องนี้ในเอกสารนี้

เคล็ดลับคือการพิจารณากลุ่มตัวอย่าง nonuniform ของคุณว่ามีการสร้างขึ้นใหม่จากตัวอย่างสม่ำเสมอผ่านการแก้ไขแบบซิน ตามสัญลักษณ์ในกระดาษ:

$$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}.$$

ในสมการข้างต้นคือจำนวนตัวอย่างเครื่องแบบที่ไม่รู้จักคือค่าผกผันของอัตราตัวอย่างสม่ำเสมอและคือจำนวนตัวอย่างที่ไม่เป็นรูปแบบ (ซึ่งอาจมากกว่า ) ด้วยการคำนวณวิธีกำลังสองน้อยที่สุดของระบบนั้นจะสามารถสร้างตัวอย่างแบบสม่ำเสมอได้ ในทางเทคนิคเท่านั้นตัวอย่างสม่ำเสมอเป็นสิ่งจำเป็น แต่ขึ้นอยู่กับวิธีการ "กระจัดกระจาย" พวกเขาอยู่ในเวลาเมทริกซ์การแก้ไขอาจจะน่ากลัวป่วยปรับอากาศ เมื่อเป็นเช่นนั้นการใช้ตัวอย่างที่ไม่ได้เป็นรูปแบบปกติจะช่วยได้มากขึ้นT m n $n$$T$$m$$n$$n$

เป็นตัวอย่างของเล่นต่อไปนี้เป็นการเปรียบเทียบ (โดยใช้numpy ) ระหว่างวิธีการข้างบนและการแก้ไขลูกบาศก์ spline บนตารางที่มีการสั่นเล็กน้อย:

(รหัสในการทำซ้ำพล็อตข้างต้นรวมอยู่ในตอนท้ายของคำตอบนี้)

ทั้งหมดที่กล่าวมาสำหรับวิธีการที่มีคุณภาพสูงและมีประสิทธิภาพเริ่มต้นด้วยบางสิ่งในเอกสารใดเอกสารหนึ่งต่อไปนี้อาจจะเหมาะสมกว่า:

A. Aldroubi และ Karlheinz Grochenig การสุ่มตัวอย่าง Nonuniform และการสร้างใหม่ในช่องว่าง shift-invariant , SIAM Rev. , 2001, no. 4, 585-620 ( ลิงก์ pdf )

K. Grochenig และ H. Schwab, วิธีการสร้างใหม่แบบเร็วสำหรับการสุ่มตัวอย่างแบบไม่สม่ำเสมอในช่องว่าง shift-invariant , SIAM J. Matrix Anal 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()

ดูเหมือนว่าปัญหาของการแปลงอัตราตัวอย่างแบบอะซิงโครนัส ในการแปลงจากอัตราตัวอย่างหนึ่งไปเป็นอัตราอื่นเราสามารถคำนวณการแสดงสัญญาณต่อเนื่องของเวลาโดยดำเนินการแก้ไขแบบ sinc จากนั้นทำการสุ่มที่อัตราตัวอย่างใหม่ของเรา สิ่งที่คุณกำลังทำไม่แตกต่างกันมาก คุณต้องสุ่มสัญญาณของคุณใหม่เพื่อให้มีเวลาตัวอย่างที่ได้รับการแก้ไข

สัญญาณเวลาต่อเนื่องสามารถคำนวณได้โดยการชักตัวอย่างแต่ละตัวอย่างด้วยฟังก์ชัน sinc เนื่องจากฟังก์ชั่น 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]})$

ฉันหวังว่าสิ่งนี้จะช่วย ... แต่ฉันอาจทำผิดไปตลอดทางและอาจเป็นวิชาคณิตศาสตร์เล็กน้อย ฉันอยากจะแนะนำการวิจัยการแปลงอัตราตัวอย่างสำหรับข้อมูลเพิ่มเติม บางทีคนอื่นที่นี่อาจให้คำอธิบายที่ดีกว่า

ฉันคิดว่าคำตอบของยาโคบทำได้ดีมาก

วิธีที่ง่ายกว่าซึ่งอาจไม่ดีเท่าที่ควรในการแนะนำการบิดเบือนคือการแก้ไขพหุนาม ฉันจะใช้การประมาณเชิงเส้น (ง่ายไม่ดีเท่าประสิทธิภาพสัญญาณที่ชาญฉลาด) หรือลูกบาศก์ splines (ยังไม่ยากเกินไปประสิทธิภาพสัญญาณดีกว่า) เพื่อสร้างตัวอย่างในเวลาใดก็ได้ที่คุณต้องการจากตัวอย่างเวลาโดยพลการของคุณ

(หนึ่งเดือนต่อมา) มีสองตัวเลือกหลักสำหรับวิธีการแก้ไขใด ๆ :
1) จำนวนจุดข้อมูลที่ใกล้ที่สุดกับจุดที่หายไปที่จะใช้ไม่ 2 4 6 ... 2) ชั้นของฟังก์ชั่นพื้นฐานที่จะใช้: เชิงเส้นพหุนาม ไซน์ - โคไซน์ (ฟูริเยร์), คิวบิกคิวรี่ (B-spline หรือ interpolating spline), sinc-like ... (ตัวเลือก 0 คือว่าจะใช้วิธีการและรหัสของคนอื่นหรือทำมันด้วยตัวเอง)$Nnear$

ฟิตติ้งเป็นเส้นตรงไปจุดเป็นเรื่องง่าย: 2 จุด [-1, ], [1 ]:ประเมิน จุดมีค่าเฉลี่ย :ค่าเฉลี่ย ทั่วไป :ดูเช่น สูตรคำนวณตัวเลข p 781: พอดีบรรทัด และประเมินซิม One สามารถใส่ quadratics, cubics, sine-cosines ได้ในลักษณะเดียวกันY - 1ปี$Nnear$
$y_{-1}$$y_1$
$\qquad$[ x i , y i ] x i = $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$y 0 ∼ $a + b x$$y_0 \sim a$
$\qquad$

ฉันเข้าใจว่าคุณมีข้อมูลที่เว้นระยะเท่ากันโดยมีจุดขาดหายไปสองสามข้อใช่ไหม?
การแก้ไขเชิงเส้นทำงานได้ดีแค่ไหนสำหรับกรณีนี้
ทีนี้ลอง cosกับ = 0.25: 1 0 -1 0 1 0 -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บน SO), ทำงานใน 2d 3d ขึ้นไปเช่นกัน แต่มันยากที่จะวิเคราะห์ตามหลักวิชา

(เห็นได้ชัดว่าไม่มีวิธีการแก้ไขเพียงครั้งเดียวอาจพอดี zillions ของการรวมกันของ
[สัญญาณเสียงตัวชี้วัดข้อผิดพลาดฟังก์ชั่นการทดสอบ] ที่เกิดขึ้นในความเป็นจริง.
มีวิธีการอื่น ๆ ในโลกโดยมีลูกบิดมากขึ้นกว่าฟังก์ชั่นการทดสอบ.
อย่างไรก็ตามแกลเลอรี่ วิธีการและฟังก์ชั่นทดสอบอาจมีประโยชน์)

หากคุณทำงานกับ matlab คุณสามารถทำได้โดยทำงานกับ timeseries

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

ก่อนที่คุณจะทำการประมวลผลที่แปลกใหม่คุณสามารถลองอะไรแบบนี้ได้ง่าย ๆ (โค้ดหลอก - ไม่มีการแก้ไข แต่สามารถเพิ่มได้)

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]
   }
}

คำตอบของ IMHO Datageist นั้นถูกต้องคำตอบของ Jacob นั้นไม่ถูกต้อง วิธีง่ายๆในการตรวจสอบสิ่งนี้คืออัลกอริทึมที่แนะนำของนักข้อมูลรับประกันว่าจะสอดแทรกผ่านตัวอย่างดั้งเดิม (สมมติว่าความแม่นยำเชิงตัวเลขที่ไม่มีที่สิ้นสุด) ในขณะที่คำตอบของจาค็อบไม่ได้

• สำหรับกรณีการสุ่มตัวอย่างที่เหมือนกันชุดของฟังก์ชัน sinc คือ orthogonal: ถ้าฟังก์ชัน sinc ที่เลื่อนแต่ละหน่วยถูกแยกออกจากตัวอย่างอินพุตพวกมันจะกลายเป็นเมทริกซ์เอกลักษณ์ที่ไม่มีที่สิ้นสุด นี่เป็นเพราะบาป (n pi) / (n pi) เป็นศูนย์สำหรับ n ทั้งหมดยกเว้น n = 0
• อย่างไรก็ตามคุณสมบัตินี้ไม่สามารถคาดการณ์ได้ในกรณีที่ไม่เหมือนกัน: ชุดฟังก์ชัน sinc ที่คล้ายกันซึ่งแยกส่วนไปจากตัวอย่างอินพุตจะให้เมทริกซ์ที่ไม่น่าสนใจ ดังนั้นการมีส่วนร่วมจากตัวอย่างรอบข้างจะไม่เป็นศูนย์และการสร้างใหม่จะไม่สอดแทรกเข้าไปในตัวอย่างอินพุตอีกต่อไป