Crie o TensorFlow Lite para Android

Este documento descreve como criar a biblioteca Android do TensorFlow Lite por conta própria. Normalmente, você não precisa criar localmente a biblioteca Android do TensorFlow Lite. Se você quiser apenas usá-lo, consulte o início rápido do Android para obter mais detalhes sobre como usá-los em seus projetos Android.

Use instantâneos noturnos

Para usar snapshots noturnos, adicione o seguinte repositório à configuração raiz do build 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'
        }
    }
}

adicione instantâneos noturnos às dependências (ou edite conforme necessário) ao seu 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, você pode querer usar uma versão local do TensorFlow Lite. Por exemplo, você pode estar criando um binário personalizado que inclui operações selecionadas no TensorFlow ou pode querer fazer alterações locais no TensorFlow Lite.

Configure o ambiente de construção usando Docker

  • Baixe o arquivo Docker. Ao baixar o arquivo Docker, você concorda que os seguintes termos de serviço regem seu uso:

Ao clicar para 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 (tal URL pode ser atualizado ou alterado pelo Google de tempos em tempos).

Você deve reconhecer os termos de serviço para baixar o arquivo.

  • Opcionalmente, você pode alterar a versão do Android SDK ou NDK. Coloque o arquivo Docker baixado em uma pasta vazia e crie sua 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).

  • Uma vez dentro do contêiner, você pode executar o seguinte para baixar ferramentas e bibliotecas Android adicionais (observe que pode ser necessário aceitar a licença):
sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Agora você deve prosseguir para a seção Configurar WORKSPACE e .bazelrc para definir as configurações de compilação.

Depois de terminar de construir as bibliotecas, você pode copiá-las para /host_dir dentro do contêiner para poder acessá-las no host.

Configure o ambiente de construção sem Docker

Instale os pré-requisitos do Bazel e do Android

Bazel é o principal sistema de compilação do TensorFlow. Para construir com ele, você deve ter ele e o Android NDK e SDK instalados em seu sistema.

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

Configurar WORKSPACE e .bazelrc

Esta é uma etapa de configuração única necessária para construir 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 das compilações ./WORKSPACE para Android. O script tentará definir as configuraçõ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 deverão ser fornecidas interativamente 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"

Construir e instalar

Depois que o Bazel estiver configurado corretamente, você poderá criar o TensorFlow Lite AAR a partir do diretório de checkout 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 irá gerar um arquivo AAR em bazel-bin/tensorflow/lite/java/ . Observe que isso cria um AAR "gordo" com diversas arquiteturas diferentes; se você não precisar de todos eles, use o subconjunto apropriado para seu ambiente de implementação.

Você pode criar arquivos AAR menores direcionados apenas a 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 irá 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 obter mais detalhes, consulte a seção Reduzir o tamanho binário do TensorFlow Lite .

Adicione AAR diretamente ao projeto

Mova o arquivo tensorflow-lite.aar para um diretório chamado libs em seu projeto. Modifique o arquivo build.gradle do seu aplicativo para fazer referência ao novo diretório e substitua a dependência existente do TensorFlow Lite 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')
}

Instale o AAR no repositório Maven local

Execute o seguinte comando em seu diretório de checkout raiz:

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 seu aplicativo, certifique-se de ter a dependência mavenLocal() e substitua a dependência padrão do TensorFlow Lite por aquela que tem 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'
}

Observe que a versão 0.1.100 aqui é puramente para teste/desenvolvimento. Com o AAR local instalado, você pode usar as APIs de inferência Java padrão do TensorFlow Lite no código do seu aplicativo.