¿Qué es un algoritmo para volver a muestrear de una tasa variable a una tasa fija?

Tengo un sensor que informa sus lecturas con una marca de tiempo y un valor. Sin embargo, no genera lecturas a una velocidad fija.

Encuentro los datos de tasa variable difíciles de manejar. La mayoría de los filtros esperan una frecuencia de muestreo fija. Dibujar gráficos también es más fácil con una frecuencia de muestreo fija.

¿Existe un algoritmo para volver a muestrear de una frecuencia de muestreo variable a una frecuencia de muestreo fija?

El enfoque más simple es hacer algún tipo de interpolación de spline como sugiere Jim Clay (lineal o de otro tipo). Sin embargo, si tiene el lujo del procesamiento por lotes, y especialmente si tiene un conjunto sobredeterminado de muestras no uniformes, hay un algoritmo de "reconstrucción perfecta" que es extremadamente elegante. Por razones numéricas, puede no ser práctico en todos los casos, pero al menos vale la pena conocerlo conceptualmente. Lo leí por primera vez en este artículo .

El truco consiste en considerar que su conjunto de muestras no uniformes ya ha sido reconstruido a partir de muestras uniformes mediante interpolación sinc . Siguiendo la notación en el documento:

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

Tenga en cuenta que esto proporciona un conjunto de ecuaciones lineales, una para cada muestra no uniforme , donde las incógnitas son las muestras igualmente espaciadas , así: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}.$$

En la ecuación anterior, es el número de muestras uniformes desconocidas, es el inverso de la frecuencia de muestreo uniforme, es el número de muestras no uniformes (que pueden ser mayores que ). Al calcular la solución de mínimos cuadrados de ese sistema, se pueden reconstruir las muestras uniformes. Técnicamente, solo se necesitan muestras no uniformes, pero dependiendo de cuán "dispersas" estén en el tiempo, la matriz de interpolación puede estar terriblemente mal acondicionada . Cuando ese es el caso, usar más muestras no uniformes generalmente ayuda.T $n$$T$$m$$n$$n$

Como ejemplo de juguete, aquí hay una comparación (usando numpy ) entre el método anterior y la interpolación de spline cúbico en una cuadrícula ligeramente nerviosa:

(El código para reproducir la trama anterior se incluye al final de esta respuesta)

Dicho todo esto, para métodos robustos de alta calidad, comenzar con algo en uno de los siguientes documentos probablemente sería más apropiado:

A. Aldroubi y Karlheinz Grochenig, Muestreo no uniforme y reconstrucción en espacios invariables por turnos , SIAM Rev., 2001, no. 4, 585-620. ( enlace pdf ).

K. Grochenig y H. Schwab, Métodos de reconstrucción local rápida para muestreo no uniforme en espacios invariables por desplazamiento , 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()

Esto suena como un problema de conversión asincrónica de frecuencia de muestreo. Para convertir de una frecuencia de muestreo a otra, podemos calcular la representación de tiempo continuo de la señal realizando una interpolación sinc y luego volver a muestrear a nuestra nueva frecuencia de muestreo. Lo que estás haciendo no es muy diferente. Debe volver a muestrear su señal para tener tiempos de muestra fijos.

La señal de tiempo continuo se puede calcular convolucionando cada muestra con una función sinc. Dado que la función sinc continúa indefinidamente, utilizamos algo más práctico como un sinc con ventana de una longitud finita práctica. La parte difícil es que debido a que sus muestras se mueven a tiempo, puede ser necesario utilizar un sinc con un desfase de fase diferente para cada muestra al volver a muestrear.

Señal de tiempo continuo de la señal muestreada:

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

donde es su tiempo de muestra. En su caso, sin embargo, su tiempo de muestreo no es fijo. Así que creo que debe reemplazarlo con el tiempo de muestra en esa muestra.$T_s$

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

A partir de esto, puede volver a muestrear la señal:

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

donde es el tiempo de muestra deseado.$T_{ns}$

Poniendo todo junto, obtienes:

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

Como esto no es causal o manejable, la función sinc se puede reemplazar con una función de soporte finito y los límites de suma se ajustan en consecuencia.

Deje que kernel (t) sea una ventana sinc u otra función similar de longitud 2k y luego:

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

Espero que esto ayude ..., pero podría haber cometido un error en el camino y podría ser un poco intensivo en matemáticas. Recomendaría investigar la conversión de frecuencia de muestreo para obtener más información. Quizás alguien más aquí podría dar una mejor explicación o solución también.

Creo que la respuesta de Jacob es muy viable.

Un método más fácil que probablemente no sea tan bueno en términos de introducción de distorsión es hacer una interpolación polinómica. Usaría interpolación lineal (fácil, no tan buena señal de rendimiento) o splines cúbicos (todavía no demasiado duro, mejor rendimiento de señal) para producir muestras en cualquier momento que desee de sus muestras de tiempo arbitrario.

$Nnear$

$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$ Uno puede ajustar cuadráticos, cúbicos, seno-cosenos ... de la misma manera.

$2 \pi f t$$f$

La interpretación lineal con 4 u 6 u 8 vecinos podría funcionar lo suficientemente bien para sus datos.
Sugeriría comenzar con un método que comprenda a fondo antes de sumergirse en splines, como sinc ... aunque también puede ser divertido.

---

Otro método bastante diferente es la ponderación de distancia inversa . Es fácil de implementar (ver idw-interpolation-with-python en SO), también funciona en 2d 3d y superior, pero es difícil de analizar teóricamente.

(Obviamente, NINGÚN método de interpolación único puede adaptarse a los miles de millones de combinaciones de
[señal, ruido, métrica de error, función de prueba] que ocurren en la realidad.
Hay más métodos en el mundo, con más botones, que funciones de prueba.
Sin embargo, una galería de métodos y funciones de prueba pueden ser útiles).

Si trabaja con matlab, puede hacerlo trabajando con series de tiempo.

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

Antes de comenzar a realizar un procesamiento exótico, puede probar algo simple como esto (pseudocódigo, sin interpolación, pero podría agregarse)

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

La respuesta de IMHO Datageist es correcta, la respuesta de Jacob no lo es. Una manera fácil de verificar esto es que el algoritmo sugerido por datageist está garantizado para interpolar a través de las muestras originales (suponiendo una precisión numérica infinita), mientras que la respuesta de Jacob no.

• Para el caso de muestreo uniforme, el conjunto de funciones sinc es ortogonal: si cada función sinc desplazada se discretiza sobre las muestras de entrada, forman una matriz de identidad infinita. Esto se debe a que sin (n pi) / (n pi) es cero para todos los n excepto n = 0.
• Sin embargo, esta propiedad no puede simplemente extrapolarse al caso no uniforme: un conjunto similar de funciones sinc, discretizadas sobre las muestras de entrada, producirá una matriz no trivial. Por lo tanto, las contribuciones de las muestras circundantes no serán cero y la reconstrucción ya no se interpolará a través de las muestras de entrada.