Một thuật toán để lấy mẫu lại từ một tỷ lệ biến thành một tỷ lệ cố định là gì?

Tôi có một cảm biến báo cáo bài đọc của nó với dấu thời gian và giá trị. Tuy nhiên, nó không tạo ra bài đọc ở một tỷ lệ cố định.

Tôi thấy dữ liệu tỷ lệ biến khó đối phó. Hầu hết các bộ lọc mong đợi một tỷ lệ mẫu cố định. Vẽ biểu đồ dễ dàng hơn với tỷ lệ mẫu cố định là tốt.

Có một thuật toán để lấy mẫu lại từ một tỷ lệ mẫu thay đổi thành một tỷ lệ mẫu cố định không?

Cách tiếp cận đơn giản nhất là thực hiện một số loại nội suy spline như Jim Clay gợi ý (tuyến tính hoặc cách khác). Tuy nhiên, nếu bạn có sự sang trọng của xử lý hàng loạt và đặc biệt là nếu bạn có một bộ mẫu không định dạng quá mức, thì có một thuật toán "tái tạo hoàn hảo" cực kỳ thanh lịch. Vì lý do số, nó có thể không thực tế trong mọi trường hợp, nhưng ít nhất nó đáng để biết về khái niệm. Lần đầu tiên tôi đọc về nó trong bài báo này .

Bí quyết là xem xét tập hợp các mẫu không hình thành của bạn như đã được xây dựng lại từ các mẫu thống nhất thông qua phép nội suy chân thành . Theo ký hiệu trong bài báo:

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

Lưu ý rằng điều này cung cấp một tập hợp các phương trình tuyến tính, một phương trình cho mỗi mẫu không dạng , trong đó các ẩn số là các mẫu có khoảng cách đều nhau , như vậy:$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}.$$

Trong phương trình trên, là số lượng mẫu đồng nhất chưa biết, là tỷ lệ nghịch của tỷ lệ mẫu thống nhất và là số lượng mẫu không đồng nhất (có thể lớn hơn ). Bằng cách tính toán giải pháp bình phương nhỏ nhất của hệ thống đó, các mẫu thống nhất có thể được xây dựng lại. Về mặt kỹ thuật, chỉ có mẫu phi hình thành là cần thiết, nhưng tùy thuộc vào mức độ "phân tán" của chúng trong thời gian, ma trận nội suy có thể bị điều hòa khủng khiếp . Khi đó là trường hợp, sử dụng nhiều mẫu nonuniform thường giúp.$n$$T$$m$$n$$n$

Như một ví dụ về đồ chơi, đây là một so sánh (sử dụng numpy ) giữa phương pháp trên và phép nội suy spline khối trên một lưới bị xáo trộn nhẹ:

(Mã để tái tạo âm mưu trên được bao gồm ở cuối câu trả lời này)

Tất cả những gì đang được nói, đối với các phương pháp mạnh mẽ, chất lượng cao, bắt đầu bằng một thứ gì đó trong một trong các giấy tờ sau đây có lẽ sẽ phù hợp hơn:

A. Aldroubi và Karlheinz Grochenig, Lấy mẫu và tái cấu trúc Nonuniform trong không gian bất biến , SIAM Rev., 2001, no. 4, 585-620. ( liên kết pdf ).

K. Grochenig và H. Schwab, Phương pháp tái tạo cục bộ nhanh để lấy mẫu không đồng nhất trong không gian bất biến thay đổi , SIAM J. Matrix Anal. Ứng dụng, 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()

Điều này có vẻ như là một vấn đề về chuyển đổi tỷ lệ mẫu không đồng bộ. Để chuyển đổi từ tốc độ mẫu này sang tốc độ mẫu khác, chúng ta có thể tính toán biểu diễn thời gian liên tục của tín hiệu bằng cách thực hiện phép nội suy chân thực, sau đó lấy mẫu lại ở tốc độ mẫu mới của chúng tôi. Những gì bạn đang làm không có nhiều khác biệt. Bạn cần lấy mẫu lại tín hiệu của mình để có thời gian mẫu được cố định.

Tín hiệu thời gian liên tục có thể được tính bằng cách kết hợp từng mẫu với hàm chân. Vì chức năng chân thành tiếp tục vô định, chúng tôi sử dụng một cái gì đó thực tế hơn như một cửa sổ chân thành có độ dài hữu hạn thực tế. Phần khó khăn là bởi vì các mẫu của bạn di chuyển kịp thời, một chân với độ lệch pha khác nhau có thể cần được sử dụng cho mỗi mẫu khi lấy mẫu lại.

Tín hiệu thời gian liên tục từ tín hiệu được lấy mẫu:

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

Trong đó là thời gian mẫu của bạn. Tuy nhiên, trong trường hợp của bạn, thời gian mẫu của bạn không cố định. Vì vậy, tôi nghĩ rằng bạn cần phải thay thế nó với thời gian mẫu tại mẫu đó.$T_s$

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

Từ đây bạn có thể lấy mẫu lại tín hiệu:

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

Trong đó là thời gian mẫu mong muốn.$T_{ns}$

Đặt tất cả lại với nhau bạn nhận được:

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

Vì đây không phải là nguyên nhân hoặc có thể điều khiển được, nên hàm chân có thể được thay thế bằng chức năng hỗ trợ hữu hạn và giới hạn tổng hợp được điều chỉnh tương ứng.

Đặt kernel (t) là một cửa sổ chân thành hoặc hàm tương tự khác có độ dài 2k thì:

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

Tôi hy vọng điều này sẽ giúp ... nhưng tôi có thể đã phạm sai lầm trên đường đi và nó có thể hơi chuyên sâu về toán học. Tôi sẽ khuyên bạn nên nghiên cứu chuyển đổi tỷ lệ mẫu để biết thêm thông tin. Có lẽ ai đó khác ở đây cũng có thể đưa ra một lời giải thích hoặc giải pháp tốt hơn.

Tôi nghĩ câu trả lời của Jacob rất khả thi.

Một phương pháp dễ dàng hơn có lẽ không hoàn toàn tốt về mặt giới thiệu biến dạng là thực hiện phép nội suy đa thức. Tôi sẽ sử dụng phép nội suy tuyến tính (dễ, không phải là hiệu suất tín hiệu tốt) hoặc khối vuông (vẫn không quá khó, hiệu suất tín hiệu tốt hơn) để tạo mẫu bất cứ lúc nào bạn muốn từ các mẫu thời gian tùy ý.

(Một tháng sau), có hai lựa chọn chính cho bất kỳ phương pháp nội suy nào:
1) số lượng điểm dữ liệu gần điểm thiếu nhất để sử dụng, 2 4 6 ... 2) lớp các hàm cơ bản sẽ sử dụng: tuyến tính, đa thức, sin-cosine (Fourier), khối piecewise (B-spline hoặc spline nội suy), giống như ... (Lựa chọn 0 là sử dụng phương pháp và mã của người khác, hoặc tự làm.)$Nnear$

một đường thẳng vào rất dễ dàng: 2 điểm [-1, ], [1, ]: ước tính điểm với trung bình : trung bình chung : xem ví dụ: Bí quyết số p. 781: vừa một dòng và ước tính . Một người có thể phù hợp với tứ giác, hình khối, hình sin ... theo cùng một cách.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 $\qquad y_0 \sim$$y_i$
$[x_i, y_i]$
$\qquad$y 0 ∼ $a + b x$$y_0 \sim a$
$\qquad$

Tôi hiểu rằng bạn có dữ liệu cách đều nhau với một vài điểm bị thiếu, đúng không?
Làm thế nào tốt nội suy tuyến tính làm việc cho trường hợp này?
Chà, hãy thử cos với = 0,25: 1 0 -1 0 1 0 -1 0 ... 2 hàng xóm của bất kỳ điểm trung bình nào đến 0, thật tệ. 4 hàng xóm: trung bình [1 0 (thiếu -1) 0 1] = 1/2, khủng khiếp. (Hãy thử bộ lọc 4 lân cận [-1 3 3 -1] / 4 về điều này.)$2 \pi f t$$f$

Kết nối tuyến tính với 4 hoặc 6 hoặc 8 hàng xóm có thể hoạt động đủ tốt cho dữ liệu của bạn.
Tôi khuyên bạn nên bắt đầu với một phương pháp mà bạn hiểu thấu đáo trước khi lao vào splines, giống như ... mặc dù chúng cũng có thể thú vị.

---

Một phương pháp khác, khá khác biệt là trọng số khoảng cách nghịch đảo . Thật dễ dàng để thực hiện (xem idw-interpolation-with-python trên SO), hoạt động trong 2d 3d trở lên, nhưng rất khó để phân tích về mặt lý thuyết.

(Rõ ràng, NO phương pháp nội suy duy nhất có thể có thể phù hợp với những zillions của sự kết hợp của
[tín hiệu, tiếng ồn, lỗi hệ mét, chức năng kiểm tra] xảy ra trong thực tế.
Có rất nhiều phương pháp trên thế giới, với nhiều nút bấm, hơn chức năng kiểm tra.
Tuy nhiên một bộ sưu tập phương pháp và chức năng kiểm tra có thể hữu ích.)

Nếu bạn làm việc với MATLAB, bạn có thể làm điều đó bằng cách làm việc với thời gian.

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

Trước khi bạn bắt đầu thực hiện một số xử lý kỳ lạ, bạn có thể thử một cái gì đó đơn giản như thế này (mã giả - không có nội suy, nhưng có thể được thêm vào)

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

Câu trả lời của IMHO Datageist là chính xác, câu trả lời của Jacob thì không. Một cách dễ dàng để xác minh điều này là thuật toán đề xuất của nhà dữ liệu được đảm bảo để nội suy qua các mẫu ban đầu (giả sử độ chính xác số vô hạn), trong khi câu trả lời của Jacob thì không.

• Đối với trường hợp lấy mẫu thống nhất, tập hợp các hàm chân là trực giao: nếu mỗi hàm chân được dịch chuyển bị rời rạc trên các mẫu đầu vào, chúng tạo thành một ma trận nhận dạng vô hạn. Điều này là do sin (n pi) / (n pi) bằng 0 đối với tất cả n ngoại trừ n = 0.
• Tuy nhiên, thuộc tính này không thể đơn giản được ngoại suy cho trường hợp không đồng nhất: một tập hợp các hàm chân tương tự, được phân tách trên các mẫu đầu vào, sẽ tạo ra một ma trận không cần thiết. Do đó, các đóng góp từ các mẫu xung quanh sẽ không bằng 0 và việc tái cấu trúc sẽ không còn nội suy qua các mẫu đầu vào.