Integra clasificadores de imágenes

La clasificación de imágenes es un uso común del aprendizaje automático para identificar representa. Por ejemplo, es posible que queramos saber qué tipo de animal aparece en una imagen determinada. La tarea de predecir lo que representa una imagen se llama clasificación de imágenes. Un clasificador de imágenes se entrena para reconocer varios clases de imágenes. Por ejemplo, un modelo podría entrenarse para que reconozca fotos que representan tres tipos diferentes de animales: conejos, hámsteres y perros. Consulta el ejemplo de clasificación de imágenes para obtener más información sobre los clasificadores de imágenes.

Usa la API de ImageClassifier de la Biblioteca de tareas para implementar tu imagen personalizada clasificadores personalizados o previamente entrenados en sus aplicaciones para dispositivos móviles.

Funciones clave de la API de ImageClassifier

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

  • Región de interés de la imagen de entrada.

  • Etiqueta la configuración regional del mapa.

  • Umbral de puntuación para filtrar los resultados.

  • Resultados de clasificación de Top-K.

  • Lista de entidades permitidas y listas de bloqueo de etiquetas.

Modelos clasificadores de imágenes compatibles

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

Ejecuta inferencias en Java

Consulta la App de referencia de clasificación de imágenes a fin de ver un ejemplo de cómo usar ImageClassifier 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
ImageClassifierOptions options =
    ImageClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
ImageClassifier imageClassifier =
    ImageClassifier.createFromFileAndOptions(
        context, modelFile, options);

// Run inference
List<Classifications> results = imageClassifier.classify(image);

Consulta la código fuente y javadoc si quieres obtener más opciones para configurar ImageClassifier.

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 detalles sobre cómo 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: "birds_V1",
                                            ofType: "tflite") else { return }

let options = ImageClassifierOptions(modelPath: modelPath)

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

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

// Run inference
let classificationResults = try classifier.classify(mlImage: mlImage)

Objective-C

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

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

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

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

TFLImageClassifier *classifier = [TFLImageClassifier imageClassifierWithOptions:options
                                                                          error:nil];

// Convert the input image to MLImage.
UIImage *image = [UIImage imageNamed:@"sparrow.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
TFLClassificationResult *classificationResult =
    [classifier classifyWithGMLImage:gmlImage error:nil];

Consulta la código fuente si quieres obtener más opciones para configurar TFLImageClassifier.

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)
classification_options = processor.ClassificationOptions(max_results=2)
options = vision.ImageClassifierOptions(base_options=base_options, classification_options=classification_options)
classifier = vision.ImageClassifier.create_from_options(options)

# Alternatively, you can create an image classifier in the following manner:
# classifier = vision.ImageClassifier.create_from_file(model_path)

# Run inference
image = vision.TensorImage.create_from_file(image_path)
classification_result = classifier.classify(image)

Consulta la código fuente si quieres obtener más opciones para configurar ImageClassifier.

Ejecuta inferencias en C++

// Initialization
ImageClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::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 ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

Consulta la código fuente si quieres obtener más opciones para configurar ImageClassifier.

Resultados de ejemplo

A continuación, se muestra un ejemplo de los resultados de clasificación de un clasificador de aves.

gorrión

Results:
  Rank #0:
   index       : 671
   score       : 0.91406
   class name  : /m/01bwb9
   display name: Passer domesticus
  Rank #1:
   index       : 670
   score       : 0.00391
   class name  : /m/01bwbt
   display name: Passer montanus
  Rank #2:
   index       : 495
   score       : 0.00391
   class name  : /m/0bwm6m
   display name: Passer italiae

Prueba lo sencillo Herramienta de demostración de la CLI para ImageClassifier con tu propio modelo y datos de prueba.

Requisitos de compatibilidad del modelo

La API de ImageClassifier espera un modelo TFLite con Metadatos del modelo de TFLite. Consulta ejemplos de creación de metadatos para clasificadores de imágenes con el API de TensorFlow Lite Metadata Writer

Los modelos clasificadores de imágenes 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 (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 puntuación de salida (kTfLiteUInt8/kTfLiteFloat32)

    • con clases N y 2 o 4 dimensiones, es decir, [1 x N] o [1 x 1 x 1 x N]
    • Mapas de etiquetas opcionales (pero recomendados) como AssociatedFile-s con tipo TENSOR_AXIS_LABELS, que contiene una etiqueta por línea. Consulta la ejemplo de archivo de etiqueta. El primer archivo AssociatedFile (si corresponde) se usa para completar el campo label. (llamada class_name en C++) de los resultados. El campo display_name se completará desde el AssociatedFile (si existe) cuya configuración regional coincida con Campo display_names_locale de la ImageClassifierOptions 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.