Thử nghiệm trong ghi dữ liệu nâng cao (Sử dụng Python): 11 bước

2024 Tác giả: John Day | [email protected]. Sửa đổi lần cuối: 2024-01-30 13:31

Có rất nhiều tài liệu hướng dẫn ghi dữ liệu, vì vậy khi tôi muốn xây dựng một dự án ghi nhật ký của riêng mình, tôi đã xem xét rất nhiều thứ. Một số thì tốt, một số thì không quá nhiều, vì vậy tôi quyết định lấy một số ý tưởng hay hơn và làm ứng dụng của riêng mình. Điều này dẫn đến một dự án vừa cao cấp hơn vừa phức tạp hơn tôi mong đợi lúc đầu. Một phần của nó đã trở thành một loạt các thí nghiệm trong việc xử lý dữ liệu cảm biến. Hướng dẫn này cho phép bạn thử các thử nghiệm tương tự hoặc tương tự.

(Bạn có thể xem tất cả mã và tải xuống tại: Mã tại GitHub Bạn có thể vào xem, có lẽ trong một cửa sổ khác, chỉ với 2 cú nhấp chuột)

Thông thường, việc ghi dữ liệu bao gồm những điều sau:

• Thu thập dữ liệu: Đọc một số dữ liệu từ cảm biến. Thường thì đây chỉ là đọc một bộ chuyển đổi tương tự sang kỹ thuật số (ADC) trên một thiết bị như Arduino.
• Xử lý dữ liệu: Khi đọc một giá trị ADC, đầu ra của bộ chuyển đổi thông thường cần được điều chỉnh tỷ lệ đến đúng đơn vị. Cũng có thể cần phải thực hiện một số điều chỉnh để hiệu chỉnh các giá trị để sửa lỗi cảm biến.
• Lọc: Dữ liệu thường chứa một số nhiễu, điều này có thể được lọc để bạn đang tìm kiếm tín hiệu trong dữ liệu của mình chứ không phải nhiễu.
• Lưu trữ dữ liệu: Dữ liệu được lưu, có thể vào tệp văn bản, có thể vào đám mây. Dữ liệu sẽ tồn tại ngay cả khi mất điện. Việc lưu quá nhiều dữ liệu rất dễ xảy ra, chúng ta có một mẹo nhỏ để giảm dung lượng lưu trữ dữ liệu.
• Hiển thị dữ liệu: Các phương pháp để xem dữ liệu của bạn, không thực sự ghi dữ liệu, nhưng nếu bạn không thực hiện một số loại hiển thị dữ liệu tại sao lại thu thập dữ liệu?
• Truy cập từ xa: Không cần thiết nhưng rất vui nếu có.

Hầu hết các hướng dẫn bao gồm một số nhưng không phải tất cả những điều trên, hoặc thực hiện chúng theo một cách rất đơn giản. Tài liệu hướng dẫn này sẽ giải quyết 2 trong số các vấn đề ghi nhật ký thường bị bỏ qua và như một phần thưởng cung cấp cho bạn phương tiện vẽ đồ thị dữ liệu của mình mà không cần sử dụng dịch vụ đám mây. Bạn có thể sử dụng toàn bộ hoặc tách ra từng mảnh và ghép chúng lại thành một dự án của riêng bạn.

Bước 1: Công cụ và vật liệu

Ví dụ này hoàn toàn bằng Python nên nó sẽ chạy trên và các thành phần có thể được sử dụng trên hầu hết mọi hệ điều hành bao gồm Mac, PC, Linux và Raspberry Pi.

Vì vậy, để sử dụng có hướng dẫn này, tất cả những gì bạn cần là một môi trường Python 3.6 đang chạy và tải xuống mã đính kèm. Sau khi chạy mã mà tôi đã thiết lập, bạn có thể sửa đổi mã cho các thử nghiệm của riêng mình. Như thường lệ với Python, bạn có thể cần thêm một số gói / mô-đun để mọi thứ hoạt động. Môi trường Spyder của tôi đi kèm với khá nhiều phần bắt buộc tại chỗ (xem: Dạng xem có thể hướng dẫn bằng biểu đồ với Python Screen Scraping). Khi bạn chạy lần đầu tiên, hãy để ý bất kỳ thông báo lỗi nào, chúng sẽ cho bạn biết về bất kỳ bộ phận nào bị thiếu trong môi trường của bạn.

Hai bước tiếp theo sẽ cho bạn biết cách xây dựng và chạy một thử nghiệm của riêng bạn, nhưng có lẽ tốt hơn là bạn nên đợi cho đến khi bạn chạy các thử nghiệm được bao gồm trước khi thử của riêng mình.

Để hiểu mã, bạn sẽ cần có một chút kinh nghiệm với Python hướng đối tượng, giải thích rằng điều đó nằm ngoài phạm vi của hướng dẫn này, nhưng Google sẽ cung cấp cho bạn bất kỳ trợ giúp nào mà bạn có thể cần.

Lưu ý mã: (Mã tại GitHub Bạn có thể xem, có lẽ trong một cửa sổ khác, chỉ với 2 cú nhấp chuột) hiện đang ở Python 3.6, vì vậy tốt nhất nên có 3.6. Phiên bản cũ hơn của mã ở đây trong các liên kết bên dưới.

Bước 2: Xây dựng thử nghiệm

Có ba bước lập trình (và các dòng) trong việc xây dựng một thử nghiệm. Mỗi thử nghiệm là một hàm trong đối tượng LoggingSim trong tệp simulate_logging.py. Hãy xem thử nghiệm 1 (chỉ là biểu đồ đầu tiên) mà chúng ta sẽ chạy trong bước tiếp theo:

def Experiment_with_sample_rates (self):

print "" "Thử nghiệm với Tỷ lệ Mẫu Xem xét các tỷ lệ mẫu khác nhau bằng cách thay đổi delta T" "" self.start_plot (plot_title = "Tỷ lệ Mẫu - Phần 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", biên độ = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Mỗi thử nghiệm được viết dưới dạng chức năng riêng của nó nên chúng ta có một dòng xác định chức năng (thử nghiệm def…..)

Dòng tiếp theo, không phải chú thích, (start_plot (….) Tạo đối tượng cho thử nghiệm và đặt tên cho nó.

Dòng tiếp theo, không phải dòng chú thích, (add_sensor_data (…) được chia thành nhiều dòng. Nó mô phỏng một cảm biến đo tín hiệu có khả năng bị nhiễu và một số quá trình xử lý. Các đối số của hàm như sau:

• name: tên được đặt trên biểu đồ cuối cùng để xác định dữ liệu
• biên độ: tín hiệu lớn như thế nào, chúng ta sẽ luôn sử dụng biên độ là 1. trong hướng dẫn này.
• noise_amp: tiếng ồn lớn như thế nào, 0. là tiếng ồn không, chúng ta sẽ bắt đầu ở đây.
• delta_t: thời gian giữa các lần đo, kiểm soát tốc độ mẫu.
• max_t: thời gian tối đa chúng tôi thu thập dữ liệu, chúng tôi sẽ luôn sử dụng 10 trong hướng dẫn này.
• run_ave: xử lý bằng cách sử dụng mức trung bình đang chạy, 0 có nghĩa là không xử lý.
• trigger_value: xử lý bằng cách sử dụng kích hoạt, 0 nghĩa là không xử lý

dòng cuối cùng, không phải chú thích, (self.show_plot ……) hiển thị biểu đồ.

Để làm cho mọi thứ phức tạp hơn một chút, bạn có thể có nhiều đường trên một biểu đồ hoặc nhiều biểu đồ trong một thử nghiệm, điều này sẽ rõ ràng với các thử nghiệm tiếp theo.

Bước 3: Chạy thử nghiệm

Đây là mã để chạy thử nghiệm. Như phổ biến trong Python, nó được đặt ở cuối tệp.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Đây chỉ là 2 dòng:

• Tạo trình mô phỏng ghi nhật ký (LoggingSim ())
• Chạy nó (sim_logging.experiment_with_sample_rates ())

Trong đoạn mã đã tải xuống, tôi có thêm một vài dòng và nhận xét, có thể dễ dàng tìm ra.

Bước 4: Thử nghiệm: Tỷ lệ mẫu

Trình mô phỏng, như được thiết lập ở đây, luôn tạo ra một sóng sin mịn đẹp có biên độ 1. Đối với thí nghiệm này, chúng tôi sẽ làm rối với tốc độ mẫu, như được điều chỉnh bởi delta_t, chênh lệch thời gian giữa các mẫu. Chúng tôi sẽ không có tiếng ồn hoặc xử lý khác. Mã sử dụng 3 tỷ lệ mẫu (delta_t = 1,0, 0,1 và 0,01.) Vì các biểu đồ nằm chồng lên nhau, thử nghiệm được thiết lập để tạo ra 3 biểu đồ khác nhau. Các biểu đồ kết quả là hình ảnh cho bước này.

def Experiment_with_sample_rates (self):

print "" "Thử nghiệm với Tỷ lệ mẫu Xem xét các tốc độ mẫu khác nhau bằng cách thay đổi delta T" "" self.start_plot (plot_title = "Tỷ lệ mẫu thử nghiệm 1/3: Delta T = 1,0") self.add_sensor_data (name = "dt = 1. ", biên độ = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Tỷ lệ mẫu thử nghiệm 2/3: Delta T = 0,1 ") self.add_sensor_data (name =" dt = 1 ", biên độ = 1, noise_amp =.0, delta_t = 0,1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ bản thân.start_plot (plot_title = "Tỷ lệ mẫu thử nghiệm 3/3: Delta T = 0,01") self.add_sensor_data (name = "dt = 1.", biên độ = 1, nhiễu_amp =.0, delta_t = 0,01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Để chạy nó, hãy sử dụng dòng: sim_logging.experiment_with_sample_rates ()

Kết luận có thể:

• Tỷ lệ lấy mẫu quá thấp thực sự không tốt.
• Tỷ lệ cao thường tốt hơn.

(Mã Python 3.6 tại liên kết GitHub bên dưới tại hướng dẫn, 2.7)

Bước 5: Thử nghiệm: Hiển thị tiếng ồn

Trong thử nghiệm này, chúng tôi giữ cùng một tín hiệu, sử dụng tỷ lệ mẫu trung bình và có lượng nhiễu khác nhau (noise_amp =.0,.1, 1.0.) Chạy nó với: sim_logging.experiment_showing_noise (). Đầu ra là một đồ thị có 3 dòng.

Kết luận có thể xảy ra:

Tiếng ồn khiến bạn khó nhìn thấy tín hiệu, hãy giảm bớt nó nếu bạn có thể

Mật mã:

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

def Experiment_showing_noise (self): print "" "Thử nghiệm hiển thị tiếng ồn Xem các lượng tiếng ồn khác nhau bằng cách thay đổi biên độ tiếng ồn." "" self.start_plot (plot_title = "Thử nghiệm hiển thị tiếng ồn") self.add_sensor_data (name = "noise = 0.0 ", biên độ = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" noise = 0.1 ", biên độ = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name = "noise = 1.0", biên độ = 1, noise_amp = 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Bước 6: Thử nghiệm: Giảm tiếng ồn bằng đường trung bình động

Một đường trung bình động (ví dụ với độ dài 8) lấy 8 phép đo cuối cùng và tính trung bình của chúng. Nếu tiếng ồn là ngẫu nhiên, chúng tôi hy vọng nó sẽ trung bình gần bằng 0. Chạy thử nghiệm với: sim_logging.experiment_showing_noise (). Đưa ra một biểu đồ.

Kết luận có thể có:

• Đường trung bình động loại bỏ nhiều tiếng ồn
• Đường trung bình động càng dài thì tiếng ồn càng giảm
• Đường trung bình động dài hơn có thể làm giảm và làm sai lệch tín hiệu

Mật mã:

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

def Experiment_with_moving_average (self): print "" "Thử nghiệm với MovingAverage Xem xét các Đường trung bình khác nhau bằng cách thay đổi độ dài. Tất cả đều có cùng một tiếng ồn." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No Moving Average") tự.add_sensor_data (name = "ave len = 0", biên độ = 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-Phần 2/2: Len 8 và 32") self.add_sensor_data (name = "ave len = 8", biên độ = 1, noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (name = "ave len = 32", biên độ = 1, noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Bước 7: Thử nghiệm: Trung bình động và Tỷ lệ mẫu

Trong thí nghiệm này, chúng tôi so sánh tín hiệu thô với nhiễu và 2 biến thể khác nhau về cách giảm nhiễu.

1. Tỷ lệ mẫu trung bình và trung bình chạy trung bình
2. Tỷ lệ mẫu cao và độ dài trung bình chạy cao

Chạy nó với: sim_logging …… Đầu ra là một đồ thị. Tôi nghĩ rõ ràng là # 2 làm tốt hơn công việc giảm tiếng ồn nên chúng tôi có thể kết luận rằng:

Tỷ lệ mẫu cao và trung bình chạy độ dài cao là tốt

Nhưng bạn phải ghi nhớ rằng có một khoản chi phí. # 2 cần xử lý nhiều hơn và dẫn đến nhiều dữ liệu được lưu hơn. Chi phí có thể có hoặc có thể không đáng giá. Trong thử nghiệm tiếp theo, chúng tôi sẽ thêm một trình kích hoạt, một thiết bị để giảm lượng dữ liệu được lưu trữ.

Mật mã:

def Experiment_with_moving_average_and_sample_rate (self):

print "" "Thử nghiệm với Đường trung bình Động và Tốc độ Mẫu, dt, mức trung bình chạy thay đổi" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Moving Average and Sample Rate") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", biên độ = 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 ", biên độ = 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", biên độ = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Bước 8: Thử nghiệm: Ghi nhật ký bằng trình kích hoạt

Trong thử nghiệm này, chúng tôi thêm một trình kích hoạt. Đầu tiên, ý tôi là gì về một trình kích hoạt? Trình kích hoạt là một kỹ thuật mà chúng tôi thu thập dữ liệu nhưng chỉ lưu dữ liệu đó sau khi một số biến đã thay đổi một lượng đáng kể. Trong những thử nghiệm này, tôi đặt một trình kích hoạt trên biến thời gian (trục x). Bằng cách sử dụng trình kích hoạt, tôi có thể lấy lượng lớn dữ liệu từ việc lấy mẫu nhanh và giảm nó xuống một lượng dữ liệu hợp lý hơn. Nó đặc biệt hữu ích với tỷ lệ mẫu cao và trung bình chạy dài.

Tôi đã lấy dòng số 2 từ thử nghiệm cuối cùng là "tốt" khi thêm một trình kích hoạt. Chạy nó với: sim_logging …… Đầu ra là một đồ thị, x dòng.

Điều gì xảy ra? Chúng tôi nhận được một âm mưu "tốt" với một lượng dữ liệu hợp lý (giống như # 1). Đã có một số chi phí trong quá trình xử lý cao hơn. Tuy nhiên, nhìn chung, kết quả giống với # 1 là tỷ lệ mẫu thấp hơn với ít lọc hơn. Bạn có thể kết luận:

• Thời gian hoạt động trung bình với kích hoạt có thể giảm nhiễu tốt với lượng dữ liệu hợp lý.
• Việc xử lý thêm có thể không mang lại kết quả tốt hơn nhiều và đi kèm với một chi phí.

Mật mã:

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

def Experiment_with_trigger (self): print "" "Thử nghiệm với Kích hoạt, dt, trung bình chạy và kích hoạt tất cả đều khác nhau" "" # ----------------------- ------------------------- self.start_plot (plot_title = "Kích hoạt 1/1 - Kích hoạt Bật") self.add_sensor_data (name = "dt =.1 ra = 10, trig = 0 ", biên độ = 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 ", biên độ = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Bước 9: Thử nghiệm: Ghi nhật ký bằng trình kích hoạt - Tiếng ồn lớn hơn

Hãy thực hiện thử nghiệm tương tự như bước cuối cùng và tăng độ ồn. Chạy nó với: sim_logging …… Đầu ra là một đồ thị, 2 dòng.

Bây giờ việc xử lý bổ sung trông có giá trị hơn trong khi. Một kết luận hợp lý ở đây có thể là:

Việc chọn số lượng và kiểu xử lý để giảm tiếng ồn phụ thuộc vào tín hiệu và tiếng ồn của bạn

Mật mã:

def Experiment_with_trigger_louder_noise (self):

print "" "Tiếng ồn lớn hơn so với thử nghiệm trước đó" "" self.start_plot (plot_title = "Một Thử nghiệm với Tiếng ồn Kích hoạt-To hơn") self.add_sensor_data (name = "… dt =.1 ra = 10", biên độ = 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", biên độ = 1, noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

Bước 10: Thực hiện thử nghiệm của riêng bạn

Tại thời điểm này, tôi hy vọng bạn thấy rằng các kỹ thuật trong hướng dẫn này có thể hữu ích trong việc ghi dữ liệu, nhưng chúng cũng phải được sử dụng với một số suy nghĩ. Thử nghiệm với chúng có thể giúp ích cho quá trình đó.

Một số nhận xét về các thử nghiệm và những điều bạn có thể xem xét:

• Sóng hình sin không phải là loại tín hiệu thú vị duy nhất, hãy thử những loại khác, sóng khác hoặc đường dốc hoặc…..
• Tôi đã sử dụng một phân phối chuẩn cho tiếng ồn, có rất nhiều loại tiếng ồn; bạn nên xem xét những người khác
• Trung bình chạy là một phương pháp đơn giản, nhưng không phải là phương pháp duy nhất để xem xét tiếng ồn

Lưu ý: ghi lại hình ảnh từ Wikipedia.

Bước 11: Sử dụng các kỹ thuật trong phần mềm ghi nhật ký của bạn

Mã của tôi là hướng đối tượng và quá trình xử lý trung bình đang chạy và trình kích hoạt chỉ có thể được sao chép vào môi trường Python của bạn và sau đó sử dụng. Các đối tượng là:

• DataTrigger trong data_trigger.py
• MovingAverage trong move_average.py

Đối tượng chính của tôi LoggingSim trong simulate_logging.py sẽ cung cấp cho bạn một ví dụ điển hình về cách sử dụng nó. Nếu bạn sử dụng ngôn ngữ khác, bạn có thể đọc mã của tôi và triển khai bằng ngôn ngữ của bạn.

Mã này có thể cung cấp cho dự án của bạn ghi dữ liệu tốt hơn, hãy thử nó.

Biểu đồ trên là từ Biểu đồ năng lượng mặt trời của bạn của russ_hensel, sử dụng cùng một đối tượng trung bình đang hoạt động.