Filtro de suavização Savitzky-Golay para dados não igualmente espaçados

Eu tenho um sinal medido em 100Hz e preciso aplicar o filtro de suavização Savitzky-Golay neste sinal. No entanto, em uma inspeção mais minuciosa, meu sinal não é medido a uma taxa perfeitamente constante, o delta entre as medições varia entre 9,7 e 10,3 ms.

Existe uma maneira de usar o filtro Savitzky-Golay em dados não igualmente espaçados? Existem outros métodos que eu poderia aplicar?

Um método seria reamostrar seus dados para que sejam igualmente espaçados, para que você possa fazer o processamento que quiser. A reamostragem ilimitada de banda usando filtragem linear não será uma boa opção, pois os dados não são uniformemente espaçados, portanto, você pode usar algum tipo de interpolação polinomial local (por exemplo, splines cúbicos) para estimar quais são os valores "exatos" do sinal subjacente Intervalos de 10 milissegundos.

Devido à maneira como o filtro Savitzky-Golay é derivado (ou seja, como o polinômio local dos mínimos quadrados se encaixa), existe uma generalização natural para a amostragem não uniforme - é apenas muito mais caro em termos computacionais.

Filtros Savitzky-Golay em geral

Para o filtro padrão, a idéia é ajustar um polinômio a um conjunto local de amostras [usando mínimos quadrados] e substituir a amostra central pelo valor do polinômio no índice central (ou seja, 0). Isso significa que os coeficientes de filtro SG padrão podem ser gerados invertendo uma matriz de Vandermonde de indicações de amostra. Por exemplo, para gerar um ajuste parabólico local em cinco amostras (com indicações locais -2, -1,0,1,2), o sistema de equações de design A c = $y_0\dots y_4$$Ac = y$ seria o seguinte:

$$\begin{bmatrix}-2^0 & -2^1 & -2^2 \\ -1^0 & -1^1 & -1^2 \\ 0^0 & 0^1 & 0^2 \\ 1^0 & 1^1 & 1^2 \\ 2^0 & 2^1 & 2^2 \end{bmatrix} \begin{bmatrix} c_0 \\ c_1 \\ c_2 \end{bmatrix} = \begin{bmatrix} y_0 \\ y_1 \\ y_2 \\ y_3 \\ y_4 \end{bmatrix}.$$

Acima, são os coeficientes desconhecidos do polinômio de mínimos quadrados c 0 + c 1 x + c 2 x 2 . Como o valor do polinômio em x = 0 é apenas c 0 , o cálculo do pseudo - inverso da matriz de projeto (ou seja, c = ( A T A ) - 1 A T y ) produzirá os coeficientes do filtro SG na linha superior. Nesse caso, eles seriam$c_0 \dots c_2$$c_0 + c_1x + c_2x^2$$x = 0$$c_0$$c = (A^TA)^{-1}A^T y\space$

$$\begin{bmatrix}c_0 \\ c_1 \\ c_2 \end{bmatrix} = \begin{bmatrix} -3 & 12 & 17 & 12 & -3 \\ -7 & -4 & 0 & 4 & 7 \\ 5 & -3 & -5 & -3 & 5 \\ \end{bmatrix} \begin{bmatrix} y_0 \\ y_1 \\ y_2 \\ y_3 \\ y_4 \end{bmatrix}.$$

Observe que, como a derivada de é c 1 + 2 c 2 x , a segunda linha da matriz (que avalia $c_0 + c_1x + c_2x^2$$c_1 + 2c_2x$ ) será um filtro de derivada suavizada. O mesmo argumento se aplica a linhas sucessivas - elas fornecem derivadas de ordem superior suavizadas. Observe que dimensionei a matriz em 35 para que a primeira linha correspondesse aos coeficientes de suavização fornecidos na Wikipedia (acima). Os filtros derivativos diferem por outros fatores de escala.$c_1$

Amostragem não uniforme

Quando as amostras são espaçadas uniformemente, os coeficientes do filtro são invariantes à conversão, portanto, o resultado é apenas um filtro FIR. Para amostras não uniformes, os coeficientes diferem com base no espaçamento local da amostra, portanto, a matriz de projeto precisará ser construída e invertida em cada amostra. Se os tempos de amostra não uniformes são , e construímos coordenadas locais t n com cada tempo de amostra central fixo em 0 , ou seja,$x_n$$t_n$$0$

$$\begin{align} t_{-2} & = x_{-2} - x_0 \\ t_{-1} & = x_{-1} - x_0 \\ t_0 & = x_0 - x_0 \\ t_1 & = x_1 - x_0 \\ t_2 & = x_2 - x_0 \end{align}$$

cada matriz de design terá a seguinte forma:

$$A = \begin{bmatrix} t_{-2}^0 & t_{-2}^1 & t_{-2}^2 \\ t_{-1}^0 & t_{-1}^1 & t_{-1}^2 \\ t_0^0 & t_0^1 & t_0^2 \\ t_1^0 & t_1^1 & t_1^2 \\ t_2^0 & t_2^1 & t_2^2 \end{bmatrix} = \begin{bmatrix} 1 & t_{-2} & t_{-2}^2 \\ 1 & t_{-1} & t_{-1}^2 \\ 1 & 0 & 0 \\ 1 & t_1 & t_1^2 \\ 1 & t_2 & t_2^2 \end{bmatrix}.$$

A primeira linha do pseudoinverso de $A$ pontilhado com os valores da amostra local produzirá$c_0$, o valor suavizado nessa amostra.

"Como uma alternativa barata, pode-se simplesmente fingir que os pontos de dados estão igualmente espaçados ...
se a mudança no$f$ em toda a largura do $N$ janela de ponto é menor que $\sqrt{N/2}$ vezes o ruído de medição em um único ponto, o método barato pode ser usado ".
$\qquad -$ Receitas Numéricas pp. 771-772

(derivação alguém?)

("Finja igualmente espaçado" significa:
pegue a$\pm N/2$ pontos em torno de cada $t$ onde você quer SavGol ($t$),
não encaixe tudo$t_i \to i$. Isso pode ser óbvio, mas me pegou por um tempo.)

Eu descobri que existem duas maneiras de usar o algoritmo savitzky-golay no Matlab. Uma vez como filtro e outra como função de suavização, mas basicamente eles devem fazer o mesmo.

1. yy = sgolayfilt (y, k, f): Aqui, os valores y = y (x) são assumidos como igualmente espaçados em x.
2. yy = suave (x, y, span, 'sgolay', degree): Aqui você pode ter x como uma entrada extra e, consultando a ajuda do Matlab, x não precisa ser igualmente espaçado!

Se for de alguma ajuda, fiz uma implementação em C do método descrito pelo datageist. Livre para usar por sua conta e risco.

/**
 * @brief smooth_nonuniform
 * Implements the method described in  /signals/1676/savitzky-golay-smoothing-filter-for-not-equally-spaced-data
 * free to use at the user's risk
 * @param n the half size of the smoothing sample, e.g. n=2 for smoothing over 5 points
 * @param the degree of the local polynomial fit, e.g. deg=2 for a parabolic fit
 */
bool smooth_nonuniform(uint deg, uint n, std::vector<double>const &x, std::vector<double> const &y, std::vector<double>&ysm)
{
    if(x.size()!=y.size()) return false; // don't even try
    if(x.size()<=2*n)      return false; // not enough data to start the smoothing process
//    if(2*n+1<=deg+1)       return false; // need at least deg+1 points to make the polynomial

    int m = 2*n+1; // the size of the filter window
    int o = deg+1; // the smoothing order

    std::vector<double> A(m*o);         memset(A.data(),   0, m*o*sizeof(double));
    std::vector<double> tA(m*o);        memset(tA.data(),  0, m*o*sizeof(double));
    std::vector<double> tAA(o*o);       memset(tAA.data(), 0, o*o*sizeof(double));

    std::vector<double> t(m);           memset(t.data(),   0, m*  sizeof(double));
    std::vector<double> c(o);           memset(c.data(),   0, o*  sizeof(double));

    // do not smooth start and end data
    int sz = y.size();
    ysm.resize(sz);           memset(ysm.data(), 0,sz*sizeof(double));
    for(uint i=0; i<n; i++)
    {
        ysm[i]=y[i];
        ysm[sz-i-1] = y[sz-i-1];
    }

    // start smoothing
    for(uint i=n; i<x.size()-n; i++)
    {
        // make A and tA
        for(int j=0; j<m; j++)
        {
            t[j] = x[i+j-n] - x[i];
        }
        for(int j=0; j<m; j++)
        {
            double r = 1.0;
            for(int k=0; k<o; k++)
            {
                A[j*o+k] = r;
                tA[k*m+j] = r;
                r *= t[j];
            }
        }

        // make tA.A
        matMult(tA.data(), A.data(), tAA.data(), o, m, o);

        // make (tA.A)-¹ in place
        if (o==3)
        {
            if(!invert33(tAA.data())) return false;
        }
        else if(o==4)
        {
            if(!invert44(tAA.data())) return false;
        }
        else
        {
            if(!inverseMatrixLapack(o, tAA.data())) return false;
        }

        // make (tA.A)-¹.tA
        matMult(tAA.data(), tA.data(), A.data(), o, o, m); // re-uses memory allocated for matrix A

        // compute the polynomial's value at the center of the sample
        ysm[i] = 0.0;
        for(int j=0; j<m; j++)
        {
            ysm[i] += A[j]*y[i+j-n];
        }
    }

    std::cout << "      x       y       y_smoothed" << std::endl;
    for(uint i=0; i<x.size(); i++) std::cout << "   " << x[i] << "   " << y[i]  << "   "<< ysm[i] << std::endl;

    return true;
}