Com os metadados da LiteRT, os desenvolvedores podem gerar código wrapper para ativar a integração no Android. Para a maioria dos desenvolvedores, interface gráfica da Android Studio ML Model Binding é a mais fáceis de usar. Se você precisar de mais personalização ou estiver usando a linha de comando ferramenta, o LiteRT Codegen também está disponível.
Usar o ML Model Binding do Android Studio
Para modelos LiteRT aprimorados com metadados,
os desenvolvedores podem usar o ML Model Binding do Android Studio para configurar automaticamente
para o projeto e gerar classes de wrapper com base no modelo
metadados. O código wrapper elimina a necessidade de interagir diretamente com
ByteBuffer
: Em vez disso, os desenvolvedores podem interagir com o modelo LiteRT
com objetos tipados, como Bitmap
e Rect
.
Importar um modelo LiteRT no Android Studio
Clique com o botão direito do mouse no módulo em que você quer usar o modelo TFLite ou clique
File
, depoisNew
>Other
>LiteRT Model
Selecione o local do seu arquivo TFLite. Observe que as ferramentas configure a dependência do módulo por você com a vinculação de modelos de ML e todas as dependências inseridas automaticamente
build.gradle
.Opcional: marque a segunda caixa de seleção para importar a GPU do TensorFlow se você querem usar a aceleração de GPU.
Clique em
Finish
.A tela a seguir será exibida após a conclusão da importação. Para começar usando o modelo, selecione Kotlin ou Java, copie e cole o código na Seção
Sample Code
. Para voltar a esta tela, clique duas vezes o modelo TFLite no diretórioml
do Android Studio.
Como acelerar a inferência de modelos
O ML Model Binding oferece aos desenvolvedores uma maneira de acelerar o código usando o uso de delegados e o número de threads.
Etapa 1. Verifique se o arquivo build.gradle
do módulo contém o seguinte
dependência:
dependencies {
...
// TFLite GPU delegate 2.3.0 or above is required.
implementation 'com.google.ai.edge.litert:litert-gpu:2.3.0'
}
Etapa 2. Detectar se a GPU em execução no dispositivo é compatível com a GPU do TensorFlow delegado, se não for possível executar o modelo usando várias linhas de execução 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
Gerar interfaces de modelo com o gerador de código LiteRT
Para o modelo LiteRT aprimorado com metadados:
os desenvolvedores podem usar o gerador de código do wrapper LiteRT do Android 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 TensorFlow
Modelo Lite com objetos tipados, como Bitmap
e Rect
.
A utilidade do gerador de código depende da integridade do
Entrada de metadados do modelo LiteRT. Consulte a seção <Codegen usage>
nos campos relevantes da
metadata_schema.fbs,
para saber como a ferramenta Codegen analisa cada campo.
Gerar código do wrapper
Você precisará instalar as seguintes ferramentas no 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 vai estar localizado no diretório de destino. Se você for usando o Google Colab ou outro controle remoto ambiente, talvez seja mais fácil compactar o resultado em um arquivo zip e fazer o download ao 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
Etapa 1: importar o código gerado
Se necessário, descompacte o código gerado em uma estrutura de diretórios. A raiz
o código gerado é considerado SRC_ROOT
.
Abra o projeto do Android Studio em que você quer usar a LiteRT
e importe o módulo gerado por: E File -> Novo -> Import Module ->
selecionar SRC_ROOT
Usando o exemplo acima, o diretório e o módulo importados seriam chamados
classify_wrapper
:
Etapa 2: atualizar o arquivo build.gradle
do app
No módulo do app que vai 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: uso do 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();
}
Como acelerar a inferência de modelos
O código gerado oferece aos desenvolvedores uma maneira de acelerar o código com o uso de delegados e o número de fios Eles podem ser definidos ao inicializar o objeto de modelo, porque são necessários três parâmetros:
Context
: contexto da atividade ou serviço do Android- (Opcional)
Device
: delegado de aceleração do TFLite. Por exemplo: GPUDelegate - (Opcional)
numThreads
: número de linhas de execução usadas para executar o modelo. o padrão é um.
Por exemplo, para usar um delegado de GPU e até três linhas de execução, você pode inicializar o modelo assim:
try {
myImageClassifier = new MyClassifierModel(this, Model.Device.GPU, 3);
} catch (IOException io){
// Error reading the model
}
Solução de problemas
Se você receber uma mensagem 'java.io.FileNotFoundException: Este arquivo não pode ser aberto como um file descritor de arquivo; provavelmente está compactado" insira as seguintes linhas na seção android do módulo do app que usará o módulo de biblioteca:
aaptOptions {
noCompress "tflite"
}