Eksperimenti u naprednom evidentiranju podataka (pomoću Pythona): 11 koraka

2024 Autor: John Day | [email protected]. Zadnja izmjena: 2024-01-30 08:04

Postoji mnogo instrukcija za bilježenje podataka, pa kad sam htio izgraditi vlastiti projekt bilježenja, pogledao sam oko sebe u hrpu. Neki su bili dobri, neki ne toliko, pa sam odlučio uzeti neke bolje ideje i podnijeti vlastitu aplikaciju. Ovo je rezultiralo projektom i naprednijim i kompliciranijim nego što sam isprva očekivao. Jedan dio toga postao je niz eksperimenata u obradi podataka senzora. Ova instrukcija vam omogućuje da isprobate iste ili slične eksperimente.

(Možete pogledati cijeli kôd i preuzeti ga na: Kôd na GitHubu Možete pristupiti pregledu, možda u drugom prozoru, sa samo 2 klika)

Zapisivanje podataka obično uključuje sljedeće:

• Prikupljanje podataka: Pročitajte neke podatke sa senzora. Često je ovo samo čitanje analogno -digitalnog pretvarača (ADC) na uređaju poput Arduina.
• Obrada podataka: Prilikom čitanja vrijednosti ADC -a izlaz pretvarača obično se mora skalirati na prave jedinice. Možda će također biti potrebno izvršiti određena prilagođavanja kako bi se kalibrirale vrijednosti kako bi se ispravile greške senzora.
• Filtriranje: Podaci obično sadrže malo šuma, to se može filtrirati tako da tražite signal u svojim podacima, a ne šum.
• Pohrana podataka: Podaci se spremaju, možda u tekstualnu datoteku, možda u oblak. Podaci bi trebali preživjeti čak i ako se napajanje isključi. Lako je uštedjeti previše podataka, imamo mali trik za smanjenje prostora za pohranu podataka.
• Prikaz podataka: Metode za pregled vaših podataka, a ne zapisivanje podataka, ali ako ne napravite neku vrstu prikaza podataka zašto ih prikupljati?
• Daljinski pristup: Nije potrebno, ali je lijepo imati.

Većina instrukcija uključuje neke, ali ne sve gore navedene, ili ih čini na vrlo jednostavan način. Ovo uputstvo će riješiti 2 od često preskakanih problema evidentiranja i kao bonus će vam dati način grafičkog prikaza vaših podataka bez korištenja usluge u oblaku. Možete upotrijebiti cijelu stvar ili izvući komadiće i izmiješati ih u vlastiti projekt.

Korak 1: Alati i materijali

Ovaj primjer je sav u Pythonu pa će se pokrenuti i komponente se mogu koristiti na gotovo svakom OS -u, uključujući Mac, PC, Linux i Raspberry Pi.

Dakle, da biste koristili ovu instrukciju, sve što vam je potrebno je pokrenuto okruženje Python 3.6 i preuzmite priloženi kod. Nakon pokretanja koda koji sam postavio, možete ga izmijeniti za svoje eksperimente. Kao što je uobičajeno s Pythonom, možda ćete morati dodati neke pakete/module da bi sve funkcioniralo. Moje okruženje Spyder dolazi s gotovo svim potrebnim dijelovima (vidi: Grafikoni prikazanih prikaza s Python ekranom za struganje). Kad prvi put pokrenete program Watch for any error, obavijestit će vas o svim dijelovima koji nedostaju u vašem okruženju.

Sljedeća dva koraka će vam reći kako izgraditi i pokrenuti vlastiti eksperiment, ali vjerovatno je bolje sačekati dok ne pokrenete uključene eksperimente prije nego što pokušate sami.

Da biste razumjeli kôd, morat ćete imati malo iskustva s objektno orijentiranim Pythonom, objašnjavajući da to izlazi iz okvira ovog uputstva, ali Google bi vam trebao pružiti pomoć koja vam može zatrebati.

Obratite pažnju na kôd: (Kod na GitHub -u Možete pristupiti gledanju, možda u drugom prozoru, sa samo 2 klika) sada je u Pythonu 3.6, pa bi 3.6 bilo najbolje. Starija verzija koda je ovdje na donjim vezama.

Korak 2: Izgradnja eksperimenta

Postoje tri programska koraka (i linije) u izgradnji eksperimenta. Svaki eksperiment je funkcija u objektu LoggingSim u datoteci simulate_logging.py. Pogledajmo eksperiment 1 (samo prvi grafikon) koji ćemo izvesti u sljedećem koraku:

def_eksperiment_sa_uzorcima_ (sam):

print "" "Eksperimentirajte sa brzinama uzorka Gledajući različite stope uzorkovanja promjenom delte T" "" self.start_plot (plot_title = "Uzorke - dio 1/3: 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 ()

Svaki eksperiment je napisan kao vlastita funkcija pa imamo liniju koja definira funkciju (def eksperiment …..)

Sljedeća linija bez komentara, (start_plot (….)) Stvara objekt za eksperiment i daje mu ime.

Sljedeća linija bez komentara, (add_sensor_data (…) podijeljena je u nekoliko redova. Simulira senzor koji mjeri signal s potencijalno šumom i određenom obradom. Argumenti funkcije su sljedeći:

• name: ime stavljeno na završni grafikon za identifikaciju podataka
• amplitude: koliko je veliki signal, uvijek ćemo koristiti amplitudu 1. u ovom uputstvu.
• noise_amp: kolika je buka, 0. nema buke, počet ćemo ovdje.
• delta_t: vrijeme između mjerenja, kontrolira brzinu uzorkovanja.
• max_t: maksimalno vrijeme prikupljanja podataka, uvijek ćemo koristiti 10 u ovom uputstvu.
• run_ave: obrada pomoću tekućeg prosjeka, 0 znači da nema obrade.
• trigger_value: obrada pomoću okidanja, 0 znači da nema obrade

poslednja linija bez komentara, (self.show_plot ……) prikazuje grafikon.

Da stvari budu malo kompliciranije, u eksperimentu možete imati više linija na grafikonu ili više grafikona, to bi trebalo biti jasno iz eksperimenata koji slijede.

Korak 3: Izvođenje eksperimenta

Ovo je kôd za pokretanje eksperimenta. Kao što je uobičajeno u Pythonu, postavlja se na kraj datoteke.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Ovo su samo 2 retka:

• Napravite simulator zapisivanja (LoggingSim ())
• Pokreni ga (sim_logging.experiment_with_sample_rates ())

U preuzetom kodu imam još nekoliko redaka i komentara, trebalo bi biti lako shvatiti.

Korak 4: Eksperiment: Brzina uzorkovanja

Simulator, kako je ovdje postavljen, uvijek daje lijepi glatki sinusni val amplitude 1. Za ovaj eksperiment ćemo se petljati sa brzinom uzorkovanja, prilagođenom delta_t, vremenskom razlikom između uzoraka. Nećemo imati buku ili drugu obradu. Kod koristi 3 brzine uzorkovanja (delta_t = 1,0, 0,1 i 0,01.) Budući da se grafikoni nalaze jedan na drugom, eksperiment je postavljen tako da proizvede 3 različita grafikona. Dobijeni grafikoni su slike za ovaj korak.

def_eksperiment_sa_uzorcima_ (sam):

print "" "Eksperimentirajte sa brzinama uzorka Gledajući različite stope uzorkovanja promjenom delte T" "" self.start_plot (plot_title = "Brzine uzorka eksperimenta 1/3: 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 () # ------------- ----------------------------------- self.start_plot (plot_title = "Brzine uzorka eksperimenta 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 () # ------------------------------------------------ sebe.start_plot (plot_title = "Eksperimentalne uzorke 3/3: Delta T = 0,01") self.add_sensor_data (name = "dt = 1.", amplituda = 1., noise_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Da biste ga pokrenuli, koristite redak: sim_logging.experiment_with_sample_rates ()

Mogući zaključci:

• Preniska stopa uzorkovanja je zaista loša.
• Visoke stope su često bolje.

(Python 3.6 kod na GitHub -u donja veza na uputstvima, 2.7)

Korak 5: Eksperiment: Pokazivanje buke

U ovom eksperimentu zadržavamo isti signal, koristimo srednju frekvenciju uzorkovanja i imamo različite količine šuma (noise_amp =.0,.1, 1.0.) Pokrenite ga sa: sim_logging.experiment_showing_noise (). Izlaz je jedan grafikon sa 3 linije.

Mogući zaključak:

Buka otežava gledanje signala, smanjite ga ako možete

Kod:

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

def Experiment_showing_noise (self): print "" "Eksperiment prikazuje šum Gledajući različite količine šuma promjenom amplitude šuma." "" self.start_plot (plot_title = "Eksperiment prikazuje šum") 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 ()

Korak 6: Eksperiment: Smanjite buku pokretnim prosjekom

Pokretni prosjek (na primjer s dužinom 8) uzima posljednjih 8 mjerenja i prosjekuje ih. Ako je buka slučajna, nadamo se da će biti u prosjeku blizu 0. Pokrenite eksperiment sa: sim_logging.experiment_showing_noise (). Ispišite jedan grafikon.

Mogući zaključci:

• Pokretni prosjek eliminira veći dio buke
• Što je dulji pokretni prosjek, to je smanjenje buke veće
• Duži pokretni prosjek može smanjiti i iskriviti signal

Kod:

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

def Experiment_with_moving_average (self): print "" "Eksperimentirajte sa MovingAverage Gledajući različite MovingAverage promjenom dužine. Svi imaju istu buku." "" # ------------------ ------------------------------ 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 ()

Korak 7: Eksperiment: pomični prosjek i brzina uzorkovanja

U ovom eksperimentu uspoređujemo sirovi signal sa šumom i 2 različite varijacije smanjenja šuma.

1. Srednja stopa uzorkovanja i srednje tekući prosjek
2. Velika stopa uzorkovanja i veliki dužinski tekući prosjek

Pokrenite ga sa: sim_logging …… Izlaz je jedan grafikon. Mislim da je jasno da #2 bolje radi na smanjenju buke pa bismo mogli zaključiti sljedeće:

Visoka stopa uzorkovanja i veliki dužinski prosjek su dobri

Ali morate imati na umu da postoji trošak. #2 zahtijeva mnogo više obrade i rezultira spremanjem mnogo više podataka. Troškovi mogu i ne moraju biti vrijedni. U sljedećem eksperimentu ćemo dodati okidač, uređaj za smanjenje količine pohranjenih podataka.

Kod:

def eksperimenta_sa_mjerljivim_srednjim_i_smjerom_smjera (samo):

print "" "Eksperimentirajte s pomičnim prosjekom i brzinom uzorkovanja, dt, mijenjajte prosjek" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Pokretni prosjek i brzina uzorkovanja") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" dt =.1 ra = 10 trig = 0 ", 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 ()

Korak 8: Eksperiment: Zapisivanje pomoću okidača

U ovom eksperimentu dodajemo okidač. Prvo, šta mislim pod okidačem? Okidač je tehnika u kojoj prikupljamo podatke, ali ih spremamo samo nakon što se neka varijabla promijenila za značajnu količinu. U ovim eksperimentima sam stavio okidač na varijablu vremena (osa x). Korištenjem okidača mogu uzeti veliku količinu podataka iz brzog uzorkovanja i smanjiti je na razumniju količinu podataka. Posebnost je korisna s velikom stopom uzorkovanja i dugotrajnim prosjekom.

Uzeo sam liniju #2 iz prošlog eksperimenta koja je bila "dobra" i dodao okidač. Pokrenite ga sa: sim_logging …… Izlaz je jedan grafikon, x linija.

Šta se dešava? Dobijamo "dobar" zaplet sa razumnom količinom podataka (isto kao i broj 1). Bilo je nekih troškova u višoj obradi. Sveukupno, međutim, rezultati su približno isti kao i broj 1 niža stopa uzorkovanja s manje filtriranja. Možete zaključiti:

• Dugotrajni prosjek sa okidanjem može dati dobro smanjenje buke uz razumne količine podataka.
• Dodatna obrada možda neće dati toliko bolje rezultate i ima svoju cijenu.

Kod:

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

def Experiment_with_trigger (self): print "" "Eksperimentirajte s okidanjem, dt, pokrenite prosjek i aktivirajte sve varijacije" "" # ----------------------- ------------------------- 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 ()

=

Korak 9: Eksperiment: Zapis sa okidačem - glasnija buka

Uzmimo isti eksperiment kao posljednji korak i pojačamo buku. Pokrenite ga sa: sim_logging …… Izlaz je jedan grafikon, 2 linije.

Sada dodatna obrada izgleda vrijednija. Razumni zaključak ovdje bi mogao biti:

Odabir količine i vrste obrade za smanjenje šuma ovisi o vašem signalu i šumu

Kod:

def eksperiment_s_trigger_louder_noise (samo):

ispisati "" "Jači šum od prethodnog eksperimenta" "" self.start_plot (plot_title = "Eksperiment sa bukom jačom od okidača") 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 ()

Korak 10: Napravite vlastite eksperimente

Nadam se da ćete u ovom trenutku vidjeti da tehnike u ovom uputstvu mogu biti korisne u evidentiranju podataka, ali i da se moraju koristiti s malo razmišljanja. Eksperimentiranje s njima može pomoći u tom procesu.

Neke napomene o eksperimentima i stvarima na koje biste mogli obratiti pažnju:

• Sinusni valovi nisu jedina zanimljiva vrsta signala, isprobajte druge, druge valove ili rampe ili…..
• Za buku sam koristio normalnu distribuciju, postoji toliko mnogo vrsta buke; trebali biste uzeti u obzir druge
• Trčni prosjeci su jednostavna, ali ne i jedina metoda za sagledavanje buke

Napomena: bilježenje slika s Wikipedije.

Korak 11: Upotreba tehnika u vašem softveru za bilježenje

Moj kôd je objektno orijentisan, a obrada za trčanje prosjeka i okidač može se jednostavno kopirati u vaše Python okruženje i zatim koristiti. Objekti su:

• DataTrigger u data_trigger.py
• MovingAverage u moving_average.py

Moj glavni objekt LoggingSim u simulate_logging.py trebao bi vam dati dobar primjer kako ga koristiti. Ako koristite drugi jezik, možete pročitati moj kôd i implementirati ga na svom jeziku.

Ovaj kôd može vašem projektu omogućiti bolje bilježenje podataka, pokušajte.

Gornji grafikon je iz grafikona Vaše solarne energije od strane russ_hensel koji koristi isti objekt s prosječnim trčanjem.