Weitere Informationen zu den Ankündigungen der Google AI Edge auf der Google I/O

Diese Seite wurde von der Cloud Translation API übersetzt.

Objektdetektoren einbinden

Objektdetektoren können ermitteln, welche Objekte einer bekannten Gruppe vorhanden sind und liefern Informationen zu ihren Positionen innerhalb des jeweiligen Bildes oder Videos. . Ein Objektdetektor ist darauf trainiert, die Anwesenheit und den Standort Objektklassen zugeordnet werden können. Beispielsweise kann ein Modell mit Bildern trainiert werden, die verschiedene Obststücke enthalten, sowie ein Label, das die verschiedenen Früchte angibt. Art der Früchte, die sie darstellen (z.B. ein Apfel, eine Banane oder eine Erdbeere) und Daten geben an, wo die einzelnen Objekte im Bild zu sehen sind. Weitere Informationen finden Sie in der Beispiel für eine Objekterkennung finden Sie weitere Informationen zu Objektdetektoren.

Benutzerdefinierte Objektdetektoren mit der ObjectDetector Task Library API bereitstellen in Ihre mobilen Apps integrieren.

Wichtige Features der ObjectDetector API

Eingabebildverarbeitung, einschließlich Drehung, Größenanpassung und Farbraum Conversion.
Sprache der Labelzuordnung.
Punktzahlgrenzwert zum Filtern von Ergebnissen.
Top-K-Erkennungsergebnisse.
Zulassungsliste und Sperrliste für Labels.

Unterstützte Objektdetektormodelle

Die folgenden Modelle sind garantiert kompatibel mit dem ObjectDetector der API erstellen.

Die vortrainierte Objekterkennungsmodelle auf TensorFlow Hub.
Modelle erstellt von AutoML Vision Edge-Objekterkennung
Modelle erstellt von TensorFlow Lite Model Maker für Objektdetektor
Benutzerdefinierte Modelle, die den Anforderungen an die Modellkompatibilität.

Inferenz in Java ausführen

Weitere Informationen finden Sie in der Referenz-App zur Objekterkennung findest du ein Beispiel für die Verwendung von ObjectDetector in einer Android-App.

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

Kopieren Sie die Modelldatei .tflite in das Asset-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 der Datei build.gradle des Moduls die TensorFlow Lite-Bibliothek 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 Informationen finden Sie in der Quellcode und Javadoc finden Sie weitere Optionen zum Konfigurieren von ObjectDetector.

Inferenzen in iOS ausführen

Schritt 1: Abhängigkeiten installieren

Die Task Library unterstützt die Installation mit CocoaPods. Achten Sie darauf, dass CocoaPods auf Ihrem System installiert ist. In der Installationsanleitung für CocoaPods .

In der CocoaPods-Leitfaden für wie Sie Pods zu einem Xcode-Projekt hinzufügen.

Fügen Sie der Podfile-Datei den Pod TensorFlowLiteTaskVision hinzu.

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

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

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 Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von TFLObjectDetector.

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 Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von ObjectDetector.

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 Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von ObjectDetector.

Beispielergebnisse

Hier ist ein Beispiel für die Ergebnisse der Erkennung von ssd mobilenet v1 von 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

Rendern Sie die Begrenzungsrahmen auf dem Eingabebild:

Erkennungsausgabe

Probieren Sie die einfache CLI-Demotool für ObjectDetector mit eigenen Modell- und Testdaten.

Anforderungen an die Modellkompatibilität

Die ObjectDetector API erwartet ein TFLite-Modell mit obligatorischen TFLite-Modellmetadaten. Beispiele für die Erstellung für Objektdetektoren mithilfe des TensorFlow Lite Metadata Writer API

Die kompatiblen Objektdetektormodelle müssen die folgenden Anforderungen erfüllen:

Eingabebild-Tensor: (kTfLiteUInt8/kTfLiteFloat32)
- Bildeingabe mit der Größe [batch x height x width x channels].
- 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.
Ausgabetensoren müssen die vier Ausgaben eines DetectionPostProcess-Vorgangs sein, d. h.:
- Standort-Tensor (kTfLiteFloat32) <ph type="x-smartling-placeholder">
  - Tensor der Größe [1 x num_results x 4], das innere Array, das für Begrenzungsrahmen in der Form [top, left, right, bottom].
  - BoundingBoxProperties müssen an die Metadaten angehängt werden und muss type=BOUNDARIES und `coordinate_type=RATIO angeben.
- Klassen "tensor" (kTfLiteFloat32)
  - Tensor der Größe [1 x num_results], wobei jeder Wert den Ganzzahlindex einer Klasse.
  - optionale (aber empfohlene) Labelzuordnung(en) kann/können als AssociatedFile-s vom Typ TENSOR_VALUE_LABELS mit einem Label pro Zeile. Weitere Informationen finden Sie in der Beispiel-Labeldatei. Die erste solche AssociatedFile (falls vorhanden) wird zum Füllen des class_name der Ergebnisse. Das Feld display_name ist aus AssociatedFile (falls vorhanden) gefüllt, deren Sprache mit der Feld display_names_locale von ObjectDetectorOptions verwendet bei Erstellungszeit (standardmäßig "en", also Englisch). Wenn keiner dieser verfügbar ist, wird nur das Feld index der Ergebnisse gefüllt.
- Score-Tensor (kTfLiteFloat32)
  - Tensor der Größe [1 x num_results], wobei jeder Wert den Wert des erkannten Objekts.
- Anzahl des Erkennungstensors (kTfLiteFloat32)
  - Ganzzahl num_results als Tensor der Größe [1].