ตัวกรองที่ปรับให้เรียบของ Savitzky-Golay มีระยะห่างไม่เท่ากัน

ฉันมีสัญญาณที่วัดได้ที่ 100Hz และฉันจำเป็นต้องใช้ตัวกรองการปรับให้เรียบของ Savitzky-Golay กับสัญญาณนี้ อย่างไรก็ตามในการตรวจสอบอย่างใกล้ชิดสัญญาณของฉันไม่ได้ถูกวัดที่อัตราคงที่ที่สมบูรณ์แบบเดลต้าระหว่างการวัดอยู่ระหว่าง 9.7 ถึง 10.3 มิลลิวินาที

มีวิธีใช้ตัวกรอง Savitzky-Golay กับข้อมูลที่มีระยะห่างไม่เท่ากันหรือไม่? มีวิธีอื่นที่ฉันสามารถสมัครได้หรือไม่?

วิธีหนึ่งคือการสุ่มข้อมูลของคุณใหม่เพื่อให้มีระยะห่างเท่ากันจากนั้นคุณสามารถทำสิ่งที่คุณต้องการได้ การ จำกัด การสุ่มใหม่โดยใช้การกรองเชิงเส้นจะไม่เป็นตัวเลือกที่ดีเนื่องจากข้อมูลไม่ได้เว้นระยะอย่างสม่ำเสมอดังนั้นคุณสามารถใช้การแก้ไขพหุนามแบบท้องถิ่น (เช่นลูกบาศก์ Splines) เพื่อประเมินว่าค่าสัญญาณพื้นฐานอยู่ที่ "แน่นอน" ช่วงเวลา 10 มิลลิวินาที

เนื่องจากวิธีการที่ได้มาจากตัวกรอง Savitzky-Golay (เช่นเป็นพหุนามแบบสี่เหลี่ยมจัตุรัสที่น้อยที่สุดในท้องถิ่น) จึงมีลักษณะทั่วไปตามธรรมชาติในการสุ่มตัวอย่างแบบไม่เป็นรูปแบบ - มันมีราคาแพงกว่าการคำนวณ

ตัวกรอง Savitzky-Golay โดยทั่วไป

สำหรับตัวกรองมาตรฐานความคิดคือให้พอดีกับพหุนามกับกลุ่มตัวอย่างท้องถิ่น [ใช้กำลังสองน้อยที่สุด] จากนั้นแทนที่ตัวอย่างกึ่งกลางด้วยค่าของพหุนามที่ดัชนีกลาง (เช่นที่ 0) นั่นหมายถึงค่าสัมประสิทธิ์ตัวกรอง SG มาตรฐานสามารถสร้างได้โดยการแปลงเมทริกซ์ Vandermondeของตัวบ่งชี้ตัวอย่าง ตัวอย่างเช่นหากต้องการสร้างพาราโบลาให้พอดีกับตัวอย่างห้าตัวอย่าง (ด้วยการบ่งชี้ในพื้นที่ -2, -1,0,1,2) ระบบของสมการการออกแบบA c = yจะเป็นดังนี้:$y_0\dots y_4$$Ac = y$

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

ในข้างต้นมีค่าสัมประสิทธิ์ที่ไม่รู้จักของสี่เหลี่ยมน้อยพหุนามค0 + ค1 x + ค2 x 2 เนื่องจากค่าของพหุนามที่x = 0เป็นแค่c 0 การคำนวณpseudoinverseของเมทริกซ์การออกแบบ (เช่นc = ( A T A ) - 1 A T y ) จะให้ค่าสัมประสิทธิ์ตัวกรอง SG ในแถวบนสุด ในกรณีนี้พวกเขาจะเป็น$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}.$$

โปรดทราบว่าเนื่องจากอนุพันธ์ของคือc 1 + 2 c 2 xแถวที่สองของเมทริกซ์ (ซึ่งประเมินc 1 ) จะเป็นตัวกรองอนุพันธ์ที่ทำให้เรียบ อาร์กิวเมนต์เดียวกันนี้ใช้กับแถวที่ต่อเนื่องกัน - มันให้อนุพันธ์ที่มีลำดับสูงกว่าอย่างราบรื่น โปรดทราบว่าฉันปรับอัตราส่วนเมทริกซ์ที่ 35 ดังนั้นแถวแรกจะตรงกับค่าสัมประสิทธิ์การปรับให้เรียบใน Wikipedia (ด้านบน) ตัวกรองอนุพันธ์แตกต่างกันไปตามปัจจัยการปรับอื่น ๆ$c_0 + c_1x + c_2x^2$$c_1 + 2c_2x$$c_1$

การสุ่มตัวอย่างแบบ nonuniform

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

ดังนั้นแต่ละเมทริกซ์การออกแบบจะอยู่ในรูปแบบต่อไปนี้:

$$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$ $c_0$

$f$$N$$\sqrt{N/2}$
$\qquad -$

(มาทุกคนหรือไม่)

$\pm N/2$$t$$t$
$t_i \to i$

ฉันพบว่ามีสองวิธีในการใช้อัลกอริทึม savitzky-golay ใน Matlab เมื่อเป็นตัวกรองและฟังก์ชั่นปรับให้เรียบ แต่โดยทั่วไปแล้วพวกเขาควรทำเช่นเดียวกัน

1. yy = sgolayfilt (y, k, f): ที่นี่ค่า y = y (x) จะถือว่ามีระยะห่างเท่ากันใน x
2. yy = smooth (x, y, span, 'sgolay', degree): ที่นี่คุณสามารถมี x เป็นอินพุตพิเศษและอ้างอิงถึง Matlab help x ไม่จำเป็นต้องเว้นระยะเท่ากัน!

หากเป็นความช่วยเหลือใด ๆ ฉันได้ใช้งาน C ของวิธีการที่อธิบายโดย datageist ฟรีที่จะใช้ความเสี่ยงของคุณเอง

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