Bagaimana cara memuluskan kurva dengan cara yang benar?

Mari kita asumsikan kita memiliki dataset yang mungkin diberikan kira-kira oleh

import numpy as np
x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2

Oleh karena itu kami memiliki variasi 20% dari dataset. Gagasan pertama saya adalah menggunakan fungsi UnivariateSpline dari Scipy, tetapi masalahnya adalah ini tidak mempertimbangkan kebisingan kecil dengan cara yang baik. Jika Anda mempertimbangkan frekuensinya, latar belakangnya jauh lebih kecil daripada sinyal, sehingga hanya spline dari cutoff yang mungkin merupakan ide, tetapi itu akan melibatkan transformasi bolak-balik fourier, yang mungkin mengakibatkan perilaku buruk. Cara lain akan menjadi rata-rata bergerak, tetapi ini juga akan membutuhkan pilihan penundaan yang tepat.

Adakah petunjuk / buku atau tautan bagaimana mengatasi masalah ini?

Saya lebih suka filter Savitzky-Golay . Menggunakan kuadrat terkecil untuk mundur jendela kecil data Anda ke polinomial, lalu menggunakan polinomial untuk memperkirakan titik di tengah jendela. Akhirnya jendela digeser maju oleh satu titik data dan proses berulang. Ini berlanjut sampai setiap titik telah disesuaikan secara optimal relatif terhadap tetangganya. Ini bekerja sangat baik bahkan dengan sampel berisik dari sumber non-periodik dan non-linear.

Berikut ini adalah contoh buku masak yang menyeluruh . Lihat kode saya di bawah ini untuk mendapatkan ide betapa mudahnya menggunakannya. Catatan: Saya meninggalkan kode untuk mendefinisikan savitzky_golay()fungsi karena Anda benar-benar dapat menyalin / menempelnya dari contoh buku masak yang saya tautkan di atas.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2
yhat = savitzky_golay(y, 51, 3) # window size 51, polynomial order 3

plt.plot(x,y)
plt.plot(x,yhat, color='red')
plt.show()

PEMBARUAN: Telah menjadi perhatian saya bahwa contoh buku resep yang saya tautkan telah dihapus. Untungnya, filter Savitzky-Golay telah dimasukkan ke dalam perpustakaan SciPy , seperti yang ditunjukkan oleh @dodohjk . Untuk mengadaptasi kode di atas dengan menggunakan sumber SciPy, ketik:

from scipy.signal import savgol_filter
yhat = savgol_filter(y, 51, 3) # window size 51, polynomial order 3

Cara cepat dan kotor untuk memuluskan data yang saya gunakan, berdasarkan kotak rata-rata bergerak (berdasarkan konvolusi):

x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.8

def smooth(y, box_pts):
    box = np.ones(box_pts)/box_pts
    y_smooth = np.convolve(y, box, mode='same')
    return y_smooth

plot(x, y,'o')
plot(x, smooth(y,3), 'r-', lw=2)
plot(x, smooth(y,19), 'g-', lw=2)

Jika Anda tertarik pada versi "halus" dari sinyal yang periodik (seperti contoh Anda), maka FFT adalah cara yang tepat. Ambil transformasi fourier dan kurangi frekuensi dengan kontribusi rendah:

import numpy as np
import scipy.fftpack

N = 100
x = np.linspace(0,2*np.pi,N)
y = np.sin(x) + np.random.random(N) * 0.2

w = scipy.fftpack.rfft(y)
f = scipy.fftpack.rfftfreq(N, x[1]-x[0])
spectrum = w**2

cutoff_idx = spectrum < (spectrum.max()/5)
w2 = w.copy()
w2[cutoff_idx] = 0

y2 = scipy.fftpack.irfft(w2)

Bahkan jika sinyal Anda tidak sepenuhnya periodik, ini akan sangat membantu mengurangi white noise. Ada banyak jenis filter untuk digunakan (high-pass, low-pass, dll ...), yang sesuai tergantung pada apa yang Anda cari.

Memasukkan rata-rata bergerak ke data Anda akan memuluskan kebisingan, lihat jawaban ini untuk cara melakukannya.

Jika Anda ingin menggunakan LOWESS agar sesuai dengan data Anda (ini mirip dengan moving average tetapi lebih canggih), Anda bisa melakukannya menggunakan perpustakaan statsmodels :

import numpy as np
import pylab as plt
import statsmodels.api as sm

x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2
lowess = sm.nonparametric.lowess(y, x, frac=0.1)

plt.plot(x, y, '+')
plt.plot(lowess[:, 0], lowess[:, 1])
plt.show()

Akhirnya, jika Anda tahu bentuk fungsional sinyal Anda, Anda bisa memasukkan kurva ke data Anda, yang mungkin merupakan hal terbaik untuk dilakukan.

Pilihan lain adalah menggunakan KernelReg di statsmodels :

from statsmodels.nonparametric.kernel_regression import KernelReg
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0,2*np.pi,100)
y = np.sin(x) + np.random.random(100) * 0.2

# The third parameter specifies the type of the variable x;
# 'c' stands for continuous
kr = KernelReg(y,x,'c')
plt.plot(x, y, '+')
y_pred, y_std = kr.fit(x)

plt.plot(x, y_pred)
plt.show()

Lihat ini! Ada definisi yang jelas tentang penghalusan sinyal 1D.

http://scipy-cookbook.readthedocs.io/items/SignalSmooth.html

Jalan pintas:

import numpy

def smooth(x,window_len=11,window='hanning'):
    """smooth the data using a window with requested size.

    This method is based on the convolution of a scaled window with the signal.
    The signal is prepared by introducing reflected copies of the signal 
    (with the window size) in both ends so that transient parts are minimized
    in the begining and end part of the output signal.

    input:
        x: the input signal 
        window_len: the dimension of the smoothing window; should be an odd integer
        window: the type of window from 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'
            flat window will produce a moving average smoothing.

    output:
        the smoothed signal

    example:

    t=linspace(-2,2,0.1)
    x=sin(t)+randn(len(t))*0.1
    y=smooth(x)

    see also: 

    numpy.hanning, numpy.hamming, numpy.bartlett, numpy.blackman, numpy.convolve
    scipy.signal.lfilter

    TODO: the window parameter could be the window itself if an array instead of a string
    NOTE: length(output) != length(input), to correct this: return y[(window_len/2-1):-(window_len/2)] instead of just y.
    """

    if x.ndim != 1:
        raise ValueError, "smooth only accepts 1 dimension arrays."

    if x.size < window_len:
        raise ValueError, "Input vector needs to be bigger than window size."


    if window_len<3:
        return x


    if not window in ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']:
        raise ValueError, "Window is on of 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'"


    s=numpy.r_[x[window_len-1:0:-1],x,x[-2:-window_len-1:-1]]
    #print(len(s))
    if window == 'flat': #moving average
        w=numpy.ones(window_len,'d')
    else:
        w=eval('numpy.'+window+'(window_len)')

    y=numpy.convolve(w/w.sum(),s,mode='valid')
    return y




from numpy import *
from pylab import *

def smooth_demo():

    t=linspace(-4,4,100)
    x=sin(t)
    xn=x+randn(len(t))*0.1
    y=smooth(x)

    ws=31

    subplot(211)
    plot(ones(ws))

    windows=['flat', 'hanning', 'hamming', 'bartlett', 'blackman']

    hold(True)
    for w in windows[1:]:
        eval('plot('+w+'(ws) )')

    axis([0,30,0,1.1])

    legend(windows)
    title("The smoothing windows")
    subplot(212)
    plot(x)
    plot(xn)
    for w in windows:
        plot(smooth(xn,10,w))
    l=['original signal', 'signal with noise']
    l.extend(windows)

    legend(l)
    title("Smoothing a noisy signal")
    show()


if __name__=='__main__':
    smooth_demo()

Jika Anda merencanakan grafik deret waktu dan jika Anda telah menggunakan mtplotlib untuk menggambar grafik maka gunakan metode median untuk menghaluskan grafik

smotDeriv = timeseries.rolling(window=20, min_periods=5, center=True).median()

di mana timeseriesset data Anda berlalu, Anda dapat mengubah windowsizeagar lebih halus.