Eksperimen dalam Pembalakan Data Lanjutan (Menggunakan Python): 11 Langkah

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:07

Terdapat banyak instruksi pembalakan data, jadi ketika saya ingin membina projek pembalakan saya sendiri, saya melihat banyak. Ada yang bagus, ada yang tidak begitu banyak, jadi saya memutuskan untuk mengambil beberapa idea yang lebih baik dan membuat aplikasi saya sendiri. Ini menghasilkan projek yang lebih maju dan lebih rumit daripada yang saya jangkakan pada mulanya. Salah satu bahagiannya menjadi satu siri eksperimen dalam memproses data sensor. Kaedah pengajaran ini membolehkan anda mencuba eksperimen yang sama atau serupa.

(Anda dapat melihat semua kod dan memuat turunnya di: Kod di GitHub Anda dapat melihat, mungkin di tetingkap lain, dengan hanya 2 klik)

Biasanya pembalakan data melibatkan perkara berikut:

• Perolehan data: Baca beberapa data dari sensor. Selalunya ini hanya membaca analog ke digital converter (ADC) pada peranti seperti Arduino.
• Pemprosesan data: Semasa membaca nilai ADC, output penukar biasanya perlu ditimbang ke unit yang betul. Mungkin juga ada keperluan untuk melakukan penyesuaian untuk mengkalibrasi nilai untuk memperbaiki kesalahan sensor.
• Penyaringan: Data biasanya mengandung sedikit kebisingan, ini dapat disaring sehingga Anda melihat isyarat dalam data anda, bukan suara.
• Penyimpanan data: Data disimpan, mungkin ke fail teks, mungkin ke awan. Data harus bertahan walaupun kuasa padam. Sangat mudah untuk menyimpan terlalu banyak data, kita mempunyai sedikit muslihat untuk mengurangkan ruang penyimpanan data.
• Paparan data: Kaedah untuk melihat data anda, bukan log data sebenarnya, tetapi jika anda tidak membuat paparan data mengapa mengumpulkannya?
• Akses Jauh: Tidak perlu tetapi senang dimiliki.

Sebilangan besar instruksional merangkumi beberapa tetapi tidak semua perkara di atas, atau melakukannya dengan cara yang sangat mudah. Instruksional ini akan menangani 2 masalah pembalakan yang sering dilangkau dan sebagai bonus memberi anda kaedah grafik data anda tanpa menggunakan perkhidmatan cloud. Anda boleh menggunakan keseluruhannya atau mengeluarkan potongan-potongan dan memasukkannya semula ke dalam projek anda sendiri.

Langkah 1: Alat dan Bahan

Contoh ini terdapat di Python sehingga akan berjalan, dan komponen dapat digunakan, hampir semua OS termasuk Mac, PC, Linux dan Raspberry Pi.

Oleh itu, untuk menggunakan arahan ini, semua yang anda perlukan adalah persekitaran Python 3.6 yang sedang berjalan, dan muat turun kod yang dilampirkan. Setelah menjalankan kod yang telah saya siapkan, anda boleh mengubahnya untuk percubaan anda sendiri. Seperti biasa dengan Python, anda mungkin perlu menambahkan beberapa pakej / modul agar semuanya berfungsi. Persekitaran Spyder saya dilengkapi dengan hampir semua bahagian yang diperlukan (lihat: Paparan Boleh Diarahkan Grafik dengan Mengikis Skrin Python). Semasa pertama kali berjaga-jaga untuk melihat mesej ralat, mereka akan memberitahu anda mengenai bahagian yang hilang di persekitaran anda.

Dua langkah seterusnya akan memberitahu anda bagaimana membuat dan menjalankan eksperimen anda sendiri, tetapi mungkin lebih baik menunggu sehingga anda menjalankan eksperimen yang disertakan sebelum anda mencuba sendiri.

Untuk memahami kod tersebut, anda perlu mempunyai sedikit pengalaman dengan Python yang berorientasi objek, yang menjelaskan bahawa di luar skop ini dapat diarahkan, tetapi Google harus memberikan bantuan yang mungkin anda perlukan.

Perhatikan kodnya: (Kod di GitHub Anda dapat melihat, mungkin di tetingkap lain, dengan hanya 2 klik) kini ada di Python 3.6, jadi mempunyai 3.6 adalah yang terbaik. Versi kod lama ada di pautan di bawah.

Langkah 2: Membina Eksperimen

Terdapat tiga langkah pengaturcaraan (dan baris) dalam membina eksperimen. Setiap eksperimen adalah fungsi dalam objek LoggingSim dalam fail simulate_logging.py. Mari kita lihat eksperimen 1 (hanya graf pertama) yang akan kita jalankan pada langkah seterusnya:

def experiment_with_sample_rates (diri):

cetak "" "Eksperimen dengan Kadar Sampel Melihat kadar sampel yang berbeza dengan menukar delta T" "" self.start_plot (plot_title = "Kadar Sampel - Bahagian 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitud = =, noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Setiap eksperimen ditulis sebagai fungsinya sendiri sehingga kita mempunyai garis yang menentukan fungsi (def eksperimen…..)

Baris tanpa komen seterusnya, (start_plot (….) Membuat objek untuk eksperimen dan memberikannya nama.

Baris baris tanpa komen seterusnya, (add_sensor_data (…) dibahagikan kepada beberapa baris. Ia mensimulasikan sensor mengukur isyarat dengan kemungkinan bunyi dan beberapa pemprosesan. Argumen fungsi adalah seperti berikut:

• name: nama yang diletakkan pada grafik akhir untuk mengenal pasti data
• amplitud: seberapa besar isyaratnya, kita akan selalu menggunakan amplitud 1. dalam arahan ini.
• noise_amp: seberapa besar bunyi itu, 0. tidak ada bunyi, kita akan bermula di sini.
• delta_t: masa antara pengukuran, mengawal kadar sampel.
• max_t: masa maksimum kami mengumpulkan data, kami akan selalu menggunakan 10 dalam arahan ini.
• run_ave: memproses menggunakan purata berjalan, 0 bermaksud tidak ada pemprosesan.
• trigger_value: memproses menggunakan pemicu, 0 bermaksud tiada pemprosesan

baris terakhir, bukan komen, (self.show_plot ……) memaparkan grafik.

Untuk membuat perkara menjadi lebih rumit, anda boleh mempunyai beberapa baris pada graf atau beberapa graf dalam eksperimen, ini harus jelas dari eksperimen yang berikut.

Langkah 3: Menjalankan Eksperimen

Ini adalah kod untuk menjalankan eksperimen. Seperti biasa di Python ia diletakkan di hujung fail.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Ini hanya 2 baris:

• Buat simulator pembalakan (LoggingSim ())
• Jalankannya (sim_logging.experiment_with_sample_rates ())

Dalam kod yang dimuat turun, saya mempunyai beberapa baris dan komen, semestinya mudah difahami.

Langkah 4: Eksperimen: Kadar Sampel

Simulator, seperti yang disiapkan di sini, selalu menghasilkan gelombang amplitudo sinus halus yang bagus 1. Untuk eksperimen ini, kita akan mengacaukan kadar sampel, seperti yang disesuaikan dengan delta_t, perbezaan masa antara sampel. Kami tidak akan mempunyai suara atau pemprosesan lain. Kod ini menggunakan 3 kadar sampel (delta_t = 1.0, 0.1 dan 0.01.) Oleh kerana graf jatuh di atas satu sama lain, eksperimen disiapkan untuk menghasilkan 3 graf yang berbeza. Grafik yang dihasilkan adalah gambar untuk langkah ini.

def experiment_with_sample_rates (diri):

cetak "" "Eksperimen dengan Kadar Sampel Melihat kadar sampel yang berbeza dengan menukar delta T" "" self.start_plot (plot_title = "Kadar Contoh Eksperimen 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitudo = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Kadar Contoh Eksperimen 2/3: Delta T = 0.1 ") self.add_sensor_data (name =" dt = 1. ", amplitudo = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ diri.start_plot (plot_title = "Kadar Contoh Eksperimen 3/3: Delta T = 0.01") self.add_sensor_data (name = "dt = 1.", amplitudo = 1., noise_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Untuk menjalankannya gunakan baris: sim_logging.experiment_with_sample_rates ()

Kesimpulan yang mungkin:

• Terlalu rendah kadar persampelan sangat buruk.
• Kadar tinggi selalunya lebih baik.

(Python 3.6 Code di pautan GitHub di bawah pada arahan, 2.7)

Langkah 5: Eksperimen: Menunjukkan Bunyi

Dalam eksperimen ini, kami mengekalkan isyarat yang sama, menggunakan kadar sampel sederhana, dan ada jumlah bunyi yang berbeza (noise_amp =.0,.1, 1.0.) Jalankan dengan: sim_logging.experiment_showing_noise (). Keluarannya adalah satu graf dengan 3 baris.

Kemungkinan Kesimpulan:

Kebisingan menjadikannya sukar untuk melihat isyarat, mengurangkannya jika anda boleh

Kodnya:

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

def experiment_showing_noise (self): print "" "Eksperimen menunjukkan kebisingan Melihat jumlah bunyi yang berbeza dengan mengubah amplitud bunyi." "" self.start_plot (plot_title = "Eksperimen Menunjukkan Bunyi") self.add_sensor_data (name = "noise = 0.0 ", amplitudo = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" noise = 0.1 ", amplitudo = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name = "noise = 1.0", amplitudo = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Langkah 6: Eksperimen: Kurangkan Bunyi Dengan Purata Pergerakan

Purata bergerak (misalnya dengan panjang 8) mengambil 8 ukuran terakhir dan mengira rata-rata. Sekiranya kebisingan secara rawak, kami harap suaranya hampir mendekati 0. Jalankan eksperimen dengan: sim_logging.experiment_showing_noise (). Keluarkan satu graf.

Kesimpulan yang Mungkin:

• Purata bergerak menghilangkan banyak bunyi
• Semakin lama purata bergerak, semakin banyak pengurangan bunyi
• Purata bergerak yang lebih lama dapat mengurangkan dan memutarbelitkan isyarat

Kodnya:

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

def experiment_with_moving_average (self): print "" "Eksperimen dengan MovingAverage Melihat MovingAverage yang berbeza dengan mengubah panjang. Semua mempunyai bunyi yang sama." "# ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No Moving Average") diri.add_sensor_data (name = "ave len = 0", amplitudo = 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", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (name = "ave len = 32", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Langkah 7: Eksperimen: Purata Bergerak dan Kadar Sampel

Dalam eksperimen ini kami membandingkan isyarat mentah dengan bunyi bising dan 2 variasi berbeza untuk mengurangkan bunyi.

1. Kadar sampel sederhana dan purata berjalan sederhana
2. Kadar sampel tinggi dan rata-rata jangka panjang yang tinggi

Jalankan dengan: sim_logging …… Output adalah satu graf. Saya rasa jelas bahawa # 2 melakukan pekerjaan yang lebih baik dalam mengurangkan kebisingan sehingga kita dapat menyimpulkan bahawa:

Kadar sampel yang tinggi dan rata-rata jangka panjang yang baik adalah baik

Tetapi anda harus ingat bahawa ada kos. # 2 memerlukan lebih banyak pemprosesan dan menghasilkan lebih banyak data yang akan disimpan. Kosnya mungkin atau tidak sepadan. Dalam eksperimen seterusnya, kami akan menambahkan pencetus, peranti untuk mengurangkan jumlah data yang disimpan.

Kodnya:

def experiment_with_moving_average_and_sample_rate (diri):

cetak "" "Eksperimen dengan Purata Bergerak dan Kadar Sampel, dt, rata-rata jangka yang berubah-ubah" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Purata Bergerak dan Kadar Sampel") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", amplitudo = 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 ", amplitudo = 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", amplitudo = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Langkah 8: Eksperimen: Log Dengan Pencetus

Dalam eksperimen ini, kami menambah pencetus. Pertama, apa yang saya maksudkan dengan pencetus? Pencetus adalah teknik di mana kita mengumpulkan data tetapi hanya menyimpannya setelah beberapa pemboleh ubah telah berubah dengan jumlah yang besar. Dalam eksperimen ini saya meletakkan pemboleh ubah pada pemboleh ubah masa (paksi x). Dengan menggunakan pencetus, saya dapat mengambil jumlah data yang tinggi dari persampelan cepat dan mengurangkannya menjadi jumlah data yang lebih munasabah. Keistimewaannya berguna dengan kadar sampel yang tinggi dan rata-rata jangka panjang.

Saya telah mengambil baris # 2 dari percubaan terakhir yang "baik" sebagai tambahan pencetus. Jalankan dengan: sim_logging …… Output adalah satu graf, garis x.

Apa yang berlaku? Kami mendapat plot "baik" dengan jumlah data yang berpatutan (sama dengan # 1). Terdapat beberapa kos dalam pemprosesan yang lebih tinggi. Secara keseluruhan, bagaimanapun, hasilnya hampir sama dengan # 1 kadar sampel yang lebih rendah dengan penapisan yang lebih sedikit. Anda mungkin membuat kesimpulan:

• Rata-rata jangka masa panjang dengan pemicu dapat memberikan pengurangan kebisingan yang baik dengan jumlah data yang berpatutan.
• Pemprosesan tambahan mungkin tidak memberikan hasil yang jauh lebih baik dan memerlukan kos.

Kodnya:

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

def experiment_with_trigger (self): print "" "Eksperimen dengan Triggering, dt, run rata dan mencetuskan semua yang bervariasi" "" # ----------------------- ------------------------- self.start_plot (plot_title = "Trigger 1/1 - Triggering On") self.add_sensor_data (name = "dt =.1 ra = 10, trig = 0 ", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (nama =" dt =.01 ra = 100, trig =.1 ", amplitudo = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Langkah 9: Eksperimen: Log Dengan Pencetus - Suara Lebih Keras

Mari kita lakukan eksperimen yang sama dengan langkah terakhir dan meningkatkan kebisingan. Jalankan dengan: sim_logging …… Output adalah satu graf, 2 baris.

Kini pemprosesan tambahan kelihatan lebih bernilai. Kesimpulan yang munasabah di sini ialah:

Memilih jumlah dan jenis pemprosesan untuk pengurangan kebisingan bergantung pada isyarat dan kebisingan anda

Kodnya:

def experiment_with_trigger_louder_noise (diri):

cetak "" "Bunyi yang lebih kuat daripada percubaan sebelumnya" "" self.start_plot (plot_title = "Satu Eksperimen dengan Pencetus-Kebisingan yang Lebih Besar") self.add_sensor_data (nama = "… dt =.1 ra = 10", amplitudo = 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", amplitudo = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

Langkah 10: Buat Eksperimen Anda Sendiri

Pada ketika ini saya harap anda dapat melihat bahawa teknik-teknik dalam instruksional ini dapat berguna dalam log data, tetapi mereka juga harus digunakan dengan sedikit pemikiran. Mengeksperimen dengan mereka dapat membantu proses itu.

Beberapa komen mengenai eksperimen dan perkara yang mungkin anda perhatikan:

• Gelombang sinus bukan satu-satunya jenis isyarat yang menarik, cuba yang lain, gelombang atau tanjakan lain atau…..
• Saya menggunakan taburan biasa untuk bunyi bising, terdapat banyak jenis bunyi; anda harus mempertimbangkan orang lain
• Purata berjalan adalah kaedah yang mudah, tetapi bukan satu-satunya kaedah untuk melihat kebisingan

Catatan: mencatatkan gambar dari Wikipedia.

Langkah 11: Menggunakan Teknik dalam Perisian Pembalakan Anda

Kod saya berorientasikan objek dan pemprosesan untuk menjalankan rata-rata dan pencetus hanya dapat disalin ke persekitaran Python anda dan kemudian digunakan. Objeknya adalah:

• DataTrigger dalam data_trigger.py
• MovingAverage dalam move_average.py

Objek utama saya LoggingSim dalam simulate_logging.py harus memberi anda contoh yang baik tentang cara menggunakannya. Sekiranya anda menggunakan bahasa lain, anda boleh membaca kod saya dan menerapkannya dalam bahasa anda.

Kod ini dapat memberikan projek anda pembalakan data yang lebih baik, cubalah.

Grafik di atas adalah dari Graph Your Solar Power oleh russ_hensel yang menggunakan objek rata-rata yang sama.