Làm thế nào để làm phẳng một đường cong đúng cách?

Giả sử chúng ta có một bộ dữ liệu có thể được cung cấp khoảng

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

Do đó, chúng tôi có một biến thể 20% của bộ dữ liệu. Ý tưởng đầu tiên của tôi là sử dụng chức năng UnivariateSpline của scipy, nhưng vấn đề là điều này không xem xét tiếng ồn nhỏ theo cách tốt. Nếu bạn xem xét các tần số, nền nhỏ hơn nhiều so với tín hiệu, do đó, một spline chỉ có thể bị cắt có thể là một ý tưởng, nhưng điều đó sẽ liên quan đến chuyển đổi phạm vi qua lại, có thể dẫn đến hành vi xấu. Một cách khác sẽ là một đường trung bình động, nhưng điều này cũng cần có sự lựa chọn đúng về độ trễ.

Bất kỳ gợi ý / sách hoặc liên kết làm thế nào để giải quyết vấn đề này?

Tôi thích bộ lọc Savitzky-Golay . Nó sử dụng bình phương tối thiểu để hồi quy một cửa sổ nhỏ dữ liệu của bạn lên một đa thức, sau đó sử dụng đa thức để ước tính điểm ở giữa cửa sổ. Cuối cùng, cửa sổ được chuyển về phía trước bởi một điểm dữ liệu và quá trình lặp lại. Điều này tiếp tục cho đến khi mọi điểm đã được điều chỉnh tối ưu so với các nước láng giềng. Nó hoạt động tuyệt vời ngay cả với các mẫu nhiễu từ các nguồn không định kỳ và phi tuyến tính.

Dưới đây là một ví dụ nấu ăn kỹ lưỡng . Xem mã của tôi dưới đây để có được một ý tưởng về việc sử dụng nó dễ dàng như thế nào. Lưu ý: Tôi đã bỏ qua mã để xác định savitzky_golay()chức năng bởi vì bạn có thể sao chép / dán nó theo nghĩa đen từ ví dụ sách nấu ăn mà tôi đã liên kết ở trên.

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()

CẬP NHẬT: Tôi đã nhận thấy rằng ví dụ về sách dạy nấu ăn mà tôi liên kết đã bị gỡ xuống. May mắn thay, bộ lọc Savitzky-Golay đã được tích hợp vào thư viện SciPy , như được chỉ ra bởi @dodohjk . Để điều chỉnh mã trên bằng cách sử dụng nguồn SciPy, gõ:

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

Một cách nhanh chóng và bẩn để làm mịn dữ liệu tôi sử dụng, dựa trên hộp trung bình di chuyển (bằng tích chập):

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)

Nếu bạn quan tâm đến phiên bản "mượt" của tín hiệu định kỳ (như ví dụ của bạn), thì FFT là cách phù hợp. Thực hiện chuyển đổi fourier và trừ đi các tần số đóng góp thấp:

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)

Ngay cả khi tín hiệu của bạn không hoàn toàn định kỳ, điều này sẽ làm rất tốt việc loại bỏ nhiễu trắng. Có nhiều loại bộ lọc để sử dụng (high-pass, low-pass, v.v ...), loại phù hợp phụ thuộc vào những gì bạn đang tìm kiếm.

Gắn trung bình di động vào dữ liệu của bạn sẽ làm giảm nhiễu, hãy xem câu trả lời này để biết cách thực hiện.

Nếu bạn muốn sử dụng THẤP để phù hợp với dữ liệu của mình (tương tự như mức trung bình di động nhưng tinh vi hơn), bạn có thể thực hiện điều đó bằng thư viện 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()

Cuối cùng, nếu bạn biết dạng chức năng của tín hiệu của mình, bạn có thể điều chỉnh đường cong cho dữ liệu của mình, đây có thể là điều tốt nhất để làm.

Một tùy chọn khác là sử dụng KernelReg trong 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()

Kiểm tra này! Có một định nghĩa rõ ràng về làm mịn tín hiệu 1D.

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

Đường tắt:

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()

Nếu bạn đang vẽ đồ thị chuỗi thời gian và nếu bạn đã sử dụng mtplotlib để vẽ biểu đồ thì hãy sử dụng phương pháp trung bình để làm mịn biểu đồ

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

nơi timeserieslà bộ dữ liệu của bạn thông qua bạn có thể thay đổi windowsizecho smoothining hơn.