Ti presentiamo Google AI Edge Portal: esegui il benchmarking dell'IA di Edge su larga scala. Registrati per richiedere l'accesso durante l'anteprima privata.

Questa pagina è stata tradotta dall'API Cloud Translation.

Integrare la segmentazione delle immagini

I segmentatori 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 con la classificazione delle immagini, che classifica l'immagine complessiva. Per saperne di più sui segmentatori di immagini, consulta l'esempio di panoramica della segmentazione delle immagini.

Utilizza l'API Task Library ImageSegmenter per eseguire il deployment di segmentatori di immagini personalizzati o preaddestrati nelle tue app mobile.

Funzionalità chiave dell'API ImageSegmenter

Elaborazione dell'immagine di input, inclusi rotazione, ridimensionamento e conversione dello spazio colore.
Etichetta della località sulla mappa.
Due tipi di output: maschera di categoria e maschere di confidenza.
Etichetta colorata a scopo di visualizzazione.

Modelli di segmentazione delle immagini supportati

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

I modelli di segmentazione delle immagini preaddestrati su TensorFlow Hub.
Modelli personalizzati che soddisfano i requisiti di compatibilità dei modelli.

Esegui l'inferenza in Java

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

Passaggio 1: importa la dipendenza Gradle e altre impostazioni

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

Per altre opzioni di configurazione di ImageSegmenter, consulta il codice sorgente e javadoc.

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La libreria delle attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installato sul tuo sistema. Per istruzioni, consulta la guida all'installazione di CocoaPods.

Per informazioni dettagliate sull'aggiunta di pod a un progetto Xcode, consulta la guida CocoaPods.

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 bundle dell'app.

Passaggio 2: utilizza il 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];

Per altre opzioni di configurazione di TFLImageSegmenter, consulta il codice sorgente.

Esegui l'inferenza in Python

Passaggio 1: installa il pacchetto pip

pip install tflite-support

Passaggio 2: utilizza il 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 il codice sorgente 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 il codice sorgente per altre opzioni di configurazione di 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 avere il seguente aspetto:

segmentation-output

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

Requisiti di compatibilità del modello

L'API ImageSegmenter prevede un modello TFLite con metadati del modello TFLite obbligatori. Consulta gli esempi di creazione di metadati per i segmentatori di immagini utilizzando l'API TensorFlow Lite Metadata Writer.

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 (channels deve essere 3).
- Se il tipo è kTfLiteFloat32, è necessario allegare NormalizzazioneOptions ai metadati per la normalizzazione dell'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 le dimensioni delle maschere di segmentazione prodotte dal modello e num_classes è il numero di classi supportate dal modello.
- Le mappe delle etichette facoltative (ma consigliate) possono essere allegate come AssociatedFile con tipo TENSOR_AXIS_LABELS, contenenti un'etichetta per riga. Il primo AssociatedFile (se presente) viene utilizzato per compilare il campo label (denominato class_name in C++) dei risultati. Il campo display_name viene compilato dal campo AssociatedFile (se presente) la cui impostazione locale corrisponde al campo display_names_locale del campo ImageSegmenterOptions utilizzato al momento della creazione ("en" per impostazione predefinita, ovvero inglese). Se nessuno di questi è disponibile, verrà compilato solo il campo index dei risultati.