Wissensdatenbank

Für diejenigen, die KI-Anwendungen in eingebetteten Systemen entwickeln möchten, bietet TensorFlow Lite (TFLite) kleine und schnell laufende Modelle. Durch die Integration mit C++ können hochleistungsfähige Objekterkennungssysteme insbesondere auf Edge-Geräten wie Android-Geräten, Raspberry Pi und Nvidia Jetson eingerichtet werden.

In diesem Leitfaden wird Schritt für Schritt erklärt, wie Sie mit TensorFlow Lite C++ eine COCO-basierte Objekterkennungsanwendung von Grund auf entwickeln. Wir gehen auf jedes Detail ein, von der Leistungsoptimierung bis zum Label-Management.

Was ist TensorFlow Lite?

TensorFlow Lite ist eine von Google entwickelte Open-Source-Bibliothek, die es ermöglicht, TensorFlow-Modelle schnell auf Geräten mit geringem Stromverbrauch auszuführen.

• Geringe Latenz

• Kleine Modelldateien (.tflite)

• Android/iOS/Linux-Unterstützung

• C++, Java, Python, Swift Integrationen

⚙️ Vorbereitung: Erforderliche Dateien und Konfiguration

1. Ihre .tflite Modelldatei (mobilnetv2-ssd, yolov5-lite usw.)

2. labelmap.txt oder coco_labels.txt (Klassennamen des COCO-Datensatzes)

3. TensorFlow Lite C++ API

4. OpenCV (für die Bildverarbeitung)

5. Build-System mit CMake oder Makefile

sudo apt install libopencv-dev

Was ist ein COCO-Label?

COCO (Common Objects in Context) ist ein weit verbreiteter Datensatz zur Objekterkennung, der aus 80 Klassen besteht.

Beispielklassen:

• person, bicycle, car, motorbike, airplane, dog, cat, chair, tv...

Die von Ihnen verwendete coco_labels.txt-Datei sieht normalerweise wie folgt aus:

0
person
bicycle
car
...

Die erste Zeile sollte leer sein (Hintergrundklasse). Die Indexreihenfolge kann je nach Modell variieren.

️ Laden des TensorFlow Lite-Modells mit C++

#include "tensorflow/lite/model.h"
#include "tensorflow/lite/interpreter.h"
#include "tensorflow/lite/kernels/register.h"
#include "tensorflow/lite/tools/gen_op_registration.h"

std::unique_ptr model =
    tflite::FlatBufferModel::BuildFromFile("model.tflite");

Interpreter-Konfiguration:

std::unique_ptr interpreter;
tflite::ops::builtin::BuiltinOpResolver resolver;
tflite::InterpreterBuilder(*model, resolver)(&interpreter);
interpreter->AllocateTensors();

Vorbereitung des Bildeingangs (mit OpenCV)

cv::Mat frame;
cv::resize(frame, resized, cv::Size(300, 300)); // Modell-Eingangsgröße
uint8_t* input = interpreter->typed_input_tensor(0);
memcpy(input, resized.data, 300 * 300 * 3);

Auslesen der Ausgabe-Tensoren

float* boxes = interpreter->typed_output_tensor(0);
float* class_ids = interpreter->typed_output_tensor(1);
float* scores = interpreter->typed_output_tensor(2);
int* detections = interpreter->typed_output_tensor(3);

Jede Box: [ymin, xmin, ymax, xmax] und alle Werte liegen zwischen 0 und 1.

Visualisierung der Erkennungsergebnisse

for (int i = 0; i < detections[0]; ++i) {
    if (scores[i] > 0.5) {
        int class_id = class_ids[i];
        cv::rectangle(frame, cv::Rect(...));
        cv::putText(frame, labels[class_id], ...);
    }
}

Empfehlungen zur Leistungsverbesserung

• Verwenden Sie ein quantisiertes Modell (INT8)

• Verwendung von Delegates: GPU Delegate, NNAPI

• Reduzieren Sie die Modellgröße (mobilnet vs.)

• Reduzieren Sie die Eingangsgröße (300x300 → 224x224)

• Begrenzen Sie die Analysezeit pro Frame

Raspberry Pi Anwendungsszenario

1. Installieren Sie Raspberry Pi OS Lite und kompilieren Sie die OpenCV + TFLite-Bibliotheken

2. Verwenden Sie das Raspberry Pi Camera Module oder schließen Sie eine USB-Kamera an

3. Erzielen Sie Echtzeit-Erkennung mit C++-Leistung anstelle von Python

4. Für GPU-gestützte Ausführung können Sie zusätzliche Hardware wie den Coral USB Accelerator verwenden

C++ Objekterkennung mit Android NDK

• Die NDK-Installation erfolgt über Android Studio

• Die TFLite C++ Library wird mit JNI aufgerufen

• Die Kameraintegration kann mit dem OpenCV Android SDK erfolgen

• Das .tflite-Modell wird zum assets-Ordner hinzugefügt und mit dem AssetManager geladen

❗️ Häufige Probleme und Lösungen

Fazit

Das Einrichten von Echtzeit-Objekterkennungssystemen, die mit TensorFlow Lite auf C++-Seite laufen, ist dank weit verbreiteter Datensätze wie COCO sehr flexibel. Label-Management, Eingangs-/Ausgangs-Tensoranalyse, der Deployment-Prozess auf Geräten wie Raspberry Pi & Android und Leistungsoptimierungen sind die Schlüsselfaktoren für den Erfolg bei solchen Projekten.