उन्नत डेटा लॉगिंग में प्रयोग (पायथन का उपयोग करके): 11 चरण

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:19

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

(आप सभी कोड देख सकते हैं और इसे यहां डाउनलोड कर सकते हैं: कोड गिटहब पर आप देखने में आ सकते हैं, शायद किसी अन्य विंडो में, केवल 2 क्लिक के साथ)

आमतौर पर डेटा लॉगिंग में निम्नलिखित शामिल होते हैं:

• डेटा प्राप्ति: सेंसर से कुछ डेटा पढ़ें। अक्सर यह सिर्फ Arduino जैसे डिवाइस पर एनालॉग टू डिजिटल कन्वर्टर (ADC) पढ़ रहा है।
• डेटा प्रोसेसिंग: एडीसी मान पढ़ते समय कन्वर्टर्स आउटपुट को सामान्य रूप से सही इकाइयों तक बढ़ाया जाना चाहिए। सेंसर त्रुटियों को ठीक करने के लिए मानों को कैलिब्रेट करने के लिए कुछ समायोजन करने की भी आवश्यकता हो सकती है।
• फ़िल्टरिंग: डेटा में आमतौर पर कुछ शोर होता है, इसे फ़िल्टर किया जा सकता है ताकि आप अपने डेटा में सिग्नल देख रहे हों, शोर नहीं।
• डेटा संग्रहण: डेटा सहेजा जाता है, शायद टेक्स्ट फ़ाइल में, शायद क्लाउड में। बिजली बंद होने पर भी डेटा जीवित रहना चाहिए। बहुत अधिक डेटा सहेजना आसान है, डेटा संग्रहण स्थान को कम करने के लिए हमारे पास एक छोटी सी चाल है।
• डेटा प्रदर्शन: अपने डेटा को देखने के तरीके, वास्तव में डेटा लॉगिंग नहीं, लेकिन यदि आप डेटा का किसी प्रकार का प्रदर्शन नहीं करते हैं तो इसे क्यों इकट्ठा करें?
• रिमोट एक्सेस: जरूरी नहीं है लेकिन अच्छा है।

अधिकांश अनुदेशों में कुछ शामिल हैं, लेकिन उपरोक्त सभी नहीं हैं, या उन्हें बहुत ही सरल तरीके से करते हैं। यह निर्देशयोग्य अक्सर छोड़े गए लॉगिंग मुद्दों में से 2 को संबोधित करेगा और एक बोनस के रूप में आपको क्लाउड सेवा का उपयोग किए बिना अपने डेटा को रेखांकन करने का एक साधन प्रदान करेगा। आप पूरी चीज़ का उपयोग कर सकते हैं या बिट्स और टुकड़ों को बाहर निकाल सकते हैं और उन्हें अपने स्वयं के प्रोजेक्ट में रीमिक्स कर सकते हैं।

चरण 1: उपकरण और सामग्री

यह उदाहरण सभी पायथन में है, इसलिए यह चलेगा, और घटकों का उपयोग मैक, पीसी, लिनक्स और रास्पबेरी पाई सहित किसी भी ओएस पर किया जा सकता है।

तो इस निर्देश का उपयोग करने के लिए आपको केवल एक चल रहे पायथन 3.6 वातावरण की आवश्यकता है, और संलग्न कोड डाउनलोड करें। मेरे द्वारा सेट किए गए कोड को चलाने के बाद, आप इसे अपने स्वयं के प्रयोगों के लिए संशोधित कर सकते हैं। जैसा कि पायथन के साथ हमेशा होता है, आपको सब कुछ काम करने के लिए कुछ पैकेज/मॉड्यूल जोड़ने की आवश्यकता हो सकती है। माई स्पाइडर एनवायरनमेंट सभी आवश्यक भागों के साथ आता है (देखें: पायथन स्क्रीन स्क्रैपिंग के साथ ग्राफ़ इंस्ट्रक्शनल व्यू)। जब आप पहली बार किसी त्रुटि संदेश के लिए घड़ी चलाते हैं तो वे आपको आपके परिवेश में किसी भी लापता हिस्से के बारे में बताएंगे।

अगले दो चरण आपको बताएंगे कि कैसे अपना स्वयं का प्रयोग बनाना और चलाना है, लेकिन अपने स्वयं के प्रयोग करने से पहले शामिल किए गए प्रयोगों को चलाने तक प्रतीक्षा करना शायद बेहतर होगा।

कोड को समझने के लिए आपको ऑब्जेक्ट ओरिएंटेड पायथन के साथ थोड़ा अनुभव करने की आवश्यकता होगी, यह समझाते हुए कि यह इस निर्देश के दायरे से बाहर है, लेकिन Google को आपको कोई भी मदद देनी चाहिए जिसकी आपको आवश्यकता हो सकती है।

कोड पर ध्यान दें: (GitHub पर कोड आप देखने में आ सकते हैं, शायद किसी अन्य विंडो में, केवल 2 क्लिक के साथ) अब Python 3.6 में है, इसलिए 3.6 होना सबसे अच्छा होगा। कोड का पुराना संस्करण यहां नीचे दिए गए लिंक में है।

चरण 2: एक प्रयोग का निर्माण

एक प्रयोग के निर्माण में तीन प्रोग्रामिंग चरण (और रेखाएं) हैं। प्रत्येक प्रयोग सिमुलेट_लॉगिंग.py फ़ाइल में लॉगिंगसिम ऑब्जेक्ट में एक फ़ंक्शन है। आइए प्रयोग 1 (सिर्फ पहला ग्राफ) देखें, जिसे हम अगले चरण में चलाएंगे:

def प्रयोग_with_sample_rates (स्वयं):

डेल्टा टी """ सेल्फ.स्टार्ट_प्लॉट (प्लॉट_टाइटल = "नमूना दरें - भाग 1/3: डेल्टा टी = 1.0") को बदलकर नमूना दरों के साथ प्रयोग करें। 1.", आयाम = 1., शोर_एम्प =.0, डेल्टा_टी = 1., मैक्स_टी = 10., रन_वे = 0, ट्रिगर_वैल्यू = 0) self.show_plot ()

प्रत्येक प्रयोग अपने स्वयं के कार्य के रूप में लिखा जाता है, इसलिए हमारे पास फ़ंक्शन को परिभाषित करने वाली एक रेखा होती है (def प्रयोग…..)

अगली, गैर-टिप्पणी पंक्ति, (start_plot(….) प्रयोग के लिए ऑब्जेक्ट बनाता है और उसे एक नाम देता है।

अगली, गैर-टिप्पणी लाइन लाइन, (add_sensor_data(…) कई लाइनों में विभाजित है। यह संभावित शोर और कुछ प्रसंस्करण के साथ एक सिग्नल को मापने वाले सेंसर का अनुकरण करता है। फ़ंक्शन तर्क इस प्रकार हैं:

• नाम: डेटा की पहचान करने के लिए अंतिम ग्राफ पर रखा गया नाम
• आयाम: संकेत कितना बड़ा है, हम हमेशा इस निर्देश में 1 के आयाम का उपयोग करेंगे।
• शोर_एम्प: शोर कितना बड़ा है, 0. कोई शोर नहीं है, हम यहां से शुरू करेंगे।
• delta_t: माप के बीच का समय, नमूना दर को नियंत्रित करता है।
• max_t: अधिकतम समय हम डेटा एकत्र करते हैं, हम हमेशा इस निर्देश में 10 का उपयोग करेंगे।
• run_ave: रनिंग एवरेज का उपयोग करके प्रोसेसिंग, 0 का मतलब कोई प्रोसेसिंग नहीं है।
• ट्रिगर_वैल्यू: ट्रिगरिंग का उपयोग करके प्रसंस्करण, 0 का अर्थ है कोई प्रसंस्करण नहीं

अंतिम, गैर टिप्पणी पंक्ति, (self.show_plot……) ग्राफ़ प्रदर्शित करता है।

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

चरण 3: एक प्रयोग चलाना

यह एक प्रयोग चलाने के लिए कोड है। जैसा कि आमतौर पर पायथन में होता है, इसे फ़ाइल के अंत में रखा जाता है।

सिम_लॉगिंग = लॉगिंगसिम ()

sim_logging.experiment_with_sample_rates ()

यह सिर्फ 2 पंक्तियाँ हैं:

• एक लॉगिंग सिम्युलेटर बनाएं (लॉगिंगसिम ())
• इसे चलाएँ (sim_logging.experiment_with_sample_rates ())

डाउनलोड किए गए कोड में मेरे पास कुछ और पंक्तियां और टिप्पणियां हैं, इसे समझना आसान होना चाहिए।

चरण 4: प्रयोग: नमूना दर

सिम्युलेटर, जैसा कि यहां स्थापित किया गया है, हमेशा आयाम 1 की एक अच्छी चिकनी साइन लहर का उत्पादन करता है। इस प्रयोग के लिए हम नमूना दर के साथ गड़बड़ करेंगे, जैसा कि डेल्टा_टी द्वारा समायोजित किया गया है, नमूनों के बीच का समय अंतर। हमारे पास कोई शोर या अन्य प्रसंस्करण नहीं होगा। कोड 3 नमूना दरों का उपयोग करता है (delta_t = 1.0, 0.1 और 0.01।) चूंकि ग्राफ़ एक-दूसरे के ऊपर आते हैं, इसलिए 3 अलग-अलग ग्राफ़ बनाने के लिए प्रयोग सेट किया गया है। परिणामी रेखांकन इस चरण के लिए चित्र हैं।

def प्रयोग_with_sample_rates (स्वयं):

डेल्टा टी """ सेल्फ.स्टार्ट_प्लॉट (प्लॉट_टाइटल = "प्रयोग नमूना दरें 1/3: डेल्टा टी = 1.0") को बदलकर नमूना दरों के साथ प्रयोग करें। ।", आयाम = 1., शोर_एम्प =.0, डेल्टा_टी = 1., मैक्स_टी = 10., रन_वे = 0, ट्रिगर_वैल्यू = 0) self.show_plot() # ------------- ----------------------------------- स्व.स्टार्ट_प्लॉट (प्लॉट_टाइटल = "प्रयोग नमूना दर 2/3: डेल्टा टी = 0.1") self.add_sensor_data (नाम = "डीटी = 1.", आयाम = 1., शोर_एम्प =.0, डेल्टा_टी = 0.1, मैक्स_टी = 10., रन_वे = 0, ट्रिगर_वैल्यू = 0) self.show_plot () # ------------------------------------------------ स्वयं.start_plot(plot_title = "प्रयोग नमूना दर 3/3: डेल्टा टी = 0.01") self.add_sensor_data(name = "dt = 1.", आयाम = 1., शोर_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, ट्रिगर_वैल्यू = 0) self.show_plot ()

इसे चलाने के लिए लाइन का उपयोग करें: sim_logging.experiment_with_sample_rates()

संभावित निष्कर्ष:

• बहुत कम नमूना दर वास्तव में खराब है।
• उच्च दरें अक्सर बेहतर होती हैं।

(पायथन 3.6 कोड GitHub लिंक पर नीचे दिए गए इंस्ट्रक्शंस पर, 2.7)

चरण 5: प्रयोग: शोर दिखा रहा है

इस प्रयोग में हम एक ही सिग्नल रखते हैं, एक मध्यम नमूना दर का उपयोग करते हैं, और अलग-अलग मात्रा में शोर होता है (noise_amp =.0,.1, 1.0.) इसे इसके साथ चलाएं: sim_logging.experiment_showing_noise()। आउटपुट 3 लाइनों वाला एक ग्राफ है।

संभावित निष्कर्ष:

शोर से सिग्नल को देखना मुश्किल हो जाता है, हो सके तो इसे कम कर दें।

कोड:

# ------------------------------------------------

def प्रयोग_शोइंग_नॉइज़ (स्व): प्रिंट """ शोर दिखाते हुए प्रयोग शोर आयाम को बदलकर शोर की विभिन्न मात्राओं को देखते हुए। """ self.start_plot(plot_title = "प्रयोग दिखा रहा है शोर") self.add_sensor_data(name = "noise = 0.0 ", आयाम = 1., शोर_एम्प =.0, डेल्टा_टी =.1, मैक्स_टी = 10., रन_वे = 0, ट्रिगर_वैल्यू = 0) self.add_sensor_data (नाम = "शोर = 0.1", आयाम = 1., शोर_एम्प =। 1, delta_t =.1, max_t = 10., run_ave = 0, ट्रिगर_वैल्यू = 0) self.add_sensor_data (नाम = "शोर = 1.0", आयाम = 1., शोर_एम्प = 1., डेल्टा_टी =.1, मैक्स_टी = 10., run_ave = 0, ट्रिगर_वैल्यू = 0) self.show_plot ()

चरण 6: प्रयोग: चलती औसत के साथ शोर कम करें

एक चलती औसत (उदाहरण के लिए लंबाई 8 के साथ) अंतिम 8 माप लेता है और उन्हें औसत करता है। यदि शोर यादृच्छिक है, तो हम आशा करते हैं कि यह औसत 0 के करीब होगा। प्रयोग को इसके साथ चलाएं: sim_logging.experiment_showing_noise()। आउटपुट एक ग्राफ।

संभावित निष्कर्ष:

• मूविंग एवरेज ज्यादा शोर को खत्म कर देता है
• चलती औसत जितनी लंबी होगी, शोर में कमी उतनी ही अधिक होगी
• लंबी चलती औसत सिग्नल को कम और विकृत कर सकती है

कोड:

# ------------------------------------------------

def प्रयोग_with_moving_average(self): प्रिंट """ मूविंग एवरेज के साथ प्रयोग लंबाई बदलकर अलग-अलग मूविंग एवरेज को देखते हुए। सभी का शोर समान है। """ # ------------------ ----------------------------- self.start_plot(plot_title = "मूविंग एवरेज-पार्ट 1/2: नो मूविंग एवरेज") सेल्फ.add_sensor_data(name = "ave len=0", आयाम = 1., शोर_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, ट्रिगर_वैल्यू = 0) self.show_plot() self.start_plot(plot_title) = "मूविंग एवरेज-पार्ट 2/2: लेन 8 और 32") self.add_sensor_data(name = "ave len=8", आयाम = 1., शोर_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, ट्रिगर_वैल्यू = 0) self.add_sensor_data(name = "ave len=32", आयाम = 1., शोर_एम्प =.1, delta_t =.1, max_t = 10., run_ave = 32, ट्रिगर_वैल्यू = 0) self.show_plot ()

चरण 7: प्रयोग: चलती औसत और नमूना दर

इस प्रयोग में हम कच्चे सिग्नल की तुलना शोर से करते हैं और शोर को कम करने पर 2 अलग-अलग बदलाव करते हैं।

1. मध्यम नमूना दर और मध्यम चलने वाला औसत
2. उच्च नमूना दर और उच्च लंबाई चलने वाला औसत

इसे इसके साथ चलाएं: sim_logging…… आउटपुट एक ग्राफ है। मुझे लगता है कि यह स्पष्ट है कि #2 शोर को कम करने में बेहतर काम करता है ताकि हम यह निष्कर्ष निकाल सकें:

उच्च नमूना दर और उच्च लंबाई चलने वाले औसत अच्छे हैं

लेकिन आपको यह ध्यान रखना होगा कि एक लागत है। # 2 बहुत अधिक प्रसंस्करण लेता है और इसके परिणामस्वरूप बहुत अधिक डेटा सहेजा जाता है। लागत इसके लायक हो भी सकती है और नहीं भी। अगले प्रयोग में हम संग्रहीत डेटा की मात्रा को कम करने के लिए एक ट्रिगर, एक उपकरण जोड़ेंगे।

कोड:

def प्रयोग_with_moving_average_and_sample_rate(स्वयं):

प्रिंट """ मूविंग एवरेज और सैंपल रेट के साथ प्रयोग, डीटी, रन एवरेज अलग-अलग """ # ----------------------------- ------------------------ self.start_plot(plot_title = "मूविंग एवरेज और सैंपल रेट") self.add_sensor_data(name = "dt=.1 ra=0 trig= 0", आयाम = 1., शोर_एम्प =.1, डेल्टा_टी =.1, मैक्स_टी = 10., रन_वे = 0, ट्रिगर_वैल्यू = 0) self.add_sensor_data(name = "dt=.1 ra=10 trig=0", आयाम = 1., शोर_एम्प =.1, डेल्टा_टी =.1, मैक्स_टी = 10., रन_वे = 10, ट्रिगर_वैल्यू = 0) self.add_sensor_data (नाम = "डीटी =.01 आरए = 100 ट्रिगर = 0", आयाम = 1 शोर_एम्प =.1, डेल्टा_टी =.01, मैक्स_टी = 10., रन_वे = 100, ट्रिगर_वैल्यू = 0) self.show_plot ()

चरण 8: प्रयोग: ट्रिगर के साथ लॉगिंग

इस प्रयोग में हम एक ट्रिगर जोड़ते हैं। सबसे पहले, ट्रिगर से मेरा क्या मतलब है? ट्रिगर एक ऐसी तकनीक है, जहां हम डेटा एकत्र करते हैं, लेकिन उसे केवल तभी सहेजते हैं, जब कुछ चर एक महत्वपूर्ण राशि से बदल जाते हैं। इन प्रयोगों में मैंने समय (x अक्ष) चर पर एक ट्रिगर लगाया। ट्रिगर का उपयोग करके मैं तेजी से नमूने से उच्च मात्रा में डेटा ले सकता हूं और इसे अधिक उचित मात्रा में डेटा तक कम कर सकता हूं। यह उच्च नमूना दरों और लंबे समय तक चलने वाले औसत के साथ विशेष रूप से उपयोगी है।

मैंने पिछले प्रयोग से #2 लाइन ली है जो "अच्छा" था और एक ट्रिगर जोड़ा। इसे इसके साथ चलाएं: sim_logging…… आउटपुट एक ग्राफ है, x लाइनें।

क्या होता है? हमें उचित मात्रा में डेटा (# 1 के समान) के साथ "अच्छा" प्लॉट मिलता है। उच्च प्रसंस्करण में कुछ लागत आई है। कुल मिलाकर, हालांकि, परिणाम कम फ़िल्टरिंग के साथ कम नमूना दर # 1 के समान हैं। आप निष्कर्ष निकाल सकते हैं:

• ट्रिगरिंग के साथ लंबे समय तक चलने वाला औसत उचित मात्रा में डेटा के साथ अच्छा शोर में कमी दे सकता है।
• अतिरिक्त प्रसंस्करण उतना बेहतर परिणाम नहीं दे सकता है और लागत के साथ आता है।

कोड:

# ------------------------------------------------

def प्रयोग_with_trigger(self): प्रिंट """ ट्रिगरिंग के साथ प्रयोग, डीटी, रन एवरेज और ट्रिगर ऑल बीइंग डिफरेंट """ # ----------------------- ------------------------ स्व.स्टार्ट_प्लॉट (प्लॉट_टाइटल = "ट्रिगर 1/1 - ट्रिगरिंग ऑन") self.add_sensor_data (नाम = "डीटी =.1 आरए=10, ट्रिगर = 0", आयाम = 1., शोर_एम्प =.1, डेल्टा_टी =.1, मैक्स_टी = 10., रन_वे = 10, ट्रिगर_वैल्यू = 0) self.add_sensor_data(name = "dt=.01 आरए=100, ट्रिगर =.1", आयाम = 1., शोर_एम्प =.1, डेल्टा_टी =.01, मैक्स_टी = 10., रन_वे = 100, ट्रिगर_वैल्यू =.1) self.show_plot()

=

चरण 9: प्रयोग: ट्रिगर के साथ लॉगिंग - लाउडर शोर

आइए अंतिम चरण के समान प्रयोग करें और शोर को बढ़ाएं। इसे इसके साथ चलाएं: sim_logging…… आउटपुट एक ग्राफ, 2 लाइन है।

अब अतिरिक्त प्रसंस्करण अधिक मूल्य का दिखता है। यहाँ एक उचित निष्कर्ष हो सकता है:

शोर में कमी के लिए प्रसंस्करण की मात्रा और प्रकार चुनना आपके सिग्नल और शोर पर निर्भर करता है।

कोड:

def प्रयोग_with_trigger_louder_noise (स्वयं):

प्रिंट """ पूर्व प्रयोग की तुलना में अधिक शोर """ self.start_plot(plot_title = "ट्रिगर-लाउडर शोर के साथ एक प्रयोग") self.add_sensor_data(name = "…dt=.1 ra=10", आयाम = 1., शोर_एम्प =.5, डेल्टा_टी =.1, मैक्स_टी = 10., रन_वे = 10, ट्रिगर_वैल्यू = 0) self.add_sensor_data (नाम = "..dt =.01 आरए = 100 टीवी =.1", आयाम = 1., शोर_एम्प =.5, डेल्टा_टी =.01, मैक्स_टी = 10., रन_वे = 100, ट्रिगर_वैल्यू =.1) self.show_plot ()

चरण 10: अपने स्वयं के प्रयोग करें

इस बिंदु पर मुझे आशा है कि आप देखेंगे कि इस निर्देश में तकनीकें डेटा लॉगिंग में उपयोगी हो सकती हैं, लेकिन उन्हें भी कुछ सोच-समझकर इस्तेमाल करना होगा। उनके साथ प्रयोग करने से उस प्रक्रिया में मदद मिल सकती है।

उन प्रयोगों और चीजों पर कुछ टिप्पणियां जिन पर आप गौर कर सकते हैं:

• साइन वेव्स केवल दिलचस्प सिग्नल प्रकार नहीं हैं, दूसरों को आज़माएं, अन्य तरंगें या रैंप या…..
• मैंने शोर के लिए एक सामान्य वितरण का उपयोग किया, बहुत सारे प्रकार के शोर हैं; आपको दूसरों पर विचार करना चाहिए
• रनिंग एवरेज एक सरल है, लेकिन शोर को देखने का एकमात्र तरीका नहीं है

नोट: विकिपीडिया से तस्वीरें लॉगिंग।

चरण 11: अपने लॉगिंग सॉफ़्टवेयर में तकनीकों का उपयोग करना

मेरा कोड ऑब्जेक्ट ओरिएंटेड है और रनिंग एवरेज और ट्रिगर के लिए प्रोसेसिंग को सिर्फ आपके पायथन वातावरण में कॉपी किया जा सकता है और फिर इस्तेमाल किया जा सकता है। वस्तुएं हैं:

• DataTrigger में data_trigger.py
• मूविंग एवरेज में मूविंग_एवरेज.py

मेरा मुख्य उद्देश्य LoggingSim में सिमुलेट_लॉगिंग.py आपको इसका उपयोग करने का एक अच्छा उदाहरण देना चाहिए। यदि आप किसी अन्य भाषा का उपयोग करते हैं तो आप मेरा कोड पढ़ सकते हैं और अपनी भाषा में लागू कर सकते हैं।

यह कोड आपके प्रोजेक्ट को बेहतर डेटा लॉगिंग दे सकता है, इसे आजमाएं।

ऊपर दिया गया ग्राफ russ_hensel द्वारा ग्राफ़ योर सोलर पावर से लिया गया है जो समान चलने वाली औसत वस्तु का उपयोग करता है।