Intégrer des détecteurs d'objets

Les détecteurs d'objets peuvent identifier les objets d'un ensemble connu qui peuvent être présents et fournir des informations sur leur position dans l'image ou le flux vidéo donné. Un détecteur d'objets est entraîné à détecter la présence et l'emplacement de plusieurs classes d'objets. Par exemple, un modèle peut être entraîné avec des images contenant divers fruits, ainsi qu'une étiquette spécifiant la classe de fruits qu'ils représentent (par exemple, une pomme, une banane ou une fraise) et des données indiquant où chaque objet apparaît dans l'image. Pour en savoir plus sur les détecteurs d'objets, consultez l'exemple de détection d'objets.

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

Principales fonctionnalités de l'API ObjectDetector

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

  • Paramètres régionaux de la carte des libellés.

  • Seuil de score permettant de filtrer les résultats.

  • Résultats de détection top-k.

  • Listes d'autorisation et de blocage de libellés.

Modèles de détecteur d'objets compatibles

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

Exécuter une inférence en Java

Consultez l'application de référence Object Detection pour obtenir un exemple d'utilisation de 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 des éléments du module Android dans lequel 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
    implementation 'org.tensorflow:tensorflow-lite-task-vision'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Étape 2 : Utiliser le 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);

Consultez le code source et le Javadoc pour découvrir d'autres options de configuration de ObjectDetector.

Exécuter l'inférence dans iOS

Étape 1 : Installez les dépendances

La bibliothèque de tâches est compatible avec l'installation à l'aide de CocoaPods. Assurez-vous que CocoaPods est installé sur votre système. Pour obtenir des instructions, consultez le guide d'installation de CocoaPods.

Pour savoir comment ajouter des pods à un projet Xcode, consultez le guide CocoaPods.

Ajoutez le pod TensorFlowLiteTaskVision dans le fichier 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 package d'application.

Étape 2 : Utiliser le modèle

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

Pour découvrir d'autres options de configuration de TFLObjectDetector, consultez le code source.

Exécuter l'inférence en Python

Étape 1 : Installez le package pip

pip install tflite-support

Étape 2 : Utiliser le 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)

Pour découvrir d'autres options de configuration de ObjectDetector, consultez le code source.

Exécuter une 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();

Pour découvrir d'autres options de configuration de ObjectDetector, consultez le code source.

Exemples de résultats

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

chiens

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 :

résultat de la détection

Essayez l'outil de démonstration simple de l'interface de ligne de commande 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étection d'objets compatibles doivent répondre aux exigences suivantes :

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

    • image d'entrée de taille [batch x height x width x channels].
    • L'inférence par lots n'est pas acceptée (batch doit être défini sur 1).
    • Seules les entrées RVB sont acceptées (channels doit être égal à 3).
    • Si le type est kTfLiteFloat32, des options de normalisation doivent être associées aux métadonnées pour la normalisation des entrées.

  • Les Tensors de sortie doivent être les quatre sorties d'une opération DetectionPostProcess, c'est-à-dire :

    • Tensor des emplacements (kTfLiteFloat32)
    • Tensor de taille [1 x num_results x 4], le tableau intérieur représentant les cadres de sélection sous la forme [haut, gauche, droite, bas].
    • Les BoundingBoxProperties doivent être associées aux métadonnées et doivent spécifier type=BOUNDARIES et "coordinate_type=RATIO".

    • Classes tensor (kTfLiteFloat32)

    • Tensor de taille [1 x num_results], chaque valeur représentant l'index entier d'une classe.

    • Des fichiers de mappage de libellés facultatifs (mais recommandés) peuvent être associés en tant que fichiers associés de type TENSOR_VALUE_LABELS, contenant un libellé par ligne. Consultez l'exemple de fichier de libellés. Le premier AssociatedFile de ce type (le cas échéant) est utilisé pour remplir le champ class_name des résultats. Le champ display_name est rempli à partir de AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent au champ display_names_locale de ObjectDetectorOptions utilisé lors de la création ("en" par défaut, c'est-à-dire l'anglais). Si aucune de ces informations n'est disponible, seul le champ index des résultats sera renseigné.

    • Tensor de scores (kTfLiteFloat32)

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

    • Nombre de tenseurs de détection (kTfLiteFloat32)

    • Entier num_results sous forme de Tensor de taille [1].