ექსპერიმენტები მონაცემთა მოწინავე ჩანაწერში (პითონის გამოყენებით): 11 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

არსებობს უამრავი მონაცემების აღწერის ინსტრუქცია, ასე რომ, როდესაც მინდოდა ხე -ტყის პროექტის შექმნა, მე თვალი გადავავლე თაიგულს. ზოგი კარგი იყო, ზოგი არც ისე ბევრი, ამიტომ გადავწყვიტე უკეთესი იდეების მიღება და საკუთარი განაცხადის გაკეთება. ამან გამოიწვია პროექტი უფრო მოწინავე და უფრო რთული, ვიდრე თავიდან ველოდი. მისი ერთი ნაწილი გახდა სენსორული მონაცემების დამუშავების ექსპერიმენტების სერია. ეს ინსტრუქცია საშუალებას გაძლევთ სცადოთ იგივე ან მსგავსი ექსპერიმენტები.

(თქვენ შეგიძლიათ ნახოთ ყველა კოდი და გადმოწეროთ აქ: კოდი GitHub– ში შეგიძლიათ ნახოთ, ალბათ სხვა ფანჯარაში, სულ რაღაც 2 დაწკაპუნებით)

როგორც წესი, მონაცემთა აღრიცხვა მოიცავს შემდეგს:

• მონაცემთა მოპოვება: წაიკითხეთ ზოგიერთი მონაცემი სენსორიდან. ხშირად ეს არის მხოლოდ ციფრული ციფრული გადამყვანის (ADC) წაკითხვა ისეთ მოწყობილობაზე, როგორიცაა Arduino.
• მონაცემთა დამუშავება: ADC მნიშვნელობის წაკითხვისას, ჩვეულებრივ, კონვერტორების გამომავალი უნდა იყოს სწორი ერთეულებით. ასევე შეიძლება საჭირო გახდეს გარკვეული კორექტირების გაკეთება ღირებულებების დაკალიბრების მიზნით სენსორის შეცდომების გამოსასწორებლად.
• გაფილტვრა: მონაცემები ჩვეულებრივ შეიცავს გარკვეულ ხმაურს, ის შეიძლება გაფილტრული იყოს, ასე რომ თქვენ ეძებთ სიგნალს თქვენს მონაცემებში და არა ხმაურს.
• მონაცემთა შენახვა: მონაცემები ინახება, შესაძლოა ტექსტურ ფაილში, შესაძლოა ღრუბელში. მონაცემები უნდა შენარჩუნდეს მაშინაც კი, თუ დენი გამორთულია. ძალიან ბევრი მონაცემის შენახვაა ადვილი, ჩვენ გვაქვს პატარა ხრიკი მონაცემთა შესანახი სივრცის შესამცირებლად.
• მონაცემების ჩვენება: მეთოდები, რათა შეხედოთ თქვენს მონაცემებს, არა მონაცემების აღრიცხვას, მაგრამ თუ მონაცემების რაიმე სახის ჩვენებას არ აკეთებთ, რატომ აგროვებთ მას?
• დისტანციური წვდომა: არ არის აუცილებელი, მაგრამ სასიამოვნოა.

ინსტრუქციის უმეტესობა მოიცავს ზოგიერთს, მაგრამ არა ყველა ზემოაღნიშნულს, ან აკეთებს მათ ძალიან მარტივად. ეს გაკვეთილი ეხება 2 ხშირად გამოტოვებულ პრობლემას და როგორც ბონუსი მოგცემთ საშუალებას აჩვენოთ თქვენი მონაცემები ღრუბლოვანი სერვისის გამოყენების გარეშე. თქვენ შეგიძლიათ გამოიყენოთ ყველაფერი ან ამოიღოთ ნაჭრები და გადააკეთოთ ისინი თქვენს პროექტში.

ნაბიჯი 1: ინსტრუმენტები და მასალები

ეს მაგალითი არის Python– ში, ასე რომ ის იმუშავებს და კომპონენტები შეიძლება გამოყენებულ იქნას თითქმის ყველა OS– ზე, მათ შორის Mac, PC, Linux და Raspberry Pi.

ამ ინსტრუქციის გამოსაყენებლად ყველაფერი რაც თქვენ გჭირდებათ არის გაშვებული Python 3.6 გარემო და ჩამოტვირთეთ თანდართული კოდი. მას შემდეგ რაც გაუშვებ ჩემს მიერ შექმნილ კოდს, შეგიძლია შეცვალო იგი საკუთარი ექსპერიმენტებისთვის. როგორც ჩვეულებრივ პითონში, შეიძლება დაგჭირდეთ რამდენიმე პაკეტის/მოდულის დამატება, რომ ყველაფერი იმუშაოს. ჩემი Spyder გარემოს გააჩნია თითქმის ყველა საჭირო ნაწილი ადგილზე (იხ.: გრაფიკული ინსტრუქციული ხედები პითონის ეკრანის სკრაპინგით). როდესაც პირველად გაუშვებთ უყურებთ შეცდომების შეტყობინებებს, ისინი გაცნობებთ თქვენს გარემოს დაკარგული ნაწილების შესახებ.

მომდევნო ორი ნაბიჯი გეტყვით, თუ როგორ უნდა ააწყოთ და ჩაატაროთ საკუთარი ექსპერიმენტი, მაგრამ ალბათ სჯობს დაელოდოთ სანამ ჩაატარებთ ექსპერიმენტებს, სანამ საკუთარ ცდას შეასრულებთ.

კოდის გასაგებად, თქვენ უნდა გქონდეთ გარკვეული გამოცდილება ობიექტზე ორიენტირებულ პითონთან, ახსენით, რომ ეს არ არის ამ ინსტრუქციის ფარგლებში, მაგრამ Google- მა უნდა მოგაწოდოთ ნებისმიერი დახმარება, რაც შეიძლება დაგჭირდეთ.

გაითვალისწინეთ კოდი: (კოდი GitHub– ში შეგიძლიათ ნახოთ, ალბათ სხვა ფანჯარაში, სულ რაღაც 2 დაწკაპუნებით) ახლა არის Python 3.6 – ში, ასე რომ 3.6 – ის ქონა საუკეთესო იქნებოდა. კოდის ძველი ვერსია მოცემულია ქვემოთ მოცემულ ბმულებში.

ნაბიჯი 2: ექსპერიმენტის შექმნა

ექსპერიმენტის შესაქმნელად სამი პროგრამირების ნაბიჯი (და ხაზი) არსებობს. თითოეული ექსპერიმენტი არის ფუნქცია LoggingSim ობიექტში ფაილში simulate_logging.py. მოდით შევხედოთ ექსპერიმენტს 1 (მხოლოდ პირველი გრაფიკი), რომელსაც ჩვენ განვახორციელებთ შემდეგ ეტაპზე:

def ექსპერიმენტი_ ნიმუშის_ფასებით (საკუთარი თავი):

ბეჭდვა "" "ექსპერიმენტი საცდელი ტარიფებით სხვადასხვა ნიმუშის მაჩვენებლების მიხედვით დელტა T- ს შეცვლით" "self.start_plot (plot_title =" ნიმუშის განაკვეთები - ნაწილი 1/3: დელტა T = 1.0 ") self.add_sensor_data (name =" dt = 1. ", ამპლიტუდა 1.

თითოეული ექსპერიმენტი იწერება როგორც საკუთარი ფუნქცია, ასე რომ ჩვენ გვაქვს ფუნქციის განმსაზღვრელი ხაზი (ექსპერიმენტი …)

შემდეგი, არაკომენტარული ხაზი, (start_plot (….) ქმნის ობიექტს ექსპერიმენტისთვის და აძლევს მას სახელს.

მომდევნო, არაკომენტარული ხაზის ხაზი, (add_sensor_data (…) იყოფა რამდენიმე ხაზად. ის ახდენს სიმულაციის სენსორის სიმულაციას პოტენციურად ხმაურით და გარკვეული დამუშავებით. ფუნქციის არგუმენტები შემდეგია:

• სახელი: სახელი, რომელიც მოცემულია საბოლოო გრაფაში მონაცემების იდენტიფიცირებისთვის
• ამპლიტუდა: რამდენად დიდია სიგნალი, ჩვენ ყოველთვის გამოვიყენებთ 1. ამპლიტუდას ამ სასწავლო ინსტრუქციაში.
• noise_amp: რამდენად დიდია ხმაური, 0. არ არის ხმაური, ჩვენ ვიწყებთ აქ.
• delta_t: გაზომვებს შორის დრო, აკონტროლებს შერჩევის მაჩვენებელს.
• max_t: მონაცემების შეგროვების მაქსიმალური დრო, ჩვენ ყოველთვის გამოვიყენებთ 10 -ს ამ ინსტრუქციაში.
• run_ave: დამუშავება საშუალო დონის გამოყენებით, 0 ნიშნავს დამუშავებას.
• trigger_value: დამუშავება ტრიგერის გამოყენებით, 0 ნიშნავს დამუშავებას

ბოლო, არაკომენტარული ხაზი, (self.show_plot ……) აჩვენებს გრაფიკს.

იმისათვის, რომ ყველაფერი ცოტათი გართულდეს, შეგიძლიათ გქონდეთ რამოდენიმე ხაზი გრაფიკზე ან რამდენიმე გრაფიკი ექსპერიმენტში, ეს გასაგები უნდა იყოს მომდევნო ექსპერიმენტებიდან.

ნაბიჯი 3: ექსპერიმენტის ჩატარება

ეს არის ექსპერიმენტის ჩატარების კოდი. როგორც ჩვეულებრივ პითონში, ის მოთავსებულია ფაილის ბოლოს.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

ეს მხოლოდ 2 სტრიქონია:

• შექმენით ხეების სიმულატორი (LoggingSim ())
• გაუშვით (sim_logging.experiment_with_sample_rates ())

გადმოწერილ კოდში მაქვს კიდევ რამდენიმე სტრიქონი და კომენტარი, ადვილი გასაგები უნდა იყოს.

ნაბიჯი 4: ექსპერიმენტი: საცდელი მაჩვენებელი

სიმულატორი, როგორც აქ არის დაყენებული, ყოველთვის გამოაქვს ამპლიტუდის სასიამოვნო გლუვი სინუსური ტალღა 1. ამ ექსპერიმენტისთვის ჩვენ შევაფერხებთ ნიმუშის სიჩქარეს, როგორც ეს არის მორგებული delta_t- ით, ნიმუშებს შორის დროის სხვაობას. ჩვენ არ გვექნება ხმაური და სხვა დამუშავება. კოდი იყენებს 3 ნიმუშის მაჩვენებელს (delta_t = 1.0, 0.1 და 0.01.) ვინაიდან გრაფიკები ერთმანეთზე დაეცემა, ექსპერიმენტი იქმნება 3 სხვადასხვა გრაფიკის შესაქმნელად. შედეგად მიღებული გრაფიკები არის სურათები ამ ნაბიჯისათვის.

def ექსპერიმენტი_ ნიმუშის_ფასებით (საკუთარი თავი):

ბეჭდვა "" "ექსპერიმენტი ნიმუშის ტარიფებთან სხვადასხვა ნიმუშის მაჩვენებლების მიხედვით დელტა T- ის შეცვლით" "self.start_plot (plot_title =" ექსპერიმენტის ნიმუშის განაკვეთები 1/3: დელტა T = 1.0 ") self.add_sensor_data (name =" dt = 1 " --------------------------------------- self.start_plot (plot_title = "ექსპერიმენტის ნიმუშის განაკვეთები 2/3: დელტა T = 0.1 ") self.add_sensor_data (name =" dt = 1. ", ამპლიტუდა = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ საკუთარი თავი.start_plot (plot_title = "ექსპერიმენტის ნიმუშის განაკვეთები 3/3: დელტა T = 0.01") self.add_sensor_data (სახელი = "dt = 1.", ამპლიტუდა = 1., ხმაური_ამყარი =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

მისი გასაშვებად გამოიყენეთ ხაზი: sim_logging.experiment_with_sample_rates ()

შესაძლო დასკვნები:

• შერჩევის ძალიან დაბალი მაჩვენებელი მართლაც ცუდია.
• მაღალი მაჩვენებლები ხშირად უკეთესია.

(პითონის 3.6 კოდი GitHub ბმულზე ქვემოთ ინსტრუქციებში, 2.7)

ნაბიჯი 5: ექსპერიმენტი: ხმაურის ჩვენება

ამ ექსპერიმენტში ჩვენ ვინახავთ ერთსა და იმავე სიგნალს, ვიყენებთ საშუალო შერჩევის მაჩვენებელს და გვაქვს სხვადასხვა რაოდენობის ხმაური (ხმაურის გამაძლიერებელი =.0,.1, 1.0.) გაუშვით: sim_logging.experiment_showing_noise (). გამომავალი არის ერთი გრაფიკი 3 ხაზით.

შესაძლო დასკვნა:

ხმაური ართულებს სიგნალის დანახვას, შეამცირეთ თუ შეიძლება

Კოდი:

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

def experiment_showing_noise (self): print "" "ხმაურის ჩვენების ექსპერიმენტი ხმაურის ამპლიტუდის შეცვლით ხმაურის სხვადასხვა რაოდენობის დათვალიერება." "self.start_plot (plot_title =" ექსპერიმენტი ხმაურის ჩვენებისას ") self.add_sensor_data (name =" ხმაური = 0.0 ", ამპლიტუდა = 1., ხმაურის გამა =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (სახელი =" ხმაური = 0.1 ", ამპლიტუდა = 1., ხმაურის amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (სახელი = "ხმაური = 1.0", ამპლიტუდა = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

ნაბიჯი 6: ექსპერიმენტი: შეამცირეთ ხმაური მოძრავი საშუალო საშუალებით

მოძრავი საშუალო (მაგალითად, სიგრძით 8) იღებს ბოლო 8 გაზომვას და ახდენს მათ საშუალო მაჩვენებელს. თუ ხმაური შემთხვევითია, ვიმედოვნებთ, რომ ის საშუალოდ 0 -მდე იქნება. ჩაატარეთ ექსპერიმენტი: sim_logging.experiment_showing_noise (). გამოუშვით ერთი გრაფიკი.

შესაძლო დასკვნები:

• მოძრავი საშუალო ნამდვილად აღმოფხვრის ხმაურის დიდ ნაწილს
• რაც უფრო გრძელია მოძრავი საშუალო, მით მეტია ხმაურის შემცირება
• უფრო ხანგრძლივმა მოძრავმა საშუალომ შეიძლება შეამციროს და დაამახინჯოს სიგნალი

Კოდი:

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

def ექსპერიმენტი_მოძრაობის_შუალებით (საკუთარი თავის): ბეჭდვა "" "ექსპერიმენტი MovingAverage- ით შეხედეთ სხვადასხვა MovingAverage- ს სიგრძის შეცვლით. ყველას ერთნაირი ხმაური აქვს." " # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No a 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 ()

ნაბიჯი 7: ექსპერიმენტი: საშუალო გადაადგილება და საცდელი მაჩვენებელი

ამ ექსპერიმენტში ჩვენ ვადარებთ უმი სიგნალს ხმაურთან და ხმაურის შემცირების 2 განსხვავებულ ვარიაციას.

1. საშუალო შერჩევის მაჩვენებელი და საშუალო გაშვებული საშუალო
2. შერჩევის მაღალი მაჩვენებელი და მაღალი სიგრძის საშუალო მაჩვენებელი

გაუშვით: sim_logging …… გამომავალი არის ერთი გრაფიკი. მე ვფიქრობ, რომ ნათელია, რომ #2 უკეთეს საქმეს აკეთებს ხმაურის შემცირებაში, ასე რომ, ჩვენ შეგვიძლია დავასკვნათ, რომ:

მაღალი ნიმუშის მაჩვენებელი და მაღალი სიგრძის საშუალო საშუალო კარგია

მაგრამ თქვენ უნდა გახსოვდეთ, რომ ფასი აქვს. #2 გაცილებით მეტ დამუშავებას მოითხოვს და შედეგად გაცილებით მეტი მონაცემის შენახვაა საჭირო. ღირებულება შეიძლება იყოს ან არ ღირს. შემდეგ ექსპერიმენტში ჩვენ დავამატებთ ტრიგერს, მოწყობილობას, რომელიც შეამცირებს შენახული მონაცემების რაოდენობას.

Კოდი:

def ექსპერიმენტი_ საშუალო_მოძრაობის_და_შეფასების (თვით):

ბეჭდვა "" "ექსპერიმენტი საშუალო მოძრავი და საცდელი მაჩვენებლით, dt, გაშვებული საშუალო ცვალებადია" " # ---------------------------- -------------------- self.start_plot (plot_title = "საშუალო მოძრავი და ნიმუშის მაჩვენებელი") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", ამპლიტუდა = 1., ხმაურის გამაძლიერებელი =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (სახელი =" dt =.1 ra = 10 trig = 0 ", ამპლიტუდა = 1., ხმაურის_ამპირი =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (სახელი = "dt =.01 ra = 100 trig = 0", ამპლიტუდა = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

ნაბიჯი 8: ექსპერიმენტი: იმოძრავეთ ტრიგერით

ამ ექსპერიმენტში ჩვენ ვამატებთ ტრიგერს. პირველი, რას ვგულისხმობ გამომწვევში? ტრიგერი არის ტექნიკა, როდესაც ჩვენ ვაგროვებთ მონაცემებს, მაგრამ ვინახავთ მას მხოლოდ მას შემდეგ, რაც ცვლადი შეიცვლება მნიშვნელოვანი რაოდენობით. ამ ექსპერიმენტებში მე ჩავრთე დროის (x ღერძის) ცვლადი. ტრიგერის გამოყენებით შემიძლია ავიღო მონაცემთა დიდი რაოდენობა სწრაფი შერჩევიდან და შევამცირო ის უფრო გონივრულ ოდენობამდე. ეს განსაკუთრებით სასარგებლოა შერჩევის მაღალი მაჩვენებლებით და საშუალო ხანგრძლივობით.

მე ავიღე #2 ხაზი ბოლო ექსპერიმენტიდან, რომელიც "კარგი" იყო და დამატებული გამომწვევი. გაუშვით: sim_logging …… გამომავალი არის ერთი გრაფიკი, x ხაზები.

Რა მოხდა? ჩვენ ვიღებთ "კარგ" ნაკვეთს გონივრული რაოდენობით მონაცემებით (იგივე #1). უფრო მაღალი დამუშავების ხარჯები იყო. საერთო ჯამში, შედეგები დაახლოებით იგივეა, რაც #1 დაბალი ნიმუშის მაჩვენებელი ნაკლები ფილტრაციით. თქვენ შეგიძლიათ დაასკვნათ:

• გაშვების საშუალო ხანგრძლივობამ შეიძლება გამოიწვიოს ხმაურის კარგი შემცირება მონაცემთა გონივრული რაოდენობით.
• დამატებითმა დამუშავებამ შეიძლება არ მისცეს ბევრად უკეთესი შედეგი და გააჩნია ფასი.

Კოდი:

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

def experim_w_trigger (self): ამობეჭდვა "" "ექსპერიმენტი გააქტიურებით, dt, გაუშვით საშუალო და გამოიწვიეთ ყველა განსხვავებული" "" # ----------------------- ------------------------- self.start_plot (plot_title = "გააქტიურება 1/1-ჩართვა") self.add_sensor_data (name = "dt =.1 ra = 10, trig = 0 ", ამპლიტუდა = 1., ხმაურის გამაძლიერებელი =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) თვითმმართველობის ra = 100, trig =.1 ", ამპლიტუდა = 1., ხმაურის გამაძლიერებელი =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

ნაბიჯი 9: ექსპერიმენტი: ტრიგერით დარეგისტრირება - უფრო მაღალი ხმაური

მოდით გავიაროთ იგივე ექსპერიმენტი, როგორც ბოლო ნაბიჯი და გავაძლიეროთ ხმაური. გაუშვით: sim_logging …… გამომავალი არის ერთი გრაფიკი, 2 ხაზი.

ახლა დამატებითი დამუშავება უფრო ღირსეულად გამოიყურება. აქ გონივრული დასკვნა შეიძლება იყოს:

ხმაურის შემცირების დამუშავების მოცულობისა და ტიპის არჩევა დამოკიდებულია თქვენს სიგნალზე და ხმაურზე

Კოდი:

def ექსპერიმენტი_ტრიგერის_ ხმამაღალი_ ხმაურით (საკუთარი თავის):

print "" "უფრო დიდი ხმაური ვიდრე წინა ექსპერიმენტი" "self.start_plot (plot_title =" ექსპერიმენტი გამომწვევ-ხმამაღალი ხმაურით ") self.add_sensor_data (name ="… dt =.1 ra = 10 ", ამპლიტუდა = 1., ხმაურის_ამპირი =.5, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (name = "..dt =.01 ra = 100 tv =.1", ამპლიტუდა = 1., ხმაურის ამპე =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

ნაბიჯი 10: გააკეთეთ საკუთარი ექსპერიმენტები

ამ მომენტში, ვიმედოვნებ, რომ ხედავთ, რომ ამ ინსტრუქციის ტექნიკა შეიძლება სასარგებლო იყოს მონაცემთა აღრიცხვისთვის, მაგრამ რომ ისინი ასევე უნდა იქნას გამოყენებული გააზრებული. მათთან ექსპერიმენტმა შეიძლება ხელი შეუწყოს ამ პროცესს.

რამოდენიმე შენიშვნა ექსპერიმენტებზე და საკითხებზე, რომელთა შესწავლაც შეიძლება:

• სინუსური ტალღები არ არის ერთადერთი საინტერესო სიგნალის ტიპი, სცადეთ სხვა, სხვა ტალღები ან პანდუსები ან…..
• ხმაურის ნორმალური განაწილება გამოვიყენე, ამდენი სახის ხმაურია; თქვენ უნდა გაითვალისწინოთ სხვები
• საშუალო გაშვება არის მარტივი, მაგრამ არა ერთადერთი მეთოდი ხმაურის დასათვალიერებლად

შენიშვნა: შეიყვანეთ სურათები ვიკიპედიიდან.

ნაბიჯი 11: ტექნიკის გამოყენება თქვენი პროგრამული უზრუნველყოფის სისტემაში

ჩემი კოდი არის ობიექტზე ორიენტირებული და დამუშავების საშუალო და გამომწვევი შეიძლება უბრალოდ კოპირდეს თქვენს პითონის გარემოში და შემდეგ გამოიყენოთ. ობიექტებია:

• DataTrigger data_trigger.py- ში
• MovingAverage მოძრავი_ საშუალო. Py

ჩემი მთავარი ობიექტი LoggingSim in simulate_logging.py უნდა მოგაწოდოთ კარგი მაგალითი იმისა, თუ როგორ გამოიყენოთ იგი. თუ იყენებთ სხვა ენას, შეგიძლიათ წაიკითხოთ ჩემი კოდი და განახორციელოთ თქვენს ენაზე.

ამ კოდს შეუძლია თქვენს პროექტს მისცეს მონაცემების უკეთესი ჩანაწერი, სცადეთ.

ზემოთ მოყვანილი გრაფიკი არის თქვენი მზის ენერგიის გრაფიკიდან russ_hensel, რომელიც იყენებს იმავე საშუალო გაშვებული ობიექტს.