Presentamos Google AI Edge Portal: Compara la IA de Edge a gran escala. Regístrate para solicitar acceso durante la vista previa privada.

Se usó la API de Cloud Translation para traducir esta página.

Integrar segmentadores de imágenes

Los segmentadores de imágenes predicen si cada píxel de una imagen se asocia con una clase determinada. 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 general. Consulta el ejemplo de descripción general de la segmentación de imágenes para obtener más información sobre los segmentadores de imágenes.

Usa la API de la biblioteca de tareas ImageSegmenter para implementar segmentadores de imágenes personalizados o preentrenados en tus apps para dispositivos móviles.

Funciones clave de la API de ImageSegmenter

Procesamiento de imágenes de entrada, incluida la rotación, el cambio de tamaño y la conversión del espacio de color
Es la configuración regional del mapa de etiquetas.
Dos tipos de salida: máscara de categoría y máscaras de confianza.
Es una etiqueta de color para fines de visualización.

Modelos de segmentación de imágenes compatibles

Se garantiza que los siguientes modelos son compatibles con la API de ImageSegmenter.

Los modelos de segmentación de imágenes previamente entrenados en TensorFlow Hub
Modelos personalizados que cumplen con los requisitos de compatibilidad del modelo

Ejecuta la inferencia en Java

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

Paso 1: Importa la dependencia de Gradle y otros parámetros de configuración

Copia el archivo del modelo .tflite en el directorio de recursos del módulo de Android en el que se ejecutará el modelo. Especifica que el archivo no se debe comprimir y agrega la biblioteca de 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
    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: Cómo 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);

Consulta el código fuente y el Javadoc para obtener más opciones para configurar ImageSegmenter.

Ejecuta la inferencia en iOS

Paso 1: Instala las dependencias

La biblioteca de tareas admite la instalación con CocoaPods. Asegúrate de que CocoaPods esté instalado en tu sistema. Consulta la guía de instalación de CocoaPods para obtener instrucciones.

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

Agrega el pod de TensorFlowLiteTaskVision en el Podfile.

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

Asegúrate de que el modelo .tflite que usarás para la inferencia esté presente en el paquete de tu app.

Paso 2: Cómo usar el modelo

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 el código fuente para obtener más opciones para configurar TFLImageSegmenter.

Ejecuta la inferencia en Python

Paso 1: Instala el paquete pip

pip install tflite-support

Paso 2: Cómo 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)

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

Ejecuta la 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();

Consulta 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 la 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 de la siguiente manera:

segmentation-output

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

Requisitos de compatibilidad del modelo

La API de ImageSegmenter espera un modelo de TFLite con metadatos del modelo de TFLite obligatorios. Consulta ejemplos de cómo crear metadatos para segmentadores de imágenes con la API de TensorFlow Lite Metadata Writer.

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 (batch debe ser 1).
- Solo se admiten entradas RGB (channels debe ser 3).
- Si el tipo es kTfLiteFloat32, se requiere que NormalizationOptions se adjunte 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], en el que batch debe ser 1, mask_width y mask_height son las dimensiones de las máscaras de segmentación que produce el modelo, y num_classes es la cantidad de clases que admite el modelo.
- Se pueden adjuntar mapas de etiquetas opcionales (pero recomendados) como AssociatedFile-s con el tipo TENSOR_AXIS_LABELS, que contienen una etiqueta por línea. El primer AssociatedFile de este tipo (si existe) se usa para completar el campo label (denominado class_name en C++) de los resultados. El campo display_name se completa con el AssociatedFile (si existe) cuya configuración regional coincide con el campo display_names_locale del ImageSegmenterOptions que se usó en el momento de la creación ("en" de forma predeterminada, es decir, inglés). Si no hay ninguno disponible, solo se completará el campo index de los resultados.