Apa yang dimaksud dengan algoritma untuk sampel ulang dari tingkat variabel ke tarif tetap?

Saya memiliki sensor yang melaporkan pembacaannya dengan cap waktu dan nilai. Namun, itu tidak menghasilkan bacaan pada tingkat yang tetap.

Saya menemukan data tingkat variabel sulit untuk ditangani. Sebagian besar filter mengharapkan tingkat sampel tetap. Menggambar grafik lebih mudah dengan laju sampel tetap juga.

Apakah ada algoritma untuk melakukan sampel ulang dari laju sampel variabel ke laju sampel tetap?

Pendekatan paling sederhana adalah dengan melakukan semacam interpolasi spline seperti yang disarankan Jim Clay (linier atau lainnya). Namun, jika Anda memiliki kemewahan pemrosesan batch, dan terutama jika Anda memiliki set sampel tidak seragam yang ditentukan secara berlebihan, ada algoritma "rekonstruksi sempurna" yang sangat elegan. Untuk alasan numerik, mungkin tidak praktis dalam semua kasus, tetapi setidaknya perlu diketahui secara konseptual. Saya pertama kali membacanya di makalah ini .

Caranya adalah dengan mempertimbangkan set sampel tidak seragam Anda yang telah direkonstruksi dari sampel yang seragam melalui interpolasi tulus . Mengikuti notasi di koran:

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

Perhatikan bahwa ini menyediakan satu set persamaan linear, satu untuk setiap sampel tidak seragam , di mana yang tidak diketahui adalah sampel dengan spasi yang sama , seperti:$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}.$$

Dalam persamaan di atas, adalah jumlah sampel seragam yang tidak diketahui, adalah kebalikan dari laju sampel seragam, dan adalah jumlah sampel tidak seragam (yang mungkin lebih besar dari ). Dengan menghitung solusi kuadrat terkecil dari sistem itu, sampel yang seragam dapat direkonstruksi. Secara teknis, hanya sampel tidak seragam yang diperlukan, tetapi tergantung pada seberapa "tersebar" mereka dalam waktu, matriks interpolasi mungkin sangat buruk dikondisikan . Ketika itu masalahnya, menggunakan lebih banyak sampel yang tidak seragam biasanya membantu.$n$$T$$m$$n$$n$

Sebagai contoh mainan, inilah perbandingan (menggunakan numpy ) antara metode di atas dan interpolasi spline kubik pada kisi yang agak gugup:

(Kode untuk mereproduksi plot di atas termasuk di akhir jawaban ini)

Semua yang dikatakan, untuk metode berkualitas tinggi, kuat, dimulai dengan sesuatu di salah satu makalah berikut mungkin akan lebih tepat:

A. Aldroubi dan Karlheinz Grochenig, Pengambilan sampel dan rekonstruksi yang tidak seragam dalam ruang-ruang yang tidak berubah , SIAM Rev., 2001, no. 4, 585-620. ( tautan pdf ).

K. Grochenig dan H. Schwab, Metode rekonstruksi lokal cepat untuk pengambilan sampel tidak seragam di ruang 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()

Ini terdengar seperti masalah konversi laju sampel asinkron. Untuk mengonversi dari satu laju sampel ke yang lain, kami dapat menghitung representasi waktu kontinyu dari sinyal dengan melakukan interpolasi tulus, lalu melakukan pengujian ulang pada laju sampel baru kami. Apa yang Anda lakukan tidak jauh berbeda. Anda perlu menguji ulang sinyal Anda untuk mendapatkan waktu sampel yang diperbaiki.

Sinyal waktu kontinu dapat dihitung dengan menggabungkan setiap sampel dengan fungsi sinc. Karena fungsi sinc berlanjut tanpa batas, kami menggunakan sesuatu yang lebih praktis seperti jendela berjendela dengan panjang yang praktis. Bagian yang sulit adalah bahwa karena sampel Anda bergerak dalam waktu, sinc dengan fase offset yang berbeda mungkin perlu digunakan untuk setiap sampel ketika melakukan resampling.

Sinyal waktu kontinu dari sinyal sampel:

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

di mana adalah waktu sampel Anda. Namun, dalam kasus Anda, waktu sampel Anda tidak tetap. Jadi saya pikir Anda perlu menggantinya dengan waktu sampel di sampel itu.$T_s$

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

Dari ini, Anda dapat menguji ulang sinyal:

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

di mana adalah waktu sampel yang diinginkan.$T_{ns}$

Menyatukan semuanya Anda dapatkan:

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

Karena ini bukan sebab akibat atau dapat ditelusuri, fungsi sinc dapat diganti dengan fungsi dukungan yang terbatas dan batas penjumlahan disesuaikan sesuai.

Biarkan kernel (t) menjadi sinc jendela atau fungsi lain yang serupa dengan panjang 2k kemudian:

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

Saya harap ini membantu ..., tapi saya mungkin telah membuat kesalahan di sepanjang jalan dan mungkin sedikit intensif secara matematika. Saya akan merekomendasikan meneliti konversi laju sampel untuk informasi lebih lanjut. Mungkin orang lain di sini bisa memberikan penjelasan atau solusi yang lebih baik juga.

Saya pikir jawaban Yakub sangat bisa diterapkan.

Metode yang lebih mudah yang mungkin tidak begitu baik dalam hal memperkenalkan distorsi adalah dengan melakukan interpolasi polinomial. Saya akan menggunakan interpolasi linier (mudah, tidak sebagus kinerja sinyal-bijaksana) atau splines kubik (masih tidak terlalu keras, kinerja sinyal lebih baik) untuk menghasilkan sampel kapan saja Anda inginkan dari sampel waktu sewenang-wenang Anda.

(Sebulan kemudian) ada dua pilihan utama untuk setiap metode interpolasi:
1) jumlah titik data terdekat dengan titik yang hilang untuk digunakan, 2 4 6 ... 2) kelas fungsi basis yang digunakan: linear, polinomial, sine-cosine (Fourier), piecewise cubic (B-spline atau interpolasi spline), seperti-seperti ... (Pilihan 0 adalah apakah menggunakan metode dan kode orang lain, atau melakukannya sendiri).$Nnear$

Memasukkan garis lurus ke titik mudah: 2 poin [-1, ], [1, ]: Estimasi poin dengan rata-rata : rata-rata umum : lihat misalnya Numerical Recipes h. 781: paskan baris dan perkirakan . Seseorang dapat kuadrat, kubik, sinus-cosinus ... dengan cara yang sama.$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$

Saya mengerti bahwa Anda memiliki data dengan spasi yang sama dengan beberapa poin yang hilang, apakah itu benar?
Seberapa baik interpolasi linier berfungsi untuk kasus ini?
Baiklah, mari kita coba cos dengan = 0.25: 1 0 -1 0 1 0 -1 0 ... 2 tetangga dari setiap titik rata-rata ke 0, mengerikan. 4 tetangga: rata-rata [1 0 (hilang -1) 0 1] = 1/2, mengerikan. (Coba filter 4-tetangga [-1 3 3 -1] / 4 untuk ini.)$2 \pi f t$$f$

Interplasi linear dengan 4 atau 6 atau 8 tetangga mungkin bekerja cukup baik untuk data Anda.
Saya sarankan memulai dengan metode yang Anda pahami sebelum menyelam ke splines, seperti-tulus ... meskipun itu bisa menyenangkan juga.

---

Metode lain yang sangat berbeda adalah pembobotan jarak terbalik . Sangat mudah untuk diimplementasikan (lihat idw-interpolasi-dengan-python pada SO), bekerja dalam 2d 3d dan juga, tetapi afaik sulit untuk dianalisis secara teoritis.

(Jelas, TIDAK ada metode interpolasi tunggal yang dapat cocok dengan zillions kombinasi
[sinyal, noise, metrik kesalahan, fungsi tes] yang terjadi dalam kenyataan.
Ada lebih banyak metode di dunia, dengan lebih banyak kenop, daripada fungsi pengujian.
Meskipun demikian galeri metode dan fungsi pengujian mungkin berguna.)

Jika Anda bekerja dengan matlab, Anda dapat melakukannya dengan bekerja dengan pengaturan waktu.

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

Sebelum Anda mulai melakukan beberapa pemrosesan eksotis Anda dapat mencoba sesuatu yang sederhana seperti ini (kode semu - tidak ada interpolasi, tetapi itu bisa ditambahkan)

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

Jawaban IMHO Datageist benar, jawaban Yakub tidak. Cara mudah untuk memverifikasi ini adalah bahwa algoritma yang disarankan datageist dijamin untuk diinterpolasi melalui sampel asli (dengan asumsi ketepatan angka tak terbatas), sedangkan jawaban Yakub tidak.

• Untuk kasus pengambilan sampel yang seragam, rangkaian fungsi sinc adalah ortogonal: jika setiap fungsi sinc yang digeser diskritkan atas sampel input, mereka membentuk matriks identitas yang tak terbatas. Ini karena dosa (n pi) / (n pi) adalah nol untuk semua n kecuali n = 0.
• Namun, properti ini tidak dapat dengan mudah diekstrapolasi ke kasus yang tidak seragam: seperangkat fungsi sinc yang sama, didiskritkan atas sampel input, akan menghasilkan matriks nontrivial. Oleh karena itu, kontribusi dari sampel di sekitarnya tidak akan nol, dan rekonstruksi tidak akan lagi diinterpolasi melalui sampel input.