¡Google I/O es una envoltura! Póngase al día con las sesiones de TensorFlow Ver sesiones

Integrar clasificadores de imágenes

La clasificación de imágenes es un uso común del aprendizaje automático para identificar lo que representa una imagen. Por ejemplo, podríamos querer saber qué tipo de animal aparece en una imagen dada. La tarea de predecir lo que representa una imagen se denomina clasificación de imágenes. Un clasificador de imágenes está entrenado para reconocer varias clases de imágenes. Por ejemplo, se puede entrenar a un modelo para que reconozca fotografías que representen tres tipos diferentes de animales: conejos, hámsteres y perros. Consulte la descripción general de la clasificación de imágenes para obtener más información sobre los clasificadores de imágenes.

Utilice la API de ImageClassifier de la biblioteca de tareas para implementar sus clasificadores de imágenes personalizados o preentrenados en sus aplicaciones móviles.

Características clave de la API de ImageClassifier

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

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

  • Localización del mapa de etiquetas.

  • Umbral de puntuación para filtrar resultados.

  • Resultados de la clasificación Top-k.

  • Etiquete la lista de permitidos y la lista de denegados.

Modelos de clasificador de imágenes admitidos

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

Ejecutar inferencia en Java

Consulte la aplicación de referencia Clasificación de imágenes para ver un ejemplo de cómo usar ImageClassifier 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. Especifica que el archivo no debe comprimirse y agrega 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:0.4.0'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.0'
}

Paso 2: Usando 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);

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

Ejecutar inferencia en iOS

Paso 1: Instala 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 de CocoaPods para obtener detalles sobre cómo agregar pods a un proyecto de Xcode.

Agregue el pod de TensorFlowLiteTaskVision en el Podfile.

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

Asegúrese de que el modelo .tflite que usará para la inferencia esté presente en su paquete de aplicaciones.

Paso 2: Usando el modelo

Rápido

// 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.imageClassifier(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(gmlImage: mlImage)

C objetivo

// Imports
#import <TensorFlowLiteTaskVision/TFLTaskVision.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];

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

Ejecutar inferencia en Python

Paso 1: Instale el paquete pip

pip install tflite-support

Paso 2: Usando 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)

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

Ejecutar inferencia en C++

// Initialization
ImageClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_file);
std::unique_ptr<ImageClassifier> image_classifier = ImageClassifier::CreateFromOptions(options).value();

// Run inference
const ClassificationResult result = image_classifier->Classify(*frame_buffer).value();

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

Resultados de ejemplo

Aquí hay 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

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

Requisitos de compatibilidad de modelos

La API ImageClassifier espera un modelo TFLite con metadatos de modelo TFLite obligatorios. Vea ejemplos de creación de metadatos para clasificadores de imágenes con la API de escritor de metadatos de TensorFlow Lite .

Los modelos de clasificadores de imágenes compatibles deben cumplir los siguientes requisitos:

  • Tensor de imagen de entrada (kTfLiteUInt8/kTfLiteFloat32)

    • entrada de imagen de tamaño [batch x height x width x channels] .
    • la inferencia por lotes no es compatible (se requiere que el batch sea 1).
    • solo se admiten entradas RGB (se requiere que los channels sean 3).
    • si el tipo es kTfLiteFloat32, es necesario adjuntar NormalizationOptions a los metadatos para la normalización de entrada.
  • Tensor de puntuación de salida (kTfLiteUInt8/kTfLiteFloat32)

    • con N clases 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 contienen una etiqueta por línea. Consulte el archivo de etiquetas de ejemplo . El primer AssociatedFile (si lo hay) se usa para llenar el campo de label (llamado class_name en C++) de los resultados. El campo display_name se rellena con AssociatedFile (si lo hay) cuya configuración regional coincide con el campo display_names_locale de ImageClassifierOptions 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 de index de los resultados.