Intégrer des détecteurs d'objets

Les détecteurs d'objets peuvent identifier lesquels d'un ensemble connu d'objets pourraient être présents et fournir des informations sur leurs positions dans l'image donnée ou un flux vidéo. Un détecteur d'objets est formé pour détecter la présence et l'emplacement de plusieurs classes d'objets. Par exemple, un modèle peut être formé avec des images qui contiennent divers morceaux de fruits, ainsi qu'une étiquette qui spécifie la classe de fruits qu'ils représentent (par exemple, une pomme, une banane ou une fraise), et des données spécifiant où chaque objet apparaît dans l'image. Voir l' introduction de la détection d'objets pour plus d'informations sur les détecteurs d'objets.

Utilisez l'API Task Library ObjectDetector pour déployer vos détecteurs d'objets personnalisés ou pré-formés dans vos applications mobiles.

Principales fonctionnalités de l'API ObjectDetector

• Traitement de l'image d'entrée, y compris la rotation, le redimensionnement et la conversion de l'espace colorimétrique.

• Étiqueter les paramètres régionaux de la carte.

• Seuil de score pour filtrer les résultats.

• Top-k résultats de détection.

• Étiquetez la liste d'autorisation et la liste de refus.

Modèles de détecteurs d'objets pris en charge

Les modèles suivants sont garantis compatibles avec l'API ObjectDetector .

• Les modèles de détection d'objets pré-entraînés sur TensorFlow Hub .

• Modèles créés par AutoML Vision Edge Object Detection .

• Modèles créés par TensorFlow Lite Model Maker pour le détecteur d'objets .

• Modèles personnalisés qui répondent aux exigences de compatibilité des modèles .

Exécuter l'inférence en Java

Voir l' application de référence Object Detection pour un exemple d'utilisation d' ObjectDetector dans une application Android.

Étape 1 : Importer la dépendance Gradle et d'autres paramètres

Copiez le fichier de modèle .tflite dans le répertoire assets du module Android où le modèle sera exécuté. Spécifiez que le fichier ne doit pas être compressé et ajoutez la bibliothèque TensorFlow Lite au fichier build.gradle du module :

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 (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-vision'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Remarque : à partir de la version 4.1 du plugin Android Gradle, .tflite sera ajouté à la liste noCompress par défaut et les aaptOptions ci-dessus ne sont plus nécessaires.

Étape 2 : Utilisation du modèle

// 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);

Voir le code source et javadoc pour plus d'options pour configurer ObjectDetector .

Exécuter l'inférence dans iOS

Étape 1 : Installer les dépendances

La bibliothèque de tâches prend en charge l'installation à l'aide de CocoaPods. Assurez-vous que CocoaPods est installé sur votre système. Veuillez consulter le guide d'installation de CocoaPods pour obtenir des instructions.

Veuillez consulter le guide CocoaPods pour plus de détails sur l'ajout de pods à un projet Xcode.

Ajoutez le pod TensorFlowLiteTaskVision dans le Podfile.

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

Assurez-vous que le modèle .tflite que vous utiliserez pour l'inférence est présent dans votre app bundle.

Étape 2 : Utilisation du modèle

Rapide

// 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)

Objectif 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];

Consultez le code source pour plus d'options pour configurer TFLObjectDetector .

Exécuter l'inférence en Python

Étape 1 : Installez le package pip

pip install tflite-support

Étape 2 : Utilisation du modèle

# 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)

Voir le code source pour plus d'options pour configurer ObjectDetector .

Exécuter l'inférence en C++

// 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();

Voir le code source pour plus d'options pour configurer ObjectDetector .

Exemples de résultats

Voici un exemple des résultats de détection de ssd mobilenet v1 de TensorFlow Hub.

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

Affichez les cadres de délimitation sur l'image d'entrée :

Essayez l' outil de démonstration CLI simple pour ObjectDetector avec votre propre modèle et vos données de test.

Exigences de compatibilité des modèles

L'API ObjectDetector attend un modèle TFLite avec des métadonnées de modèle TFLite obligatoires. Consultez des exemples de création de métadonnées pour les détecteurs d'objets à l'aide de l' API TensorFlow Lite Metadata Writer .

Les modèles de détecteurs d'objets compatibles doivent répondre aux exigences suivantes :

• Tenseur d'image d'entrée : (kTfLiteUInt8/kTfLiteFloat32)

  • entrée d'image de taille [batch x height x width x channels] .
  • l'inférence par lot n'est pas prise en charge ( batch doit être égal à 1).
  • seules les entrées RVB sont prises en charge ( channels doivent être 3).
  • si le type est kTfLiteFloat32, NormalizationOptions doit être joint aux métadonnées pour la normalisation des entrées.

• Les tenseurs de sortie doivent être les 4 sorties d'une DetectionPostProcess , c'est-à-dire :

  • Tenseur d'emplacements (kTfLiteFloat32)
    • tenseur de taille [1 x num_results x 4] , le tableau interne représentant les boîtes englobantes sous la forme [top, left, right, bottom].
    • Les BoundingBoxProperties doivent être attachées aux métadonnées et doivent spécifier type=BOUNDARIES et `coordinate_type=RATIO.

  • Tenseur de classes (kTfLiteFloat32)

    • tenseur de taille [1 x num_results] , chaque valeur représentant l'indice entier d'une classe.
    • Les cartes d'étiquettes facultatives (mais recommandées) peuvent être attachées en tant qu'AssociatedFile-s avec le type TENSOR_VALUE_LABELS, contenant une étiquette par ligne. Voir l' exemple de fichier d'étiquette . Le premier AssociatedFile (le cas échéant) est utilisé pour remplir le champ class_name des résultats. Le champ display_name est renseigné à partir de l'AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent au champ display_names_locale des ObjectDetectorOptions utilisés au moment de la création ("en" par défaut, c'est-à-dire l'anglais). Si aucun de ceux-ci n'est disponible, seul le champ d' index des résultats sera rempli.

  • Tenseur des scores (kTfLiteFloat32)

    • tenseur de taille [1 x num_results] , chaque valeur représentant le score de l'objet détecté.

  • Nombre de tenseur de détection (kTfLiteFloat32)

    • entier num_results comme un tenseur de taille [1] .