KI-Modelle für das Coral AI Dev Board Mini erweitern

In den bisherigen Beiträgen dieser Serie hast du gesehen, wie das Dev Board Mini aufgebaut ist, wie man es bedient, und wie du mit dem Betriebssystem Mendel Linux umgehst. Darüber hinaus hast du bereits trainierte Modelle eingesetzt, um spannende Projekte mit Bild-, Sprach- und Gestenerkennung durchzuführen. Zum Abschluss der Serie erfährst du, wie du die Modelle mit eigenen Daten anreichern kannst, um weiter damit zu experimentieren und neue Möglichkeiten zu erschließen.

In diesem Blog erscheint nach und nach eine Serie von Artikeln, die sich mit dem Coral Dev Board Mini beschäftigen und dir zeigen, wie du damit umgehst und was du alles damit machen kannst.

Teil 1: Coral Dev Board Mini: Künstliche Intelligenz für den Hobbykeller

Teil 2: Das Coral AI Dev Board Mini im Überblick

Teil 3: Das Coral Dev Board Mini anschließen und loslegen

Teil 4: Mendel Linux: Das Betriebssystem des Coral AI Dev Board Mini

Teil 5: Kamera an das Coral AI Dev Board Mini anschließen

Teil 6: Die Erweiterungsleiste des Coral Dev Board Mini

Teil 7: Programmieren mit dem Coral AI Dev Board Mini

Teil 8: Bilderkennung mit dem Dev Board Mini und der Coral Camera

Teil 9: Spracherkennung mit dem Coral Dev Board Mini

Teil 10: Gestenerkennung mit dem Coral Dev Board Mini

Teil 11: KI-Modelle für das Coral AI Dev Board Mini erweitern

Extra: Mit dem Edge TPU-Compiler Modelle für das Coral Dev Board Mini erstellen

 

 

Ein Modell von Grund auf zu trainieren, ist eine komplizierte und zeitaufwendige Angelegenheit. Doch statt ein eigenes Modell zu erstellen und es dann zu trainieren, kannst du ein vorhandenes Modell, das mit der Edge TPU des Dev Boards kompatibel ist, anpassen und teilweise umtrainieren. Diese Technik nennt sich Transfer Learning.

 

Transfer Learning mit dem Dev Board Mini

Ein neuronales Netzwerks von Grund auf zu trainieren, kann Tage an Rechenzeit in Anspruch nehmen. Zudem erfordert es eine große Menge an Trainingsdaten. Beim Transfer Learning kannst du mit einem Modell beginnen, das bereits für eine bestimmte Aufgabe trainiert ist, und dann ein zusätzliches Training durchführen, um dem Modell neue Klassifizierungen beizubringen.


Es gibt zwei unterschiedliche Techniken des Transfer Learning auf dem Dev Board Mini. Beim Weight Imprinting wird die Ausgabe des Basismodells verwendet. Diese Werte werden zur Berechnung neuer Gewichte in der letzten versteckten Schicht des neuronalen Netzwerks, direkt vor der Ausgabeschicht, eingesetzt. Das ermöglicht ein effektives Training neuer Klassen mit wenigen Beispielbildern. Backpropagation ist die traditionellere Trainingsstrategie, die im Allgemeinen eine höhere Genauigkeit erzielt, aber mehr Bilder und mehrere Trainingsiterationen erfordert. Auch hier werden nur die Gewichte für die letzte versteckte Schicht anhand der Abweichungen in der Ausgabeschicht aktualisiert.

 

Transfer Learning mit Weight Imprinting

Um zu sehen, wie das funktioniert, verwendest du ein Beispielskript, das die ImprintingEngine verwendet, um mit einem Modell Transfer Learning auf dem Dev Board durchzuführen. Die ImprintingEngine-API kapselt das gesamte Modell. Du kannst damit Trainingsdaten übergeben, um die Gewichte in der letzten Schicht zu aktualisieren und dem Modell neues Wissen beizubringen.


Das bereits trainierte Modell erkennt 1.000 Bilder aus dem ImageNet-Datensatz. Diese Bild-Datenbank enthält mehr als eine Million Trainingsdateien. In diesem Beispiel trainierst du das Modell neu, damit es zehn neue Klassen, d.h. zehn weitere Objektarten, erkennt.


Verbinde dein Board mit dem Host-PC, öffne die Git Bash und starte mit mdt shell das Terminal von Mendel Linux. Dann legst du dein Verzeichnis fest, in dem du das Projekt speicherst. Dazu führst du im Terminal die folgenden beiden Befehle durch:
DEMO_DIR=$HOME/edgetpu/retrain-imprinting
mkdir -p $DEMO_DIR

Nun lädst du das vortrainierte Modell herunter. Es handelt sich dabei um eine modifizierte Version von MobileNet v1. MobileNets lassen sich effizient auf Geräten die TensorFlow Lite unterstützen ausführen – das Dev Board ist ein solches Gerät. Das erledigt der Befehl
wget https://github.com/google-coral/test_data/raw/master/mobilenet_v1_1.0_224_l2norm_quant_edgetpu.tflite -P $DEMO_DIR

Er gehört in eine einzelne Befehlszeile. Lade nun den neuen Trainingsdatensatz herunter. Er enthält zehn Klassen mit jeweils rund 20 Fotos. Ein Blick in die Labels-Datei „imagenet_labels.txt“ zeigt, dass diese zehn Klassen nicht zu den 1.000 Klassen zählen, die das Modell bereits kennt. Führe nun nacheinander die folgenden drei Befehle aus:
wget https://dl.google.com/coral/sample_data/imprinting_data_script.tar.gz -P $DEMO_DIR
tar zxf $DEMO_DIR/imprinting_data_script.tar.gz -C $DEMO_DIR
bash $DEMO_DIR/imprinting_data_script/download_imprinting_test_data.sh $DEMO_DIR


Das Herunterladen der rund 200 Bilder kann eine Weile dauern. Jetzt holst du dir den Code, der das Transfer Learning durchführt. Wenn du die Artikel-Serie bis hierhin nachvollzogen hast, dann hast du den Code bereits auf deinem Dev Board. Andernfalls führst du den entsprechenden Download damit durch:
mkdir coral && cd coral
git clone https://github.com/google-coral/pycoral.git
cd pycoral/examples/


Jetzt kommt der große Moment. Da startest das Transfer Learning auf der Edge TPU:
python3 imprinting_learning.py \
--model_path ${DEMO_DIR}/mobilenet_v1_1.0_224_l2norm_quant_edgetpu.tflite \
--data ${DEMO_DIR}/open_image_v4_subset \
--output ${DEMO_DIR}/retrained_imprinting_model.tflite

Das dauert nur wenige Minuten. Das neu trainierte Modell ist unter dem Namen „retrained_imprinting_model.tflite“ gespeichert.

 

Per Transfer Learning lernt das Modell zehn neue Klassen kennenIn diesem Transfer Learning lernt das Modell mit wenigen Trainingsdaten zehn neu Klassen kennen wie Seesterne, Katzen und Wecker.
 

Nun gilt es herauszufinden, was es gelernt hat. Eine Katze soll als Beispiel dienen. Zunächst lädst du ein Katzenfoto von Flickr herunter, das das Modell dann erkennen soll:
curl -o ${DEMO_DIR}/cat.jpg https://c4.staticflickr.com/4/3685/10013800466_8f2fb8697e_z.jpg

Dann testest du das neu trainierte Modell mit Hilfe des Python-Skripts „classify_image.py“.
python3 classify_image.py \
--model ${DEMO_DIR}/retrained_imprinting_model.tflite \
--label ${DEMO_DIR}/retrained_imprinting_model.txt \
--Eingabe ${DEMO_DIR}/cat.jpg

Als Ergebnis erscheint etwas wie
cat: 0.95312

Voilà. Durch das Training mit nur wenigen Bildern erkennt das Modell das Tier auf dem Foto mit einer Wahrscheinlichkeit von 95,3 Prozent als Katze. Du hast erfolgreich ein Transfer Learning auf deinem Dev Board durchgeführt.

 

Das neu trainierte Modell erkennt die Katze mit einer Wahrscheinlichkeit von 95,3 ProzentDiese Katze erkennt dein neu trainiertes Modell mit einer Wahrscheinlichkeit von 95,3 Prozent. 

Um mit eigenen Datensätzen zu experimentieren, fügst du einfach ein neues Verzeichnis im Verzeichnis „open_image_v4_subset“ hinzu, und speicherst dort einige Fotos einer neuen Klasse. Rund ein Dutzend sollte genügen. Dann wiederholst du die Schritte mit „imprinting_learning.py“ und „classify_image.py“, um das Modell neu zu trainieren und eine Inferenz durchzuführen.


Transfer Learning mit Backpropagation

Nun lernst du noch die zweite Technik des Transfer Learning kennen. Sie liefert genauere Ergebnisse, benötigt aber mehr Trainingsmaterial und ist auf Modelle zur Bilderkennung beschränkt. Um ein Training durchzuführen, lässt du die Trainingsdaten durch das Basismodell laufen und speist dann die Ergebnisse in die entsprechende Schicht ein.


In diesem Beispiel geht es darum, Blumen zu erkennen. Im ersten Schritt richtest du wieder Verzeichnis ein, in dem du das Projekt speicherst:
DEMO_DIR=$HOME/edgetpu/retrain-backprop
mkdir -p $DEMO_DIR

Dann lädst du einen Datensatz mit Blumenbildern herunter und extrahierst ihn:

wget http://download.tensorflow.org/example_images/flower_photos.tgz
tar zxf blumen_fotos.tgz -C $DEMO_DIR

Da siehst an der Größe des Datensatzes, dass hier wesentlich mehr Trainingsdaten erforderlich sind. Statt 10 bis 20 sind hier mehrere Hundert Bilder für eine neue Klasse notwendig.

Jetzt holst du das Basismodell auf dein Dev Board. Dabei handelt es sich um eine Version des neuronalen Netzwerks ohne die letzte verbundene Schicht und vortrainiert auf ImageNet. Eine manuelle Möglichkeit, diese Schichten zu entfernen, liefert der Python-Befehl tflite_convert.
wget https://github.com/google-coral/test_data/raw/master/mobilenet_v1_1.0_224_quant_embedding_extractor_edgetpu.tflite -P $DEMO_DIR

Wechsle in das Verzeichnis /home/mendel/coral/pycoral/examples. Dann startest du das Transfer Learning mit Backpropagation auf der Edge TPU:
python3 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}


Das dauert mehrere Minuten, und im Terminal siehst du die Trainingsprotokolle. Jetzt probierst du aus, ob das neu trainierte Modell Blumen erkennt. Lade ein Rosenbild von Open Images herunter:

curl -o ${DEMO_DIR}/rose.jpg https://c2.staticflickr.com/4/3062/3067374593_f2963e50b7_o.jpg

Dann lässt du das Modell wiederum durch das Skript „classify_image.py“ laufen.
python3 classify_image.py \
--model ${DEMO_DIR}/retrained_model_edgetpu.tflite \
--label ${DEMO_DIR}/label_map.txt \
--Eingabe ${DEMO_DIR}/rose.jpg

Das Ergebnis lautet etwa
roses: 0.99656

Das bedeutet, das Modell hat das Motiv mit einer Wahrscheinlichkeit von 99,7 Prozent als Rose erkannt.
Im untenstehenden Kasten findest du Links mit Ausgangsmaterial für weitere Experimente. Viel Spaß!

 

Ausblick: CoralAI Dev Board Micro

Die Familie der Coral AI Dev Boards bekommt Zuwachs. Das Coral Dev Board Micro verfügt über eine eingebaute Kamera mit einer Auflösung von 324 x 324 Pixel, ein Mikrofon und eine Coral Edge TPU. Es verfügt über 512 MByte RAM und 1 GByte Flash-Memory. Ein Wifi/Bluetooth-Modul und ein Ethernet/POE-Modul sollen separat erhältlich sein. Der Preis und das genaue Erscheinungsdatum stehen noch nicht fest. Das Dev Board Micro ist insbesondere für geringe Energieaufnahme optimiert worden.

Das kommende Coral Dev Board Micro bietet sogar eine integrierte KameraDas Coral Dev Board Micro bietet eine integrierte Kamera und steht bereits in den Startlöchern.

 

 

Nützliche Links


PyCoral API examples

Hier findest du eine Reihe von Python-Skripts, um bestimmte Modelle auszuprobieren und Transfer Learning durchzuführen.

 

TensorFlow Hub

Das ist das zentrale Sammelbecken für Modelle, die bereits im geeigneten Modellformat TensorFlow Lite vorliegen. Sie müssen mit dem Edge TPU Compiler für das Dev Board compiliert werden. Dazu erscheint in diesem Blog ein separater Artikel.

 

Modelle für die Coral Edge TPU

Auf dieser Seite findest du zahlreiche trainierte Modelle, die schon für die Coral Edge TPU kompiliert und somit sofort einsatzbereit sind.

 

TensorFlow Lite-Beispiel-Apps

Hier sind viele Modell-Kategorien wie Objekterkennung, Spracherkennung und Posenschätzung aufgeführt. Die jeweiligen Seiten erklären detailliert, wie das Modell aufgebaut ist und wie es funktioniert.

Leave a comment

All comments are moderated before being published