Integrar segmentadores de imágenes

Los segmentadores de imágenes predicen si cada píxel de una imagen está asociado con una determinada clase. Esto contrasta con la detección de objetos , que detecta objetos en regiones rectangulares, y la clasificación de imágenes , que clasifica la imagen en general. Consulte la descripción general de la segmentación de imágenes para obtener más información sobre los segmentadores de imágenes.

Utilice la API ImageSegmenter de la biblioteca de tareas para implementar sus segmentadores de imágenes personalizados o previamente entrenados en sus aplicaciones móviles.

Características clave de la API ImageSegmenter

  • Procesamiento de imágenes de entrada, incluida la rotación, el cambio de tamaño y la conversión del espacio de color.

  • Localización del mapa de etiquetas.

  • Dos tipos de salida, máscara de categoría y máscaras de confianza.

  • Etiqueta de color para fines de visualización.

Modelos de segmentadores de imágenes compatibles

Se garantiza que los siguientes modelos serán compatibles con la API ImageSegmenter .

Ejecutar inferencia en Java

Consulte la aplicación de referencia de Segmentación de imágenes para ver un ejemplo de cómo usar ImageSegmenter en una aplicación de Android.

Paso 1: importar la dependencia de Gradle y otras configuraciones

Copie el archivo del modelo .tflite en el directorio de activos del módulo de Android donde se ejecutará el modelo. Especifique que el archivo no debe comprimirse y agregue la biblioteca TensorFlow Lite al archivo build.gradle del módulo:

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

Paso 2: usar el modelo

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

Consulte el código fuente y javadoc para obtener más opciones para configurar ImageSegmenter .

Ejecutar inferencia en iOS

Paso 1: instalar las dependencias

La biblioteca de tareas admite la instalación mediante CocoaPods. Asegúrese de que CocoaPods esté instalado en su sistema. Consulte la guía de instalación de CocoaPods para obtener instrucciones.

Consulte la guía CocoaPods para obtener detalles sobre cómo agregar pods a un proyecto Xcode.

Agregue el pod TensorFlowLiteTaskVision en el Podfile.

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

Asegúrese de que el modelo .tflite que utilizará para la inferencia esté presente en el paquete de su aplicación.

Paso 2: usar el modelo

Rápido

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

C objetivo

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

Consulte el código fuente para obtener más opciones para configurar TFLImageSegmenter .

Ejecutar inferencia en Python

Paso 1: instale el paquete pip

pip install tflite-support

Paso 2: usar el modelo

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

Consulte el código fuente para obtener más opciones para configurar ImageSegmenter .

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

Consulte el código fuente para obtener más opciones para configurar ImageSegmenter .

Resultados de ejemplo

A continuación se muestra un ejemplo de los resultados de segmentación de deeplab_v3 , un modelo de segmentación genérico disponible en TensorFlow Hub.

avión

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 máscara de categoría de segmentación debería verse así:

salida de segmentación

Pruebe la sencilla herramienta de demostración CLI para ImageSegmenter con su propio modelo y datos de prueba.

Requisitos de compatibilidad del modelo

La API ImageSegmenter espera un modelo TFLite con metadatos del modelo TFLite obligatorios. Vea ejemplos de creación de metadatos para segmentadores de imágenes utilizando la API de escritura de metadatos de TensorFlow Lite .

  • Tensor de imagen de entrada (kTfLiteUInt8/kTfLiteFloat32)

    • entrada de imagen de tamaño [batch x height x width x channels] .
    • No se admite la inferencia por lotes (se requiere que batch sea 1).
    • Solo se admiten entradas RGB (se requieren 3 channels ).
    • si el tipo es kTfLiteFloat32, es necesario adjuntar NormalizationOptions a los metadatos para la normalización de la entrada.
  • Tensor de máscaras de salida: (kTfLiteUInt8/kTfLiteFloat32)

    • tensor de tamaño [batch x mask_height x mask_width x num_classes] , donde se requiere que batch sea 1, mask_width y mask_height son las dimensiones de las máscaras de segmentación producidas por el modelo, y num_classes es el número de clases admitidas por el modelo.
    • Los mapas de etiquetas opcionales (pero recomendados) se pueden adjuntar como AssociatedFile-s con tipo TENSOR_AXIS_LABELS, que contienen una etiqueta por línea. El primer AssociatedFile (si lo hay) se utiliza para completar el campo label (denominado class_name en C++) de los resultados. El campo display_name se completa desde AssociatedFile (si lo hay) cuya configuración regional coincide con el campo display_names_locale de ImageSegmenterOptions utilizado en el momento de la creación ("en" de forma predeterminada, es decir, inglés). Si ninguno de estos está disponible, solo se completará el campo index de los resultados.