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.

Integra detectores de objetos

Los detectores de objetos pueden identificar cuáles de un conjunto conocido de objetos podrían estar presentes y proporcionar información sobre sus posiciones dentro de la imagen o el flujo de video determinados. Se entrena un detector de objetos para detectar la presencia y la ubicación de varias clases de objetos. Por ejemplo, un modelo se puede entrenar con imágenes que contienen varias frutas, junto con una etiqueta que especifica la clase de fruta que representan (p.ej., una manzana, una banana o una fresa) y datos que especifican dónde aparece cada objeto en la imagen. Consulta el ejemplo de detección de objetos para obtener más información sobre los detectores de objetos.

Usa la API de la biblioteca de tareas ObjectDetector para implementar tus detectores de objetos personalizados o los preentrenados en tus apps para dispositivos móviles.

Funciones clave de la API de ObjectDetector

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.
Es el umbral de puntuación para filtrar los resultados.
Son los resultados de detección de los k elementos más relevantes.
Listas de entidades permitidas y denegadas de etiquetas

Modelos de detectores de objetos compatibles

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

Los modelos de detección de objetos previamente entrenados en TensorFlow Hub.
Modelos creados por la detección de objetos de AutoML Vision Edge.
Modelos creados por TensorFlow Lite Model Maker para el detector de objetos.
Modelos personalizados que cumplen con los requisitos de compatibilidad del modelo.

Ejecuta la inferencia en Java

Consulta la app de referencia de detección de objetos para ver un ejemplo de cómo usar ObjectDetector 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
ObjectDetectorOptions options =
    ObjectDetectorOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ObjectDetector objectDetector =
    ObjectDetector.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Detection> results = objectDetector.detect(image);

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

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: "ssd_mobilenet_v1",
                                            ofType: "tflite") else { return }

let options = ObjectDetectorOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let detector = try ObjectDetector.detector(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: "cats_and_dogs.jpg"), let mlImage = MLImage(image: image) else { return }

// Run inference
let detectionResult = try detector.detect(mlImage: mlImage)

Objective-C

// Imports
#import <TensorFlowLiteTaskVision/TensorFlowLiteTaskVision.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"ssd_mobilenet_v1" ofType:@"tflite"];

TFLObjectDetectorOptions *options = [[TFLObjectDetectorOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLObjectDetector *detector = [TFLObjectDetector objectDetectorWithOptions:options
                                                                     error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"dogs.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
TFLDetectionResult *detectionResult = [detector detectWithGMLImage:gmlImage error:nil];

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

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)
detection_options = processor.DetectionOptions(max_results=2)
options = vision.ObjectDetectorOptions(base_options=base_options, detection_options=detection_options)
detector = vision.ObjectDetector.create_from_options(options)

# Alternatively, you can create an object detector in the following manner:
# detector = vision.ObjectDetector.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
detection_result = detector.detect(image)

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

Ejecuta la inferencia en C++

// Initialization
ObjectDetectorOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ObjectDetector> object_detector = ObjectDetector::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 DetectionResult result = object_detector->Detect(*frame_buffer).value();

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

Resultados de ejemplo

A continuación, se muestra un ejemplo de los resultados de detección de ssd mobilenet v1 de TensorFlow Hub.

dogs

Results:
 Detection #0 (red):
  Box: (x: 355, y: 133, w: 190, h: 206)
  Top-1 class:
   index       : 17
   score       : 0.73828
   class name  : dog
 Detection #1 (green):
  Box: (x: 103, y: 15, w: 138, h: 369)
  Top-1 class:
   index       : 17
   score       : 0.73047
   class name  : dog

Renderiza los cuadros de límite en la imagen de entrada:

Resultado de la detección

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

Requisitos de compatibilidad del modelo

La API de ObjectDetector espera un modelo de TFLite con metadatos del modelo de TFLite obligatorios. Consulta ejemplos de cómo crear metadatos para detectores de objetos con la API de TensorFlow Lite Metadata Writer.

Los modelos de detección de objetos compatibles deben cumplir con los siguientes requisitos:

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.
Los tensores de salida deben ser los 4 resultados de una operación DetectionPostProcess, es decir:
- Tensor de ubicaciones (kTfLiteFloat32)
- Tensor de tamaño [1 x num_results x 4], en el que el array interno representa cuadros de límite en el formato [arriba, izquierda, derecha, abajo].
- Las propiedades de BoundingBox deben adjuntarse a los metadatos y especificar type=BOUNDARIES y "coordinate_type=RATIO".
- Tensor de clases (kTfLiteFloat32)
- Tensor de tamaño [1 x num_results], en el que cada valor representa el índice entero de una clase.
- Se pueden adjuntar mapas de etiquetas opcionales (pero recomendados) como AssociatedFile-s con el tipo TENSOR_VALUE_LABELS, que contienen una etiqueta por línea. Consulta el archivo de etiquetas de ejemplo. El primer AssociatedFile de este tipo (si hay alguno) se usa para completar el campo class_name de los resultados. El campo display_name se completa a partir del AssociatedFile (si hay alguno) cuya configuración regional coincide con el campo display_names_locale del ObjectDetectorOptions que se usó 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.
- Tensor de puntuaciones (kTfLiteFloat32)
- Tensor de tamaño [1 x num_results], en el que cada valor representa la puntuación del objeto detectado.
- Cantidad de tensores de detección (kTfLiteFloat32)
- Es un número entero num_results como un tensor de tamaño [1].