Experimenty v pokročilém protokolování dat (pomocí Pythonu): 11 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:19

Existuje mnoho instrukcí pro protokolování dat, takže když jsem chtěl vytvořit svůj vlastní projekt protokolování, podíval jsem se kolem. Některé byly dobré, některé ne tolik, a tak jsem se rozhodl vzít některé lepší nápady a vytvořit si vlastní aplikaci. Výsledkem byl projekt pokročilejší a komplikovanější, než jsem původně očekával. Jednou z jejích částí se stala série experimentů při zpracování dat ze senzorů. Tento návod vám umožňuje vyzkoušet stejné nebo podobné experimenty.

(Celý kód si můžete zobrazit a stáhnout na adrese: Kód na GitHub Do zobrazení se můžete dostat třeba v jiném okně pouhými 2 kliknutími)

Protokolování dat obvykle zahrnuje následující:

• Sběr dat: Přečtěte některá data ze senzoru. Často se jedná pouze o čtení analogově digitálního převodníku (ADC) na zařízení, jako je Arduino.
• Zpracování dat: Při čtení hodnoty ADC je obvykle nutné převést výstup převodníků na správné jednotky. Může být také nutné provést určité úpravy pro kalibraci hodnot, aby byly opraveny chyby snímačů.
• Filtrování: Data běžně obsahují určitý šum, který lze filtrovat, takže hledáte signál ve svých datech, nikoli šum.
• Ukládání dat: Data se ukládají, možná do textového souboru, možná do cloudu. Data by měla přežít, i když se vypne napájení. Je snadné uložit příliš mnoho dat, máme malý trik, jak zmenšit prostor pro ukládání dat.
• Zobrazení dat: Metody prohlížení vašich dat, nikoli skutečné protokolování dat, ale pokud neprovedete nějaké zobrazení dat, proč je shromažďovat?
• Vzdálený přístup: Není to nutné, ale je příjemné to mít.

Většina pokynů obsahuje některé, ale ne všechny výše uvedené, nebo je proveďte velmi jednoduchým způsobem. Tento instruktážní program se bude zabývat 2 často přeskočenými problémy s protokolováním a jako bonus vám poskytne způsob vykreslení dat bez použití cloudové služby. Můžete použít celou věc nebo vytáhnout kousky a remixovat je do vlastního projektu.

Krok 1: Nástroje a materiály

Tento příklad je v Pythonu, takže poběží a komponenty lze použít na téměř jakémkoli operačním systému, včetně Mac, PC, Linux a Raspberry Pi.

Chcete -li tedy použít tento návod, potřebujete pouze spuštěné prostředí Python 3.6 a stáhněte si přiložený kód. Po spuštění kódu, který jsem nastavil, jej můžete upravit pro vlastní experimenty. Jak je u Pythonu obvyklé, možná budete muset přidat nějaké balíčky/moduly, aby vše fungovalo. Moje prostředí Spyder je dodáváno s téměř všemi požadovanými součástmi (viz: Graficky upravitelné pohledy se škrábáním obrazovky Pythonu). Při prvním spuštění sledujte všechny chybové zprávy, které vás informují o chybějících částech ve vašem prostředí.

Následující dva kroky vám řeknou, jak vytvořit a spustit vlastní experiment, ale před vlastním pokusem je pravděpodobně lepší počkat, až spustíte zahrnuté experimenty.

Abyste porozuměli kódu, budete potřebovat trochu zkušeností s objektově orientovaným Pythonem, což vysvětluje, že to přesahuje rámec tohoto návodu, ale Google by vám měl poskytnout jakoukoli pomoc, kterou byste mohli potřebovat.

Všimněte si kódu: (Kód na GitHub K prohlížení se můžete dostat třeba v jiném okně pouhými 2 kliknutími) je nyní v Pythonu 3.6, takže nejlepší bude mít 3.6. Starší verze kódu je zde v níže uvedených odkazech.

Krok 2: Budování experimentu

Při vytváření experimentu existují tři programovací kroky (a řádky). Každý experiment je funkcí v objektu LoggingSim v souboru simulate_logging.py. Podívejme se na experiment 1 (jen první graf), který spustíme v dalším kroku:

def experiment_with_sample_rates (vlastní):

tisk "" "Experiment se vzorkovacími rychlostmi Při pohledu na různé vzorkovací frekvence změnou delta T" "" self.start_plot (plot_title = "Sample Rates - Část 1/3: Delta T = 1,0") self.add_sensor_data (name = "dt = 1. ", amplituda = 1., hluk_amp = = 0, delta_t = 1., max_t = 10, run_ave = 0, trigger_value = 0) self.show_plot ()

Každý experiment je zapsán jako jeho vlastní funkce, takže máme řádek definující funkci (def experiment …..)

Další řádek bez komentáře (start_plot (….) Vytvoří objekt pro experiment a pojmenuje ho.

Další řádek řádku bez komentářů (add_sensor_data (…) je rozdělen do několika řádků. Simuluje senzor měřící signál s potenciálním šumem a určitým zpracováním. Argumenty funkce jsou následující:

• name: jméno uvedené v konečném grafu k identifikaci dat
• amplituda: jak velký je signál, v tomto pokynu vždy použijeme amplitudu 1.
• noise_amp: jak velký je hluk, 0. není žádný hluk, začneme zde.
• delta_t: čas mezi měřeními, řídí vzorkovací frekvenci.
• max_t: maximální dobu, po kterou shromažďujeme data, v tomto pokynu vždy použijeme 10.
• run_ave: zpracování pomocí běžného průměru, 0 znamená žádné zpracování.
• trigger_value: zpracování pomocí spouštění, 0 znamená žádné zpracování

poslední řádek bez komentářů (self.show_plot ……) zobrazuje graf.

Aby to bylo trochu komplikovanější, můžete mít v experimentu více čar na grafu nebo více grafů, to by mělo být zřejmé z experimentů, které následují.

Krok 3: Spuštění experimentu

Toto je kód pro spuštění experimentu. Jak je v Pythonu běžné, je umístěn na konci souboru.

sim_logging = LoggingSim ()

sim_logging.experiment_w_sample_rates ()

Toto jsou jen 2 řádky:

• Vytvořit simulátor protokolování (LoggingSim ())
• Spusťte jej (sim_logging.experiment_with_sample_rates ())

Ve staženém kódu mám několik dalších řádků a komentářů, mělo by být snadné to zjistit.

Krok 4: Experiment: Vzorkovací frekvence

Simulátor, jak je zde nastaven, vždy vydává pěknou hladkou sinusovou vlnu amplitudy 1. Pro tento experiment si popleteme vzorkovací frekvenci, upravenou o delta_t, časový rozdíl mezi vzorky. Nebudeme mít žádný hluk ani jiné zpracování. Kód používá 3 vzorkovací frekvence (delta_t = 1,0, 0,1 a 0,01.) Protože grafy na sebe padají, je experiment nastaven tak, aby vytvořil 3 různé grafy. Výsledné grafy jsou obrázky pro tento krok.

def experiment_with_sample_rates (vlastní):

tisk "" "Experiment se vzorkovacími rychlostmi Při pohledu na různé vzorkovací frekvence změnou delta T" "" self.start_plot (plot_title = "Experimentální vzorkovací frekvence 1/3: Delta T = 1,0") self.add_sensor_data (name = "dt = 1. ", amplituda = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Vzorky sazeb experimentu 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 () # ------------------------------------------------ vlastní.start_plot (plot_title = "Vzorky experimentu 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 ()

Chcete -li jej spustit, použijte řádek: sim_logging.experiment_with_sample_rates ()

Možné závěry:

• Příliš nízká vzorkovací frekvence je opravdu špatná.
• Vysoké ceny jsou často lepší.

(Kód Pythonu 3.6 na odkazu GitHub níže v instructables, 2.7)

Krok 5: Experiment: Zobrazení šumu

V tomto experimentu udržujeme stejný signál, používáme střední vzorkovací frekvenci a máme různá množství šumu (noise_amp =.0,.1, 1.0.) Spusťte jej pomocí: sim_logging.experiment_showing_noise (). Výstupem je jeden graf se 3 řádky.

Možný závěr:

Hluk ztěžuje vidění signálu, pokud můžete, snižte jej

Kód:

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

def experiment_showing_noise (self): print "" "Experiment ukazující šum Při pohledu na různá množství šumu změnou amplitudy hluku." "" self.start_plot (plot_title = "Experiment Showing Noise") self.add_sensor_data (name = "noise = 0,0 ", amplituda = 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 ()

Krok 6: Experiment: Snižte hluk klouzavým průměrem

Klouzavý průměr (například s délkou 8) provede posledních 8 měření a zprůměruje je. Pokud je šum náhodný, doufáme, že bude průměrný téměř na 0. Spusťte experiment s: sim_logging.experiment_showing_noise (). Výstup jednoho grafu.

Možné závěry:

• Klouzavý průměr eliminuje velkou část hluku
• Čím delší je klouzavý průměr, tím větší je redukce šumu
• Delší klouzavý průměr může snížit a zkreslit signál

Kód:

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

def experiment_with_moving_average (self): print "" "Experiment with MovingAverage Při pohledu na různé MovingAverage změnou délky. Všechny mají stejný hluk." "" # ------------------ ------------------------------ 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 ()

Krok 7: Experiment: Klouzavý průměr a vzorkovací frekvence

V tomto experimentu porovnáváme surový signál se šumem a 2 různé variace na snížení šumu.

1. Střední vzorkovací frekvence a střední klouzavý průměr
2. Vysoká vzorkovací frekvence a dlouhý průměr

Spusťte jej pomocí: sim_logging …… Výstupem je jeden graf. Myslím, že je jasné, že #2 dělá lepší práci při snižování hluku, takže bychom mohli dojít k závěru, že:

Dobrá je vysoká vzorkovací frekvence a dlouhý průměr

Ale musíte mít na paměti, že to stojí náklady. #2 vyžaduje mnohem více zpracování a vede k uložení mnohem více dat. Náklady mohou, ale nemusí stát za to. V dalším experimentu přidáme spoušť, zařízení ke snížení množství uložených dat.

Kód:

def experiment_s_pohybem_průměrné_a_sample_rate (vlastní):

tisk "" "Experiment s klouzavým průměrem a vzorkovací frekvencí, dt, průměr běhu se mění" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Klouzavý průměr a vzorkovací frekvence") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", amplituda = 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 ", 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 = 0", amplituda = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Krok 8: Experiment: Protokolování pomocí spouště

V tomto experimentu přidáme spoušť. Za prvé, co mám rozumět pod spouštěčem? Spoušť je technika, při které shromažďujeme data, ale ukládáme je až poté, co se některá proměnná výrazně změní. V těchto experimentech jsem spustil spoušť na proměnné času (osa x). Použitím spouště mohu odebrat velké množství dat z rychlého vzorkování a snížit je na rozumnější množství dat. Je to zvláště užitečné s vysokými vzorkovacími frekvencemi a dlouhodobým průměrem.

Převzal jsem řádek č. 2 z posledního experimentu, který byl „dobrý“, a přidal spoušť. Spusťte jej pomocí: sim_logging …… Výstupem je jeden graf, x řádků.

Co se stalo? Získáme „dobrý“graf s přiměřeným množstvím dat (stejný jako #1). Vyšší zpracování přineslo určité náklady. Celkově jsou však výsledky přibližně stejné jako #1 nižší vzorkovací frekvence s menším filtrováním. Můžete dojít k závěru:

• Dlouhodobý průměr se spouštěním může poskytnout dobrou redukci šumu s rozumným množstvím dat.
• Dodatečné zpracování nemusí poskytovat mnohem lepší výsledky a přichází s náklady.

Kód:

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

def experiment_with_trigger (self): print "" "Experiment s Triggering, dt, run average and trigger all being changed" "" # ----------------------- ------------------------- 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 ()

=

Krok 9: Experiment: Protokolování pomocí spouště - Hlasitější hluk

Vezměme stejný experiment jako poslední krok a zesilte hluk. Spusťte jej pomocí: sim_logging …… Výstupem je jeden graf, 2 řádky.

Nyní vypadá další zpracování hodnotněji. Rozumný závěr zde může být:

Výběr množství a typu zpracování pro redukci šumu závisí na vašem signálu a šumu

Kód:

def experiment_with_trigger_louder_noise (self):

tisknout "" "Hlučnější než předchozí experiment" "" self.start_plot (plot_title = "Experiment se spouštěcím hlukem") self.add_sensor_data (name = "… dt =.1 ra = 10", amplituda = 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 ()

Krok 10: Vytvořte si vlastní experimenty

V tuto chvíli doufám, že vidíte, že techniky v tomto instruktážním programu mohou být užitečné při protokolování dat, ale že je také nutné je použít s určitou myšlenkou. Experimentování s nimi může tomuto procesu pomoci.

Několik poznámek k experimentům a věcem, na které byste se mohli podívat:

• Sinusové vlny nejsou jediným zajímavým typem signálu, zkuste jiné, jiné vlny nebo rampy nebo …..
• Pro hluk jsem použil normální rozdělení, existuje tolik druhů hluku; měli byste brát ohled na ostatní
• Běžecké průměry jsou jednoduchou, ale ne jedinou metodou pro sledování hluku

Poznámka: protokolování obrázků z Wikipedie.

Krok 11: Použití technik v softwaru pro protokolování

Můj kód je objektově orientovaný a zpracování pro běžící průměr a spoušť lze jen zkopírovat do vašeho prostředí Python a poté použít. Předměty jsou:

• DataTrigger v data_trigger.py
• MovingPrůměr v moving_average.py

Můj hlavní objekt LoggingSim v simulate_logging.py by vám měl dát dobrý příklad, jak jej používat. Pokud používáte jiný jazyk, můžete si přečíst můj kód a implementovat ho ve svém jazyce.

Tento kód může dát vašemu projektu lepší protokolování dat, zkuste to.

Výše uvedený graf pochází z grafu Your Solar Power od russ_hensel, který používá stejný průměrný objekt.