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 segmenteurs d'images

Les segmenteurs d'images prédisent si chaque pixel d'une image est associé à un une certaine classe. Cela diffère de la détection d'objets, qui détecte les objets dans les régions rectangulaires et la classification d'images, qui classe l'ensemble l'image. Consultez la présentation de la segmentation d'image. exemple pour en savoir plus sur les segmenteurs d'images.

Déployer vos segmenteurs d'images personnalisés à l'aide de l'API ImageSegmenter de la bibliothèque de tâches ou pré-entraînés dans vos applications mobiles.

Principales fonctionnalités de l'API ImageSegmenter

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.
Deux types de sortie : le masque de catégorie et les masques de confiance.
Étiquette colorée à des fins d'affichage.

Modèles de segmenteur d'images compatibles

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

Les modèles de segmentation d'image pré-entraînés sur TensorFlow Hub.
Des modèles personnalisés qui répondent aux critères de compatibilité exigences.

Exécuter une inférence en Java

Voir la documentation de référence sur la segmentation d'image l'appli pour obtenir un exemple d'utilisation de ImageSegmenter 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
ImageSegmenterOptions options =
    ImageSegmenterOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setOutputType(OutputType.CONFIDENCE_MASK)
        .build();
ImageSegmenter imageSegmenter =
    ImageSegmenter.createFromFileAndOptions(context, modelFile, options);

// Run inference
List<Segmentation> results = imageSegmenter.segment(image);

Consultez le code source et javadoc pour afficher d'autres options de configuration de ImageSegmenter.

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 la page d'installation de CocoaPods ce guide pour obtenir des instructions.

Veuillez consulter la page CocoaPods guide pour en savoir plus sur en ajoutant des 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: "deeplabv3",
                                            ofType: "tflite") else { return }

let options = ImageSegmenterOptions(modelPath: modelPath)

// Configure any additional options:
// options.outputType = OutputType.confidenceMasks

let segmenter = try ImageSegmenter.segmenter(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: "plane.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let segmentationResult = try segmenter.segment(mlImage: mlImage)

Objective-C

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

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

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

// Configure any additional options:
// options.outputType = TFLOutputTypeConfidenceMasks;

TFLImageSegmenter *segmenter = [TFLImageSegmenter imageSegmenterWithOptions:options
                                                                      error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"plane.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
TFLSegmentationResult *segmentationResult =
    [segmenter segmentWithGMLImage:gmlImage error:nil];

Consultez la source du code pour afficher d'autres options de configuration de TFLImageSegmenter.

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)
segmentation_options = processor.SegmentationOptions(
    output_type=processor.SegmentationOptions.output_type.CATEGORY_MASK)
options = vision.ImageSegmenterOptions(base_options=base_options, segmentation_options=segmentation_options)
segmenter = vision.ImageSegmenter.create_from_options(options)

# Alternatively, you can create an image segmenter in the following manner:
# segmenter = vision.ImageSegmenter.create_from_file(model_path)

# Run inference
image_file = vision.TensorImage.create_from_file(image_path)
segmentation_result = segmenter.segment(image_file)

Consultez la source du code pour afficher d'autres options de configuration de ImageSegmenter.

Exécuter une inférence en C++

// Initialization
ImageSegmenterOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ImageSegmenter> image_segmenter = ImageSegmenter::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 SegmentationResult result = image_segmenter->Segment(*frame_buffer).value();

Consultez la source du code pour afficher d'autres options de configuration de ImageSegmenter.

Exemples de résultats

Voici un exemple des résultats de segmentation de deeplab_v3 un modèle de segmentation générique disponible sur TensorFlow Hub.

avion

Color Legend:
 (r: 000, g: 000, b: 000):
  index       : 0
  class name  : background
 (r: 128, g: 000, b: 000):
  index       : 1
  class name  : aeroplane

# (omitting multiple lines for conciseness) ...

 (r: 128, g: 192, b: 000):
  index       : 19
  class name  : train
 (r: 000, g: 064, b: 128):
  index       : 20
  class name  : tv
Tip: use a color picker on the output PNG file to inspect the output mask with
this legend.

Le masque de catégorie de segmentation doit se présenter comme suit:

segmentation-output

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

Exigences de compatibilité des modèles

L'API ImageSegmenter attend un modèle TFLite avec un modèle TFLite obligatoire Métadonnées. Consulter des exemples de création de métadonnées pour une image segmentateurs à l'aide de TensorFlow Lite Metadata Writer API.

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.
Tensor des masques de sortie: (kTfLiteUInt8/kTfLiteFloat32)
- Tensor de taille [batch x mask_height x mask_width x num_classes], où batch doit avoir la valeur 1, mask_width et mask_height sont les les dimensions des masques de segmentation produits par le modèle ; num_classes est le nombre de classes compatibles avec le modèle.
- des cartes de libellés facultatives (mais recommandées) peuvent être jointes Fichiers associés de type TENSOR_AXIS_LABELS, contenant une étiquette par ligne. Le premier fichier AssociatedFile de ce type (le cas échéant) est utilisé pour remplir l'élément label. (nommé class_name en C++) des résultats. display_name est rempli à partir du fichier AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent à Champ display_names_locale de l'ImageSegmenterOptions 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.