Intégrer des segmenteurs d'images

Les segmenteurs d'images prédisent si chaque pixel d'une image est associé à une certaine classe. Cela contraste avec la détection d'objets, qui détecte les objets dans des régions rectangulaires, et la classification d'images, qui classe l'image globale. Pour en savoir plus sur les segmentateurs d'images, consultez l'exemple de présentation de la segmentation d'images.

Utilisez l'API Task Library ImageSegmenter pour déployer vos segmentateurs d'images personnalisés ou préentraînés dans vos applications mobiles.

Principales fonctionnalités de l'API ImageSegmenter

  • 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.

  • Deux types de sortie : masque de catégorie et masques de confiance.

  • Libellé coloré à des fins d'affichage.

Modèles de segmentation d'images compatibles

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

Exécuter une inférence en Java

Consultez l'application de référence sur la segmentation d'images pour obtenir un exemple d'utilisation de ImageSegmenter 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
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 le Javadoc pour découvrir d'autres options de configuration de ImageSegmenter.

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

Pour découvrir d'autres options de configuration de TFLImageSegmenter, 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)
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)

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

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

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

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 simple de l'interface de ligne de commande 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 des métadonnées de modèle TFLite obligatoires. Consultez des exemples de création de métadonnées pour les segmenteurs d'images à l'aide de l'API TensorFlow Lite Metadata Writer.

  • 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.

  • Tenseur de masques de sortie : (kTfLiteUInt8/kTfLiteFloat32)

    • Tensor de taille [batch x mask_height x mask_width x num_classes], où batch doit être égal à 1, mask_width et mask_height sont les dimensions des masques de segmentation produits par le modèle, et num_classes est le nombre de classes compatibles avec le modèle.
    • Des cartes de libellés facultatives (mais recommandées) peuvent être jointes en tant que AssociatedFile-s de type TENSOR_AXIS_LABELS, contenant un libellé par ligne. Le premier AssociatedFile de ce type (le cas échéant) est utilisé pour remplir le champ label (nommé class_name en C++) des résultats. Le champ display_name est rempli à partir du champ AssociatedFile (le cas échéant) dont le paramètre régional correspond au champ display_names_locale du ImageSegmenterOptions utilisé au moment 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é.