Что такое алгоритм для повторной выборки с переменной скоростью до фиксированной?

У меня есть датчик, который сообщает о своих показаниях с отметкой времени и значением. Тем не менее, он не генерирует показания с фиксированной скоростью.

Мне трудно работать с данными с переменной скоростью. Большинство фильтров ожидают фиксированную частоту дискретизации. Рисовать графики проще с фиксированной частотой дискретизации.

Существует ли алгоритм для повторной выборки с переменной частотой дискретизации до фиксированной частоты дискретизации?

Самый простой подход - это выполнить некоторую сплайн-интерполяцию, как предлагает Джим Клэй (линейный или другой). Однако, если у вас есть возможность пакетной обработки, и особенно если у вас есть переопределенный набор неоднородных выборок, есть алгоритм «идеальной реконструкции», который чрезвычайно элегантен. По численным причинам это может быть не практичным во всех случаях, но, по крайней мере, стоит знать об этом концептуально. Я впервые прочитал об этом в этой статье .

Хитрость заключается в том, чтобы рассматривать ваш набор неоднородных выборок как уже восстановленный из однородных выборок путем синхрополяции . Следуя обозначениям в статье:

$$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 неоднородных выборок, но в зависимости от того, насколько они «разбросаны» во времени, интерполяционная матрица может быть ужасно плохо обусловлена . В этом случае обычно помогает использование большего количества неоднородных образцов.$n$$T$$m$$n$$n$

В качестве игрушечного примера, вот сравнение (с использованием numpy ) вышеупомянутого метода и интерполяции кубического сплайна на сетке с мягким волнением:

(Код для воспроизведения приведенного выше сюжета приведен в конце этого ответа)

Все это, как говорится, для качественных и надежных методов, начиная с чего-то в одной из следующих статей, вероятно, будет более уместным

A. Aldroubi и Karlheinz Grochenig, Неоднородный отбор и реконструкция в инвариантных к сдвигу пространствах , SIAM Rev., 2001, no. 4, 585-620. ( pdf ссылка ).

K. Grochenig и H. Schwab, Методы быстрой локальной реконструкции для неоднородной выборки в пространствах , инвариантных к сдвигу , 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 можно заменить функцией конечной поддержки и соответствующим образом скорректировать пределы суммирования.

Пусть kernel (t) будет оконным sinc или другой подобной функцией длины 2k, тогда:

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

Я надеюсь, что это помогает ..., но я мог ошибиться, и это может быть немного интенсивным математикой. Я бы порекомендовал изучить преобразование частоты дискретизации для получения дополнительной информации. Может быть, кто-то еще мог бы дать лучшее объяснение или решение.

Я думаю, что ответ Джейкоба очень выполним.

Более простой метод, который, вероятно, не так хорош с точки зрения введения искажения, - это выполнить полиномиальную интерполяцию. Я бы использовал линейную интерполяцию (простая, но не с хорошей производительностью сигнала) или кубические сплайны (но не слишком жесткие, с лучшей производительностью сигнала) для получения выборок в любое время, которое вы хотите из выборок произвольного времени.

$Nnear$ 2 4 6 ...
2) класс используемых базовых функций: линейный, полиномиальный, синус-косинус (Фурье), кусочно-кубический (B-сплайн или интерполирующий сплайн), подобный sinc ...
(Вариант 0 - использовать ли чужой метод и код или делать самому).

$Nnear$
$y_{-1}$$y_1$ ]:
$\qquad$$y_0 \sim (y_{-1} + y_1) / 2$
$[x_i, y_i]$$x_i = 0$
$\qquad y_0 \sim$$y_i$
$[x_i, y_i]$ :
$\qquad$$a + b x$$y_0 \sim a$ .
$\qquad$ Можно подобрать квадратики, кубики, синус-косинусы ... таким же образом.

$2 \pi f t$$f$ = 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.)

Линейная взаимосвязь с 4, 6 или 8 соседями может работать достаточно хорошо для ваших данных.
Я бы посоветовал начать с метода, который вы хорошо понимаете, прежде чем погрузиться в сплайны, похожие на синки ... хотя они тоже могут быть забавными

---

Другой, совершенно другой метод - это обратное взвешивание . Его легко реализовать (см. Idw-interpolation-with-python для SO), он работает в 2d 3d и выше, но теоретически его сложно анализировать.

(Не очевидно, NO один метод интерполяции может возможно соответствовать несметным комбинациям
[сигнал, шум, ошибки метрики, тест функция] , которые происходят в действительности.
Есть несколько методов в мире, с большим количеством кнопок, чем тест - функции.
Тем не менее в галерее методов и тестовых функций могут быть полезны.)

Если вы работаете с 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

Прежде чем приступить к какой-то экзотической обработке, вы можете попробовать что-то простое, например: (псевдокод - без интерполяции, но это можно добавить)

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

ИМХО Ответ Datageist правильный, ответ Джейкоба - нет. Простой способ проверить это состоит в том, что предложенный алгоритм datageist гарантированно интерполируется через исходные выборки (предполагая бесконечную числовую точность), тогда как ответ Джейкоба - нет.

• Для случая равномерной выборки набор функций sinc является ортогональным: если каждая сдвинутая функция sinc дискретизируется по входным выборкам, они образуют бесконечную единичную матрицу. Это потому, что sin (n pi) / (n pi) равен нулю для всех n, кроме n = 0.
• Однако это свойство нельзя просто экстраполировать на неоднородный случай: подобный набор функций sinc, дискретизированный по входным выборкам, даст нетривиальную матрицу. Следовательно, вклады от окружающих выборок не будут равны нулю, и реконструкция больше не будет интерполировать входные выборки.