O Dia da Comunidade de ML é dia 9 de novembro! Junte-nos para atualização de TensorFlow, JAX, e mais Saiba mais

Gerar interfaces de modelo usando metadados

Usando os metadados TensorFlow Lite , os desenvolvedores podem gerar um código wrapper para permitir a integração no Android. Para a maioria dos desenvolvedores, a interface gráfica do Android Studio ML Model Binding é a mais fácil de usar. Se você precisar de mais personalização ou estiver usando ferramentas de linha de comando, o TensorFlow Lite Codegen também está disponível.

Use o Android Studio ML Model Binding

Para modelos do TensorFlow Lite aprimorados com metadados , os desenvolvedores podem usar o Android Studio ML Model Binding para definir automaticamente as configurações do projeto e gerar classes de wrapper com base nos metadados do modelo. O código do wrapper elimina a necessidade de interagir diretamente com ByteBuffer . Em vez disso, os desenvolvedores podem interagir com o modelo TensorFlow Lite com objetos digitados, como Bitmap e Rect .

Importar um modelo TensorFlow Lite no Android Studio

  1. Clique com o botão direito do mouse no módulo que deseja usar no modelo TFLite ou clique em File e em New > Other > TensorFlow Lite Model Menus do botão direito para acessar a funcionalidade de importação do TensorFlow Lite

  2. Selecione a localização do seu arquivo TFLite. Observe que o conjunto de ferramentas configurará a dependência do módulo em seu nome com a vinculação do modelo de ML e todas as dependências inseridas automaticamente no arquivo build.gradle do módulo Android.

    Opcional: marque a segunda caixa de seleção para importar a GPU do TensorFlow se quiser usar a aceleração da GPU. Diálogo de importação para o modelo TFLite

  3. Clique em Finish .

  4. A tela a seguir aparecerá após a importação ser bem-sucedida. Para começar a usar o modelo, selecione Kotlin ou Java, copie e cole o código na seção Sample Code . Você pode voltar a esta tela clicando duas vezes no modelo TFLite no diretório ml no Android Studio. Página de detalhes do modelo no Android Studio

Acelerando a inferência do modelo

A vinculação de modelo de ML fornece uma maneira para os desenvolvedores acelerarem seu código por meio do uso de delegados e do número de threads.

Etapa 1. Verifique se o arquivo do módulo build.gradle contém a seguinte dependência:

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
    }

Etapa 2. Detectar se a GPU em execução no dispositivo é compatível com o delegado de GPU do TensorFlow, caso não execute o modelo usando vários threads de CPU:

Kotlin

    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice) {
        // if the device has a supported GPU, add the GPU delegate
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        // if the GPU is not supported, run on 4 threads
        Model.Options.Builder().setNumThreads(4).build()
    }

    // Initialize the model as usual feeding in the options object
    val myModel = MyModel.newInstance(context, options)

    // Run inference per sample code
      

Java

    import org.tensorflow.lite.support.model.Model
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Model.Options options;
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        options = Model.Options.Builder().setDevice(Model.Device.GPU).build();
    } else {
        // if the GPU is not supported, run on 4 threads
        options = Model.Options.Builder().setNumThreads(4).build();
    }

    MyModel myModel = new MyModel.newInstance(context, options);

    // Run inference per sample code
      

Gere interfaces de modelo com gerador de código TensorFlow Lite

Para o modelo TensorFlow Lite aprimorado com metadados , os desenvolvedores podem usar o gerador de código do wrapper TensorFlow Lite Android para criar o código do wrapper específico da plataforma. O código do wrapper elimina a necessidade de interagir diretamente com ByteBuffer . Em vez disso, os desenvolvedores podem interagir com o modelo TensorFlow Lite com objetos digitados, como Bitmap e Rect .

A utilidade do gerador de código depende da integridade da entrada de metadados do modelo TensorFlow Lite. Consulte a seção <Codegen usage> nos campos relevantes em metadata_schema.fbs , para ver como a ferramenta codegen analisa cada campo.

Gerar código de invólucro

Você precisará instalar as seguintes ferramentas em seu terminal:

pip install tflite-support

Depois de concluído, o gerador de código pode ser usado usando a seguinte sintaxe:

tflite_codegen --model=./model_with_metadata/mobilenet_v1_0.75_160_quantized.tflite \
    --package_name=org.tensorflow.lite.classify \
    --model_class_name=MyClassifierModel \
    --destination=./classify_wrapper

O código resultante estará localizado no diretório de destino. Se você estiver usando o Google Colab ou outro ambiente remoto, talvez seja mais fácil compactar o resultado em um arquivo zip e baixá-lo para seu projeto Android Studio:

# Zip up the generated code
!zip -r classify_wrapper.zip classify_wrapper/

# Download the archive
from google.colab import files
files.download('classify_wrapper.zip')

Usando o código gerado

Etapa 1: importe o código gerado

Descompacte o código gerado, se necessário, em uma estrutura de diretório. A raiz do código gerado é considerada SRC_ROOT .

Abra o projeto do Android Studio em que deseja usar o modelo TensorFlow Lite e importe o módulo gerado por: And File -> New -> Import Module -> selecione SRC_ROOT

Usando o exemplo acima, o diretório e o módulo importado seriam chamados classify_wrapper .

Etapa 2: atualize o arquivo build.gradle do aplicativo

No módulo de aplicativo que consumirá o módulo de biblioteca gerado:

Na seção android, adicione o seguinte:

aaptOptions {
   noCompress "tflite"
}

Na seção de dependências, adicione o seguinte:

implementation project(":classify_wrapper")

Etapa 3: usando o modelo

// 1. Initialize the model
MyClassifierModel myImageClassifier = null;

try {
    myImageClassifier = new MyClassifierModel(this);
} catch (IOException io){
    // Error reading the model
}

if(null != myImageClassifier) {

    // 2. Set the input with a Bitmap called inputBitmap
    MyClassifierModel.Inputs inputs = myImageClassifier.createInputs();
    inputs.loadImage(inputBitmap));

    // 3. Run the model
    MyClassifierModel.Outputs outputs = myImageClassifier.run(inputs);

    // 4. Retrieve the result
    Map<String, Float> labeledProbability = outputs.getProbability();
}

Acelerando a inferência do modelo

O código gerado fornece uma maneira para os desenvolvedores acelerarem seu código por meio do uso de delegados e do número de threads. Eles podem ser definidos ao iniciar o objeto de modelo, pois leva três parâmetros:

  • Context : Contexto da atividade ou serviço Android
  • (Opcional) Device : delegado de aceleração TFLite, por exemplo GPUDelegate ou NNAPIDelegate
  • (Opcional) numThreads : Número de threads usados ​​para executar o modelo - o padrão é um.

Por exemplo, para usar um delegado NNAPI e até três threads, você pode inicializar o modelo assim:

try {
    myImageClassifier = new MyClassifierModel(this, Model.Device.NNAPI, 3);
} catch (IOException io){
    // Error reading the model
}

Solução de problemas

Se você obtiver uma 'java.io.FileNotFoundException: Este arquivo não pode ser aberto como um descritor de arquivo; provavelmente é um erro compactado, insira as seguintes linhas na seção android do módulo do aplicativo que usará o módulo da biblioteca:

aaptOptions {
   noCompress "tflite"
}