Los desarrolladores de aplicaciones móviles suelen interactuar con objetos escritos, como mapas de bits, o primitivos, como números enteros. Sin embargo, la API del intérprete de TensorFlow Lite que ejecuta el modelo de aprendizaje automático en el dispositivo utiliza tensores en forma de ByteBuffer, que pueden ser difíciles de depurar y manipular. La biblioteca de soporte de Android de TensorFlow Lite está diseñada para ayudar a procesar la entrada y salida de los modelos de TensorFlow Lite y hacer que el intérprete de TensorFlow Lite sea más fácil de usar.
Empezando
Importar 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. Especifique que el archivo no debe comprimirse y agregue 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 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'
}
Explore el AAR de la biblioteca de soporte de TensorFlow Lite alojado en MavenCentral para ver diferentes versiones de la biblioteca de soporte.
Manipulación y conversión de imágenes básicas.
La biblioteca de soporte de TensorFlow Lite tiene un conjunto de métodos básicos de manipulación de imágenes, como recortar y cambiar el tamaño. Para usarlo, cree un ImagePreprocessor y agregue las operaciones requeridas. Para convertir la imagen al formato tensorial requerido por el intérprete de TensorFlow Lite, cree una TensorImage para usarla 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);
DataType de un tensor se puede leer a través de la biblioteca del extractor de metadatos , así como otra información del modelo.
Procesamiento básico de datos de audio.
La biblioteca de soporte de TensorFlow Lite también define una clase TensorAudio que incluye algunos métodos básicos de procesamiento de datos de audio. Se utiliza principalmente junto con AudioRecord y captura muestras de audio en un búfer en 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()
Crear objetos de salida y ejecutar el modelo.
Antes de ejecutar el modelo, necesitamos crear los objetos contenedores 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);
Cargando el modelo y ejecutando 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());
}
Accediendo al resultado
Los desarrolladores pueden acceder al resultado directamente a través de probabilityBuffer.getFloatArray() . Si el modelo produce una salida cuantificada, recuerde convertir el resultado. Para el modelo cuantificado de MobileNet, el desarrollador debe dividir cada valor de salida entre 255 para obtener una probabilidad que oscila entre 0 (menos probable) y 1 (más probable) para cada categoría.
Opcional: asignación de resultados a etiquetas
Opcionalmente, los desarrolladores también pueden asignar los resultados a etiquetas. Primero, copie el archivo de texto que contiene las etiquetas en el directorio de activos del módulo. A continuación, cargue el archivo de etiqueta usando 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);
}
El siguiente fragmento demuestra cómo asociar las probabilidades con 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 de casos de uso actual
La versión actual de la biblioteca de soporte de TensorFlow Lite cubre:
- tipos de datos comunes (float, uint8, imágenes, audio y matriz de estos objetos) como entradas y salidas de modelos tflite.
- operaciones básicas de imagen (recortar imagen, cambiar tamaño y rotar).
- normalización y cuantificación
- utilidades de archivo
Las versiones futuras mejorarán la compatibilidad con aplicaciones relacionadas con texto.
Arquitectura del procesador de imágenes
El diseño de ImageProcessor permitió que las operaciones de manipulación de imágenes se definieran desde el principio y se optimizaran durante el proceso de construcción. ImageProcessor actualmente admite tres operaciones básicas de preprocesamiento, como se describe en los tres comentarios en el fragmento de código a continuación:
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();
Vea más detalles aquí sobre normalización y cuantificación.
El objetivo final de la biblioteca de soporte es admitir todas las transformaciones 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 estar alineado con el proceso de entrenamiento; es decir, se debe aplicar el mismo preprocesamiento tanto al entrenamiento como a la inferencia para aumentar la reproducibilidad.
Cuantización
Al iniciar objetos de entrada o salida como TensorImage o TensorBuffer , debe 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);
El TensorProcessor se puede utilizar para cuantificar tensores de entrada o descuantizar tensores de salida. Por ejemplo, al procesar un TensorBuffer de salida cuantificado, el desarrollador puede usar DequantizeOp para descuantificar el resultado a 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 cuantificación de un tensor se pueden leer a través de la biblioteca extractora de metadatos .