Google Coral USB Accelerator – Versnel AI-taken met de Edge TPU-coprocessor
Neurale netwerken zijn een belangrijke techniek in machine learning, maar helaas ook rekenintensief en energieverslindend. Met de Coral USB Accelerator biedt Google een handig versnellerbordje aan. Je gebruikt het op je laptop of een Raspberry Pi 4.
Koen Vervloesem
De Google Coral USB Accelerator is een hardwareversneller die tot 4 biljoen () bewerkingen per seconde kan uitvoeren voor een model van een neuraal netwerk. Het hart bestaat uit een Edge TPU-coprocessor, die slechts 2 W verbruikt, een heel laag verbruik voor dit soort berekeningen.
Het is een klein kastje ter grootte van een wat brede USB-stick. Er wordt een usb-c-kabel meegeleverd met aan de andere kant een USB-3-connector, zodat je de Coral USB Accelerator op een USB-3-poort van je computer of de Raspberry Pi 4 kunt aansluiten. Een USB-2-poort past uiteraard ook, maar dan kun je niet van de volledige snelheid van de Edge TPU-coprocessor genieten. Dat betekent ook dat je voor de beste prestaties met een Raspberry Pi model 4 nodig hebt omdat de oudere modellen alleen USB 2 aanbieden.
De Google Coral USB Accelerator bevat een chip die AI-taken heel efficiënt uitvoert.
Neurale netwerken
De Edge TPU-chip in het versnellerbordje is een ‘tensor processing unit’, zo genoemd omdat het is geoptimaliseerd om bewerkingen met TensorFlow uit te voeren, een bibliotheek van Google voor neurale netwerken. Correcter is eigenlijk: de Edge TPU is geoptimaliseerd voor TensorFlow Lite, een versie van TensorFlow voor toestellen met beperktere verwerkingskracht, zoals de Raspberry Pi.
Als we met een neuraal netwerk willen werken, hebben we een ‘model’ nodig. Zo’n model is een netwerk dat getraind is op een boel data, bijvoorbeeld foto’s van verschillende voorwerpen die we willen classificeren op basis van het voorwerp dat erin wordt voorgesteld.
Als we dan een nieuwe foto willen classificeren, passen we het model erop toe en krijgen we hopelijk als uitvoer de juiste classificatie omdat het model heeft geleerd te generaliseren uit de trainingsdata en dus ook foto’s correct herkent die het nog nooit gezien heeft.
Voor de Coral USB Accelerator hebben we een TensorFlow-Lite model nodig, dat doorgaans de extensie .tflite heeft. Heb je zo’n model, dan kan de Edge TPU-chip in het versnellerbordje dit heel efficiënt uitvoeren.
Installatie
De Coral USB Accelerator ondersteunt Linux, macOS en Windows. De Linux-software is gebouwd voor Debian GNU/Linux en draait dus ook op Ubuntu of Raspberry Pi OS. De voorbeelden in dit artikel hebben we op een Raspberry Pi 4 met 32-bits Raspberry Pi OS 10 (Buster) uitgeprobeerd.
Voeg eerst de repository van Coral en de bijbehorende gpg-sleutel toe, en update de pakketbronnen:
$ echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list $ curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add - $ sudo apt update
Installeer dan de Edge TPU runtime:
$ sudo apt install libedgetpu1-std
Dit installeert overigens een versie van de runtime die de Coral USB Accelerator op gereduceerde snelheid draait. Het versnellerbordje wordt immers al snel heet als je het op maximale snelheid draait. Heb je toch maximale prestaties nodig, installeer dan het pakket libedgetpu1-max. Maar dan moet je verzekeren dat de temperatuur niet boven de 25 graden Celsius oploopt. Voorzie eventueel een ventilator. Ook op gereduceerde snelheid mag de temperatuur niet te hoog oplopen: 35 graden Celsius maximum.
Installeer daarna de TensorFlow Lite runtime voor je gekozen platform en Python-versie (Python 3.5 tot en met 3.7 zijn ondersteund). Voor 32-bits Raspberry Pi OS Buster met Python 3.7 is dat dus:
$ pip3 install https://dl.google.com/coral/python/tflite_runtime-2.1.0.post1-cp37-cp37m-linux_armv7l.whl
Vogels herkennen
Sluit je Coral USB Accelerator nu op een van de USB-3-poorten van de Pi 4 aan. Als je die voor de installatie van de Edge TPU runtime al had aangesloten, trek de kabel dan even uit en sluit hem opnieuw aan: de runtime heeft immers udev-regels geïnstalleerd die uitgevoerd moeten worden. Download eerst de voorbeeldcode van Google Coral:
$ git clone https://github.com/google-coral/tflite.git
En ga dan naar de juiste map en installeer de afhankelijkheden:
$ cd tflite/python/examples/classification $ ./install_requirements.sh
Er missen nog enkele afhankelijkheden in het installatiescript:
$ sudo apt install libopenjp2-7-dev libtiff5
Het project in deze map herkent vogelsoorten in foto’s. Het installatiescript downloadt een model dat op vogels getraind is, samen met een bestand dat de bijbehorende namen van de herkende vogels bevat. Het script downloadt ook een voorbeeldfoto van een geelvleugelara, zodat je het onmiddellijk kunt uitproberen.
Je voert het classificatieprogramma als volgt uit:
$ python3 classify_image.py --model models/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite --labels models/inat_bird_labels.txt --input images/parrot.jpg ----INFERENCE TIME---- Note: The first inference on Edge TPU is slow because it includes loading the model into Edge TPU memory. 17.5ms 4.4ms 4.4ms 4.4ms 4.4ms -------RESULTS-------- Ara macao (Scarlet Macaw): 0.77734
Je ziet dat we hier het model, de labels en de invoer doorgeven aan het Python-programma. De uitvoer toont dat het inderdaad om een geelvleugelara gaat, of toch met een kleine 78% waarschijnlijkheid.
Probeer dit nu eens uit met enkele andere foto’s die je van internet haalt. De resultaten zijn meestal heel goed.
Snelheidsverbetering
Maar welke snelheidsverbetering haal je nu door gebruik te maken van de Coral USB Accelerator? Dat kun je eenvoudig uittesten. Het model dat je hiervoor gebruikt hebt (mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite), is gecompileerd voor de Edge TPU. Geef je in de plaats het model mobilenet_v2_1.0_224_inat_bird_quant.tflite door, dat gecompileerd is voor de CPU, dan voert TensorFlow de bewerkingen puur op de processor van de Raspberry Pi uit. Laten we dat eens bekijken:
$ python3 classify_image.py --model models/mobilenet_v2_1.0_224_inat_bird_quant.tflite --labels models/inat_bird_labels.txt --input images/parrot.jpg ----INFERENCE TIME---- Note: The first inference on Edge TPU is slow because it includes loading the model into Edge TPU memory. 117.3ms 114.4ms 114.7ms 113.9ms 113.8ms -------RESULTS-------- Ara macao (Scarlet Macaw): 0.77734
Op de Raspberry Pi 4 waarop we deze code uitprobeerden, voert de coral USB Accelerator het model dus 27 keer sneller uit. Naar de eerste tijdsduur moet je niet kijken, want zoals de opmerking in de uitvoer al zegt is die trager omdat de Edge TPU dan het model nog in zijn geheugen moet inladen. Daarom dat het programma standaard het algoritme vijf keer uitvoert.
Op een Raspberry Pi 3B voert dit script overigens zijn werk uit in 11,8 ms omdat de Coral USB Accelerator dan beperkt wordt door de lagere snelheid van USB 2.0. Zonder het versnellerbordje heeft de processor 269 ms nodig.
Woorden herkennen
Een ander voorbeeldproject van Google laat je toe om enkele sleutelwoorden te herkennen. Dat vereist dat je een werkende microfoon op je Raspberry Pi aangesloten hebt. Download de code en installeer de afhankelijkheden:
$ git clone https://github.com/google-coral/project-keyword-spotter.git $ cd project-keyword-spotter $ sh install_requirements.sh
Voer daarna het herkenningsscript uit:
$ python3 run_model.py
Als het afbreekt met een foutmelding over een timeout, dan heeft het script waarschijnlijk de verkeerde standaardmicrofoon gekozen. Voer het dan nog eens uit met de optie –mic ID, waarbij je ID vervangt door het ID dat het script bij de bijbehorende geluidskaart toont.
Zodra het script draait, luistert het continu naar de audiostroom van je microfoon. In het bestand config/labels_gc2.raw.txt staat de lijst van sleutelwoorden die het model herkent, zoals yes, no, mute, volume up, volume down, next song, start video, channel eleven enzovoort.
Spreek maar eens een van deze woorden uit, dan zie je in de uitvoer het herkende woord in het geel. Er worden zelfs een top drie van herkende woorden getoond als je iets zegt, elk met hun waarschijnlijkheid.
Modellen
Google heeft op één webpagina al zijn modellen voor de Edge TPU geplaatst, waar je ze eenvoudig kunt downloaden. Vooral voor beeldclassificatie zijn er veel modellen beschikbaar. Zo zijn er drie versies van EfficientNet, waarmee je 1000 types objecten kunt herkennen in kleine, gemiddelde of grotere afbeeldingen. Ook van MobileNet zijn er diverse varianten: om 1000 objecten te herkennen, 1000 insecten, 2000 planten en 900 soorten vogels. Ook van Inception, dat 1000 types objecten herkent, zijn er vier versies beschikbaar. Wel model voor jouw toepassing geschikt is, hangt af van de beelden die je wilt verwerken. We raden aan om verschillende modellen te testen.
Ook voor objectherkenning zijn er meerdere modellen. Objectherkenning doet meer dan beeldclassificatie: bij die laatste krijg je gewoon een label “vogel” als er een vogel in het beeld staat. Een model voor objectherkenning vertelt je niet alleen dat er een vogel te zien is, maar toont je ook de locatie. Dat kun je dan visualiseren met een kader rond het object. Er zijn twee versies van MobileNet SSD die de locatie van 90 types objecten kunnen herkennen, en één versie die de locatie van een menselijk gezicht detecteert.
Als je wat verder zoekt, vind je ook elders nog wel andere modellen. Maar je moet er altijd zeker van zijn dat ze voor de Edge TPU zijn gecompileerd.
Op de website van Google Coral vind je allerlei modellen voor de Edge TPU.
Hertrain een model
Google heeft nog zo enkele voorbeeldprogramma’s op hun website staan, maar allemaal maken ze gebruik van een bestaand model. Wat als je andere klassen van objecten wilt herkennen in afbeeldingen? Gelukkig hoef je dan niet onmiddellijk zelf een volledig nieuw model te trainen. Er bestaat een techniek transfer learning die een bestaand model hertraint om nieuwe klassen te herkennen. En het resulterende model kun je gewoon op de Edge TPU draaien.
Eén manier is om de laatste laag van het neurale netwerk te hertrainen met backpropagation. Dat kan zelfs voor een groot deel op de Edge TPU zelf, waardoor dit vrij snel gebeurt. Daarvoor heb je wel niet het originele model nodig, maar het originele model zonder de laatste laag. Die vind je op de pagina met modellen onder het kopje “On-device backpropagation (classification)”.
Bloemen herkennen
We gaan nu MobileNet, dat 1000 algemene objecten herkent, hertrainen zodat het specifiek diverse soorten bloemen herkent. Maak eerst een directory aan voor je project:
$ DEMO_DIR=$HOME/flowers $ mkdir -p $DEMO_DIR $ cd $DEMO_DIR
Download een dataset met afbeeldingen van bloemen en pak ze uit:
$ wget http://download.tensorflow.org/example_images/flower_photos.tgz $ tar xvzf flower_photos.tgz
En download dan het MobileNet-model zonder de laatste laag:
$ wget https://github.com/google-coral/edgetpu/raw/master/test_data/mobilenet_v1_1.0_224_quant_embedding_extractor_edgetpu.tflite
De code voor het hertrainen vind je in de voorbeeldcode van Google, die je ook eenvoudig installeert:
$ sudo apt install edgetpu-examples
Je vindt de voorbeeldcode dan in /usr/share/edgetpu/examples/. Daarna kun je het programma opstarten om het model te hertrainen:
$ python3 /usr/share/edgetpu/examples/backprop_last_layer.py \
--data_dir ${DEMO_DIR}/flower_photos \
--embedding_extractor_path \
${DEMO_DIR}/mobilenet_v1_1.0_224_quant_embedding_extractor_edgetpu.tflite \
--output_dir ${DEMO_DIR}
Het programma toont je welke afbeeldingen het allemaal inleest: 600 tot 900 afbeeldingen per bloemsoort, voor madeliefje, tulp, paardebloem, roos, zonnebloem. Na nog geen minuut is het hertrainen gebeurd en vind je het model in /home/pi/flowers/retrained_model_edgetpu.tflite en de bijbehorende labels in /home/pi/flowers/label_map.txt.
Probeer nu uit of je model deze soort bloemen herkent. Download bijvoorbeeld een willekeurige foto van een zonnebloem en laat deze classificeren:
$ curl -o ${DEMO_DIR}/rose.jpg https://images.pexels.com/photos/1214259/pexels-photo-1214259.jpeg
$ python3 /usr/share/edgetpu/examples/classify_image.py \
--model ${DEMO_DIR}/retrained_model_edgetpu.tflite \
--label ${DEMO_DIR}/label_map.txt \
--image ${DEMO_DIR}/rose.jpg
---------------------------
sunflowers
Score : 0.92578125
Op dezelfde manier kun je een model trainen voor andere classificaties. Maak gewoon voor elk type object dat je wilt herkennen een map aan met daarin voorbeeldafbeeldingen.
Objecten herkennen
Met het juiste model (MobileNet SSD COCO of Faces) kun je ook objecten en hun locatie in afbeeldingen herkennen. Dat kan als volgt:
$ python3 /usr/share/edgetpu/examples/object_detection.py \
--model /usr/share/edgetpu/examples/models/ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite \
--label /usr/share/edgetpu/examples/models/coco_labels.txt \
--input JEAFBEELDING.JPG \
--output ${HOME}/object_detection_results.jpg
-----------------------------------------
person
score = 0.9921875
box = [560.239709854126, 349.3849046230316, 4086.211227416992, 2406.5477085113525]
-----------------------------------------
surfboard
score = 0.12109375
box = [3524.095703125, 35.26763463020325, 5210.838684082031, 2934.12105345726]
-----------------------------------------
cell phone
score = 0.08984375
box = [3595.1825637817383, 1301.93909740448, 3679.4541091918945, 1411.7773611545563]
-----------------------------------------
potted plant
score = 0.06640625
box = [4969.983730316162, 1449.5367743968964, 5241.2756690979, 1829.9384543895721]
Dit was een eenvoudige foto van mezelf die met wat elektronische onderdelen aan het knutselen was. Die onderdelen kent het model niet, en daarom zie je hier enkele vreemde objecten ‘herkend’: een surfbord, smartphone en potplant. Geen van die objecten was in de foto aanwezig, maar de persoon werd wel met meer dan 99% zekerheid herkend. Je ziet dat je de uitvoer van het model nog moet filteren: alles onder een zelfgekozen drempelwaarde voor de score laat je het best weg.
Op dezelfde manier kun je ook gezichten in foto’s herkennen.
$ python3 /usr/share/edgetpu/examples/object_detection.py \
--model /usr/share/edgetpu/examples/models/ssd_mobilenet_v2_face_quant_postprocess_edgetpu.tflite \
--input JEAFBEELDING.JPG \
--output ${HOME}/object_detection_results.jpg
-----------------------------------------
score = 0.9921875
box = [2051.762745976448, 240.68063085526228, 2762.9795892238617, 792.7388074696064]
-----------------------------------------
score = 0.98046875
box = [1316.6589984893799, 27.02611466497183, 2043.4382076263428, 591.1641841232777]
-----------------------------------------
score = 0.69140625
box = [1650.4731440842152, 909.7686061859131, 2577.635899603367, 1638.9171080589294]
-----------------------------------------
score = 0.5
box = [551.844685614109, 754.4507395029068, 1434.9394246935844, 1454.9225406050682]
Je ziet hier dat je geen labels moet opgeven, omdat je geen verschillende klassen objecten detecteert met het model MobileNet SSD Faces, maar slechts één klasse: gezichten. Het resultaat voor de foto die we opgaven zijn vier gezichten, waarvan er twee met vrij hoge waarschijnlijkheid en twee andere met iets minder waarschijnlijkheid werden gedetecteerd.
Het model MobileNet SSD Faces detecteert menselijke gezichten.
Meer weten?
Er zijn vele voorbeeldprogramma’s in Python te vinden voor de Edge TPU. Bekijk zeker eens de officiële pagina met voorbeelden. Maar ook op GitHub vind je allerlei interessante third-party projecten. Je kunt ook realtime de beelden van een Raspberry Pi Camera Module analyseren. Dankzij de Google Coral USB Accelerator komen krachtige AI-toepassingen binnen handbereik van de Raspberry Pi waarvoor je vroeger toegang tot krachtige servers in de cloud nodig had.
