Criar LiteRT para Android

Este documento descreve como criar a biblioteca LiteRT do Android por conta própria. Normalmente, não é necessário criar a biblioteca do Android LiteRT localmente.

Usar snapshots diários

Para usar snapshots noturnos, adicione o seguinte repositório à configuração de build do Gradle raiz.

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'
        }
    }
}

Adicione snapshots noturnos às dependências (ou edite conforme necessário) no build.gradle.

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

Criar o LiteRT localmente

Em alguns casos, talvez você queira usar uma build local do LiteRT. Por exemplo, você pode estar criando um binário personalizado que inclui operações selecionadas do TensorFlow ou fazer mudanças locais no LiteRT.

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 Android Native Development Kit será regido pelo Contrato de licença do Android Software Development Kit disponível em https://developer.android.com/studio/terms. Esse URL pode ser atualizado ou alterado pelo Google periodicamente.

Você precisa aceitar os Termos de Serviço para fazer o download do arquivo.

  • Se quiser, mude a versão do SDK ou do NDK do Android. Coloque o arquivo Docker baixado em uma pasta vazia e crie a imagem do Docker executando:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Inicie o contêiner do Docker de forma 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 do host (-v hostDir:/host_dir).

  • Depois de entrar no contêiner, execute o seguinte para baixar outras ferramentas e bibliotecas do Android. Talvez seja necessário aceitar a licença:
sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Agora, acesse a seção Configurar WORKSPACE e .bazelrc para configurar as definições de build.

Depois de criar as bibliotecas, copie-as para /host_dir dentro do contêiner para que você possa acessá-las no host.

Configurar o ambiente de build sem o Docker

Instalar o Bazel e os pré-requisitos do Android

O Bazel é o principal sistema de build do TensorFlow. Para criar com ele, você precisa ter o NDK e o SDK do Android instalados no seu sistema.

  1. Instale a versão mais recente do sistema de build Bazel.
  2. O Android NDK é necessário para criar o código nativo (C/C++) do LiteRT. A versão recomendada atual é a 25b, que pode ser encontrada aqui.
    1. O SDK do Android e as ferramentas de build podem ser obtidos aqui ou como parte do Android Studio. Ferramentas de build A API >= 23 é a versão recomendada para criar o LiteRT.

Configurar WORKSPACE e .bazelrc

Essa é uma etapa de configuração única necessária para criar as bibliotecas LiteRT. Execute o script ./configure no diretório raiz do checkout do TensorFlow e responda "Sim" quando o script pedir para configurar interativamente o ./WORKSPACE para builds do Android. O script vai tentar configurar as definições usando as seguintes variáveis de ambiente:

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

Se essas variáveis não estiverem definidas, elas precisarão ser fornecidas de forma interativa no prompt do script. Uma configuração bem-sucedida vai gerar entradas semelhantes a estas 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 LiteRT no diretório de extração raiz 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 "fat" com várias arquiteturas diferentes. Se você não precisar de todas elas, use o subconjunto adequado para seu ambiente de implantação.

É possível criar arquivos AAR menores segmentando 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 estiver usando operações do TensorFlow. Para mais detalhes, consulte a seção Reduzir o tamanho do binário do LiteRT.

Adicionar 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 referenciar o novo diretório e substitua a dependência LiteRT atual 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 diretório raiz do seu checkout:

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 LiteRT por uma que tenha suporte para operações selecionadas 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'
}

A versão 0.1.100 aqui é apenas para fins de teste/desenvolvimento. Com o AAR local instalado, você pode usar as APIs de inferência Java do LiteRT padrão no código do app.