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. Consultez la présentation de la segmentation d’images pour plus d’informations sur les segmenteurs d’images.
Utilisez l'API ImageSegmenter
de la bibliothèque de tâches pour déployer vos segmenteurs d'images personnalisés 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 la conversion de l'espace colorimétrique.
Paramètres régionaux de la carte d'étiquettes.
Deux types de sortie, masque de catégorie et masques de confiance.
Étiquette colorée à des fins d’affichage.
Modèles de segmentation d'images pris en charge
Les modèles suivants sont garantis compatibles avec l'API ImageSegmenter
.
Les modèles de segmentation d'images pré-entraînés sur TensorFlow Hub .
Modèles personnalisés qui répondent aux exigences de compatibilité des modèles .
Exécuter l'inférence en Java
Consultez l' application de référence Image Segmentation pour un exemple d'utilisation 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 ressources 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'
}
Étape 2 : Utilisation du 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);
Voir le code source et javadoc pour plus d'options pour configurer ImageSegmenter
.
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 bundle d'applications.
Étape 2 : Utilisation du modèle
Rapide
// 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)
Objectif 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 le code source pour plus d'options pour configurer TFLImageSegmenter
.
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)
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 le code source pour plus d'options pour configurer ImageSegmenter
.
Exécuter l'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 le code source pour plus d'options pour configurer 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.
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 devrait ressembler à :
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 des métadonnées de modèle TFLite obligatoires. Découvrez 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)
- entrée d'image de taille
[batch x height x width x channels]
. - L'inférence par lots n'est pas prise en charge (
batch
doit être 1). - seules les entrées RVB sont prises en charge (
channels
doivent être au nombre de 3). - si le type est kTfLiteFloat32, les NormalizationOptions doivent être attachées aux métadonnées pour la normalisation des entrées.
- entrée d'image de taille
Tenseur des masques de sortie : (kTfLiteUInt8/kTfLiteFloat32)
- tenseur de taille
[batch x mask_height x mask_width x num_classes]
, oùbatch
doit être égal à 1,mask_width
etmask_height
sont les dimensions des masques de segmentation produits par le modèle, etnum_classes
est le nombre de classes prises en charge par le modèle. - Des cartes d'étiquettes facultatives (mais recommandées) peuvent être attachées en tant qu'AssociatedFile-s avec le type TENSOR_AXIS_LABELS, contenant une étiquette par ligne. Le premier AssociatedFile (le cas échéant) est utilisé pour remplir le champ
label
(nomméclass_name
en C++) des résultats. Le champdisplay_name
est rempli à partir de l'AssociatedFile (le cas échéant) dont les paramètres régionaux correspondent au champdisplay_names_locale
desImageSegmenterOptions
utilisés au moment de la création ("en" par défaut, c'est-à-dire l'anglais). Si aucun de ces éléments n'est disponible, seul le champindex
des résultats sera renseigné.
- tenseur de taille