სმენის ხტომა ჯეკი, Google Coral TPU ამაჩქარებელი ვერსია: 4 ნაბიჯი

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

ის ამოძრავებს კიდურებს, ის უსმენს თქვენს ბრძანებებს, მას ამოძრავებს მანქანათმცოდნეობის უახლესი ტექნოლოგია

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

სისტემის ძირითადი ელემენტია Google Coral TPU ამაჩქარებელი, რომელიც საშუალებას გაძლევთ გაუშვათ Tensorflow Lite მოდელები ხაზგარეშე ძალიან მაღალი სიჩქარით, თუნდაც "სუსტ" კომპიუტერზე, როგორც Raspberry Pi. ეს საშუალებას იძლევა მაგ. ობიექტების სწრაფი იდენტიფიკაცია და კლასიფიკაცია RPi კამერის გამოყენებით, არამედ ადგილობრივ მანქანათმცოდნეობაზე დაფუძნებული ხმის ამოცნობის ფუნქციების გაშვება.

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

ხმოვანი კონტროლი ემყარება მაგალითს "სმენის გველი" "პროექტის საკვანძო სიტყვების მზვერავი" (https://github.com/google-coral/project-keyword-spotter), რომელიც ახლახანს (2019 წლის სექტემბერი) განთავსდა GitHub– ზე. ჩემი კონფიგურაციით, სისტემა შედგება ჟოლოს Pi 4, რომელიც აღჭურვილია Adafruit 16 არხის სერვო კაპოტით, Google Coral TPU ამაჩქარებლით და ვებკამერით, რომელიც აქ გამოიყენება მიკროფონის სახით. Jumping Jack უკვე აღწერილი იყო წინა ინსტრუქციებში, სადაც ის ხმოვანი ბრძანებების წასაკითხად იყო Google Voice ნაკრები, მიმაგრებულია Servo Bonnet– ზე, ქვემოთ მოცემულ 2.0 ვერსიაში.

Google Voice Kit– ის წინა ვერსიას ჰქონდა სამი ცენტრალური შეზღუდვა: ეს იყო დამოკიდებული Google ვებ –ზე დაფუძნებული ხმის ამოცნობის სერვისებზე და კონფიგურაცია შედარებით რთული იყო, საჭირო იყო რაიმე სახის ღილაკის დაჭერა, სანამ ბრძანებას მისცემდით და იყო სერიოზული შეფერხება ბრძანების თქმასა და სისტემის პასუხს შორის. Google Coral ამაჩქარებლის გამოყენება ამცირებს რეაგირების დროს წამებში, დამოუკიდებელია ინტერნეტ კავშირისგან და უსმენს მუდმივად. ზოგიერთი მოდიფიკაციით თქვენ შეგიძლიათ გამოიყენოთ ის უფრო რთული მოწყობილობების გასაკონტროლებლად, როგორც Jumping Jack, როგორც რობოტები ან მანქანები, ან რისი აშენებაც და კონტროლი შეგიძლიათ Raspberry Pi– ით.

მის ამჟამინდელ ვერსიაში საკვანძო სიტყვა Spotter- ს ესმის 140 მოკლე საკვანძო სიტყვის/საკვანძო ფრაზის ერთობლიობა, განსაზღვრული თანმხლები მოდელის ფაილში ("voice_commands_v0.7_egetpu.tflite") და აღწერილია ცალკე ლეიბლის ფაილში ("labels_gc2.raw.txt") რა განისაზღვრება თავისუფლად მოდიფიცირებადი ფაილით (“commands_v2_hampelmann.txt”), ჩვენი სკრიპტის მიერ სპეციალურად გამოყენებული საკვანძო სიტყვები შემდეგ აისახება ვირტუალური კლავიატურის კლავიშებზე, მაგ. ასოებისთვის, ციფრებისთვის, ზემოთ/ქვემოთ/მარცხნივ/მარჯვნივ, crtl+c და სხვა.

შემდეგ, მაგ. pygame.key- ის გამოყენებით, ეს "კლავიშები" იკითხება და გამოიყენება იმის გასაკონტროლებლად, თუ რომელი ქმედებები უნდა შეასრულოს მოწყობილობამ, აქ - ხტუნვის ჯეკმა. ჩვენს შემთხვევაში, ეს ნიშნავს იმას, რომ ორი სერვისო გადავიყვანოთ წინასწარ განსაზღვრულ პოზიციებზე, ან LED- ები ჩართოთ ან გამორთოთ. როგორც საკვანძო სიტყვა spotter მუშაობს ცალკე tread, მას შეუძლია მუდმივად მოუსმინოს თქვენს ბრძანებებს.

ვერსია 2019 წლის 21 სექტემბერი

მარაგები

ჟოლო Pi 4, პიმორონის გავლით

Google Coral TPU ამაჩქარებელი, Mouser Germany– ს საშუალებით, 72 €

Adafruit 16 Servo Bonnet, პიმორონის გავლით, დაახლოებით 10 €

www.adafruit.com/product/3416

learn.adafruit.com/adafruit-16-channel-pwm…

სტეკერის სათაური (საჭიროების შემთხვევაში)

www.adafruit.com/product/2223

4x AA ბატარეის პაკეტი (ან სხვა 5-6V კვების წყარო) Servo Bonnet– ისთვის

ძველი ვებკამერა, როგორც მიკროფონი

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

Jumping Jack– ის საჭირო ნაწილები:

- 3 მმ ფორექსის ფირფიტა

- 2 მიკრო სერვისი

- 2 და 3 მმ ხრახნები და თხილი

- 2 თეთრი LED და რეზისტორი

- ცოტა კაბელი

ნაბიჯი 1: მოწყობილობის დაყენება

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

დააყენეთ თქვენი Raspberry Pi. Coral Github საიტზე არის Raspian სურათი, რომელიც შეიცავს ყველაფერს, რაც საჭიროა Pi- ზე Coral ამაჩქარებლის გასაშვებად და შეიცავს უამრავ პროექტს, ყველა პარამეტრი უკვე შექმნილია.

მიიღეთ პროექტის საკვანძო სიტყვა spotter Google Coral GitHub გვერდიდან. დააინსტალირეთ ყველა საჭირო პროგრამული უზრუნველყოფა, როგორც ეს მითითებულია.

დააინსტალირეთ მოწოდებული ფაილები. განათავსეთ jumping jack python სკრიპტი პროექტის საკვანძო სიტყვების spotter საქაღალდეში და შესაბამისი ბრძანებების ფაილი კონფიგურაციის ქვესაქაღალდეში.

მიამაგრეთ Adafruit Servo Bonnet Pi- ს. ვინაიდან მე ვიყენებ RPI კორპუსს გულშემატკივართან, მე დამჭირდა GPIO სტეკერების გამოყენება (მაგ. ხელმისაწვდომია პიმორონიდან) კავშირის გასააქტიურებლად. დააინსტალირეთ ყველა საჭირო ბიბლიოთეკა, როგორც ეს მითითებულია ადაფრუტის ინსტრუქციებში სერვო კაპოტისთვის.

მიამაგრეთ 5-6V დენის წყარო სერვო კაპოტზე. მიამაგრეთ სერვოები და LED- ები. მე ჩემს შემთხვევაში, მე გამოვიყენე პორტი 0 LED- ებისთვის და პორტები 11 და 15 სერვისებისთვის.

ყველაფრის შესამოწმებლად, მე გირჩევთ სცადოთ პროექტის საკვანძო სიტყვა spotter "გველის მოსმენა" მაგალითი და Adafruit servo bonnet მაგალითები.

ნაბიჯი 2: ხტუნვის ჯეკის გაშვება

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

"პოზიციის 0" -ის "პოზიციის 9" -ის შეძახილი იწვევს ხტუნვის ჯეკს, რომ დაიკავოს ერთ -ერთი წინასწარ განსაზღვრული პოზიცია. მე განვსაზღვრე "1" როგორც ორივე მკლავი ზემოთ (უუ), "3" როგორც მარცხნივ ზემოთ, მარჯვნივ ქვემოთ (უდ), "9" როგორც ორივე მკლავი ქვემოთ (დდ) და "5" როგორც ორივე მკლავი ცენტრში (სსკ).

uu uc ud = 1 2 3

cu cc cd = 4 5 6

du dc dd = 7 8 9

"0" იდენტურია "5" -ისა. "3" და "8" არ არის კარგად აღიარებული საკვანძო სიტყვის შემმოწმებლის მიერ და შეიძლება საჭირო გახდეს გამეორება.

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

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

"თამაშის შეწყვეტა" გამოიწვევს "ctrl + c" - ს და შეაჩერებს პროცესს.

"ჩართვა" და "გამორთვა" შეიძლება გამოყენებულ იქნას LED- ების ჩართვა და გამორთვა.

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

ნაბიჯი 3: კოდი და ბრძანებების ფაილი

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

შემდეგ დავამატე Adafruit Servo Bonnet– ისთვის საჭირო ნაწილები, მათი მაგალითი ფაილების საფუძველზე.

მინდა მადლობა გადავუხადო ორივე ნაწილის პროგრამისტებს.

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

# საავტორო უფლება 2019 Google LLC

# # ლიცენზირებულია Apache ლიცენზიით, ვერსია 2.0 ("ლიცენზია"); # თქვენ არ შეგიძლიათ გამოიყენოთ ეს ფაილი, გარდა ლიცენზიისა. # შეგიძლიათ მიიღოთ ლიცენზიის ასლი მისამართზე # # https://www.apache.org/licenses/LICENSE-2.0 # # თუ მოქმედი კანონმდებლობით არ არის მოთხოვნილი ან წერილობით შეთანხმებული, # ლიცენზიით განაწილებული პროგრამული უზრუნველყოფა ნაწილდება "როგორც არის" საფუძველი, # ყოველგვარი სახის გარანტიების ან პირობების გარეშე, გამოხატული ან ნაგულისხმევი. # იხილეთ ლიცენზია ლიცენზიით განსაზღვრული ნებართვებისა და # შეზღუდვების სპეციფიკური ენის შესახებ. _future_ იმპორტის აბსოლუტური_იმპორტი _futeure_ იმპორტის განყოფილება _futeure_ იმპორტი print_function იმპორტი argparse იმპორტი os შემთხვევითი იმპორტიდან randint საწყისი threading import თემა იმპორტის დრო edgetpu.basic.basic.engine adafruit_servokit იმპორტი ServoKit იმპორტი დაფა იმპორტი busio იმპორტი adafruit_pca9685 იმპორტი დრო i2c = busio. I2C (დაფა. SCL, დაფა. SDA) ქუდი = adafruit_pca9685. PCA9685 (i2c) ქუდი. სიხშირე = 60 ნაკრები = ServoKit (არხები = 16) # ნაკრები ნომერი არხების #kit.servo [0].actuation_range = 160 #kit.servo [0].set_pulse_width_range (1000, 2000) #up, mid and down პარამეტრები for left and right armers up_l = 35 md_l = 90 dn_l = 160 up_r = 160 მდ_რ = 90 დნ_რ = 35

lft = 15 # სერვო პორტის ნომერი, მარცხენა სერვო (0-8)

rgt = 11 # servo პორტის ნომერი, მარჯვენა servo (0-8) led_channel_0 = hat.channels [0] # LED კომპლექტი პორტზე 0 led_channel_0.duty_cycle = 0 # ჩართეთ LED 100% # ხელის პარამეტრების სია ცხრა პოზიციის პოზიციისთვის = [(md_l, md_r), (up_l, up_r), (up_l, md_r), (up_l, dn_r), (md_l, up_r), (md_l, md_r), (md_l, dn_r), (dn_l, up_r), (dn_l, md_r), (dn_l, dn_r)] # განსაზღვრავს 9 JumpingJack პოზიციას, რომელიც მითითებულია მთელი რიცხვებით 0-9 ცეკვა 1 = (0, 8, 7, 4, 1, 2, 3, 6, 9, 8, 5, 2, 1, 4, 7, 8, 9, 6, 3, 2, 0) # "ცეკვის" კლასი მაკონტროლებელი (ობიექტი): # უკან დაბრუნების ფუნქცია def _init _ (self, q): self._q = q def callback (self, ბრძანება): self._q.put (ბრძანება) კლასი აპლიკაცია: def _init _ (self): self._running = True def on_init (self): pygame.init () self.game_started = True self._running = True return True def on_event (თვით, მოვლენა): if event.type == pygame. QUIT: self._running = False def JumpingJack0 (self, keys): # კონტროლი Jumping Jack, საკვანძო სიტყვები: "position x" key = int (keys) p = position [გასაღები] a = p [0] b = p [1] ბეჭდვა ("პოზიცია:", გასაღები, "მარცხნივ /მარჯვნივ: ", a,"/", b," ხარისხი ") # sys.stdout.write (" პოზიცია: ", გასაღები," მარცხენა/მარჯვენა: ", a,"/", b," ხარისხი ") kit.servo [lft].angle = a kit.servo [rgt].angle = b time.sleep (0.1) def JumpingJack1 (self): # კონტროლი Jumping Jack ცეკვა, საკვანძო სიტყვა: "შემდეგი თამაში" dnce = dance1 sp = (len (dnce)) r დიაპაზონში (sp): პოზიციების # საცეკვაო რიგი, sp ნაბიჯები dc = dnce [r] თუ (dc არ არის დიაპაზონში (10)): # print ("შეყვანის შეცდომა პოზიციაში", sp) dc = 4 p = პოზიცია [dc] a = p [0] b = p [1] kit.servo [lft].angle = a kit.servo [rgt].angle = b დრო. ძილი (0.25) # ადგენს სიჩქარეს მოძრაობების def JumpingJack2 (თვითმმართველობის, გასაღებები): # კონტროლი Jumping Jack LED- ები, საკვანძო სიტყვები: "ჩართვა/გამორთვა" led = int (გასაღებები), თუ led == 1: led_channel_0.duty_cycle = 0xffff # LED ჩართვა 100% დრო. ძილი (0.1) თუ led == 0: led_channel_0.duty_cycle = 0 # გამორთეთ LED დრო. ძილი (0.1) თუ led == 2: # დახუჭეთ led_channel_0. მოვალეობა_ციკლი = 0xffff # ჩართეთ LED 100% დრო. ძილი (0.5) led_channel_0. მოვალეობა_ციკლი = 0 #LED- ის 100% -იანი დრო. ძილი (0.5) led_channel_0. მოვალეობა_ციკლი = 0xffff #ჩართეთ LED 100% დრო. ძილი (0.5) led_channel_0.duty_cycle = 0 #ჩართეთ LED 100% დრო. ძილი (0.5) led_channel_0.duty_cycle = 0xffff #ჩართეთ LED 100% დრო. ძილი (0.1) def JumpingJack3 (თვით): # კონტროლი Jumping ჯეკ ცეკვა, საკვანძო სიტყვა: "შემთხვევითი თამაში" # საათში დიაპაზონში (10): dr = randrange (9) p = პოზიცია [dr] a = p [0] b = p [1] kit.servo [lft].angle = kit.servo [rgt].angle = b დრო. ძილი (0.25) # ადგენს მოძრაობების სიჩქარეს def spotter (self, args): ძრავა = BasicEngine (args.model_file) მიკროფონი = args.mic თუ args.mic არ არის სხვა int (args.mic) model.classify_audio (მიკროფონი, ძრავა, labels_file = "config/labels_gc2.raw.txt", commands_file = "config/commands_v2_hampelmann.txt", dectection_callback = self._controler.callback, sample_rate_hz = int (args.sample_rate_hz), num_frames_hop = int (args.num_frames_hop))

def on_execute (self, args):

თუ არა self.on_init (): self._running = ყალბი q = model.get_queue () self._controler = მაკონტროლებელი (q) თუ არა args.debug_keyboard: t = თემა (target = self.spotter, args = (args,)) t.daemon = True t.start () item = -1 while self._running: pygame.event.pump () if args.debug_keyboard: keys = pygame.key.get_pressed () else: try: new_item = q.get (მართალია, 0.1) გარდა რიგისა. ცარიელი: new_item = არცერთი, თუ new_item არ არის არცერთი: item = new_item if (args.debug_keyboard and keys [pygame. K_ESCAPE]) ან item == "stop": self._running = False # if (args.debug_keyboard და გასაღებები [pygame. K_SPACE]) ან პუნქტი == "წადი": # self. JumpingJack0 (7) # if (args.debug_keyboard და გასაღებები [pygame. K_RIGHT]) ან პუნქტი == "მარჯვნივ": საკუთარი. JumpingJack0 (6) if (args.debug_keyboard and keys [pygame. K_LEFT]) or item == "left": self. JumpingJack0 (4) if (args.debug_keyboard and keys [pygame. K_UP]) or item == " up ": self. JumpingJack0 (1) if (args.debug_keyboard და გასაღებები [pygame. K_DOWN]) ან პუნქტი ==" ქვემოთ ": self. JumpingJack0 (9) if (args.debug_keyboard და გასაღებები [pygam e. K_0]) ან პუნქტი == "0": self. JumpingJack0 (0) if (args.debug_keyboard and keys [pygame. K_1]) or item == "1": self. JumpingJack0 (1) if (args debug_keyboard და გასაღებები [pygame. K_2]) ან პუნქტი == "2": self. JumpingJack0 (2) if (args.debug_keyboard and keys [pygame. K_3]) or item == "3": self. JumpingJack0 (3) თუ (args.debug_keyboard და გასაღებები [pygame. K_4]) ან პუნქტი == "4": self. JumpingJack0 (4) if (args.debug_keyboard და გასაღებები [pygame. K_5]) ან პუნქტი == "5": თვით. JumpingJack0 (5) if (args.debug_keyboard and keys [pygame. K_6]) or item == "6": self. JumpingJack0 (6) if (args.debug_keyboard and keys [pygame. K_7]) or item == "7 ": self. JumpingJack0 (7) if (args.debug_keyboard and keys [pygame. K_8]) or item ==" 8 ": self. JumpingJack0 (8) if (args.debug_keyboard and keys [pygame. K_9]) ან item == "9": self. JumpingJack0 (9) თუ (args.debug_keyboard და გასაღებები [pygame. K_a]) ან პუნქტი == "d": self. JumpingJack1 () #მოცეკვავე ჯეკი, "შემდეგი_თამაშზე" თუ (არგს. debug_keyboard და გასაღებები [pygame. K_j]) ან პუნქტი == "j": self. JumpingJack2 (0) #LED on, ON " switch_on "if (args.debug_keyboard and keys [pygame. K_k]) or item ==" k ": self. JumpingJack2 (1) #LED off, on" swithch off "if (args.debug_keyboard and keys [pygame. K_l]) ან პუნქტი == "ლ": self. JumpingJack2 (1) #LED დახუჭე "სამიზნე" თუ (args.debug_keyboard და გასაღებები [pygame. K_r]) ან პუნქტი == "r": self. JumpingJack3 () #შემთხვევითი ცეკვა "შემთხვევითი თამაში" time.sleep (0.05) self.on_cleanup () if _name_ == '_main_': parser = argparse. ArgumentParser () parser.add_argument ('-debug_keyboard', help = 'გამოიყენეთ კლავიატურა JumpingJack- ის გასაკონტროლებლად. ', action =' store_true ', default = false) model.add_model_flags (parser) args = parser.parse_args () the_app = App () the_app.on_execute (args)

ასევე არსებობს ბრძანების კონფიგურაციის ფაილი "commands_v2_hampelmann.txt". შეცვალეთ როგორც მოგწონთ. ეს მხოლოდ "ბრძანების, გასაღების, (სიძლიერის,") კომბინაციების ჩამონათვალია, ეტიკეტების ფაილზე დაყრდნობით.

position_zero, 0, პოზიცია_ერთი, 1, პოზიცია_ორი, 2, პოზიცია_ერთი, 3, პოზიცია_ოთხი, 4, პოზიცია_ხუთი, 5, პოზიცია_ექვსე, 6, პოზიცია_შვიდი, პოზიცია_7, პოზიციის_ამითი, 8, პოზიცია_ცხრა, 9, გადაადგილება_ ზემოთ, ზემოთ, წინ წასვლა, ზემოთ, გადატანა_ ქვემოთ, ქვემოთ, წასვლა_ ქვემოთ, ქვევით, გადაადგილება უკან, მარცხნივ, გადაადგილება წინ, მარჯვნივ, მიდის უკან, მარცხნივ, მიდის წინ, მარჯვნივ, 0.8 სამიზნეა, l, მუნჯი, z, დიახ, y, არა, n, switch_on, j, switch_off, k, volume_up, up, volume_down, down, შემდეგი_თამაში, დ, შემთხვევითი_თამაში, r, დაწყების_ თამაში, s, stop_game, ctrl+c,

ნაბიჯი 4: დამატებითი იდეები და სხვა მაგალითები

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

მე ვმუშაობ სკრიპტის გაგრძელებაზე MeArm– ის მართვის მიზნით და ვიმედოვნებ, რომ შევძლებ ამის წარმოდგენას 2019 წლის ოქტომბერში.

მე ასევე ვაპირებ გამოვიყენო Jumping Jack როგორც სემფორი და გამოვიყენო "project posenet" კიდურების პოზიციის ამოცნობის პროგრამა, როგორც ინსტრუმენტი Jumping Jack- ის პოზიციების წასაკითხად და მისი რიცხვზე თარგმნისთვის. ამ გზით მას შეუძლია ტექსტის კომუნიკაციაც კი, 2x 8 პოზიციის გათვალისწინებით შეიძლება მიუთითოს 64 განსხვავებული რიცხვი, რაც საკმარისზე მეტია ანბანის, რიცხვებისა და ნიშნებისთვის. ამან შეიძლება ოდნავ შეცვლილი გახადოს ფიზიკური რეალიზება შემოთავაზებული IETF- ისთვის "IP მონაცემთა მონაცემთა გადაცემა სემფორის დროშის სასიგნალო სისტემაზე (SFSS)" (https://tools.ietf.org/html/rfc4824).

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

მინდა თქვენი ყურადღება გავამახვილო შემდეგ სასწავლოზე: ობიექტის პოვნა-პერსონალური-დამხმარე-რობოტი-Ft-ჟოლო, სადაც აღწერილია ობიექტის პოვნა რობოტი Raspberry Pi და Google Coral TPU კომბინაციის გამოყენებით.