Criar o TensorFlow Lite para Android

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.

  1. Instale a versão mais recente do sistema de build Bazel (link em inglês).
  2. 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.
  3. 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.