Eksperimente in gevorderde data -aanmelding (met behulp van Python): 11 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:24

Daar is baie instruksies vir data -aanmelding, so toe ek 'n eie houtprojek wou bou, het ek na 'n klomp rondgekyk. Sommige was goed, sommige nie soveel nie, so ek het besluit om 'n paar van die beter idees te neem en my eie aansoek te doen. Dit het gelei tot 'n meer gevorderde en ingewikkelder projek as wat ek aanvanklik verwag het. Een deel daarvan was 'n reeks eksperimente in die verwerking van sensordata. Met hierdie instruksies kan u dieselfde of soortgelyke eksperimente probeer.

(U kan al die kode sien en dit aflaai by: Kode by GitHub U kan met slegs 2 klik in 'n ander venster kyk)

Datalogging behels tipies die volgende:

• Data -verkryging: Lees 'n paar data van 'n sensor. Dikwels is dit net om 'n analoog na digitale omskakelaar (ADC) op 'n toestel soos 'n Arduino te lees.
• Dataverwerking: By die lees van 'n ADC -waarde moet die uitset van die omsetters gewoonlik na die regte eenhede geskaal word. Dit kan ook nodig wees om 'n bietjie aan te pas om die waardes te kalibreer om te korrigeer vir sensorfoute.
• Filtrering: data bevat gewoonlik 'n mate van geraas; dit kan gefiltreer word, sodat u na die sein in u data kyk, nie na die geraas nie.
• Stoor data: die data word gestoor, miskien in 'n tekslêer, miskien in die wolk. Data behoort te oorleef, selfs al gaan die krag af. Dit is maklik om te veel data te stoor; ons het 'n klein truuk om die stoorplek van die data te verminder.
• Gegeeweergawe: metodes om na u data te kyk, nie eintlik data -aanmelding nie, maar waarom moet u dit versamel as u nie die data vertoon nie?
• Toegang op afstand: nie nodig nie, maar lekker om te hê.

Die meeste instruksies bevat sommige van die bogenoemde, maar nie almal nie, of doen dit op 'n baie eenvoudige manier. Hierdie instruksies behandel twee van die gereeld aangemelde logprobleme en gee u as bonus 'n manier om u data te grafiseer sonder om 'n wolkdiens te gebruik. U kan die hele ding gebruik of stukke uittrek en dit in 'n eie projek kombineer.

Stap 1: gereedskap en materiaal

Hierdie voorbeeld is alles in Python, sodat dit kan aanhou, en komponente kan op feitlik enige bedryfstelsel gebruik word, insluitend Mac, PC, Linux en die Raspberry Pi.

Om hierdie instruksies te gebruik, is 'n lopende Python 3.6 -omgewing wat u benodig, en laai die aangehegte kode af. Nadat u die kode wat ek opgestel het, uitgevoer het, kan u dit verander vir u eie eksperimente. Soos gewoonlik met Python, moet u moontlik pakkette/modules byvoeg om alles te laat werk. My Spyder -omgewing bevat bykans al die vereiste onderdele (sien: grafiese instruksies met Python -skermskraap). As u die eerste keer na enige foutboodskappe kyk, sal hulle u in kennis stel van die ontbrekende dele in u omgewing.

Die volgende twee stappe sal u vertel hoe u 'n eie eksperiment kan bou en uitvoer, maar dit is waarskynlik beter om te wag totdat u die eksperimente uitgevoer het voordat u dit self probeer.

Om die kode te verstaan, moet u 'n bietjie ervaring hê met objekgeoriënteerde Python, wat verduidelik dat dit buite die omvang van hierdie instruksies val, maar Google moet u die nodige hulp gee.

Let op die kode: (Kode by GitHub U kan met slegs 2 kliks in 'n ander venster kyk) is nou in Python 3.6, dus sou 3,6 die beste wees. Die ouer weergawe van die kode is hier op die onderstaande skakels.

Stap 2: Bou 'n eksperiment

Daar is drie programmeerstappe (en lyne) in die bou van 'n eksperiment. Elke eksperiment is 'n funksie in die LoggingSim -voorwerp in die lêer simulate_logging.py. Kom ons kyk na eksperiment 1 (net die eerste grafiek) wat ons in die volgende stap sal uitvoer:

def experiment_with_sample_rates (self):

druk "" "Eksperimenteer met steekproefkoerse Kyk na verskillende steekproefkoerse deur delta T" "" self.start_plot (plot_title = "Voorbeeld tariewe - deel 1/3: Delta T = 1.0") self.add_sensor_data (naam = "dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Elke eksperiment word as sy eie funksie geskryf, sodat ons 'n lyn het wat die funksie definieer (def eksperiment ….)

Die volgende reël sonder opmerking, (start_plot (…), skep die voorwerp vir die eksperiment en gee dit 'n naam.

Die volgende reël sonder opmerking (add_sensor_data (…) is in verskeie reëls verdeel. Dit simuleer 'n sensor wat 'n sein meet met moontlik geraas en 'n mate van verwerking. Die funksie -argumente is soos volg:

• naam: 'n naam wat op die finale grafiek geplaas word om die data te identifiseer
• amplitude: hoe groot die sein is, ons sal altyd 'n amplitude van 1. gebruik in hierdie instruksies.
• noise_amp: hoe groot die geraas is, 0. is geen geraas nie, ons begin hier.
• delta_t: die tyd tussen metings, bepaal die monstertempo.
• max_t: die maksimum tyd wat ons data versamel, gebruik ons altyd 10 in hierdie instruksies.
• run_ave: verwerking met 'n lopende gemiddelde, 0 beteken geen verwerking nie.
• trigger_value: verwerking met sneller, 0 beteken geen verwerking nie

die laaste reël sonder kommentaar, (self.show_plot ……) vertoon die grafiek.

Om dinge 'n bietjie ingewikkelder te maak, kan u verskeie lyne op 'n grafiek of meer grafieke in 'n eksperiment hê; dit moet duidelik blyk uit die volgende eksperimente.

Stap 3: voer 'n eksperiment uit

Dit is die kode vir die uitvoer van 'n eksperiment. Soos in Python, word dit aan die einde van die lêer geplaas.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Dit is slegs 2 reëls:

• Skep 'n logsimulator (LoggingSim ())
• Begin dit (sim_logging.experiment_with_sample_rates ())

In die afgelaaide kode het ek nog 'n paar reëls en opmerkings, dit moet maklik wees om uit te vind.

Stap 4: Eksperiment: Voorbeeldtempo

Die simulator, soos hier opgestel, lewer altyd 'n mooi gladde sinusgolf van amplitude 1. Vir hierdie eksperiment sal ons mors met die monstertempo, soos aangepas deur delta_t, die tydsverskil tussen monsters. Ons sal geen geraas of ander verwerking hê nie. Die kode gebruik 3 steekproefsnelhede (delta_t = 1.0, 0.1 en 0.01.) Aangesien die grafieke bo -op mekaar val, word die eksperiment opgestel om 3 verskillende grafieke te produseer. Die resulterende grafieke is die beelde vir hierdie stap.

def experiment_with_sample_rates (self):

print "" "Eksperimenteer met steekproefkoerse Kyk na verskillende steekproefsnelhede deur delta T" "" self.start_plot (plot_title = "Eksperimentmonster tariewe 1/3: Delta T = 1.0") self.add_sensor_data (naam = "dt = 1 te verander". ", 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 = "Eksperimentmonster tariewe 2/3: Delta T = 0.1 ") self.add_sensor_data (naam =" dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ self.start_plot (plot_title = "Eksperimentmonster tariewe 3/3: Delta T = 0.01") self.add_sensor_data (naam = "dt = 1.", amplitude = 1., noise_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Gebruik die reël om dit uit te voer: sim_logging.experiment_with_sample_rates ()

Moontlike gevolgtrekkings:

• 'N Te lae bemonsteringskoers is regtig sleg.
• Hoë tariewe is dikwels beter.

(Python 3.6 -kode by GitHub -skakel hieronder by instructables, 2.7)

Stap 5: Eksperiment: Geraas toon

In hierdie eksperiment behou ons dieselfde sein, gebruik ons 'n gemiddelde monstertempo en het daar verskillende hoeveelhede geraas (noise_amp =.0,.1, 1.0.) Begin dit met: sim_logging.experiment_showing_noise (). Die uitset is een grafiek met 3 reëls.

Moontlike gevolgtrekking:

Geraas maak dit moeilik om die sein te sien, verminder dit as u kan

Die kode:

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

def experiment_showing_noise (self): print "" "Eksperiment wat ruis toon Kyk na verskillende hoeveelhede geraas deur die ruisamplitude te verander." "" self.start_plot (plot_title = "Experiment wat ruis toon") 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 (naam =" noise = 0.1 ", amplitude = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (naam = "noise = 1.0", amplitude = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Stap 6: Eksperiment: Verminder geraas met 'n bewegende gemiddelde

'N bewegende gemiddelde (byvoorbeeld met lengte 8) neem die laaste 8 metings en gemiddelde dit. As die geraas willekeurig is, hoop ons dat dit gemiddeld tot naby 0. Gemiddeld sal wees. Begin die eksperiment met: sim_logging.experiment_showing_noise (). Stel een grafiek uit.

Moontlike gevolgtrekkings:

• 'N bewegende gemiddelde elimineer baie van die geraas
• Hoe langer die bewegende gemiddelde, hoe meer geraasvermindering
• Die langer bewegende gemiddelde kan die sein verminder en verdraai

Die kode:

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

def experiment_with_moving_average (self): print "" "Experiment with MovingAverage Kyk na verskillende MovingAverage deur die lengte te verander. Almal het dieselfde geraas." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No Moving Average") self.add_sensor_data (naam = "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 en 32") self.add_sensor_data (naam = "ave len = 8", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (naam = "ave len = 32", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Stap 7: Eksperiment: bewegende gemiddelde en monstertempo

In hierdie eksperiment vergelyk ons die rou sein met geraas en 2 verskillende variasies oor die vermindering van die geraas.

1. Medium steekproefkoers en gemiddelde lopende gemiddelde
2. Hoë monstertempo en lopende gemiddelde met 'n hoë lengte

Begin dit met: sim_logging …… Uitset is een grafiek. Ek dink dit is duidelik dat nommer 2 beter werk om die geraas te verminder, sodat ons tot die gevolgtrekking kan kom dat:

'N Hoë steekproef en 'n hoë gemiddelde loop is gemiddeld

Maar u moet in gedagte hou dat daar 'n koste is. #2 verg baie meer verwerking en veroorsaak dat baie meer data gestoor word. Die koste is al dan nie die moeite werd nie. In die volgende eksperiment voeg ons 'n sneller by, 'n toestel om die hoeveelheid data wat gestoor word, te verminder.

Die kode:

def experiment_with_moving_average_and_sample_rate (self):

druk "" "Eksperimenteer met bewegende gemiddelde en steekproefsnelheid, dt, gemiddelde loop word gevarieer" "" # ---------------------------- -------------------- self.start_plot (plot_title = "bewegende gemiddelde en steekproefkoers") self.add_sensor_data (naam = "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 (naam =" 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 (naam = "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 ()

Stap 8: Eksperiment: aanmeld met sneller

In hierdie eksperiment voeg ons 'n sneller by. Eerstens, wat bedoel ek met 'n sneller? 'N Sneller is 'n tegniek waar ons data versamel, maar dit slegs stoor nadat 'n veranderlike aansienlik verander het. In hierdie eksperimente plaas ek 'n sneller op die tyd (x -as) veranderlike. Deur die sneller te gebruik, kan ek die hoë hoeveelheid data uit 'n vinnige bemonstering neem en dit tot 'n redeliker hoeveelheid data verminder. Dit is veral nuttig met hoë steekproefsyfers en 'n lang gemiddelde.

Ek het die nommer 2 van die vorige eksperiment geneem, wat 'goed' was en 'n sneller bygevoeg het. Begin dit met: sim_logging …… Uitset is een grafiek, x reëls.

Wat gebeur? Ons kry 'n 'goeie' plot met 'n redelike hoeveelheid data (dieselfde as nommer 1). Daar is 'n mate van koste verbonde aan hoër verwerking. Oor die algemeen is die resultate egter ongeveer dieselfde as nommer 1 met die laer steekproef met minder filter. U kan tot die gevolgtrekking kom:

• 'N Lang loopgemiddelde met sneller kan goeie geraasvermindering bied met redelike hoeveelhede data.
• Die ekstra verwerking lewer moontlik nie soveel beter resultate nie, en dit kos 'n koste.

Die kode:

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

def experiment_with_trigger (self): print "" "Experiment with Triggering, dt, run gemiddelde and trigger all being variety" "" # ----------------------- ------------------------- self.start_plot (plot_title = "Trigger 1/1-Triggering On") 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 (naam =" dt =.01 ra = 100, trig =.1 ", amplitude = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Stap 9: Eksperiment: aanmeld met sneller - laer geraas

Kom ons neem dieselfde eksperiment as die laaste stap en versterk die geraas. Begin dit met: sim_logging …… Uitset is een grafiek, 2 reëls.

Nou lyk die ekstra verwerking die moeite werd. 'N Redelike gevolgtrekking hier kan wees:

Die keuse van die hoeveelheid en tipe verwerking vir geraasvermindering hang af van u sein en geraas

Die kode:

def experiment_with_trigger_louder_noise (self):

druk "" "Laer geraas as vorige eksperiment" "" self.start_plot (plot_title = "'n Eksperiment met sneller-laaier geraas") self.add_sensor_data (naam = "… 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 (naam = "..dt =.01 ra = 100 tv =.1", amplitude = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

Stap 10: Maak u eie eksperimente

Op hierdie stadium hoop ek dat u sien dat die tegnieke in hierdie instruksies nuttig kan wees in datalogging, maar dat dit ook met oorweging gebruik moet word. Om met hulle te eksperimenteer, kan die proses help.

Enkele opmerkings oor die eksperimente en dinge waarna u kan kyk:

• Sinegolwe is nie die enigste interessante seintipe nie, probeer ander, ander golwe of opritte of …
• Ek het 'n normale verspreiding vir die geraas gebruik, daar is soveel soorte geraas; jy moet ander in ag neem
• Lopende gemiddeldes is 'n eenvoudige, maar nie die enigste metode om na geraas te kyk nie

Nota: teken foto's van Wikipedia aan.

Stap 11: Gebruik die tegnieke in u loggingsagteware

My kode is objekgeoriënteerd en die verwerking van die gemiddelde en sneller kan net in u Python -omgewing gekopieer word en dan gebruik word. Die voorwerpe is:

• DataTrigger in data_trigger.py
• MovingAverage in moving_average.py

My hoofdoel LoggingSim in simulate_logging.py moet u 'n goeie voorbeeld gee van hoe u dit kan gebruik. As u 'n ander taal gebruik, kan u my kode lees en in u taal implementeer.

Hierdie kode kan u projek beter data -aanmelding gee, probeer dit.

Die grafiek hierbo is van Graph Your Solar Power deur russ_hensel wat dieselfde lopende gemiddelde voorwerp gebruik.