Eksperimente në regjistrimin e avancuar të të dhënave (duke përdorur Python): 11 hapa

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:10

Ka shumë udhëzime për regjistrimin e të dhënave, kështu që kur doja të ndërtoja një projekt tim për prerjet, shikova përreth një bandë. Disa ishin të mira, disa jo aq shumë, kështu që vendosa të marr disa nga idetë më të mira dhe të bëj aplikimin tim. Kjo rezultoi në një projekt edhe më të avancuar dhe më të komplikuar nga sa prisja në fillim. Një pjesë e tij u bë një seri eksperimentesh në përpunimin e të dhënave të sensorit. Ky udhëzues ju lejon të provoni eksperimente të njëjta ose të ngjashme.

(Mund ta shihni të gjithë kodin dhe ta shkarkoni në: Kodi në GitHub Mund të hyni në shikim, ndoshta në një dritare tjetër, me vetëm 2 klikime)

Zakonisht regjistrimi i të dhënave përfshin sa vijon:

• Marrja e të dhënave: Lexoni disa të dhëna nga një sensor. Shpesh kjo është thjesht leximi i një konvertuesi analog në dixhital (ADC) në një pajisje si një Arduino.
• Përpunimi i të dhënave: Kur lexoni një vlerë ADC, dalja e konvertuesve normalisht duhet të shkallëzohet në njësitë e duhura. Mund të ketë gjithashtu nevojë për të bërë disa rregullime për të kalibruar vlerat për të korrigjuar gabimet e sensorit.
• Filtrimi: Të dhënat zakonisht përmbajnë pak zhurmë, kjo mund të filtrohet kështu që ju po kërkoni një sinjal në të dhënat tuaja, jo zhurmën.
• Ruajtja e të dhënave: Të dhënat ruhen, ndoshta në një skedar teksti, ndoshta në re. Të dhënat duhet të mbijetojnë edhe nëse energjia fiket. Easyshtë e lehtë të ruani shumë të dhëna, ne kemi një truk të vogël për të zvogëluar hapësirën e ruajtjes së të dhënave.
• Shfaqja e të dhënave: Metodat për të parë të dhënat tuaja, jo vërtet regjistrimi i të dhënave, por nëse nuk bëni një lloj shfaqjeje të të dhënave pse i grumbulloni ato?
• Qasja në distancë: Nuk është e nevojshme, por është mirë të kesh.

Shumica e udhëzimeve përfshijnë disa, por jo të gjitha sa më sipër, ose i bëni ato në një mënyrë shumë të thjeshtë. Ky udhëzues do të trajtojë 2 nga çështjet e regjistrimit shpesh të anashkaluara dhe si bonus ju jep një mjet për të grafikuar të dhënat tuaja pa përdorur një shërbim cloud. Ju mund të përdorni të gjithë gjënë ose të tërhiqni copa dhe pjesë dhe t'i rimishni ato në një projekt tuajin.

Hapi 1: Mjetet dhe materialet

Ky shembull është i gjithë në Python kështu që do të funksionojë dhe komponentët mund të përdoren në pothuajse çdo OS duke përfshirë Mac, PC, Linux dhe Raspberry Pi.

Pra, për të përdorur këtë udhëzues, gjithçka që ju nevojitet është një mjedis Python 3.6, dhe shkarkoni kodin e bashkangjitur. Pas ekzekutimit të kodit që kam krijuar, mund ta modifikoni për eksperimentet tuaja. Si zakonisht me Python, mund t'ju duhet të shtoni disa pako/module për të funksionuar gjithçka. Mjedisi im Spyder vjen me pothuajse të gjitha pjesët e kërkuara në vend (shiko: Grafiku i Pamjeve të Udhëzueshme me Python Screen Scraping). Kur filloni të shikoni për çdo mesazh gabimi, ata do t'ju njoftojnë për pjesët që mungojnë në mjedisin tuaj.

Dy hapat e ardhshëm do t'ju tregojnë se si të ndërtoni dhe drejtoni një eksperiment tuajin, por ndoshta është më mirë të prisni derisa të bëni eksperimentet e përfshira para se të provoni tuajin.

Për të kuptuar kodin do t'ju duhet të keni pak përvojë me Python të orientuar drejt objekteve, duke shpjeguar se është përtej fushëveprimit të këtij udhëzuesi, por Google duhet t'ju japë çdo ndihmë që mund t'ju nevojitet.

Vini re kodin: (Kodi në GitHub Mund të shikoni, ndoshta në një dritare tjetër, me vetëm 2 klikime) tani është në Python 3.6, kështu që të kesh 3.6 do të ishte më mirë. Versioni më i vjetër i kodit është këtu në lidhjet më poshtë.

Hapi 2: Ndërtimi i një eksperimenti

Ekzistojnë tre hapa (dhe linja) programimi në ndërtimin e një eksperimenti. Çdo eksperiment është një funksion në objektin LoggingSim në skedarin simulate_logging.py. Le të shohim eksperimentin 1 (vetëm grafikun e parë) të cilin do ta ekzekutojmë në hapin tjetër:

def Experiment_with_sample_ normat (vetja):

print "" "Eksperiment me tarifat e mostrës Duke parë normat e ndryshme të mostrës duke ndryshuar deltën T" "" self.start_plot (plot_title = "Tarifat e mostrës - Pjesa 1/3: Delta T = 1.0") self.add_sensor_data (emri = "dt = 1. ", amplitudë = 1., zhurma_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, vlera e nxitjes = 0) vetë. Shfaqje_plot ()

Çdo eksperiment është shkruar si funksioni i tij, kështu që ne kemi një vijë që përcakton funksionin (def eksperimenti…..)

Linja tjetër, pa komente, (start_plot (….) Krijon objektin për eksperimentin dhe i jep një emër.

Linja tjetër, pa komente, (add_sensor_data (…) është e ndarë në disa rreshta. Ai simulon një sensor që mat një sinjal me zhurmë potencialisht dhe disa përpunime. Argumentet e funksionit janë si më poshtë:

• emri: një emër i vendosur në grafikun përfundimtar për të identifikuar të dhënat
• amplituda: sa i madh është sinjali, ne gjithmonë do të përdorim një amplitudë 1. në këtë të udhëzueshme.
• zhurma_amp: sa e madhe është zhurma, 0. nuk është zhurmë, do të fillojmë këtu.
• delta_t: koha midis matjeve, kontrollon shkallën e mostrës.
• max_t: koha maksimale që mbledhim të dhëna, ne gjithmonë do të përdorim 10 në këtë udhëzues.
• run_ave: përpunimi duke përdorur një mesatare të funksionimit, 0 do të thotë që nuk ka përpunim.
• vlera e shkaktimit: përpunimi duke përdorur shkrepjen, 0 do të thotë pa përpunim

rreshti i fundit, pa komente, (self.show_plot ……) shfaq grafikun.

Për t’i bërë gjërat pak më të komplikuara mund të keni rreshta të shumtë në një grafik ose grafë të shumtë në një eksperiment, kjo duhet të jetë e qartë nga eksperimentet që pasojnë.

Hapi 3: Drejtimi i një eksperimenti

Ky është kodi për drejtimin e një eksperimenti. Si e zakonshme në Python ajo vendoset në fund të skedarit.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Kjo është vetëm 2 rreshta:

• Krijoni një imitues të prerjeve (LoggingSim ())
• Drejtojeni atë (sim_logging.experiment_with_sample_rates ()

Në kodin e shkarkuar kam disa rreshta dhe komente të tjera, duhet të jetë e lehtë të kuptohet.

Hapi 4: Eksperiment: Shkalla e Mostrës

Simulatori, siç është vendosur këtu, nxjerr gjithmonë një valë të mirë të qetë të amplitudës 1. Për këtë eksperiment ne do të ngatërrojmë me normën e mostrës, të rregulluar nga delta_t, diferencën kohore midis mostrave. Ne nuk do të kemi zhurmë ose përpunim tjetër. Kodi përdor 3 norma të mostrës (delta_t = 1.0, 0.1 dhe 0.01.) Meqenëse grafikët bien mbi njëri -tjetrin eksperimenti është ngritur për të prodhuar 3 grafikë të ndryshëm. Grafikët që rezultojnë janë imazhet për këtë hap.

def Experiment_with_sampular_rates (vetë):

print "" "Eksperiment me normat e mostrës Duke parë norma të ndryshme të mostrës duke ndryshuar deltën T" "" self.start_plot (plot_title = "Çmimet e mostrës së eksperimentit 1/3: Delta T = 1.0") self.add_sensor_data (emri = "dt = 1 " --------------------------------------- self.start_plot (plot_title = "Çmimet e mostrës së eksperimentit 2/3: Delta T = 0.1 ") self.add_sensor_data (emri =" dt = 1. ", amplitudë = 1., zhurma_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ---------------------------------------------------- vetvetja.start_plot (plot_title = "Normat e kampionit të eksperimentit 3/3: Delta T = 0.01") vetë.add_sensor_data (emri = "dt = 1.", amplitudë = 1., zhurma_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Për ta ekzekutuar përdorni linjën: sim_logging.experiment_with_sample_rates ()

Përfundimet e mundshme:

• Një normë shumë e ulët e marrjes së mostrave është vërtet e keqe.
• Normat e larta janë shpesh më të mira.

(Python 3.6 Code në lidhjen GitHub më poshtë në udhëzimet, 2.7)

Hapi 5: Eksperimenti: Tregimi i Zhurmës

Në këtë eksperiment ne mbajmë të njëjtin sinjal, përdorim një normë mesatare të mostrës dhe kemi sasi të ndryshme zhurme (zhurma_amp =.0,.1, 1.0.) Drejtojeni atë me: sim_logging.experiment_showing_noise (). Dalja është një graf me 3 rreshta.

Përfundim i mundshëm:

Zhurma e vështirëson shikimin e sinjalit, zvogëlojeni nëse mundeni

Kodi:

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

def experiment_showing_noise (self): print "" "Eksperiment që tregon zhurmë Duke parë sasi të ndryshme të zhurmës duke ndryshuar amplituda e zhurmës." "self.start_plot (plot_title =" Eksperimenti që tregon zhurmë ") self.add_sensor_data (name =" zhurmë = 0.0 ", amplitudë = 1., zhurma_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, shkakton_vlerës = 0) vetë.add_sensor_data (emri =" zhurma = 0.1 ", amplituda = 1., zhurma_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) data.add_sensor_data (emri = "zhurma = 1.0", amplituda = 1., zhurma_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Hapi 6: Eksperiment: Ulni zhurmën me një mesatare lëvizëse

Një mesatare lëvizëse (për shembull me gjatësinë 8) merr 8 matjet e fundit dhe i bën ato mesatare. Nëse zhurma është e rastësishme shpresojmë se do të jetë mesatarisht afër 0. Kryeni eksperimentin me: sim_logging.experiment_showing_noise (). Nxjerr një grafik.

Përfundimet e mundshme:

• Një mesatare lëvizëse eliminon shumë zhurmë
• Sa më e gjatë të jetë mesatarja lëvizëse, aq më shumë zvogëlon zhurmën
• Mesatarja më e gjatë lëvizëse mund të zvogëlojë dhe shtrembërojë sinjalin

Kodi:

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

def Experiment_with_moving_average (self): print "" "Eksperimentoni me MovingAverage Looking in MovingAverage mesatare duke ndryshuar gjatësinë. Të gjithë kanë të njëjtën zhurmë." " # ------------------ ------------------------------ self.start_plot (plot_title = "Mesatarja e lëvizjes-Pjesa 1/2: Asnjë mesatare lëvizëse") vetë.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 dhe 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 (emri = "ave len = 32", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Hapi 7: Eksperimenti: Lëvizja mesatare dhe norma e mostrës

Në këtë eksperiment ne krahasojmë sinjalin e papërpunuar me zhurmën dhe 2 variacione të ndryshme në zvogëlimin e zhurmës.

1. Shkalla e mesme e mostrës dhe mesatarja e funksionimit mesatar
2. Shkalla e lartë e mostrës dhe gjatësia e lartë mesatare

Drejtojeni atë me: sim_logging …… Dalja është një graf. Unë mendoj se është e qartë se #2 bën një punë më të mirë në zvogëlimin e zhurmës, kështu që mund të konkludojmë se:

Shkalla e lartë e mostrës dhe gjatësia e lartë mesatare e vrapimit janë të mira

Por duhet të keni parasysh se ka një kosto. #2 kërkon shumë më tepër përpunim dhe rezulton në ruajtjen e më shumë të dhënave. Kostoja mund të jetë ose jo e vlefshme. Në eksperimentin tjetër ne do të shtojmë një shkas, një pajisje për të zvogëluar sasinë e të dhënave të ruajtura.

Kodi:

def Experiment_with_moving_average_and_sample_rate (self):

print "" "Eksperimentoni me lëvizjen mesatare dhe normën e mostrës, dt, mesatarja e ekzekutimit është e ndryshme" " # ---------------------------- -------------------- self.start_plot (plot_title = "Mesatarja e lëvizjes dhe norma e mostrës") self.add_sensor_data (emri = "dt =.1 ra = 0 trig = 0 ", amplitudë = 1., zhurma_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (emri =" dt =.1 ra = 10 trig = 0 ", amplitudë = 1., zhurma_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) vetë.add_sensor_data (emri = "dt =.01 ra = 100 trig = 0", amplitudë = 1., zhurma_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Hapi 8: Eksperimenti: Regjistrimi me Shkas

Në këtë eksperiment ne shtojmë një shkas. Së pari, çfarë dua të them me një shkas? Një shkaktar është një teknikë ku ne mbledhim të dhëna, por i ruajmë vetëm pasi disa ndryshore të kenë ndryshuar me një sasi të konsiderueshme. Në këto eksperimente kam vënë një shkas në ndryshoren e kohës (boshti x). Duke përdorur këmbëzën mund të marr sasi të madhe të të dhënave nga marrja e mostrave të shpejta dhe t'i zvogëloj ato në një sasi më të arsyeshme të të dhënave. Particularshtë veçanërisht e dobishme me normat e larta të mostrës dhe një mesatare afatgjatë.

Unë kam marrë linjën #2 nga eksperimenti i fundit i cili ishte "i mirë" dhe një shtysë e shtuar. Drejtojeni atë me: sim_logging …… Dalja është një graf, x rreshta.

Cfare ndodh? Ne marrim një komplot "të mirë" me një sasi të arsyeshme të të dhënave (njësoj si #1). Ka pasur një kosto në përpunimin më të lartë. Në përgjithësi, megjithatë, rezultatet janë afërsisht të njëjta me #1 normën më të ulët të mostrës me më pak filtrim. Ju mund të përfundoni:

• Mesatarja afatgjatë me nxitje mund të japë një ulje të mirë të zhurmës me sasi të arsyeshme të të dhënave.
• Përpunimi shtesë mund të mos japë rezultate shumë më të mira dhe vjen me një kosto.

Kodi:

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

def experim_with_trigger (vetë): print "" "Eksperimentoni me aktivizimin, dt, ekzekutoni mesataren dhe shkaktoni që të gjitha të jenë të ndryshme" " # ----------------------- ------------------------- self.start_plot (plot_title = "Nxitësi 1/1-Aktivizimi") self.add_sensor_data (emri = "dt =.1 ra = 10, trig = 0 ", amplitudë = 1., zhurma_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (emri =" dt =.01 ra = 100, trig =.1 ", amplitudë = 1., zhurma_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, vlera e shkaktimit =.1) vetë. shfaqje_plot ()

=

Hapi 9: Eksperimenti: Regjistrimi me Shkaktues - Zhurmë më e Lartë

Le të bëjmë të njëjtin eksperiment si hapi i fundit dhe të forcojmë zhurmën. Drejtojeni atë me: sim_logging …… Dalja është një graf, 2 rreshta.

Tani përpunimi shtesë duket më i vlefshëm. Një përfundim i arsyeshëm këtu mund të jetë:

Zgjedhja e sasisë dhe llojit të përpunimit për zvogëlimin e zhurmës varet nga sinjali dhe zhurma juaj

Kodi:

def Experiment_with_trigger_louder_noise (vetja):

print "" "Zhurmë më e madhe se eksperimenti paraprak" "" self.start_plot (plot_title = "Një eksperiment me zhurmë shkaktuese-më të madhe") self.add_sensor_data (emri = "… dt =.1 ra = 10", amplitudë = 1., zhurma_amp =.5, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (emri = "..dt =.01 ra = 100 tv =.1", amplitudë = 1., zhurma_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, vlera e nxitjes =.1) vetë.shfaq_plot ()

Hapi 10: Bëni eksperimentet tuaja

Në këtë pikë, shpresoj të shihni se teknikat në këtë udhëzues mund të jenë të dobishme në regjistrimin e të dhënave, por që ato gjithashtu duhet të përdoren me një mendim. Eksperimentimi me ta mund ta ndihmojë atë proces.

Disa vërejtje mbi eksperimentet dhe gjërat që mund të shikoni:

• Valët sinusale nuk janë i vetmi lloj sinjali interesant, provoni të tjerët, valë të tjera ose rampa ose…..
• Kam përdorur një shpërndarje normale për zhurmën, ka kaq shumë lloje zhurmash; duhet të keni parasysh të tjerët
• Mesataret e vrapimit janë një metodë e thjeshtë, por jo e vetmja për të parë zhurmën

Shënim: regjistrimi i fotografive nga Wikipedia.

Hapi 11: Përdorimi i Teknikave në Softuerin tuaj të Regjistrimit

Kodi im është i orientuar drejt objekteve dhe përpunimi për mesataren dhe këmbëzën e funksionimit thjesht mund të kopjohet në mjedisin tuaj Python dhe më pas të përdoret. Objektet janë:

• DataTrigger në data_trigger.py
• Mesatarja e Lëvizjes në mesataren e lëvizjes.py

Objekti im kryesor LoggingSim në simulate_logging.py duhet t'ju japë një shembull të mirë se si ta përdorni. Nëse përdorni një gjuhë tjetër, mund të lexoni kodin tim dhe ta zbatoni në gjuhën tuaj.

Ky kod mund t'i japë projektit tuaj regjistrim më të mirë të të dhënave, provojeni.

Grafiku i mësipërm është nga Graph Your Solar Power by russ_hensel i cili përdor të njëjtin objekt mesatar të funksionimit.