Este documento descreve como criar uma biblioteca Android do TensorFlow Lite por conta própria. Normalmente, não é necessário criar localmente a biblioteca do TensorFlow Lite para Android.
Usar os Instantâneos noturnos
Para usar snapshots noturnos, adicione o seguinte repositório à configuração de build raiz do Gradle.
allprojects {
repositories { // should be already there
mavenCentral() // should be already there
maven { // add this repo to use snapshots
name 'ossrh-snapshot'
url 'https://oss.sonatype.org/content/repositories/snapshots'
}
}
}
adicionar snapshots noturnos a dependências (ou editar conforme necessário) no build.gradle
...
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
implementation 'org.tensorflow:tensorflow-lite-gpu:0.0.0-nightly-SNAPSHOT'
implementation 'org.tensorflow:tensorflow-lite-support:0.0.0-nightly-SNAPSHOT'
...
}
...
Crie o TensorFlow Lite localmente
Em alguns casos, é recomendável usar um build local do TensorFlow Lite. Por exemplo, você pode estar criando um binário personalizado que inclui operações selecionadas do TensorFlow ou fazer alterações locais no TensorFlow Lite.
Configurar o ambiente de build usando o Docker
- Faça o download do arquivo Docker. Ao fazer o download do arquivo Docker, você concorda que os seguintes Termos de Serviço regem seu uso:
Ao clicar em "Aceitar", você concorda que todo o uso do Android Studio e do Kit de desenvolvimento nativo do Android será regido pelo Contrato de Licença do kit de desenvolvimento de software do Android, disponível em https://developer.android.com/studio/terms. Esse URL pode ser atualizado ou alterado pelo Google periodicamente.
É necessário confirmar os Termos de Serviço para fazer o download do arquivo.- Também é possível mudar a versão do SDK ou do NDK do Android. Coloque o arquivo Docker salvo em uma pasta vazia e crie a imagem Docker executando:
docker build . -t tflite-builder -f tflite-android.Dockerfile
- Inicie o contêiner do Docker de maneira interativa montando sua pasta atual em /host_dir dentro do contêiner (observe que /tensorflow_src é o repositório do TensorFlow dentro do contêiner):
docker run -it -v $PWD:/host_dir tflite-builder bash
Se você usa o PowerShell no Windows, substitua "$PWD" por "pwd".
Se você quiser usar um repositório do TensorFlow no host, monte esse diretório de host (-v hostDir:/host_dir).
- Quando estiver dentro do contêiner, você poderá executar o seguinte para fazer o download de outras ferramentas e bibliotecas do Android (pode ser necessário aceitar a licença):
sdkmanager \
"build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
"platform-tools" \
"platforms;android-${ANDROID_API_LEVEL}"
Prossiga para a seção Configurar o Espaço de Trabalho e .bazelrc para definir as configurações do build.
Depois de concluir a criação das bibliotecas, você pode copiá-las para /host_dir dentro do contêiner para poder acessá-las no host.
Configurar o ambiente de build sem o Docker
Instalar pré-requisitos do Bazel e Android
O Bazel é o principal sistema de build do TensorFlow. Para criar com ela, você precisa ter o Android NDK e o SDK instalados no seu sistema.
- Instale a versão mais recente do sistema de build Bazel (link em inglês).
- O Android NDK é necessário para criar o código nativo (C/C++) do TensorFlow Lite. A versão recomendada atual é a 25b, que pode ser encontrada neste link.
- O SDK do Android e as ferramentas de build podem ser obtidos neste link ou como parte do Android Studio. A versão 23 ou mais recente da API Build Tools é a versão recomendada para criar o TensorFlow Lite.
Configurar o ESPAÇO DE TRABALHO e um arquivo .bazelrc
Essa é uma etapa de configuração única necessária para criar as bibliotecas do
TF Lite. Execute o script ./configure
no diretório raiz de checkout do TensorFlow
e responda "Sim" quando o script solicitar a configuração interativa do ./WORKSPACE
para builds do Android. O script tentará definir as configurações usando as
variáveis de ambiente a seguir:
ANDROID_SDK_HOME
ANDROID_SDK_API_LEVEL
ANDROID_NDK_HOME
ANDROID_NDK_API_LEVEL
Se essas variáveis não forem definidas, elas precisarão ser fornecidas de maneira interativa no prompt do
script. A configuração bem-sucedida deve gerar entradas semelhantes às seguintes
no arquivo .tf_configure.bazelrc
na pasta raiz:
build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r25b"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="30.0.3"
build --action_env ANDROID_SDK_API_LEVEL="30"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"
Criar e instalar
Depois que o Bazel estiver configurado corretamente, você poderá criar o AAR do TensorFlow Lite no diretório raiz de finalização da compra da seguinte maneira:
bazel build -c opt --cxxopt=--std=c++17 --config=android_arm64 \
--fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
--define=android_dexmerger_tool=d8_dexmerger \
--define=android_incremental_dexing_tool=d8_dexbuilder \
//tensorflow/lite/java:tensorflow-lite
Isso vai gerar um arquivo AAR em bazel-bin/tensorflow/lite/java/
. Isso
cria um AAR "avançado" com várias arquiteturas diferentes. Se você não
precisar de todas elas, use o subconjunto apropriado para seu ambiente de implantação.
Você pode criar arquivos AAR menores visando apenas um conjunto de modelos, da seguinte maneira:
bash tensorflow/lite/tools/build_aar.sh \
--input_models=model1,model2 \
--target_archs=x86,x86_64,arm64-v8a,armeabi-v7a
O script acima vai gerar o arquivo tensorflow-lite.aar
e, opcionalmente, o arquivo tensorflow-lite-select-tf-ops.aar
se um dos modelos usar as operações do Tensorflow. Para ver mais detalhes, consulte a seção
Reduzir o tamanho do binário do TensorFlow Lite.
Adicione AAR diretamente ao projeto
Mova o arquivo tensorflow-lite.aar
para um diretório chamado libs
no seu
projeto. Modifique o arquivo build.gradle
do app para fazer referência ao novo diretório
e substitua a dependência do TensorFlow Lite existente pela nova biblioteca local,
por exemplo:
allprojects {
repositories {
mavenCentral()
maven { // Only for snapshot artifacts
name 'ossrh-snapshot'
url 'https://oss.sonatype.org/content/repositories/snapshots'
}
flatDir {
dirs 'libs'
}
}
}
dependencies {
compile(name:'tensorflow-lite', ext:'aar')
}
Instalar o AAR no repositório Maven local
Execute o seguinte comando no seu diretório raiz de finalização de compra:
mvn install:install-file \
-Dfile=bazel-bin/tensorflow/lite/java/tensorflow-lite.aar \
-DgroupId=org.tensorflow \
-DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar
No build.gradle
do app, verifique se você tem a dependência mavenLocal()
e
substitua a dependência padrão do TensorFlow Lite por aquela que é compatível
com algumas operações do TensorFlow:
allprojects {
repositories {
mavenCentral()
maven { // Only for snapshot artifacts
name 'ossrh-snapshot'
url 'https://oss.sonatype.org/content/repositories/snapshots'
}
mavenLocal()
}
}
dependencies {
implementation 'org.tensorflow:tensorflow-lite:0.1.100'
}
Observe que a versão do 0.1.100
apresentada aqui é meramente para fins de
teste/desenvolvimento. Com o AAR local instalado, é possível usar as
APIs de inferência Java do TensorFlow Lite padrão no código do seu app.