TensorFlow Lite mit Google Coral TPU am Raspberry Pi 4 nutzen

Anwendungen, welche Machine Learning nutzen, benötigen in der Regel eine hohe Rechenleistung. Die Berechnungen finden normalerweise auf der GPU der Grafikkarte statt. Der Raspberry Pi ist nicht unbedingt dafür ausgelegt, rechenintensive Anwendungen auszuführen. Der Google Coral USB Accelerator schafft hier Hilfe! Mithilfe dieses Geräts können wir Echtzeit-Berechnungen wie Objekterkennung in Videos nutzen.

In diesem Tutorial schauen wir uns an, wie wir am Raspberry Pi Google Coral einbinden und nutzen können. Anschließend erstellen wir eine Live-Objekterkennung in einem Videostream von der Raspberry Pi Kamera.

Zubehör

In diesem Tutorial verwende ich folgendes Zubehör. Viele der Bauteile haben wir in vorherigen Tutorials bereits verwendet.

• Raspberry Pi
• Edge TPU: Google Coral USB Accelerator
• offizielles Raspberry Pi Kamera Modul
  • alternativ: USB Webcam
• Einfache Objekte zur Erkennung (Bürogegenstände, Obst, etc.)
• optimal: Gehäuse mit Kühlern für den Pi und den USB Accelerator (kann auch 3D-gedruckt sein).

Wofür ist der Google Coral USB Accelerator zu gebrauchen?

Der Google Coral USB Accelerator enthält einen Prozesser, der für Berechnungen auf neuronalen Netzen spezialiert ist. Dieser Corprozessor wird Edge-TPU (Tensor Processing Unit) genannt.

Eine sehr gute Erklärung zu neuronalen Netzwerken, was diese genau sind und wieso man so häufig darüber im Zusammenhang mit Machine Learning ließt, gibt es in folgendem Video:

Eine der Hauptaufgaben ist also diese neuronalen Netze (in Form von Matrizen) zu lösen und das geht mit einer Edge TPU besonders gut. Damit wir von den Eigenschaften des Coral USB Accelerators profitieren können, stellt Google spezielle Bibliotheken bereit.

Google Coral Edge TPU Installation auf dem Raspberry Pi

Um die Rechenleistung der Coral Edge TPU nutzen zu können, müssen wir also ein paar Pakete installieren. Hierfür folgen wir überwiegend den Schritten der TPU Website. Öffne dazu ein Terminal (oder verbinde dich per SSH) und gib folgendes ein:

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-get update

Danach können wir die Edge-TPU Runtime installieren:

sudo apt-get install libedgetpu1-std

Hinweis: Wenn du eine „schnellere“ Runtime (bedeutet: mit höherer Frequenz) installieren willst, nutze stattdessen diesen Befehl: sudo apt-get install libedgetpu1-max Beachte allerdings, dass du nicht beide Versionen gleichzeitig installiert haben darfst. Bei der höher frequentierten Variante wird die Betriebstemperatur außerdem steigen, weshalb du es nur bei ausreichend guter Kühlung nutzen solltest.

Nach der Installation kannst du den USB Accelerator an den Raspberry Pi anschließen (am besten an einem blauen USB 3.0 Port). Falls er bereits vor der Installation angeschlossen war, entferne ihn kurz und schließe ihn erneut an.

Jetzt installieren wir die Python-Pakete. Hierfür reicht folgender Befehl:

sudo apt-get install python3-pycoral  --yes

TensorFlow Lite installieren

Wir werden außerdem natürlich TensorFlow Lite benötigen. Zunächst überprüfen wir die Version:

pip3 show tflite_runtime

Bei mir sieht das Ergebnis wie folgt aus:

Name: tflite-runtime
Version: 2.5.0
Summary: TensorFlow Lite is for mobile and embedded devices.
Home-page: https://www.tensorflow.org/lite/
Author: Google, LLC
Author-email: packages@tensorflow.org
License: Apache 2.0
Location: /usr/lib/python3/dist-packages
Requires:
Required-by: pycoral

Solltest du TensorFlow noch nicht installiert haben, kannst du das folgendermaßen nachholen und danach den Befehl noch einmal ausführen:

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-get update
sudo apt-get install python3-tflite-runtime

Objekterkennung in Videos mittels Google Coral und Raspberry Pi Kamera

Im Folgenden möchten wir die Objekterkennung live in einem Videostream aktivieren. Die Berechnungen laufen dabei auf der Edge-TPU. Um das Bild anzuzeigen, haben wir mehrere Möglichkeiten. Wir können z.B. Pakete wie PyGame, PiCamera oder OpenCV nutzen. Ich bevorzuge OpenCV, da wir damit noch viele weitere Funktionen aus dem Bereich Computer Vision nutzen können.

Zunächst verbinden wir die Raspberry Pi Kamera per CSI oder eine Webcam per USB. Die meisten Webcams werden automatisch erkannt.

Fangen wir also an mit einem Beispielprojekt. Öffne wieder das Terminal:

mkdir google-coral && cd google-coral
git clone https://github.com/google-coral/examples-camera --depth 1

Im nächsten Schritt laden wir die vortrainierten Modelle. Du kannst stattdessen auch deine eigenen trainierten Modelle nutzen. In unserem einfachen Beispiel laden wir jedoch nur das MobileNet SSD300 Modell, welches bereits viele Objekte erkennen kann.

cd examples-camera
sh download_models.sh

Der Vorgang dauert ein paar Minuten. Danach wechseln wir in den opencv-Ordner und installieren die Abhängigkeiten (falls du ein anderes Beispiel nutzen willst, hast du hier die Möglichkeit).

cd opencv
bash install_requirements.sh

Nun können wir die Beispielanwendung starten. Du brauchst dafür eine Desktopumgebung. Falls du nicht direkt am Raspberry Pi arbeitest, empfehle ich eine Remotedesktop-Verbindung.

python3 detect.py

Dadurch öffnet sich ein neues Fenster mit dem Videostream. Darin werden erkannte Objekte jeweils mit Rechtecken markiert. Außerdem siehst du die berechnete Wahrscheinlichkeit (in Prozent), mit der das Objekt erkannt wurde (Wie wahrscheinlich es sich also um dieses Objekt handelt, laut Algorithmus).

Schauen wir nun noch einmal genauer in den Code, um zu verstehen, was passiert:

• Zunächst einmal werden die benötigten PyCoral Bibliotheken eingebunden.
• In der main Funktion sind Argumente definiert, welche von der Kommandozeile übergeben werden können (Angabe des Modells usw.)
• Das Modell wird mit seinen Labels geladen und die Abmessungen anhand des Modells ermittelt (hier: 300×300)
• Anschließend wird der Videostream geöffnet (cap = cv2.VideoCapture(args.camera_idx))
• Der interessante Teil passiert hier:

  objs = get_objects(interpreter, args.threshold)[:args.top_k]

  Dabei werden die 3 Elemente mit dem höchsten „Klassifizierungs-Score“ (über einem Schwellwert) ermittelt.

• Anschließend wird jedes erkannte Objekt auf dem Bild markiert.

Auf bestimmte Objekte reagieren

Was machen wir nun, wenn wir eine Aktion auslösen wollen, sobald ein bestimmtes Objekt erkannt wurde (z.B. eine Person)?

Dazu schauen wir uns zunächst einmal den Rückgabewert der get_objects Funktion an:

[
  Object(id=16, score=0.5, bbox=BBox(xmin=-2, ymin=102, xmax=158, ymax=296)), 
  Object(id=0, score=0.16015625, bbox=BBox(xmin=6, ymin=114, xmax=270, ymax=300)), 
  Object(id=61, score=0.12109375, bbox=BBox(xmin=245, ymin=166, xmax=301, ymax=302))
]

Wir sehen, dass jedes erkannte Objekt eine id, einen score und eine Bounding Box mit Koordinaten enthält. Um festzustellen, welches Objekt erkannt wurde, werfen wir einen Blick in die Labels:

{0: 'person', 1: 'bicycle', 2: 'car', 3: 'motorcycle', 4: 'airplane', 5: 'bus', 
6: 'train', 7: 'truck', 8: 'boat', 9: 'traffic light', 10: 'fire hydrant', 1
2: 'stop sign', 13: 'parking meter', 14: 'bench', 15: 'bird', 16: 'cat', 17: 'dog', 
18: 'horse', 19: 'sheep', 20: 'cow', 21: 'elephant', 22: 'bear', 23: 'zebra',
 24: 'giraffe', 26: 'backpack', 27: 'umbrella', 30: 'handbag', 31: 'tie', 
32: 'suitcase', 33: 'frisbee',  34: 'skis', 35: 'snowboard', 36: 'sports ball', 
37: 'kite', 38: 'baseball bat', 39: 'baseball glove', 40: 'skateboard', 
41: 'surfboard', 42: 'tennis racket', 43: 'bottle', 45: 'wine glass', 46: 'cup', 
47: 'fork', 48: 'knife', 49: 'spoon', 50: 'bowl', 51: 'banana', 52: 'apple', 
53: 'sandwich', 54: 'orange', 55: 'broccoli', 56: 'carrot', 57: 'hot dog', 
58: 'pizza', 59: 'donut', 60: 'cake', 61: 'chair', 62: 'couch', 63: 'potted plant',
 64: 'bed', 66: 'dining table', 69: 'toilet', 71: 'tv', 72: 'laptop', 73: 'mouse', 
74: 'remote', 75: 'keyboard', 76: 'cell phone', 77: 'microwave', 78: 'oven', 
79: 'toaster', 80: 'sink', 81: 'refrigerator', 83: 'book', 84: 'clock', 85: 'vase', 
86: 'scissors', 87: 'teddy bear', 88: 'hair drier', 89: 'toothbrush'}

In meinem Fall wurden also die Objekte Cat (id=16), Person (id=0) und Chair (id=61) erkannt.

Falls du dich fragst, woher die ganzen Labels kommen: Diese wurden im Model trainiert und sind deshalb enthalten. Wenn du dein eigenes Model erstellst, kannst du auch nur ein einziges oder nur wenige Objekte inkludieren, welche für dich wichtig sind. Möglich wäre es auch z.B. sein eigenes Gesicht erkennen zu lassen.

Falls Interesse an einem Tutorial besteht, wie man so ein Model auf dem Raspberry Pi mit dem Google Coral USB Accelerator trainiert, würde ich mich über einen Kommentar freuen.

In dem genannten Beispiel wollen wir eine Aktion auslösen, sobald ein bestimmtes Objekt (bspw. ein Bus mit ID=5) erkannt wird. Dazu schauen wir zunächst die ID nach. Als Nächstes müssen wir prüfen, ob ein Objekt mit dieser ID gefunden wurde. Außerdem können wir noch einen Schwellwert (z.B. 0.8) für den Score einbauen. Der Pseudocode sähe so aus:

found_scores = [o.score for o in objs if o.id == 5]
if len(found_scores) > 0 and max(found_scores) >= 0.8:
  # do something

Wie du siehst, ist das Reagieren darauf sehr einfach. Danach können wir z.B. das Foto speichern.

Fazit

Die Edge-TPU von Google bietet eine tolle Gelegenheit für alle, denen die Rechenkapazität des Raspberry Pi’s nicht ausreicht. Der USB Accelerator ist om Vergleich zu High-End Grafikkarten auch sehr günstig. Diese kosten schnell einmal über Tausend Euro.

Bei einer Auflösung von 300x300px läuft die Objekterkennung sehr flüssig. Auch eine höhere Auflösung ist möglich, jedoch musst du auf die Temperatur des Geräts achten. Ich empfehle für den Dauerbetrieb einen zusätzichen Lüfter.

Google bietet außerdem noch weitere Repositories mit Lerninhalten an. Für weitere Use-Cases mit dem Coral, ist dieses Repo noch interessant und u.a. mit Beispielen zur Bilderkennung ausgestattet.

Im Übrigen können wir auch unser eigenes Objekterkennungs-Modell mit TensorFlow erstellen. Hierfür müssen wir zunächst Bilder annotieren und anschließend ein Modell trainieren. Bei Interesse folgt dazu in Zukunft ein Tutorial.

Welche weiteren Machine-Learning-Anwendungen und Use Cases interessieren dich? Ich hatte über Projekte wie das automatische Erkennen von Nummernschildern und ähnlichem gedacht, aber bin gespannt auf weitere kreative Vorschläge für den Raspberry Pi mit Google Coral TPU.