Introducing LiteRT: El entorno de ejecución de alto rendimiento de Google para la IA integrada en el dispositivo, antes conocido como TensorFlow Lite.

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 está asociado 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. Consulta la descripción general de la segmentación de imágenes ejemplo para obtener más información sobre los segmentos de imágenes.

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

Funciones clave de la API de ImageSegmenter

Procesamiento de imágenes de entrada, incluidos la rotación, el cambio de tamaño y el espacio de color conversión.
Etiqueta la configuración regional del mapa.
Dos tipos de salida: máscara de categoría y máscaras de confianza.
Etiqueta de color para mostrarla.

Modelos de segmentadores de imágenes admitidos

Se garantiza la compatibilidad de los siguientes modelos con ImageSegmenter en la API de Cloud.

Los modelos de segmentación de imágenes previamente entrenados en TensorFlow Hub
Modelos personalizados que cumplen con la compatibilidad de modelos empresariales y de seguridad.

Ejecuta inferencias en Java

Consulta la referencia sobre la segmentación de imágenes. app a fin de 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 de modelo .tflite en el directorio de recursos del módulo de Android. en la que se ejecutará el modelo. Especificar que el archivo no debe comprimirse 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: Usa 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 javadoc si quieres 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 instalación de CocoaPods guía para obtener instrucciones.

Consulta los CocoaPods guía para obtener información sobre agregar Pods a un proyecto Xcode.

Agrega el Pod 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 tu paquete de aplicación.

Paso 2: Usa 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 la fuente código si quieres obtener más opciones para configurar TFLImageSegmenter.

Ejecuta la inferencia en Python

Paso 1: Instala el paquete pip

pip install tflite-support

Paso 2: Usa 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 la fuente código si quieres obtener más opciones para configurar ImageSegmenter.

Ejecuta inferencias 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 la fuente código si quieres obtener más opciones para configurar ImageSegmenter.

Resultados de ejemplo

Este es un ejemplo de los resultados de segmentación de deeplab_v3 un modelo de segmentación genérica 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í:

segmentation-output

Prueba la sencilla herramienta de demostración de 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 el modelo de TFLite obligatorio Metadatos. Ver ejemplos de cómo crear metadatos de imágenes segmentadores con el Escritor de metadatos de TensorFlow Lite de la API de Google Ads.

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 requiere que channels sea 3).
- si el tipo es kTfLiteFloat32, NormalizationOptions debe se adjuntan a los metadatos para la normalización de 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 producidas por el modelo num_classes es la cantidad de clases que admite el modelo.
- se pueden adjuntar mapas de etiquetas opcionales (pero recomendados) como AssociatedFiles con el tipo TENSOR_AXIS_LABELS, que contiene una etiqueta por línea. El primer archivo AssociatedFile (si corresponde) se usa para completar el label. (llamado class_name en C++) de los resultados. El display_name se rellena desde el AssociatedFile (si existe) cuya configuración regional coincida con Campo display_names_locale de la ImageSegmenterOptions utilizada en “en” (“en”) de forma predeterminada, es decir, en inglés. Si ninguna de estas opciones es disponible, solo se completará el campo index de los resultados.