Savitzky-Golay चौरसाई करने के लिए समान रूप से डेटा नहीं छनन फ़िल्टर

16

मेरे पास एक सिग्नल है जिसे 100Hz पर मापा जाता है और मुझे इस सिग्नल पर सविट्ज़की-गोलय स्मूथिंग फ़िल्टर लागू करने की आवश्यकता है। हालांकि, करीब निरीक्षण पर मेरा संकेत पूरी तरह से स्थिर दर पर मापा नहीं गया है, माप के बीच डेल्टा 9.7 और 10.3 एमएस के बीच है।

वहाँ समान रूप से स्थानिक डेटा पर Savitzky-Golay फ़िल्टर का उपयोग करने का एक तरीका है? क्या अन्य तरीके हैं जो मैं लागू कर सकता हूं?

filters smoothing

— वीएलसी
स्रोत

1991 में गोरी द्वारा किया गया एक पेपर बहुत ही सटीक विषय datapdf.com/ पर है । लेकिन tldr, datageist का उत्तर सही मुख्य विचार (स्थानीय न्यूनतम-वर्ग) है। गोर्री क्या देखती है कि गुणांक केवल स्वतंत्र चर पर निर्भर करते हैं और निर्भर चर (जैसे सविट्ज़की-गोलय) में रैखिक होते हैं। फिर वह उन्हें गणना करने का एक तरीका देता है, लेकिन यदि आप एक अनुकूलित पुस्तकालय नहीं लिख रहे हैं, तो किसी भी पुराने न्यूनतम वर्ग के फिटर का उपयोग किया जा सकता है।

— डेव प्रिचर्ड

5

एक तरीका यह होगा कि आप अपने डेटा को फिर से तैयार कर लें ताकि यह समान रूप से फ़ैल जाए, फिर आप जो चाहें प्रोसेसिंग कर सकते हैं। रेखीय फ़िल्टरिंग का उपयोग करते हुए बैंडलेडेड रेज़म्पलिंग एक अच्छा विकल्प नहीं है क्योंकि डेटा समान रूप से नहीं दिया गया है, इसलिए आप अनुमान लगाने के लिए स्थानीय बहुपद इंटरपोलेशन (जैसे क्यूबिक स्प्लिन) का उपयोग कर सकते हैं ताकि यह अनुमान लगाया जा सके कि अंतर्निहित संकेत के मान "सटीक" हैं। 10-मिलीसेकंड अंतराल।

— जेसन आर
स्रोत

मेरे पास यह उपाय अंतिम उपाय के रूप में था। मैं सोच रहा था कि अंत में यह दृष्टिकोण सिर्फ यह मानने की तुलना में बेहतर समाधान देता है कि मेरा संकेत एक स्थिर दर पर मापा जाता है।

— VLC

मुझे लगता है कि भले ही यह गैर-समान रूप से सैंपल किया गया हो, फिर भी आप sinc () इंटरपोलेशन (या अलग-अलग अत्यधिक सैंपल वाले कम फिल्टर) का उपयोग कर सकते हैं। यह एक पट्टी या एक pchip तुलना में बेहतर परिणाम दे सकता है

— Hilmar

1

@ हिलमार: आप सही हैं। ऐसे कई तरीके हैं जिनसे आप डेटा को फिर से खोल सकते हैं; अनुमानित सिन इंटरपोलेशन, बैंडलेडेड रेज़म्पलिंग के लिए "आदर्श" विधि होगी।

— जेसन आर

15

सवित्स्की-गोले फ़िल्टर को जिस तरह से व्युत्पन्न किया गया है (यानी स्थानीय कम-वर्ग बहुपद फिट बैठता है) के कारण, गैर-वर्दी नमूनाकरण के लिए एक प्राकृतिक सामान्यीकरण है - यह सिर्फ अधिक कम्प्यूटेशनल रूप से महंगा है।

सविट्ज़की-गॉले फिल्टर जनरल में

$y_0\dots y_4$ $Ac = y$

[\begin{matrix} - 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{matrix}] [\begin{matrix} c_{0} \\ c_{1} \\ c_{2} \end{matrix}] = [\begin{matrix} y_{0} \\ y_{1} \\ y_{2} \\ y_{3} \\ y_{4} \end{matrix}] .

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

In the above, the $c_0 \dots c_2$ are the unknown coefficients of the least squares polynomial $c_0 + c_1x + c_2x^2$ . Since the value of the polynomial at $x = 0$ is just $c_0$ , computing the pseudoinverse of the design matrix (i.e. $c = (A^TA)^{-1}A^T y\space$ ) will yield the SG filter coefficients in the top row. In this case, they would be

[\begin{matrix} c_{0} \\ c_{1} \\ c_{2} \end{matrix}] = [\begin{matrix} - 3 & 12 & 17 & 12 & - 3 \\ - 7 & - 4 & 0 & 4 & 7 \\ 5 & - 3 & - 5 & - 3 & 5 \end{matrix}] [\begin{matrix} y_{0} \\ y_{1} \\ y_{2} \\ y_{3} \\ y_{4} \end{matrix}] .

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

Note that since the derivative of $c_0 + c_1x + c_2x^2$ is $c_1 + 2c_2x$ , the second row of the matrix (which evaluates $c_1$ ) will be a smoothed derivative filter. The same argument applies for successive rows--they give smoothed higher-order derivatives. Note that I scaled the matrix by 35 so the first row would match the smoothing coefficients given on Wikipedia (above). The derivative filters each differ by other scaling factors.

Nonuniform Sampling

When the samples are evenly spaced, the filter coefficients are translation-invariant, so the result is just an FIR filter. For nonuniform samples, the coefficients will differ based on the local sample spacing, so the design matrix will need to be constructed and inverted at each sample. If the nonuniform sample times are $x_n$ , and we construct local coordinates $t_n$ with each center sample time fixed at $0$ , i.e.

\begin{aligned} 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{aligned}

$\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}$

then each design matrix will be of the following form:

A = [\begin{matrix} 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{matrix}] = [\begin{matrix} 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{matrix}] .

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

The first row of the pseudoinverse of $A$ dotted with the local sample values will yield $c_0$ , the smoothed value at that sample.

— datageist
स्रोत

sounds like it moves from O(log(n)) to O(n^2).

— EngrStudent - Reinstate Monica

Here's an implementation of Scala described by datageist upwards.

— Medium core

1

@Mediumcore You didn't add a link to your original post. Also, I deleted it because it didn't provide an answer to the question. Please try to edit datageist's post to add a link; it'll be moderated in after review.

— Peter K.

4

"As a cheap alternative, one can simply pretend that the data points are equally spaced ...
if the change in $f$ across the full width of the $N$ point window is less than $\sqrt{N/2}$ times the measurement noise on a single point, then the cheap method can be used."
$\qquad -$ Numerical Recipes pp. 771-772

(derivation anyone ?)

("Pretend equally spaced" means:
take the nearest $\pm N/2$ points around each $t$ where you want SavGol( $t$ ),
not snap all $t_i \to i$ . That may be obvious, but got me for a while.)

— denis
स्रोत

1

I found out, that there are two ways to use the savitzky-golay algorithm in Matlab. Once as a filter, and once as a smoothing function, but basically they should do the same.

yy = sgolayfilt(y,k,f): Here, the values y=y(x) are assumed to be equally spaced in x.
yy = smooth(x,y,span,'sgolay',degree): Here you can have x as an extra input and referring to the Matlab help x does not have to be equally spaced!

— Jochen
स्रोत

0

If it's of any help, I've made a C implementation of the method described by datageist. Free to use at your own risk.

/**
 * @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;
}

— techwinder
स्रोत