Integrare la segmentazione delle immagini

I segmenti di immagini prevedono se ogni pixel di un'immagine è associato a un di una determinata classe. A differenza del rilevamento degli oggetti, che rileva oggetti in regioni rettangolari e la classificazione delle immagini, che classifica l'insieme dell'immagine. Consulta la panoramica sulla segmentazione delle immagini esempio per ulteriori informazioni sui segmentatori di immagini.

Utilizza l'API ImageSegmenter della libreria attività per eseguire il deployment dei segmentatori di immagini personalizzati o preaddestrati nelle tue app mobile.

Funzionalità principali dell'API ImageSegmenter

  • Elaborazione dell'immagine di input, inclusi rotazione, ridimensionamento e spazio colore e conversione in blocco.

  • Assegna un'etichetta alle impostazioni internazionali della mappa.

  • Due tipi di output: maschera di categoria e maschere di confidenza.

  • Etichetta colorata a scopo di visualizzazione.

Modelli di segmentazione delle immagini supportati

La compatibilità dei seguenti modelli è garantita con ImageSegmenter tramite Google Cloud CLI o tramite l'API Compute Engine.

Esegui l'inferenza in Java

Consulta le Informazioni di riferimento sulla segmentazione delle immagini app per un esempio di come utilizzare ImageSegmenter in un'app per Android.

Passaggio 1: importa la dipendenza da Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo per Android in cui verrà eseguito il modello. Specifica che il file non deve essere compresso. aggiungi 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
    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);

Vedi i codici sorgente e javadoc per altre opzioni di configurazione di ImageSegmenter.

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La libreria attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installata sul sistema. Consulta l'articolo sull'installazione di CocoaPods guida per istruzioni.

Consulta la sezione CocoaPods guida per i dettagli aggiungendo pod a un progetto Xcode.

Aggiungi il pod TensorFlowLiteTaskVision al podfile.

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

Assicurati che il modello .tflite che utilizzerai per l'inferenza sia presente nella dell'app bundle.

Passaggio 2: utilizzo del modello

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

Consulta la fonte codice per altre opzioni di configurazione di 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.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)

Consulta la fonte codice per altre opzioni di configurazione di 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();

Consulta la fonte codice per altre opzioni di configurazione di ImageSegmenter.

Risultati di esempio

Ecco un esempio dei risultati di segmentazione deeplab_v3, un modello di segmentazione generico disponibile in 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 avere il seguente aspetto:

segmentation-output

Prova il semplice strumento dimostrativo dell'interfaccia a riga di comando per ImageSegmenter con il tuo modello e dati di test.

Requisiti di compatibilità del modello

L'API ImageSegmenter prevede un modello TFLite con modello TFLite obbligatorio Metadati. Visualizza esempi di creazione di metadati per un'immagine utilizzando lo strumento Writer di metadati TensorFlow Lite tramite Google Cloud.

  • Tensore immagine di input (kTfLiteUInt8/kTfLiteFloat32)

    • input immagine di dimensioni [batch x height x width x channels].
    • l'inferenza batch non è supportata (batch deve essere 1).
    • sono supportati solo gli input RGB (è necessario che i valori channels siano 3).
    • se il tipo è kTfLiteFloat32, è necessario che le NormalizationOptions allegati ai metadati per la normalizzazione degli input.

  • Tensore delle maschere di output: (kTfLiteUInt8/kTfLiteFloat32)

    • tensore di dimensione [batch x mask_height x mask_width x num_classes], dove batch deve essere 1, mask_width e mask_height sono i le dimensioni delle maschere di segmentazione prodotte dal modello num_classes è il numero di classi supportate dal modello.
    • le mappe delle etichette facoltative (ma consigliate) possono essere allegate AssociatedFile-s di tipo TENSOR_AXIS_LABELS, contenenti un'etichetta per dalla riga di comando. Il primo AssociatedFile (se presente) viene utilizzato per riempire label (denominato class_name in C++) dei risultati. display_name viene compilato dall'elemento AssociatedFile (se presente) le cui impostazioni internazionali corrispondono alla Campo display_names_locale di ImageSegmenterOptions utilizzato alle data e ora di creazione ("en" per impostazione predefinita, ad es. inglese). Se nessuna di queste opzioni disponibile, verrà compilato solo il campo index dei risultati.