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.
|
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.
In 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.
Diese 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 MicroDie 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 Coral Dev Board Micro bietet eine integrierte Kamera und steht bereits in den Startlöchern.
Nützliche LinksHier findest du eine Reihe von Python-Skripts, um bestimmte Modelle auszuprobieren und Transfer Learning durchzuführen.
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.
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. |