Değişken orandan sabit orana yeniden örnekleme algoritması nedir?

Değerlerini zaman damgası ve değeri ile rapor eden bir sensörüm var. Ancak, sabit bir oranda okumalar üretmez.

Değişken oranlı verileri başa çıkmada zor buluyorum. Çoğu filtre sabit bir örnekleme oranı bekliyor. Grafik çizmek de sabit bir örnekleme oranıyla daha kolaydır.

Değişken bir örnekleme oranından sabit bir örnekleme oranına yeniden örnekleme için bir algoritma var mı?

En basit yaklaşım, Jim Clay'in önerdiği gibi bir çeşit spline enterpolasyonu yapmaktır (doğrusal veya başka şekilde). Bununla birlikte, toplu işleme lüksüne sahipseniz ve özellikle önceden tanımlanmış düzensiz örneklere sahipseniz, son derece zarif "mükemmel bir yeniden yapılandırma" algoritması vardır. Sayısal nedenlerle, her durumda pratik olmayabilir, ancak en azından kavramsal olarak bilmeye değer. İlk önce bu makalede okudum .

İşin püf noktası, üniform olmayan örnekler kümenizi , sinc interpolasyonu yoluyla muntazam örneklerden yeniden yapılmış olduğunu düşünmektir . Makaledeki notaları takip ederek:

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

Bunun , bilinmeyenlerin eşit aralıklı örnekler olan olduğu her bir tek tip olmayan örnek için bir doğrusal denklem kümesi sağladığını unutmayın :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}.$$

Yukarıdaki denklemde, , bilinmeyen üniform örneklerin sayısıdır, , üniform örnek oranının tersidir ve , üniform olmayan örneklerin sayısıdır (ki, büyük olabilir ). Bu sistemin en küçük kareler çözümünü hesaplayarak, homojen örnekler yeniden yapılandırılabilir. Teknik olarak, sadece biçimli olmayan örnekleri gereklidir, ama "dağılmış" şekline bağlı olarak, zaman içinde, interpolasyon matris korkunç olabilir edilir kötü durumdaki . Bu durumda, daha fazla düzgün olmayan örneklerin kullanılması genellikle yardımcı olur.T m $n$$T$$m$$n$$n$

Bir oyuncak örneği olarak, yukarıdaki yöntem ile hafif sarsıntılı bir ızgarada kübik spline enterpolasyonu arasında bir karşılaştırma ( numpy kullanarak ):

(Yukarıdaki taslağı yeniden oluşturma kodu bu cevabın sonuna eklenmiştir)

Söylenenlerin tümü, yüksek kaliteli, sağlam yöntemler için, aşağıdaki belgelerden birinde bir şeyle başlamak muhtemelen daha uygun olacaktır:

A. Aldroubi ve Karlheinz Grochenig, Değişmeyen Değişken Alanlarda Düzgün Olmayan Örnekleme ve Yeniden Yapılanma , SIAM Rev., 2001, no. 4, 585-620. ( pdf bağlantısı ).

K. Grochenig ve H. Schwab, Değişmeyen Değişen Alanlarda Tekdüzen Örneklemede Hızlı Lokal Yeniden Yapılanma Yöntemleri , 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()

Bu, zaman uyumsuz bir örnekleme hızı dönüştürme sorunu gibi geliyor. Bir örnekleme oranından diğerine dönüştürmek için, sinincin sürekli zaman gösterimini sinc enterpolasyonu yaparak hesaplayabiliriz, sonra yeni örnekleme hızımızda yeniden örnekleyebiliriz. Yaptıkların pek farklı değil. Sabit olan örnekleme zamanları için sinyalinizi yeniden örneklemeniz gerekir.

Sürekli zaman sinyali, her numunenin bir sinc işlevi ile sarılmasıyla hesaplanabilir. Sinc işlevi sürekli olarak devam ettiğinden, pratik sonlu uzunlukta pencereli bir sincap gibi daha pratik bir şey kullanıyoruz. İşin zor yanı, numunelerinizin zaman içinde hareket etmesi nedeniyle, yeniden örnekleme yapılırken her numune için farklı bir faz kaymasına sahip bir sincap kullanılması gerekebilir.

Örneklenen sinyalden sürekli zaman sinyali:

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

burada örnek zamanınızdır. Ancak, sizin durumunuzda, örnekleme zamanınız sabit değildir. Bu yüzden, o numunedeki numune zamanı ile değiştirmeniz gerektiğini düşünüyorum.$T_s$

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

Bundan, sinyali yeniden örnekleyebilirsiniz:

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

burada istenen örnekleme zamanıdır.$T_{ns}$

Hepsini bir araya getirerek:

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

Bu nedensel veya izlenebilir olmadığından, sinc işlevi sonlu destek işleviyle ve buna göre ayarlanan toplama sınırlarıyla değiştirilebilir.

Çekirdeğin (t) pencereli bir sinc ya da 2k uzunluğundaki benzer bir işlevi olmasına izin verin:

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

Umarım bu yardımcı olur ... ama yol boyunca bir hata yapmış olabilirim ve biraz matematik yoğun olabilir. Daha fazla bilgi için örneklem oranı dönüşümünü araştırmanızı tavsiye ederim. Belki buradaki bir başkası da daha iyi bir açıklama ya da çözüm sağlayabilir.

Bence Jacob'ın cevabı çok işe yarar.

Distorsiyon açısından muhtemelen pek iyi olmayan daha kolay bir yöntem polinom interpolasyonu yapmaktır. İsteğe bağlı zaman örneklerinden istediğiniz zaman numune üretmek için doğrusal enterpolasyonu (kolay, iyi sinyal performansı kadar iyi değil) veya kübik çizgi (hala çok zor değil, daha iyi sinyal performansı) kullanırdım.

(Bir ay sonra) herhangi bir enterpolasyon yöntemi için iki ana seçenek vardır:
1) kullanılacak eksik noktaya en yakın veri noktası sayısı, 2 4 6 ... 2) kullanılacak temel fonksiyonların sınıfı: doğrusal, polinom, sinüs-kosinüs (Fourier), parça parça kübik (B-spline veya enterpolasyon spline), sinc-like ... (Seçenek 0, başkasının yöntemini ve kodunu kullanıp kullanmama veya kendin yap).$Nnear$

noktalarına düz bir çizgi koymak kolaydır: 2 puan [-1, ], [1, ]: tahmini puan ortalama ile : ortalama general : bkz. örneğin Nümerik Tarifler p. 781: bir çizgi ve tahmin . Kişi aynı şekilde kuadratik, kübik, sinüs-kosinüs sığdırabilir.y - 1 y $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$

Anladığım kadarıyla eşit olmayan aralıklarda, birkaç noktanın eksik olduğu bir veri var.
Doğrusal enterpolasyon bu durum için ne kadar işe yarıyor?
Eh, hadi cos deneyin ile = 0.25: 1 0 -1 0 1 0 -1 0 ... herhangi bir nokta ortalamasının 2 komşuları 0'a korkunç. 4 komşu: ortalama [1 0 (eksik -1) 0 1] = 1/2, korkunç. (Bununla ilgili 4-komşu filtreyi [-1 3 3 -1] / 4 deneyin.)$2 \pi f t$$f$

4 ya da 6 ya da 8 komşuyla doğrusal yorum, verileriniz için yeterince iyi çalışabilir.
Spinclere dalmadan önce iyice anladığınız bir yöntemle başlamak isterim, içten benzeri ... bunlar da eğlenceli olabilir.

---

Bir başka oldukça farklı yöntem Ters mesafe ağırlıklandırmadır . Uygulaması kolaydır (bkz . SO üzerinde python ile idw-enterpolasyonu ), 2d 3d ve üzeriyle de çalışır, ancak teorik olarak analiz edilmesi zor bir iştir.

(Açıkçası, NO tek bir enterpolasyon yöntemi,
gerçekte meydana gelen [sinyal, gürültü, hata ölçümü, test fonksiyonu] kombinasyonlarının zilyonlarına uyabilir .
Dünyada, test fonksiyonlarından daha fazla düğmeyle daha fazla yöntem vardır.
Bununla birlikte, bir galeri yöntemlerin ve test işlevlerinin kullanımı yararlı olabilir.)

Matlab ile çalışıyorsanız, zaman çizelgeleriyle çalışarak yapabilirsiniz.

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

Egzotik bir işlem yapmadan önce, bunun gibi basit bir şeyi deneyebilirsiniz (sözde kod - enterpolasyon yok, ancak bu eklenebilir).

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'in cevabı doğru, Jacob'ın cevabı doğru değil. Bunu doğrulamanın kolay bir yolu, datageistin önerdiği algoritmanın, orijinal örneklerle (sonsuz sayısal hassasiyet varsayarak) enterpolasyon yapmasının garantilenmiş olmasıdır, oysa Jacob'ın cevabı yoktur.

• Düzgün örnekleme durumu için, sinc fonksiyonlarının kümesi diktir: eğer her bir sinc fonksiyonu giriş örnekleri üzerinde ayrıştırılırsa, sonsuz bir kimlik matrisi oluştururlar. Bunun sebebi sin (n pi) / (n pi), n = 0 dışındaki herkes için sıfır olmasıdır.
• Bununla birlikte, bu özellik tek tip olmayan duruma ilave edilemez: giriş numuneleri üzerinde ayrılan benzer bir sinc işlevi seti önemsiz bir matris verir. Bu nedenle, çevreleyen örneklerden gelen katkılar sıfır olmayacak ve yeniden yapılanma artık giriş numuneleri arasında enterpolasyon yapmayacaktır.