Poskusi v naprednem beleženju podatkov (z uporabo Pythona): 11 korakov

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:03

Obstaja veliko navodil za beleženje podatkov, zato sem, ko sem hotel zgraditi svoj projekt beleženja, pogledal naokrog. Nekateri so bili dobri, nekateri ne preveč, zato sem se odločil, da vzamem nekaj boljših idej in se prijavim sam. Zaradi tega je bil projekt bolj napreden in bolj zapleten, kot sem sprva pričakoval. En del je postal serija poskusov pri obdelavi senzorskih podatkov. Ta navodila vam omogočajo, da preizkusite iste ali podobne poskuse.

(Vso kodo si lahko ogledate in jo naložite na: Koda na GitHubu. Ogledate si jo lahko, morda v drugem oknu, s samo 2 kliki)

Običajno beleženje podatkov vključuje naslednje:

• Zbiranje podatkov: preberite nekaj podatkov s senzorja. Pogosto je to samo branje analogno -digitalnega pretvornika (ADC) na napravi, kot je Arduino.
• Obdelava podatkov: Pri branju vrednosti ADC je treba pretvornik običajno pretvoriti v prave enote. Morda bo treba narediti tudi nekaj prilagoditev za umerjanje vrednosti za odpravo napak senzorja.
• Filtriranje: Podatki običajno vsebujejo nekaj hrupa, to je mogoče filtrirati, tako da iščete signal v svojih podatkih, ne hrup.
• Shranjevanje podatkov: Podatki se shranijo, morda v besedilno datoteko, morda v oblak. Podatki bi morali preživeti, tudi če se napajanje izklopi. Preveč podatkov je enostavno prihraniti, imamo majhen trik za zmanjšanje prostora za shranjevanje podatkov.
• Prikaz podatkov: Metode za pregled vaših podatkov, v resnici ne beleženje podatkov, če pa ne prikažete podatkov, zakaj jih zbirate?
• Oddaljeni dostop: Ni nujno, vendar ga je lepo imeti.

Večina navodil vključuje nekaj, vendar ne vsega zgoraj navedenega, ali pa jih naredite na zelo preprost način. Ta navodila bodo obravnavala 2 pogosto preskočenih težav z beleženjem in kot bonus vam bodo omogočila grafično prikazovanje vaših podatkov brez uporabe storitve v oblaku. Lahko uporabite celotno stvar ali izvlečete koščke in jih znova premešate v svoj projekt.

Korak: Orodja in materiali

Ta primer je ves v Pythonu, zato bo deloval naprej, komponente pa lahko uporabljate v skoraj vseh operacijskih sistemih, vključno z Mac, PC, Linux in Raspberry Pi.

Če želite uporabiti to navodilo, potrebujete samo okolje Python 3.6 in prenesite priloženo kodo. Ko zaženete kodo, ki sem jo nastavil, jo lahko spremenite za lastne poskuse. Kot je običajno pri Pythonu, boste morda morali dodati nekaj paketov/modulov, da bo vse delovalo. Moje okolje Spyder vsebuje skoraj vse potrebne dele (glej: Graph Instructable Views with Python Screen Scraping). Ko prvič zaženete sporočilo o napaki, vas bodo obvestili o vseh manjkajočih delih v vašem okolju.

Naslednja dva koraka vam bosta povedala, kako sestaviti in izvesti lasten poskus, vendar je verjetno bolje počakati, da izvedete vključene poskuse, preden poskusite sami.

Če želite razumeti kodo, boste morali imeti nekaj izkušenj z objektno usmerjenim Pythonom, ki pojasnjuje, da to presega obseg tega navodila, vendar bi vam Google moral pomagati.

Upoštevajte kodo: (Koda na GitHubu, ki jo lahko odprete, morda v drugem oknu, s samo 2 kliki) je zdaj v Pythonu 3.6, zato bi bilo najbolje, če bi imeli 3.6. Starejša različica kode je tukaj na spodnjih povezavah.

2. korak: Izdelava eksperimenta

Pri izgradnji poskusa obstajajo trije koraki (in vrstice) programiranja. Vsak poskus je funkcija v objektu LoggingSim v datoteki simulate_logging.py. Poglejmo poskus 1 (samo prvi graf), ki ga bomo izvedli v naslednjem koraku:

def eksperiment_with_sample_ates (self):

print "" "Poskus z vzorčnimi stopnjami Ogled različnih vzorčnih stopenj s spreminjanjem delte T" "" self.start_plot (plot_title = "Vzorčne stopnje - 1/3. del: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Vsak poskus je zapisan kot lastna funkcija, zato imamo vrstico, ki definira funkcijo (def eksperiment …..)

Naslednja vrstica brez komentarjev (start_plot (….)) Ustvari objekt za poskus in mu da ime.

Naslednja vrstica brez komentarjev, (add_sensor_data (…) je razdeljena na več vrstic. Simulira senzor, ki meri signal s potencialno šumom in nekaj obdelave. Argumenti funkcije so naslednji:

• ime: ime, ki je na končnem grafu namenjeno identifikaciji podatkov
• amplitude: kako velik je signal, bomo v tem navodilu vedno uporabili amplitudo 1..
• noise_amp: kako velik je hrup, 0. ni hrupa, začeli bomo tukaj.
• delta_t: čas med meritvami, nadzoruje vzorčenje.
• max_t: največji čas, ko zbiramo podatke, bomo v tem navodilu vedno uporabili 10.
• run_ave: obdelava z uporabo tekočega povprečja, 0 pomeni brez obdelave.
• trigger_value: obdelava s sprožitvijo, 0 pomeni, da ni obdelave

zadnja vrstica brez komentarjev (self.show_plot ……) prikazuje graf.

Če želite stvari nekoliko zakomplicirati, imate lahko v poskusu več vrstic na grafu ali več grafov, to bi moralo biti jasno iz poskusov, ki sledijo.

3. korak: Izvedite poskus

To je koda za izvedbo poskusa. Kot običajno v Pythonu se nahaja na koncu datoteke.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

To sta samo 2 vrstici:

• Ustvarite simulator sečnje (LoggingSim ())
• Zaženi (sim_logging.experiment_with_sample_rates ())

V preneseni kodi imam še nekaj vrstic in komentarjev, to bi moralo biti enostavno ugotoviti.

4. korak: Preizkus: hitrost vzorčenja

Simulator, kot je tukaj nastavljen, vedno oddaja lep, gladek sinusni val amplitude 1. Za ta poskus se bomo zapletli s hitrostjo vzorčenja, prilagojeno z delta_t, časovno razliko med vzorci. Ne bomo imeli hrupa ali druge obdelave. Koda uporablja 3 vzorčne hitrosti (delta_t = 1,0, 0,1 in 0,01.) Ker grafi padajo drug na drugega, je poskus nastavljen tako, da ustvari 3 različne grafe. Dobljeni grafi so slike za ta korak.

def eksperiment_with_sample_ates (self):

print "" "Poskus z vzorčnimi stopnjami Ogled različnih vzorčnih stopenj s spreminjanjem delte T" "" self.start_plot (plot_title = "Vzorčne stopnje poskusa 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1 " ----------------------------------- self.start_plot (plot_title = "Vzorčne stopnje poskusa 2/3: Delta T = 0,1 ") self.add_sensor_data (name =" dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------- jaz.start_plot (plot_title = "Preskusne vzorčne stopnje 3/3: Delta T = 0,01") self.add_sensor_data (name = "dt = 1.", amplitude = 1., noise_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Za zagon uporabite vrstico: sim_logging.experiment_with_sample_rates ()

Možni zaključki:

• Prenizka stopnja vzorčenja je res slaba.
• Visoke stopnje so pogosto boljše.

(Koda Python 3.6 na spodnji povezavi GitHub pri navodilih, 2.7)

5. korak: Poskus: Prikaz hrupa

V tem poskusu ohranjamo isti signal, uporabljamo srednjo frekvenco vzorčenja in imamo različne količine hrupa (noise_amp =.0,.1, 1.0.) Zaženite ga z: sim_logging.experiment_showing_noise (). Rezultat je en graf s 3 vrsticami.

Možen zaključek:

Hrup otežuje videnje signala, če je mogoče, ga zmanjšajte

Koda:

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

def eksperiment_showing_noise (self): print "" "Eksperiment, ki prikazuje hrup Če pogledamo različne količine hrupa s spreminjanjem amplitude hrupa." "" self.start_plot (plot_title = "Poskus s hrupom") self.add_sensor_data (name = "noise = 0.0 ", amplitude = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" noise = 0.1 ", amplitude = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name = "noise = 1.0", amplitude = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

6. korak: Poskus: Zmanjšajte hrup z drsečim povprečjem

Drseče povprečje (na primer z dolžino 8) vzame zadnjih 8 meritev in jih povpreči. Če je hrup naključen, upamo, da bo v povprečju blizu 0. Zaženite poskus z: sim_logging.experiment_showing_noise (). Iznesite en graf.

Možni zaključki:

• Drseče povprečje odpravlja velik del hrupa
• Daljše kot je drseče povprečje, več hrupa se zmanjša
• Daljše drseče povprečje lahko zmanjša in izkrivi signal

Koda:

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

def eksperiment_with_moving_average (self): print "" "Poskusite z MovingAverage Gledate različno MovingAverage s spreminjanjem dolžine. Vsi imajo enak hrup." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No Moving Average") self.add_sensor_data (name = "ave len = 0", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () self.start_plot (plot_title = "MovingAverage-Part 2/2: Len 8 and 32") self.add_sensor_data (name = "ave len = 8", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (name = "ave len = 32", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

7. korak: Poskus: drseče povprečje in vzorčna hitrost

V tem poskusu primerjamo surov signal s šumom in dvema različnima različicama za zmanjšanje šuma.

1. Srednja stopnja vzorčenja in srednje tekoče povprečje
2. Visoka stopnja vzorčenja in dolgo dolžinsko povprečje

Zaženite ga z: sim_logging …… Izhod je en graf. Mislim, da je jasno, da številka 2 bolje zmanjšuje hrup, zato lahko sklepamo, da:

Visoka stopnja vzorčenja in dolgo dolžinsko povprečje sta dobra

Vendar ne pozabite, da obstajajo stroški. #2 zahteva veliko več obdelave in shrani veliko več podatkov. Stroški so lahko vredni ali pa tudi ne. V naslednjem poskusu bomo dodali sprožilec, napravo za zmanjšanje količine shranjenih podatkov.

Koda:

def_eksperiment_s_premikajočo_povprečnostjo_ in_vzorca_cene (samo):

print "" "Eksperimentirajte z drsečim povprečjem in vzorčno hitrostjo, dt, spreminjajte povprečje" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Drseče povprečje in hitrost vzorčenja") self.add_sensor_data (name = "dt =.1 ra = 0 trig = " amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (name = "dt =.01 ra = 100 trig = 0", amplitude = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

8. korak: Poskus: Zapisovanje s sprožilcem

V tem poskusu dodamo sprožilec. Prvič, kaj mislim s sprožilcem? Sprožilec je tehnika, pri kateri zbiramo podatke, vendar jih shranimo šele, ko se je določena spremenljivka spremenila za znatno količino. V teh poskusih sem sprožil časovno (os x) spremenljivko. Z uporabo sprožilca lahko iz hitrega vzorčenja vzamem veliko količino podatkov in jo zmanjšam na razumnejšo količino podatkov. Zlasti je uporaben pri visokih stopnjah vzorčenja in dolgem povprečju.

Vzel sem vrstico 2 iz zadnjega poskusa, ki je bil "dober", in dodal sprožilec. Zaženite ga z: sim_logging …… Izhod je en graf, x vrstic.

Kar se zgodi? Dobimo "dobro" ploskev z razumno količino podatkov (enako kot številka 1). Pri višji predelavi je bilo nekaj stroškov. Na splošno so rezultati približno enaki kot #1 pri nižji stopnji vzorčenja z manj filtriranja. Lahko zaključite:

• Dolgotrajno povprečje s sprožitvijo lahko dobro zmanjša hrup z razumnimi količinami podatkov.
• Dodatna obdelava morda ne bo prinesla toliko boljših rezultatov in ima svoje stroške.

Koda:

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

def eksperiment_with_trigger (self): print "" "Poskusite s sprožitvijo, dt, zaženite povprečje in sprožite vse spreminjanje" "" # ----------------------- ------------------------- self.start_plot (plot_title = "Trigger 1/1-Triggering On") self.add_sensor_data (name = "dt =.1 ra = 10, trig = 0 ", amplituda = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (name =" dt =.01 ra = 100, trig =.1 ", amplituda = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

9. korak: Poskus: Zapisovanje s sprožilcem - glasnejši hrup

Vzemimo isti poskus kot zadnji korak in povečajmo hrup. Zaženite ga z: sim_logging …… Izhod je en graf, 2 vrstici.

Zdaj se zdi dodatna obdelava bolj vredna. Tu je lahko razumen zaključek:

Izbira količine in vrste obdelave za zmanjšanje hrupa je odvisna od vašega signala in hrupa

Koda:

def eksperiment_s_trigger_looder_noise (samo):

natisni "" "Glasnejši hrup kot prejšnji poskus" "" self.start_plot (plot_title = "Poskus s sprožilcem-glasnejšim hrupom") self.add_sensor_data (name = "… dt =.1 ra = 10", amplitude = 1., noise_amp =.5, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (name = "..dt =.01 ra = 100 tv =.1", amplituda = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

10. korak: Poskusite sami

Upam, da boste na tej točki videli, da so tehnike v tem navodilu lahko koristne pri beleženju podatkov, vendar jih je treba tudi premisliti. Eksperimentiranje z njimi lahko pomaga pri tem procesu.

Nekaj opomb o poskusih in stvareh, ki bi jih lahko preučili:

• Sinusni valovi niso edina zanimiva vrsta signala, poskusite z drugimi, drugimi valovi ali rampami ali …
• Za hrup sem uporabil normalno distribucijo, obstaja toliko vrst hrupa; razmislite o drugih
• Tekaška povprečja so preprosta, a ne edina metoda za pogled na hrup

Opomba: beleženje slik iz Wikipedije.

11. korak: Uporaba tehnik v vaši programski opremi za beleženje

Moja koda je objektno naravnana, obdelavo za povprečje in sprožilec pa lahko preprosto kopirate v okolje Python in jo nato uporabite. Predmeti so:

• DataTrigger v data_trigger.py
• MovingAverage v moving_average.py

Moj glavni predmet LoggingSim v simulate_logging.py bi vam moral dati dober primer, kako ga uporabljati. Če uporabljate drug jezik, lahko preberete mojo kodo in jo implementirate v svojem jeziku.

Ta koda lahko vašemu projektu omogoči boljše beleženje podatkov, poskusite.

Zgornji graf je iz grafikona vaše sončne energije, ki ga uporablja russ_hensel, ki uporablja isti objekt povprečnega teka.