Słuchowy skok do skakania, akcelerator Google Coral TPU Accelerator: 4 kroki

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:29

Porusza kończynami, słucha Twoich rozkazów, napędza ją najnowsza technologia uczenia maszynowego

„Hearing Jumping Jack” to prosty elektromechaniczny podnośnik, napędzany dwoma mikroserwami i bardzo prostą przekładnią z diodami LED jako „oczkami”. Jest sterowany za pomocą prostych poleceń głosowych, wskazujących, którą z dziewięciu predefiniowanych pozycji ma zająć, czy dioda LED powinna się włączyć, czy wyłączyć, lub czy ma wykonać określony „taniec” lub losowy zestaw ruchów.

Sercem systemu jest akcelerator Google Coral TPU, który pozwala na uruchamianie modeli Tensorflow Lite offline z bardzo dużą prędkością, nawet na „słabym” komputerze, jakim jest Raspberry Pi. Pozwala to m.in. szybka identyfikacja i klasyfikacja obiektów za pomocą kamery RPi, ale także lokalne uruchamianie funkcji rozpoznawania głosu opartych na uczeniu maszynowym.

Według mojej wiedzy jest to pierwszy opublikowany przykład fizycznego urządzenia do majsterkowania opartego na wykrywaniu głosu Coral Accelerator, a załączony przykład kodu może być również wykorzystany do innych, bardziej złożonych projektów.

Sterowanie głosowe oparte jest na przykładzie „węża słuchowego” w „project Keyword spotter” (https://github.com/google-coral/project-keyword-spotter), który niedawno (wrzesień 2019) został umieszczony na GitHub. W mojej konfiguracji system składa się z Raspberry Pi 4 wyposażonego w 16-kanałową maskę serwomechanizmu Adafruit, akcelerator Google Coral TPU Accelerator i kamerę internetową, tutaj używaną jako mikrofon. Jumping Jack został opisany wcześniej w poprzedniej instrukcji, w której był napędzany przez zestaw Google Voice do odczytywania poleceń głosowych, jest dołączony do Servo Bonnet w wersji 2.0 opisanej poniżej.

Poprzednia wersja Google Voice Kit miała trzy główne ograniczenia: była zależna od internetowych usług rozpoznawania głosu Google, a konfiguracja była stosunkowo skomplikowana, wymagało naciśnięcia jakiegoś przycisku przed wydaniem polecenia i wystąpiło poważne opóźnienie między wypowiedzeniem polecenia a reakcją systemu. Korzystanie z akceleratora Google Coral skraca czas odpowiedzi do sekund, jest niezależne od połączenia internetowego i cały czas nasłuchuje. Z pewnymi modyfikacjami możesz go używać do sterowania urządzeniami o wiele bardziej złożonymi, takimi jak Jumping Jack, roboty lub samochody, lub cokolwiek, co możesz zbudować i kontrolować za pomocą Raspberry Pi.

W obecnej wersji Keyword Spotter rozumie zestaw około 140 krótkich słów kluczowych/fraz kluczowych, zdefiniowanych w załączonym pliku modelu („voice_commands_v0.7_egetpu.tflite”) i opisanych w osobnym pliku etykiety („labels_gc2.raw.txt”). Zdefiniowane przez dowolnie modyfikowalny plik („commands_v2_hampelmann.txt”), słowa kluczowe używane specjalnie przez nasz skrypt są następnie mapowane na naciśnięcia klawiszy na wirtualnej klawiaturze, np. dla liter, cyfr, góra/dół/lewo/prawo, crtl+c, i tak dalej.

Wtedy m.in. za pomocą pygame.key te „naciśnięcia klawiszy” są odczytywane i używane do kontrolowania, jakie czynności ma wykonywać urządzenie, w tym przypadku skaczący jack. W naszym przypadku oznacza to ustawienie dwóch serwomechanizmów w określonych pozycjach lub włączenie lub wyłączenie diod LED. Ponieważ spotter słów kluczowych działa na osobnym bieżniku, może stale słuchać twoich rozkazów.

Wersja 21 września 2019 r.

Kieszonkowe dzieci

Raspberry Pi 4 przez Pimoroni

Akcelerator Google Coral TPU, przez Mouser Niemcy, 72 €

Adafruit 16 Servo Bonnet, via Pimoroni, około 10 €

www.adafruit.com/product/3416

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

Nagłówek układarki (jeśli jest wymagany)

www.adafruit.com/product/2223

4x zestaw baterii AA (lub inne źródło zasilania 5-6V) dla Servo Bonnet

Stara kamera internetowa, jako mikrofon

Skok skokowy z serwomechanizmem, jak opisano w poprzedniej instrukcji. Rysunki układu są dołączone do następnego kroku, ale mogą wymagać korekty.

Wymagane części do Pajacyka:

-3 mm płyta Forex

- 2 mikro serwa

- śruby i nakrętki 2 i 3 mm

- 2 białe diody LED i rezystor

- kawałek kabla

Krok 1: Konfiguracja urządzenia

Aby zbudować Pajacyk, postępuj zgodnie ze wskazówkami podanymi w poprzedniej instrukcji. Użyłem Forex do mojego prototypu, ale możesz użyć laserowo wycinanych płyt akrylowych lub sklejki. Być może będziesz musiał dostosować układ do rozmiaru serw itp. Sprawdź, czy kończyny i sprzęt mogą poruszać się bez tarcia.

Skonfiguruj swoje Raspberry Pi. Na stronie Coral Github dostępny jest obraz Raspian, który zawiera wszystko, co jest wymagane do uruchomienia akceleratora Coral na Pi i zawiera wiele projektów, ze wszystkimi ustawieniami już na miejscu.

Pobierz narzędzie do wyszukiwania słów kluczowych projektu ze strony Google Coral GitHub. Zainstaluj całe wymagane oprogramowanie zgodnie ze wskazówkami.

Zainstaluj dostarczone pliki. Umieść skrypt jumping jack w Pythonie w folderze spotter słów kluczowych projektu, a odpowiedni plik poleceń w podfolderze config.

Dołącz Adafruit Servo Bonnet do Pi. Ponieważ używam obudowy RPI z wentylatorem, aby umożliwić połączenie, musiałem użyć stackerów GPIO (np. dostępnych w Pimoroni). Zainstaluj wszystkie wymagane biblioteki, jak wskazano w instrukcji Adafruit dla maski serwomechanizmu.

Podłącz źródło zasilania 5-6 V do maski serwomechanizmu. Dołącz serwa i diody LED. W moim przypadku użyłem portu 0 dla diod LED oraz portów 11 i 15 dla serw.

Aby wszystko sprawdzić, polecam najpierw wypróbować przykład słowa kluczowego spotter „hearing snake” i przykłady serwomechanizmu Adafruit.

Krok 2: Uruchamianie pajacyka

Jeśli wszystkie części są skonfigurowane i działają, spróbuj ich użyć. Możesz uruchomić skrypt w IDE lub z wiersza poleceń.

Krzycząc „pozycja 0” na „pozycja 9” spowoduje, że Pajacyk zajmie jedną z predefiniowanych pozycji. Zdefiniowałem „1” jako obie ręce w górę (uu), „3” jako lewe w górę, w prawo w dół (ud), „9” jako obie ręce w dół (dd) i „5” jako oba ramiona wyśrodkowane (cc).

uu uc ud = 1 2 3

cu cm3 cd = 4 5 6

du dc dd = 7 8 9

„0” jest identyczne z „5”. „3” i „8” nie są dobrze rozpoznawane przez wyszukiwarkę słów kluczowych i mogą wymagać powtórzenia.

Być może będziesz musiał dostosować minimalne i maksymalne wartości dla każdego serwa/strony, aby serwa nie były blokowane, a następnie pobierały zbyt dużo mocy.

„następna gra” rozpocznie „taniec”, czyli określoną sekwencję pozycji, podczas gdy „gra losowa” uruchomi Pajacyka, który wykona losową sekwencję ruchów. W obu przypadkach będą one działać w nieskończoność, więc być może będziesz musiał wstrzymać ruchy, m.in. poleceniem „pozycja zero”.

"zatrzymaj grę" wywoła "ctrl + c" i zatrzyma proces.

"włącz" i "wyłącz" można włączać i wyłączać diody LED.

Modyfikując wartości time.sleep możesz dostosować prędkość ruchów.

Krok 3: Kod i plik poleceń

Prezentowany tutaj kod jest modyfikacją kodu „węża słuchowego”, który jest częścią pakietu spotter słów kluczowych projektu. Po prostu usunąłem wszystko, co nie było potrzebne do mojej aplikacji, bez prawdziwego zrozumienia szczegółów. Wszelkie ulepszenia są mile widziane.

Następnie dodałem części wymagane dla Adafruit Servo Bonnet, na podstawie ich przykładowych plików.

Chciałbym podziękować programistom obu części.

Kod znajduje się w załączniku jako plik. Używaj go na własne ryzyko, modyfikuj go, ulepszaj, baw się nim.

# Prawa autorskie 2019 Google LLC

# # Licencjonowany na licencji Apache, wersja 2.0 ("Licencja"); # nie możesz używać tego pliku, chyba że zgodnie z Licencją. # Kopię Licencji można uzyskać pod adresem # # https://www.apache.org/licenses/LICENSE-2.0 # # O ile nie jest to wymagane przez obowiązujące prawo lub nie zostało to uzgodnione na piśmie, oprogramowanie # rozpowszechniane na podstawie Licencji jest rozpowszechniane na PODSTAWA „TAK JAK JEST”, # BEZ JAKICHKOLWIEK GWARANCJI LUB WARUNKÓW, wyraźnych lub dorozumianych. # Zapoznaj się z Licencją, aby zapoznać się z określonymi uprawnieniami dotyczącymi języka i # ograniczeniami w ramach Licencji. from _future_ import absolute_import from _future_ import Division from _future_ import print_function import argparse import os z random import randint z wątków import czas importu wątku z edgetpu.basic.basic_engine import BasicEngine import model import pygame z pygame.locals import * import kolejki z losowego import randrange z adafruit_servokit import ServoKit import board import busio import adafruit_pca9685 czas importu i2c = busio. I2C(board. SCL, board. SDA) hat = adafruit_pca9685. PCA9685(i2c) hat.frequency = 60 kit = ServoKit(kanały=16) # numer zestawu kanałów #kit.servo[0].actuation_range = 160 #kit.servo[0].set_pulse_width_range(1000, 2000) # ustawienia góra, środek i dół dla lewego i prawego ramienia up_l = 35 md_l = 90 dn_l = 160 up_r = 160 md_r = 90 dn_r = 35

lft= 15 # numer portu serwo, lewy serwo (0-8)

rgt= 11 # numer portu serwa, prawy serwo (0-8) led_channel_0 = hat.channels[0] # LED ustawiony na porcie 0 led_channel_0.duty_cycle = 0 #włącz LED 100% #lista ustawień uzbrojenia dla pozycji dziewięciu pozycji = [(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)] # definiuje 9 pozycji JumpingJack, wskazanych przez liczby całkowite 0-9 dance1 =(0, 8, 7, 4, 1, 2, 3, 6, 9, 8, 5, 2, 1, 4, 7, 8, 9, 6, 3, 2, 0) # klasa "dance" Controler(object): #Funkcja wywołania zwrotnego def _init_(self, q): self._q = q def callback(self, polecenie): self._q.put(polecenie) class Aplikacja: def _init_(self): self._running = True def on_init(self): pygame.init() self.game_started = True self._running = True return True def on_event(self, event): if event.type == pygame. QUIT: self._running = False def JumpingJack0(self, keys): # kontroluje Pajacyk, słowa kluczowe: "pozycja x" key = int(klawisze) p = pozycja [klawisz] a = p[0] b = p[1] drukuj ("Pozycja: ", klawisz, " w lewo /prawo: ", a, "/", b, "stopień") # sys.stdout.write("Pozycja: ", klucz, " lewo/prawo: ", a, "/", b, "stopień") kit.servo[lft].angle = a kit.servo[rgt].angle = b time.sleep(0.1) def JumpingJack1(self): # kontroluje taniec Jumping Jack, słowo kluczowe: "następna gra" dnce = dance1 sp=(len(dnce)) for r in range (sp): #kolejność taneczna pozycji, sp kroki dc = dnce[r] if (dc not in range(10)): # print ("błąd wejściowy na pozycji", sp) dc=4 p = pozycja[dc] a = p[0] b = p[1] kit.servo[lft].angle = a kit.servo[rgt].angle = b czas.snu (0,25) # ustawia prędkość ruchów def JumpingJack2(self, keys): # kontroluje diody Jumping Jack, słowa kluczowe: "switch on/off" led = int(keys) if led == 1: led_channel_0.duty_cycle = 0xffff #włącz LED 100% time.sleep (0.1) if led == 0: led_channel_0.duty_cycle = 0 # wyłącz LED time.sleep (0.1) if led == 2: # miga led_channel_0.duty_cycle = 0xffff #włącz LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0 #włącz LED 100% czasu.sleep (0.5) led_channel_0.duty_cycle = 0xffff #włącz LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0 #włącz LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0xffff #włącz LED 100% time.sleep (0.1) def JumpingJack3(self): # kontroluje taniec Jumping Jack, słowo kluczowe: "losowa gra" # dla h w zakresie (10): dr= randrange (9) p = position[dr] a = p[0] b = p[1] kit.servo [lft].angle = a kit.servo[rgt].angle = b time.sleep(0.25) # ustawia prędkość ruchów def spotter(self, args): engine = BasicEngine(args.model_file) mic = args.mic if args.mic to None else int(args.mic) model.classify_audio(mic, engine, label_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):

jeśli nie self.on_init(): self._running = False q = model.get_queue() self._controler = Kontroler(q) jeśli nie args.debug_keyboard: t = Thread(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 (True, 0.1) z wyjątkiem kolejki. Empty: new_item = None jeśli new_item nie jest None: item = new_item if (args.debug_keyboard and keys[pygame. K_ESCAPE]) lub item == "stop": self._running = False # if (args.debug_keyboard and keys[pygame. K_SPACE]) lub item == "go": # self. JumpingJack0(7) # if (args.debug_keyboard and keys[pygame. K_RIGHT]) lub item == "right": self. 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 and keys[pygame. K_DOWN]) lub item == "down": self. JumpingJack0(9) if (args.debug_keyboard and keys[pygam e. K_0]) lub item == "0": self. JumpingJack0(0) if (args.debug_keyboard and keys[pygame. K_1]) lub item == "1": self. JumpingJack0(1) if (args. debug_keyboard and keys[pygame. K_2]) lub item == "2": self. JumpingJack0(2) if (args.debug_keyboard and keys[pygame. K_3]) lub item == "3": self. JumpingJack0(3) if (args.debug_keyboard and keys[pygame. K_4]) lub item == "4": self. JumpingJack0(4) if (args.debug_keyboard and keys[pygame. K_5]) lub item == "5": self. 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]) lub item == "8": self. JumpingJack0(8) if (args.debug_keyboard and keys[pygame. K_9]) lub item == "9": self. JumpingJack0(9) if (args.debug_keyboard and keys[pygame. K_a]) lub item == "d": self. JumpingJack1() #dancing Jack, on "next_game" if (args. debug_keyboard i klawisze[pygame. K_j]) lub item == "j": self. JumpingJack2(0) #LED włączony, ON " switch_on" if (args.debug_keyboard and keys[pygame. K_k]) lub item == "k": self. JumpingJack2(1) #LED off, on "swithch off" if (args.debug_keyboard and keys[pygame. K_l]) lub item == "l": self. JumpingJack2(1) #LED miga "target" if (args.debug_keyboard i klawisze[pygame. K_r]) lub item == "r": self. JumpingJack3() #losowy taniec "losowa gra" time.sleep(0.05) self.on_cleanup() if _name_ == '_main_': parser = argparse. ArgumentParser() parser.add_argument('--debug_keyboard', help='Użyj klawiatury do sterowania JumpingJack.', action='store_true', default=False) model.add_model_flags(parser) args = parser.parse_args() the_app = App() the_app.on_execute(args)

Istnieje również plik konfiguracyjny poleceń "commands_v2_hampelmann.txt". Modyfikuj, jak chcesz. Jest to po prostu lista kombinacji „polecenie, klucz, (siła,)” na podstawie pliku-etykiety.

pozycja_zero, 0, pozycja_pierwsza, 1, pozycja_druga, 2, pozycja_trzy, 3, pozycja_czwarta, 4, pozycja_pięta, 5, pozycja_sześć, 6, pozycja_seven, 7, pozycja_ósma, 8, pozycja_dziewięć, 9, przesuń_w górę, góra, idź_w górę, w górę, przesuń_w dół, w dół, idź_w dół, down, move_backwards, left, move_forwards, right, go_backwards, left, go_forwards, right, 0.8 target, l, mute, z, tak, y, nie, n, włączanie, j, wyłączanie, k, zwiększanie głośności, góra, zmniejszanie głośności, dół, next_game, d, random_game, r, start_game, s, stop_game, ctrl+c,

Krok 4: Dalsze pomysły i inne przykłady

Jest całkiem oczywiste, że to ustawienie może być również używane do sterowania robotami lub innymi urządzeniami. W zasadzie wszystko, co może być sterowane przez Raspberry Pi.

Pracuję nad rozszerzeniem skryptu do prowadzenia MeArm i mam nadzieję, że będę mógł to zaprezentować w październiku 2019 roku.

Rozważam również użycie Pajacyka jako semafora i użycie programu rozpoznawania pozycji kończyn „projekt posenet” jako narzędzia do odczytania pozycji Pajacyka i przetłumaczenia go z powrotem na liczbę. W ten sposób może nawet komunikować się z tekstem, biorąc pod uwagę 2x 8 pozycji, może wskazywać 64 różne liczby, więcej niż wystarczające dla alfabetu, cyfr i znaków. Mogłoby to umożliwić, choć nieznacznie zmodyfikowane, fizyczną realizację proponowanego IETF „Transmisja datagramów IP przez system sygnalizacji flagi semaforów (SFSS)” (https://tools.ietf.org/html/rfc4824).

Ale to będzie kolejna instrukcja. I, jak wykazały pierwsze eksperymenty, podskok będzie wymagał znaczących modyfikacji, zanim zostanie rozpoznany jako człowiek przez system sztucznej inteligencji, może to wymagać trochę czasu.

Chciałbym zwrócić twoją uwagę na następującą instrukcję: Object-Finding-Personal-Assistant-Robot-FT-Raspberry, gdzie opisano robota znajdującego obiekt używający kombinacji Raspberry Pi i Google Coral TPU.