Présentation de LiteRT: l'environnement d'exécution Google hautes performances pour l'IA sur l'appareil, anciennement connu sous le nom de TensorFlow Lite.

Cette page a été traduite par l'API Cloud Translation.

Intégrer des détecteurs d'objets

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

Déployer vos détecteurs d'objets personnalisés à l'aide de l'API ObjectDetector de la bibliothèque de tâches ou pré-entraîné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 l'espace colorimétrique la conversion.
Paramètres régionaux de la carte de libellés.
Seuil de score pour filtrer les résultats.
Résultats de la détection top-k.
Liste d'autorisation et liste de blocage d'étiquettes.

Modèles de détecteur d'objets compatibles

La compatibilité des modèles suivants avec ObjectDetector est garantie. API.

La 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 la détection d'objets
Les modèles personnalisés qui répondent aux exigences de compatibilité des modèles.

Exécuter une inférence en Java

Consultez le Application de référence pour la détection d'objets pour obtenir un exemple d'utilisation de ObjectDetector dans une application Android.

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

Copiez le fichier de modèle .tflite dans le répertoire d'éléments du module Android. où le modèle sera exécuté. Spécifier que le fichier ne doit pas être compressé 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 Javadoc pour afficher d'autres options de configuration de ObjectDetector.

Exécuter une inférence sous iOS

Étape 1: Installez 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. Consultez les Guide d'installation de CocoaPods pour obtenir des instructions.

Consultez les Guide CocoaPods pour pour en savoir plus 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: 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];

Consultez le code source pour afficher d'autres options de configuration de TFLObjectDetector.

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

Consultez le code source pour afficher d'autres options de configuration de ObjectDetector.

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

Consultez le code source pour afficher d'autres options de configuration de ObjectDetector.

Exemples de résultats

Voici un exemple des 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 détection

Essayez la méthode la plus simple Outil de démonstration de la CLI 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 du modèle TFLite. Voir des exemples de création pour les détecteurs d'objets API TensorFlow Lite Metadata Writer.

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

Tensor 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 acceptée (batch doit être défini sur 1).
- Seules les entrées RVB sont acceptées (la valeur de channels doit être 3).
- Si le type est kTfLiteFloat32, les options de normalisation doivent être aux métadonnées pour la normalisation des entrées.
Les Tensors de sortie doivent correspondre aux quatre sorties d'une opération DetectionPostProcess, c'est-à-dire :
- Tensor des emplacements (kTfLiteFloat32) <ph type="x-smartling-placeholder">
  - Tensor de taille [1 x num_results x 4], le tableau interne représentant cadres de délimitation sous la forme [haut, gauche, droite, bas].
  - Les propriétés BoundingBoxProperties doivent être associées aux métadonnées et doit spécifier type=BOUNDARIES et `Coordinat_type=RATIO.
- Tensor des classes (kTfLiteFloat32)
  - Tensor de taille [1 x num_results], chaque valeur représentant le index entier d'une classe.
  - des cartes de libellés facultatives (mais recommandées) peuvent être jointes Fichiers associés de type TENSOR_VALUE_LABELS contenant un libellé par ligne. Consultez le exemple de fichier d'étiquettes. Le premier AssociatedFile (le cas échéant) est utilisé pour remplir le class_name des résultats. Le champ display_name est rempli à partir de l'élément AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent à Champ display_names_locale de l'ObjectDetectorOptions utilisé à date et heure de création ("en" par défaut, c'est-à-dire anglaise). Si aucune de ces options ne correspond disponible, seul le champ index des résultats sera rempli.
- Tensor des scores (kTfLiteFloat32)
  - Tensor de taille [1 x num_results], chaque valeur représentant le le score de l'objet détecté.
- Nombre de Tensors de détection (kTfLiteFloat32)
  - Nombre entier num_results en tant que Tensor de taille [1].