Processar dados de entrada e saída com a Biblioteca de Suporte LiteRT

Os desenvolvedores de aplicativos móveis normalmente interagem com objetos tipados, como bitmaps ou primitivos, como números inteiros. No entanto, o intérprete LiteRT A API que executa o modelo de machine learning no dispositivo usa tensores na forma de ByteBuffer, que pode ser difícil de depurar e manipular. A Biblioteca de Suporte LiteRT Android foi projetado para ajudar a processar a entrada e a saída dos modelos LiteRT; e facilitam o uso do intérprete LiteRT.

Primeiros passos

Importar a dependência do Gradle e outras configurações

Copie o arquivo modelo .tflite para o diretório de assets do módulo Android. em que o modelo será executado. Especifique que o arquivo não deve ser compactado. Adicione a biblioteca LiteRT ao arquivo build.gradle do 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 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
}

Conheça o AAR da Biblioteca de Suporte da LiteRT hospedada no MavenCentral para diferentes versões da Biblioteca de Suporte.

Manipulação e conversão básicas de imagens

A Biblioteca de Suporte LiteRT tem um pacote de manipulação básica de imagens usando outros métodos, como cortar e redimensionar. Para usá-lo, crie um ImagePreprocessor e adicione as operações necessárias. Converter a imagem para o formato de tensor exigido pelo intérprete LiteRT, crie um TensorImage para ser usado 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 LiteRT interpreter needs.
TensorImage tensorImage = new TensorImage(DataType.UINT8);

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

O DataType de um tensor pode ser lido pelo biblioteca de extratores de metadados bem como outras informações do modelo.

Processamento básico de dados de áudio

A Biblioteca de Suporte LiteRT também define um wrapper de classe TensorAudio. e alguns métodos básicos de processamento de dados de áudio. Ele é usado principalmente em conjunto AudioRecord e captura amostras de áudio em um buffer em anel.

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()

criar objetos de saída e executar o modelo

Antes de executar o modelo, precisamos criar os objetos de contêiner que armazene o 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);

Carregar o modelo e executar a inferência:

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());
}

Acessar o resultado

Os desenvolvedores podem acessar o resultado diretamente probabilityBuffer.getFloatArray(): Se o modelo produzir uma saída quantizada, lembre-se de converter o resultado. No modelo quantizado MobileNet, o desenvolvedor precisa dividir cada valor de saída por 255 para obter uma probabilidade variando de 0 (menos provável) a 1 (mais provável) para cada categoria.

Opcional: como mapear resultados para rótulos

Os desenvolvedores também podem, opcionalmente, mapear os resultados para os rótulos. Primeiro, copie o texto que contém rótulos no diretório de assets do módulo. Em seguida, carregue o rótulo usando o seguinte 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);
}

O snippet a seguir demonstra como associar as probabilidades rótulos de categoria:

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 do caso de uso atual

A versão atual da Biblioteca de Suporte LiteRT abrange:

  • Tipos de dados comuns (float, uint8, imagens, áudio e a matriz desses objetos) como entradas e saídas de modelos do tflite.
  • operações básicas de imagem (cortar, redimensionar e girar).
  • normalização e quantização
  • Utilitários de arquivo

Versões futuras melhorarão o suporte a aplicativos relacionados a texto.

Arquitetura do ImageProcessor

O design do ImageProcessor permitiu que as operações de manipulação de imagem ser definido desde o início e otimizado durante o processo de compilação. O ImageProcessor atualmente oferece suporte a três operações básicas de pré-processamento, conforme descrito no três comentários no snippet de código abaixo:

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();

Mostrar mais detalhes aqui sobre normalização e quantização.

O objetivo final da biblioteca de suporte é dar suporte a todos tf.image transformações de dados. Isso significa que a transformação será igual à do TensorFlow e a implementação é independente do sistema operacional.

Os desenvolvedores também podem criar processadores personalizados. É importante alinhar esses casos com o processo de treinamento, ou seja, os mesmos o pré-processamento deve ser aplicado ao treinamento e à inferência para aumentar reprodutibilidade.

Quantização.

Ao iniciar objetos de entrada ou saída, como TensorImage ou TensorBuffer você precisa especificar os tipos como DataType.UINT8 ou DataType.FLOAT32.

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

O TensorProcessor pode ser usado para quantizar tensores de entrada ou desquantizar a saída de carga. Por exemplo, ao processar uma saída quantizada TensorBuffer, a o desenvolvedor pode usar DequantizeOp para dequantizar o resultado em um ponto flutuante entre 0 e 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);

Os parâmetros de quantização de um tensor podem ser lidos pela biblioteca de extração de metadados.