Procesa datos de entrada y salida con la biblioteca de compatibilidad de TensorFlow Lite

Por lo general, los desarrolladores de aplicaciones para dispositivos móviles interactúan con objetos escritos, como mapas de bits, o primitivas, como números enteros. Sin embargo, la API de intérprete de TensorFlow Lite que ejecuta el modelo de aprendizaje automático en el dispositivo usa tensores con el formato ByteBuffer, que puede ser difícil de depurar y manipular. La biblioteca de compatibilidad de Android para TensorFlow Lite está diseñada para ayudar a procesar la entrada y salida de los modelos de TensorFlow Lite, y facilitar el uso del intérprete de TensorFlow Lite.

Comenzar

Cómo importar la dependencia de Gradle y otras configuraciones

Copia el archivo de 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 tflite dependencies
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    // The GPU delegate library is optional. Depend on it as needed.
    implementation 'org.tensorflow:tensorflow-lite-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'org.tensorflow:tensorflow-lite-support:0.0.0-nightly-SNAPSHOT'
}

Explora el AAR de la biblioteca de compatibilidad de TensorFlow Lite, alojado en MavenCentral, para ver las diferentes versiones de esa biblioteca.

Conversión y manipulación básica de imágenes

La biblioteca de compatibilidad de TensorFlow Lite cuenta con un conjunto de métodos básicos de manipulación de imágenes, como recortar y cambiar el tamaño. Para usarlo, crea un ImagePreprocessor y agrega las operaciones requeridas. Si quieres convertir la imagen al formato de tensor que requiere el intérprete de TensorFlow Lite, crea un TensorImage para usarlo como entrada:

import org.tensorflow.lite.DataType;
import org.tensorflow.lite.support.image.ImageProcessor;
import org.tensorflow.lite.support.image.TensorImage;
import org.tensorflow.lite.support.image.ops.ResizeOp;

// Initialization code
// Create an ImageProcessor with all ops required. For more ops, please
// refer to the ImageProcessor Architecture section in this README.
ImageProcessor imageProcessor =
    new ImageProcessor.Builder()
        .add(new ResizeOp(224, 224, ResizeOp.ResizeMethod.BILINEAR))
        .build();

// Create a TensorImage object. This creates the tensor of the corresponding
// tensor type (uint8 in this case) that the TensorFlow Lite interpreter needs.
TensorImage tensorImage = new TensorImage(DataType.UINT8);

// Analysis code for every frame
// Preprocess the image
tensorImage.load(bitmap);
tensorImage = imageProcessor.process(tensorImage);

La DataType de un tensor se puede leer con la biblioteca del extractor de metadatos y otra información del modelo.

Procesamiento básico de datos de audio

La biblioteca de compatibilidad de TensorFlow Lite también define una clase TensorAudio que une algunos métodos básicos de procesamiento de datos de audio. Se usa principalmente junto con AudioRecord y captura muestras de audio en un búfer de anillo.

import android.media.AudioRecord;
import org.tensorflow.lite.support.audio.TensorAudio;

// Create an `AudioRecord` instance.
AudioRecord record = AudioRecord(...)

// Create a `TensorAudio` object from Android AudioFormat.
TensorAudio tensorAudio = new TensorAudio(record.getFormat(), size)

// Load all audio samples available in the AudioRecord without blocking.
tensorAudio.load(record)

// Get the `TensorBuffer` for inference.
TensorBuffer buffer = tensorAudio.getTensorBuffer()

Crea objetos de salida y ejecuta el modelo

Antes de ejecutar el modelo, debemos crear los objetos del contenedor que almacenarán el resultado:

import org.tensorflow.lite.DataType;
import org.tensorflow.lite.support.tensorbuffer.TensorBuffer;

// Create a container for the result and specify that this is a quantized model.
// Hence, the 'DataType' is defined as UINT8 (8-bit unsigned integer)
TensorBuffer probabilityBuffer =
    TensorBuffer.createFixedSize(new int[]{1, 1001}, DataType.UINT8);

Carga el modelo y ejecuta la inferencia:

import java.nio.MappedByteBuffer;
import org.tensorflow.lite.InterpreterFactory;
import org.tensorflow.lite.InterpreterApi;

// Initialise the model
try{
    MappedByteBuffer tfliteModel
        = FileUtil.loadMappedFile(activity,
            "mobilenet_v1_1.0_224_quant.tflite");
    InterpreterApi tflite = new InterpreterFactory().create(
        tfliteModel, new InterpreterApi.Options());
} catch (IOException e){
    Log.e("tfliteSupport", "Error reading model", e);
}

// Running inference
if(null != tflite) {
    tflite.run(tImage.getBuffer(), probabilityBuffer.getBuffer());
}

Cómo acceder al resultado

Los desarrolladores pueden acceder al resultado directamente a través de probabilityBuffer.getFloatArray(). Si el modelo produce una salida cuantizada, recuerda convertir el resultado. Para el modelo cuantificado de MobileNet, el desarrollador debe dividir cada valor de salida por 255 a fin de obtener una probabilidad que vaya de 0 (menos probable) a 1 (más probable) para cada categoría.

Opcional: Asigna resultados a etiquetas

De manera opcional, los desarrolladores también pueden asignar los resultados a las etiquetas. Primero, copia el archivo de texto que contiene las etiquetas en el directorio de recursos del módulo. A continuación, carga el archivo de etiquetas con el siguiente código:

import org.tensorflow.lite.support.common.FileUtil;

final String ASSOCIATED_AXIS_LABELS = "labels.txt";
List<String> associatedAxisLabels = null;

try {
    associatedAxisLabels = FileUtil.loadLabels(this, ASSOCIATED_AXIS_LABELS);
} catch (IOException e) {
    Log.e("tfliteSupport", "Error reading label file", e);
}

En el siguiente fragmento, se muestra cómo asociar las probabilidades con las etiquetas de categoría:

import java.util.Map;
import org.tensorflow.lite.support.common.TensorProcessor;
import org.tensorflow.lite.support.common.ops.NormalizeOp;
import org.tensorflow.lite.support.label.TensorLabel;

// Post-processor which dequantize the result
TensorProcessor probabilityProcessor =
    new TensorProcessor.Builder().add(new NormalizeOp(0, 255)).build();

if (null != associatedAxisLabels) {
    // Map of labels and their corresponding probability
    TensorLabel labels = new TensorLabel(associatedAxisLabels,
        probabilityProcessor.process(probabilityBuffer));

    // Create a map to access the result based on label
    Map<String, Float> floatMap = labels.getMapWithFloatValue();
}

Cobertura actual de los casos de uso

La versión actual de la biblioteca de compatibilidad de TensorFlow Lite abarca lo siguiente:

  • tipos de datos comunes (float, uint8, imágenes, audio y array de estos objetos) como entradas y salidas de modelos de tflite.
  • operaciones básicas de imagen (recortar la imagen, cambiar su tamaño y rotarla).
  • normalización y cuantización
  • utilidades de archivo

Las versiones futuras mejorarán la compatibilidad de las aplicaciones relacionadas con el texto.

Arquitectura de ImageProcessor

El diseño de ImageProcessor permitió que las operaciones de manipulación de imagen se definieran por adelantado y se optimizaran durante el proceso de compilación. Actualmente, ImageProcessor admite tres operaciones básicas de procesamiento previo, como se describe en los tres comentarios del siguiente fragmento de código:

import org.tensorflow.lite.support.common.ops.NormalizeOp;
import org.tensorflow.lite.support.common.ops.QuantizeOp;
import org.tensorflow.lite.support.image.ops.ResizeOp;
import org.tensorflow.lite.support.image.ops.ResizeWithCropOrPadOp;
import org.tensorflow.lite.support.image.ops.Rot90Op;

int width = bitmap.getWidth();
int height = bitmap.getHeight();

int size = height > width ? width : height;

ImageProcessor imageProcessor =
    new ImageProcessor.Builder()
        // Center crop the image to the largest square possible
        .add(new ResizeWithCropOrPadOp(size, size))
        // Resize using Bilinear or Nearest neighbour
        .add(new ResizeOp(224, 224, ResizeOp.ResizeMethod.BILINEAR));
        // Rotation counter-clockwise in 90 degree increments
        .add(new Rot90Op(rotateDegrees / 90))
        .add(new NormalizeOp(127.5, 127.5))
        .add(new QuantizeOp(128.0, 1/128.0))
        .build();

Consulta más detalles aquí sobre la normalización y la cuantización.

El objetivo final de la biblioteca de compatibilidad es admitir todas las transformaciones de tf.image. Esto significa que la transformación será la misma que la de TensorFlow y la implementación será independiente del sistema operativo.

Los desarrolladores también pueden crear procesadores personalizados. En estos casos, es importante alinearse con el proceso de entrenamiento, es decir, se debe aplicar el mismo procesamiento previo tanto al entrenamiento como a la inferencia para aumentar la reproducibilidad.

Cuantización

Cuando inicias objetos de entrada o salida, como TensorImage o TensorBuffer, debes especificar que sus tipos sean DataType.UINT8 o DataType.FLOAT32.

TensorImage tensorImage = new TensorImage(DataType.UINT8);
TensorBuffer probabilityBuffer =
    TensorBuffer.createFixedSize(new int[]{1, 1001}, DataType.UINT8);

TensorProcessor se puede usar para cuantizar los tensores de entrada o descuantizar los tensores de salida. Por ejemplo, cuando se procesa un TensorBuffer de salida cuantizado, el desarrollador puede usar DequantizeOp para descuantizar el resultado en una probabilidad de punto flotante entre 0 y 1:

import org.tensorflow.lite.support.common.TensorProcessor;

// Post-processor which dequantize the result
TensorProcessor probabilityProcessor =
    new TensorProcessor.Builder().add(new DequantizeOp(0, 1/255.0)).build();
TensorBuffer dequantizedBuffer = probabilityProcessor.process(probabilityBuffer);

Los parámetros de cuantización de un tensor se pueden leer a través de la biblioteca del extractor de metadatos.