Scipy.signal.butter के साथ बैंड-पास बटरवर्थ फ़िल्टर कैसे लागू करें

Question 1

अपडेट करें:

मुझे इस सवाल पर आधारित एक स्कैपी रेसिपी मिली! तो, किसी के लिए भी, सीधे जाएं: सामग्री »सिग्नल प्रोसेसिंग» बटरवर्थ बैंडपास

मुझे यह हासिल करने के लिए एक कठिन समय मिल रहा है कि शुरू में 1-डी के लिए एक बटरवर्थ बैंड-पास फ़िल्टर को लागू करने का एक सरल काम लगता था (समय-श्रृंखला)।

जिन मापदंडों को मुझे शामिल करना है, वे हैं HERTZ में नमूना_ट्रेड, कटऑफ़ फ़्रीक्वेंसी और संभवतः ऑर्डर (अन्य पैरामीटर, जैसे क्षीणन, प्राकृतिक आवृत्ति, आदि मेरे लिए अधिक अस्पष्ट हैं, इसलिए कोई भी "डिफ़ॉल्ट" मान करेगा)।

मेरे पास अब यह है, जो एक उच्च-पास फिल्टर के रूप में काम करता है, लेकिन मुझे यकीन नहीं है कि मैं इसे सही कर रहा हूं:

def butter_highpass(interval, sampling_rate, cutoff, order=5):
    nyq = sampling_rate * 0.5

    stopfreq = float(cutoff)
    cornerfreq = 0.4 * stopfreq  # (?)

    ws = cornerfreq/nyq
    wp = stopfreq/nyq

    # for bandpass:
    # wp = [0.2, 0.5], ws = [0.1, 0.6]

    N, wn = scipy.signal.buttord(wp, ws, 3, 16)   # (?)

    # for hardcoded order:
    # N = order

    b, a = scipy.signal.butter(N, wn, btype='high')   # should 'high' be here for bandpass?
    sf = scipy.signal.lfilter(b, a, interval)
    return sf

यहां छवि विवरण दर्ज करें

डॉक्स और उदाहरण भ्रमित और अस्पष्ट हैं, लेकिन मैं "बैंडपास के लिए" के रूप में चिह्नित प्रशंसा में प्रस्तुत किए गए फॉर्म को लागू करना चाहूंगा। टिप्पणियों में प्रश्न चिह्न यह दिखाते हैं कि मैंने अभी कुछ उदाहरण को बिना समझे कॉपी-पेस्ट किया है कि क्या हो रहा है।

मैं कोई इलेक्ट्रिकल इंजीनियरिंग या वैज्ञानिक नहीं हूं, बस एक चिकित्सा उपकरण डिजाइनर को ईएमजी संकेतों पर फ़िल्टर करने के बजाय कुछ सीधे-सीधे बैंडपास प्रदर्शन करने की आवश्यकता है।

Question 2

आप बट्टर्ड का उपयोग छोड़ सकते हैं, और इसके बजाय केवल फ़िल्टर के लिए एक आदेश चुनें और देखें कि क्या यह आपके फ़िल्टरिंग मानदंड को पूरा करता है। एक बैंडपास फ़िल्टर के लिए फ़िल्टर गुणांक उत्पन्न करने के लिए, मक्खन () फ़िल्टर ऑर्डर, कटऑफ़ फ़्रीक्वेंसी Wn=[low, high](Nyquist आवृत्ति के अंश के रूप में व्यक्त किया जाता है, जो कि आधा नमूना आवृत्ति है) और बैंड प्रकार btype="band"।

यहां एक स्क्रिप्ट है जो बटरवर्थ बैंडपास फिल्टर के साथ काम करने के लिए कुछ सुविधा कार्यों को परिभाषित करता है। जब एक स्क्रिप्ट के रूप में चलाया जाता है, तो यह दो प्लॉट बनाता है। एक ही नमूना दर और कटऑफ आवृत्तियों के लिए कई फिल्टर आदेशों पर आवृत्ति प्रतिक्रिया दिखाती है। अन्य भूखंड नमूना समय श्रृंखला पर फ़िल्टर (आदेश = 6 के साथ) के प्रभाव को प्रदर्शित करता है।

from scipy.signal import butter, lfilter


def butter_bandpass(lowcut, highcut, fs, order=5):
    nyq = 0.5 * fs
    low = lowcut / nyq
    high = highcut / nyq
    b, a = butter(order, [low, high], btype='band')
    return b, a


def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):
    b, a = butter_bandpass(lowcut, highcut, fs, order=order)
    y = lfilter(b, a, data)
    return y


if __name__ == "__main__":
    import numpy as np
    import matplotlib.pyplot as plt
    from scipy.signal import freqz

    # Sample rate and desired cutoff frequencies (in Hz).
    fs = 5000.0
    lowcut = 500.0
    highcut = 1250.0

    # Plot the frequency response for a few different orders.
    plt.figure(1)
    plt.clf()
    for order in [3, 6, 9]:
        b, a = butter_bandpass(lowcut, highcut, fs, order=order)
        w, h = freqz(b, a, worN=2000)
        plt.plot((fs * 0.5 / np.pi) * w, abs(h), label="order = %d" % order)

    plt.plot([0, 0.5 * fs], [np.sqrt(0.5), np.sqrt(0.5)],
             '--', label='sqrt(0.5)')
    plt.xlabel('Frequency (Hz)')
    plt.ylabel('Gain')
    plt.grid(True)
    plt.legend(loc='best')

    # Filter a noisy signal.
    T = 0.05
    nsamples = T * fs
    t = np.linspace(0, T, nsamples, endpoint=False)
    a = 0.02
    f0 = 600.0
    x = 0.1 * np.sin(2 * np.pi * 1.2 * np.sqrt(t))
    x += 0.01 * np.cos(2 * np.pi * 312 * t + 0.1)
    x += a * np.cos(2 * np.pi * f0 * t + .11)
    x += 0.03 * np.cos(2 * np.pi * 2000 * t)
    plt.figure(2)
    plt.clf()
    plt.plot(t, x, label='Noisy signal')

    y = butter_bandpass_filter(x, lowcut, highcut, fs, order=6)
    plt.plot(t, y, label='Filtered signal (%g Hz)' % f0)
    plt.xlabel('time (seconds)')
    plt.hlines([-a, a], 0, T, linestyles='--')
    plt.grid(True)
    plt.axis('tight')
    plt.legend(loc='upper left')

    plt.show()

यहाँ इस लिपि द्वारा निर्मित भूखंड हैं:

कई फिल्टर आदेशों के लिए आवृत्ति प्रतिक्रिया

यहां छवि विवरण दर्ज करें

Question 3

स्वीकृत उत्तर में फ़िल्टर डिज़ाइन विधि सही है, लेकिन इसमें एक दोष है। ख के साथ बनाया गया SciPy बैंडपास फिल्टर, एक कर रहे हैं अस्थिर और में हो सकता है गलत फिल्टर पर उच्च फिल्टर आदेश ।

इसके बजाय, फ़िल्टर डिज़ाइन के एसओएस (सेकंड-ऑर्डर सेक्शन) आउटपुट का उपयोग करें।

from scipy.signal import butter, sosfilt, sosfreqz

def butter_bandpass(lowcut, highcut, fs, order=5):
        nyq = 0.5 * fs
        low = lowcut / nyq
        high = highcut / nyq
        sos = butter(order, [low, high], analog=False, btype='band', output='sos')
        return sos

def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):
        sos = butter_bandpass(lowcut, highcut, fs, order=order)
        y = sosfilt(sos, data)
        return y

इसके अलावा, आप बदलकर आवृत्ति प्रतिक्रिया की साजिश कर सकते हैं

b, a = butter_bandpass(lowcut, highcut, fs, order=order)
w, h = freqz(b, a, worN=2000)

सेवा

sos = butter_bandpass(lowcut, highcut, fs, order=order)
w, h = sosfreqz(sos, worN=2000)

Question 4

एक बैंडपास फ़िल्टर के लिए, ws एक टपल है जिसमें निचले और ऊपरी कोने की आवृत्तियाँ होती हैं। ये डिजिटल फ्रिक्वेंसी का प्रतिनिधित्व करते हैं जहां फ़िल्टर प्रतिक्रिया पासबैंड की तुलना में 3 डीबी कम है।

wp एक tuple है जिसमें स्टॉप बैंड डिजिटल फ्रीक्वेंसी होती है। वे उस स्थान का प्रतिनिधित्व करते हैं जहां अधिकतम क्षीणन शुरू होता है।

डीएसबी में पासपास में गैस्ट अधिकतम अटेंशन है जबकि स्टॉपबैंड्स में जीएसटीओपी एटेंट्रेशन है।

उदाहरण के लिए, आप sec००० और ३१०० हर्ट्ज के कोने आवृत्तियों वाले sec००० नमूनों / सेक की नमूना दर के लिए एक फ़िल्टर डिजाइन करना चाहते थे। Nyquist आवृत्ति नमूना दर दो से विभाजित है, या इस उदाहरण में, 4000 हर्ट्ज। बराबर डिजिटल आवृत्ति 1.0 है। दो कोने की आवृत्तियाँ 300/4000 और 3100/4000 हैं।

अब आप कहते हैं कि आप चाहते थे कि स्टॉपबैंड कोने के आवृत्तियों से 30 डीबी +/- 100 हर्ट्ज नीचे हो। इस प्रकार, आपके स्टॉपबैंड 200 और 3200 हर्ट्ज पर शुरू होंगे, जिसके परिणामस्वरूप 200/4000 और 3200/4000 की डिजिटल आवृत्तियाँ होंगी।

अपना फ़िल्टर बनाने के लिए, आप buttord को कॉल करेंगे

fs = 8000.0
fso2 = fs/2
N,wn = scipy.signal.buttord(ws=[300/fso2,3100/fso2], wp=[200/fs02,3200/fs02],
   gpass=0.0, gstop=30.0)

परिणामी फ़िल्टर की लंबाई स्टॉप बैंड की गहराई और प्रतिक्रिया वक्र की स्थिरता पर निर्भर होगी जो कोने की आवृत्ति और स्टॉपबैंड आवृत्ति के बीच के अंतर से निर्धारित होती है।