A LiteRT no Google Play Services também pode ser acessada usando APIs Java, no além da API nativa. Mais especificamente, LiteRT no Google Play serviços estão disponíveis por meio do Intérprete da LiteRT API.
Como usar as APIs Interpreter
A API LiteRT Interpreter, fornecida pelo ambiente de execução do TensorFlow, fornece uma interface de uso geral para criar e executar modelos de ML. Use o etapas a seguir para executar inferências com a API Interpreter usando o Lite no tempo de execução do Google Play Services.
1. Adicionar dependências do projeto
Adicione as seguintes dependências ao código do projeto do app para acessar a biblioteca Play API de serviços para LiteRT:
dependencies {
...
// LiteRT dependencies for Google Play services
implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
// Optional: include LiteRT Support Library
implementation 'com.google.android.gms:play-services-tflite-support:16.0.1'
...
}
2. Adicionar inicialização do LiteRT
Inicialize o componente LiteRT da API Google Play Services antes de usar as APIs LiteRT:
Kotlin
val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }
Java
Task<Void> initializeTask = TfLite.initialize(context);
3. Criar um intérprete e definir uma opção de ambiente de execução
Criar um intérprete usando InterpreterApi.create()
e configurá-lo para usar
O ambiente de execução do Google Play Services, chamando InterpreterApi.Options.setRuntime()
,
conforme mostrado neste código de exemplo:
Kotlin
import org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime ... private lateinit var interpreter: InterpreterApi ... initializeTask.addOnSuccessListener { val interpreterOption = InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) interpreter = InterpreterApi.create( modelBuffer, interpreterOption )} .addOnFailureListener { e -> Log.e("Interpreter", "Cannot initialize interpreter", e) }
Java
import org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime ... private InterpreterApi interpreter; ... initializeTask.addOnSuccessListener(a -> { interpreter = InterpreterApi.create(modelBuffer, new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)); }) .addOnFailureListener(e -> { Log.e("Interpreter", String.format("Cannot initialize interpreter: %s", e.getMessage())); });
Use a implementação acima para evitar o bloqueio da linha de execução da interface do usuário
do Android. Se você precisar gerenciar a execução de linhas de execução mais de perto,
adicione uma chamada Tasks.await()
à criação do interpretador:
Kotlin
import androidx.lifecycle.lifecycleScope ... lifecycleScope.launchWhenStarted { // uses coroutine initializeTask.await() }
Java
@BackgroundThread InterpreterApi initializeInterpreter() { Tasks.await(initializeTask); return InterpreterApi.create(...); }
4. Executar inferências
Usando o objeto interpreter
que você criou, chame o método run()
para gerar
uma inferência.
Kotlin
interpreter.run(inputBuffer, outputBuffer)
Java
interpreter.run(inputBuffer, outputBuffer);
Aceleração de hardware
O LiteRT permite acelerar a performance do modelo usando processadores de hardware especializados, como unidades de processamento gráfico (GPUs). Você podem aproveitar esses processadores especializados usando drivers de hardware chamados delega.
O delegado da GPU é fornecido pelo Google Play Services. e é carregado dinamicamente, assim como as versões do Google Play Services Interpreter API.
Como verificar a compatibilidade do dispositivo
Nem todos os dispositivos oferecem suporte à aceleração de hardware da GPU com o TFLite. Para
reduzir erros e possíveis falhas, use o
TfLiteGpu.isGpuDelegateAvailable
para verificar se um dispositivo está
compatíveis com o delegado da GPU.
Use este método para confirmar se um dispositivo é compatível com GPU e usar CPU como substituto para quando a GPU não tiver suporte.
useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)
Quando você tiver uma variável como useGpuTask
, poderá usá-la para determinar se
usam o delegado da GPU.
Kotlin
val interpreterTask = useGpuTask.continueWith { task -> val interpreterOptions = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) if (task.result) { interpreterOptions.addDelegateFactory(GpuDelegateFactory()) } InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions) }
Java
Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task -> InterpreterApi.Options options = new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY); if (task.getResult()) { options.addDelegateFactory(new GpuDelegateFactory()); } return options; });
GPU com APIs de intérprete
Para usar o delegado de GPU com as APIs Interpreter:
Atualize as dependências do projeto para usar o delegante de GPU do Google Play Services:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
Ative a opção de delegação de GPU na inicialização do TFLite:
Kotlin
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build())
Java
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build());
Ative o delegado da GPU nas opções do interpretador: defina a fábrica do delegado como GpuDelegateFactory chamando
addDelegateFactory() within
InterpreterApi.Options()`:Kotlin
val interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(GpuDelegateFactory())
Java
Options interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(new GpuDelegateFactory());
Migrar do LiteRT autônomo
Se você planeja migrar seu app do LiteRT independente para o API do Google Play Services, leia as orientações a seguir para atualizar seu código do projeto do aplicativo:
- Consulte a seção Limitações desta página para garantir que seu caso de uso seja compatível.
- Antes de atualizar seu código, faça verificações de desempenho e precisão nos seus modelos, especialmente se você estiver usando versões LiteRT anteriores que a versão 2.1, então você tem um valor de referência para comparar com o novo implementação.
- Se você migrou todo o código para usar a API Google Play Services para
LiteRT, remova as dependências da biblioteca de execução
do LiteRT (entradas com
org.tensorflow:tensorflow-lite:*
) do arquivo build.gradle para reduzir o tamanho do app. - Identifique todas as ocorrências da criação do objeto
new Interpreter
no seu código. e modificar cada um para que use a chamada InterpreterApi.create(). O novo TfLite.initialize é assíncrono, o que significa que, na maioria dos casos, ele não é uma substituição direta: é necessário registrar um listener para quando a chamada for concluída. Consulte o snippet de código na Etapa 3. - Adicionar
import org.tensorflow.lite.InterpreterApi;
eimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
a qualquer origem usando a funçãoorg.tensorflow.lite.Interpreter
ouorg.tensorflow.lite.InterpreterApi
. - Se alguma das chamadas resultantes para
InterpreterApi.create()
tiver apenas um argumento, anexenew InterpreterApi.Options()
à lista de argumentos. - Anexe
.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
ao último argumento de chamadas paraInterpreterApi.create()
. - Substitua todas as outras ocorrências da classe
org.tensorflow.lite.Interpreter
pororg.tensorflow.lite.InterpreterApi
.
Se você quiser usar o LiteRT independente e a API do Google Play Services ao mesmo tempo, use o LiteRT 2.9 (ou mais recente). LiteRT 2.8 e versões anteriores não são compatíveis com a versão da API Play Services.