Objektdetektoren einbinden

Objektdetektoren können erkennen, welche Objekte aus einer bekannten Menge von Objekten vorhanden sein könnten, und Informationen zu ihrer Position im angegebenen Bild oder Videostream liefern. Ein Objektdetektor wird trainiert, um das Vorhandensein und die Position mehrerer Objektklassen zu erkennen. Ein Modell kann beispielsweise mit Bildern trainiert werden, die verschiedene Obstsorten enthalten, zusammen mit einem Label, das die Obstklasse angibt (z.B. Apfel, Banane oder Erdbeere), und Daten, die angeben, wo jedes Objekt im Bild zu sehen ist. Weitere Informationen zu Objekterkennungen finden Sie im Beispiel für die Objekterkennung.

Mit der Task Library-API ObjectDetector können Sie benutzerdefinierte oder vortrainierte Objekterkennungen in Ihren mobilen Apps bereitstellen.

Wichtige Funktionen der ObjectDetector API

  • Verarbeitung von Eingabebildern, einschließlich Drehung, Größenänderung und Farbraumkonvertierung.

  • Gebietsschema für Labelkarte.

  • Schwellenwert für die Punktzahl zum Filtern von Ergebnissen.

  • Top-k-Erkennungsergebnisse.

  • Zulassungs- und Sperrliste für Labels.

Unterstützte Modelle für Objektdetektoren

Die folgenden Modelle sind garantiert mit der ObjectDetector API kompatibel.

Inferenz in Java ausführen

Ein Beispiel für die Verwendung von ObjectDetector in einer Android-App finden Sie in der Referenz-App zur Objekterkennung.

Schritt 1: Gradle-Abhängigkeit und andere Einstellungen importieren

Kopieren Sie die Modelldatei .tflite in das Assets-Verzeichnis des Android-Moduls, in dem das Modell ausgeführt wird. Geben Sie an, dass die Datei nicht komprimiert werden soll, und fügen Sie die TensorFlow Lite-Bibliothek der build.gradle-Datei des Moduls hinzu:

android {
    // Other settings

    // Specify tflite file should not be compressed for the app apk
    aaptOptions {
        noCompress "tflite"
    }
}

dependencies {
    // Other dependencies

    // Import the Task Vision Library dependency
    implementation 'org.tensorflow:tensorflow-lite-task-vision'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Schritt 2: Modell verwenden

// Initialization
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

Weitere Optionen zum Konfigurieren von ObjectDetector finden Sie im Quellcode und in der Javadoc.

Inferenz auf iOS-Geräten ausführen

Schritt 1: Abhängigkeiten installieren

Die Task Library unterstützt die Installation mit CocoaPods. Prüfen Sie, ob CocoaPods auf Ihrem System installiert ist. Eine Anleitung finden Sie im CocoaPods-Installationsleitfaden.

Weitere Informationen zum Hinzufügen von Pods zu einem Xcode-Projekt finden Sie im CocoaPods-Leitfaden.

Fügen Sie den TensorFlowLiteTaskVision-Pod in die Podfile ein.

target 'MyAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskVision'
end

Achten Sie darauf, dass das .tflite-Modell, das Sie für die Inferenz verwenden, in Ihrem App-Bundle enthalten ist.

Schritt 2: Modell verwenden

Swift

// Imports
import TensorFlowLiteTaskVision

// Initialization
guard let modelPath = Bundle.main.path(forResource: "ssd_mobilenet_v1",
                                            ofType: "tflite") else { return }

let options = ObjectDetectorOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let detector = try ObjectDetector.detector(options: options)

// Convert the input image to MLImage.
// There are other sources for MLImage. For more details, please see:
// https://developers.google.com/ml-kit/reference/ios/mlimage/api/reference/Classes/GMLImage
guard let image = UIImage (named: "cats_and_dogs.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let detectionResult = try detector.detect(mlImage: mlImage)

Objective-C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"ssd_mobilenet_v1" ofType:@"tflite"];

TFLObjectDetectorOptions *options = [[TFLObjectDetectorOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLObjectDetector *detector = [TFLObjectDetector objectDetectorWithOptions:options
                                                                     error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"dogs.jpg"];

// There are other sources for GMLImage. For more details, please see:
// https://developers.google.com/ml-kit/reference/ios/mlimage/api/reference/Classes/GMLImage
GMLImage *gmlImage = [[GMLImage alloc] initWithImage:image];

// Run inference
TFLDetectionResult *detectionResult = [detector detectWithGMLImage:gmlImage error:nil];

Weitere Optionen zum Konfigurieren von TFLObjectDetector finden Sie im Quellcode.

Inferenz in Python ausführen

Schritt 1: pip-Paket installieren

pip install tflite-support

Schritt 2: Modell verwenden

# Imports
from tflite_support.task import vision
from tflite_support.task import core
from tflite_support.task import processor

# Initialization
base_options = core.BaseOptions(file_name=model_path)
detection_options = processor.DetectionOptions(max_results=2)
options = vision.ObjectDetectorOptions(base_options=base_options, detection_options=detection_options)
detector = vision.ObjectDetector.create_from_options(options)

# Alternatively, you can create an object detector in the following manner:
# detector = vision.ObjectDetector.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
detection_result = detector.detect(image)

Weitere Optionen zum Konfigurieren von ObjectDetector finden Sie im Quellcode.

Inferenz in C++ ausführen

// Initialization
ObjectDetectorOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ObjectDetector> object_detector = ObjectDetector::CreateFromOptions(options).value();

// Create input frame_buffer from your inputs, `image_data` and `image_dimension`.
// See more information here: tensorflow_lite_support/cc/task/vision/utils/frame_buffer_common_utils.h
std::unique_ptr<FrameBuffer> frame_buffer = CreateFromRgbRawBuffer(
      image_data, image_dimension);

// Run inference
const DetectionResult result = object_detector->Detect(*frame_buffer).value();

Weitere Optionen zum Konfigurieren von ObjectDetector finden Sie im Quellcode.

Beispielergebnisse

Hier ist ein Beispiel für die Erkennungsergebnisse von ssd mobilenet v1 aus TensorFlow Hub.

Hunde

Results:
 Detection #0 (red):
  Box: (x: 355, y: 133, w: 190, h: 206)
  Top-1 class:
   index       : 17
   score       : 0.73828
   class name  : dog
 Detection #1 (green):
  Box: (x: 103, y: 15, w: 138, h: 369)
  Top-1 class:
   index       : 17
   score       : 0.73047
   class name  : dog

Begrenzungsrahmen auf das Eingabebild rendern:

Erkennungsausgabe

Testen Sie das einfache CLI-Demotool für ObjectDetector mit Ihrem eigenen Modell und Ihren eigenen Testdaten.

Anforderungen an die Modellkompatibilität

Für die ObjectDetector API ist ein TFLite-Modell mit obligatorischen TFLite-Modellmetadaten erforderlich. Beispiele für das Erstellen von Metadaten für Objekterkennung mit der TensorFlow Lite Metadata Writer API

Die kompatiblen Objekterkennungsmodelle sollten die folgenden Anforderungen erfüllen:

  • Eingabebild-Tensor: (kTfLiteUInt8/kTfLiteFloat32)

    • Bild-Eingabe der Größe [batch x height x width x channels].
    • Die Batch-Inferenz wird nicht unterstützt (batch muss 1 sein).
    • Es werden nur RGB-Eingaben unterstützt (channels muss 3 sein).
    • Wenn der Typ kTfLiteFloat32 ist, müssen NormalizationOptions an die Metadaten für die Eingabenormalisierung angehängt werden.

  • Ausgabetensoren müssen die vier Ausgaben eines DetectionPostProcess-Vorgangs sein, d.h.:

    • Tensor für Speicherorte (kTfLiteFloat32)
    • Tensor der Größe [1 x num_results x 4]. Das innere Array stellt Begrenzungsrahmen in der Form [oben, links, rechts, unten] dar.
    • BoundingBoxProperties müssen an die Metadaten angehängt werden und type=BOUNDARIES und „coordinate_type=RATIO“ angeben.

    • Klassentensor (kTfLiteFloat32)

    • Tensor der Größe [1 x num_results], wobei jeder Wert den Ganzzahlindex einer Klasse darstellt.

    • Optionale (aber empfohlene) Labelzuordnungen können als AssociatedFile-s mit dem Typ TENSOR_VALUE_LABELS angehängt werden. Sie enthalten ein Label pro Zeile. Beispiel für eine Labeldatei Die erste solche AssociatedFile (falls vorhanden) wird verwendet, um das Feld class_name der Ergebnisse zu füllen. Das Feld display_name wird aus der AssociatedFile (falls vorhanden) gefüllt, deren Gebietsschema mit dem Feld display_names_locale des ObjectDetectorOptions übereinstimmt, das bei der Erstellung verwendet wurde („en“ als Standard, d.h. Englisch). Wenn keine dieser Optionen verfügbar ist, wird nur das Feld index der Ergebnisse ausgefüllt.

    • Scores-Tensor (kTfLiteFloat32)

    • Tensor der Größe [1 x num_results], wobei jeder Wert den Score des erkannten Objekts darstellt.

    • Anzahl der Erkennungstensoren (kTfLiteFloat32)

    • Ganzzahl num_results als Tensor der Größe [1].