Usando os metadados do TensorFlow Lite , os desenvolvedores podem gerar 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 estará disponível.
Use a vinculação de modelo do Android Studio ML
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 wrapper com base nos metadados do modelo. O código 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
.
Importe um modelo do TensorFlow Lite no Android Studio
Clique com o botão direito no módulo cujo modelo TFLite você deseja usar ou clique em
File
e emNew
>Other
>TensorFlow Lite Model
Selecione o local do seu arquivo TFLite. Observe que as ferramentas configurarão 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 seu módulo Android.Opcional: marque a segunda caixa de seleção para importar a GPU do TensorFlow se quiser usar a aceleração de GPU.
Clique
Finish
.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órioml
no Android Studio.
Acelerando a inferência de modelos
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 no arquivo build.gradle
do módulo se ele 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. Detecte se a GPU em execução no dispositivo é compatível com o delegado de GPU do TensorFlow, se 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 o gerador de código TensorFlow Lite
Para o modelo TensorFlow Lite aprimorado com metadados , os desenvolvedores podem usar o gerador de código wrapper Android do TensorFlow Lite para criar código wrapper específico da plataforma. O código 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>
em campos relevantes em metadata_schema.fbs , para ver como a ferramenta codegen analisa cada campo.
Gerar código wrapper
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 o seu projeto do 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
Passo 1: Importe o código gerado
Descompacte o código gerado, se necessário, em uma estrutura de diretórios. A raiz do código gerado é considerada SRC_ROOT
.
Abra o projeto Android Studio onde você gostaria de usar o modelo TensorFlow Lite e importe o módulo gerado por: E Arquivo -> Novo -> Módulo de Importação -> 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 app que consumirá o módulo da 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 de modelos
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 inicializar o objeto do modelo, pois são necessários 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ê receber 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"
}