Questa pagina è stata tradotta dall'API Cloud Translation.

Integra segmenter di immagini

I segmenter di immagini prevedono se ogni pixel di un'immagine è associato a una determinata classe. Ciò è in contrasto con il rilevamento degli oggetti , che rileva gli oggetti in regioni rettangolari, e la classificazione delle immagini , che classifica l'immagine complessiva. Consulta la panoramica della segmentazione delle immagini per ulteriori informazioni sui segmenter delle immagini.

Usa l'API ImageSegmenter di Task Library per distribuire i tuoi segmenter di immagini personalizzati o quelli preaddestrati nelle tue app mobili.

Caratteristiche principali dell'API ImageSegmenter

Elaborazione dell'immagine di input, inclusa rotazione, ridimensionamento e conversione dello spazio colore.
Etichettare la localizzazione della mappa.
Due tipi di output, maschera di categoria e maschere di confidenza.
Etichetta colorata a scopo di visualizzazione.

Modelli di segmentatore di immagini supportati

I seguenti modelli sono garantiti per essere compatibili con l'API ImageSegmenter .

I modelli di segmentazione dell'immagine pre-addestrati su TensorFlow Hub .
Modelli personalizzati che soddisfano i requisiti di compatibilità del modello .

Esegui l'inferenza in Java

Vedere l' app di riferimento per la segmentazione delle immagini per un esempio di come utilizzare ImageSegmenter in un'app Android.

Passaggio 1: importa la dipendenza da Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo Android in cui verrà eseguito il modello. Specificare che il file non deve essere compresso e aggiungere la libreria TensorFlow Lite al file build.gradle del modulo:

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'
}

Passaggio 2: utilizzo del modello

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

Vedere il codice sorgente e javadoc per ulteriori opzioni per configurare ImageSegmenter .

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La Libreria attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installato sul tuo sistema. Consulta la guida all'installazione di CocoaPods per le istruzioni.

Consulta la guida CocoaPods per i dettagli sull'aggiunta di pod a un progetto Xcode.

Aggiungi il pod TensorFlowLiteTaskVision nel Podfile.

target 'MyAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskVision'
end

Assicurati che il modello .tflite che utilizzerai per l'inferenza sia presente nel tuo app bundle.

Passaggio 2: utilizzo del modello

Veloce

// 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)

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

Vedere il codice sorgente per ulteriori opzioni per configurare TFLImageSegmenter .

Esegui l'inferenza in Python

Passaggio 1: installa il pacchetto pip

pip install tflite-support

Passaggio 2: utilizzo del modello

# 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.OutputType.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)

Vedere il codice sorgente per ulteriori opzioni per configurare ImageSegmenter .

Esegui l'inferenza in 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();

Vedere il codice sorgente per ulteriori opzioni per configurare ImageSegmenter .

Risultati di esempio

Ecco un esempio dei risultati della segmentazione di deeplab_v3 , un modello di segmentazione generico disponibile su TensorFlow Hub.

aereo

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.

La maschera della categoria di segmentazione dovrebbe essere simile a:

segmentazione-output

Prova il semplice strumento demo CLI per ImageSegmenter con il tuo modello e i tuoi dati di prova.

Requisiti di compatibilità del modello

L'API ImageSegmenter prevede un modello TFLite con metadati del modello TFLite obbligatori. Vedere esempi di creazione di metadati per segmenter di immagini utilizzando l' API di scrittura di metadati TensorFlow Lite .

Tensore dell'immagine di ingresso (kTfLiteUInt8/kTfLiteFloat32)
- input dell'immagine della dimensione [batch x height x width x channels] .
- l'inferenza batch non è supportata ( batch deve essere 1).
- sono supportati solo gli ingressi RGB (i channels devono essere 3).
- se il tipo è kTfLiteFloat32, NormalizationOptions deve essere allegato ai metadati per la normalizzazione dell'input.
Tensore delle maschere di uscita: (kTfLiteUInt8/kTfLiteFloat32)
- tensor of size [batch x mask_height x mask_width x num_classes] , dove batch deve essere 1, mask_width e mask_height sono le dimensioni delle maschere di segmentazione prodotte dal modello e num_classes è il numero di classi supportate dal modello.
- Le mappe di etichette opzionali (ma consigliate) possono essere allegate come AssociatedFile-s con tipo TENSOR_AXIS_LABELS, contenente un'etichetta per riga. Il primo di tali AssociatedFile (se presente) viene utilizzato per riempire il campo label (denominato class_name in C++) dei risultati. Il campo display_name viene compilato dall'AssociatedFile (se presente) le cui impostazioni internazionali corrispondono al campo display_names_locale di ImageSegmenterOptions utilizzato al momento della creazione ("en" per impostazione predefinita, ovvero inglese). Se nessuno di questi è disponibile, verrà riempito solo il campo index dei risultati.