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 instantâneos noturnos, adicione o seguinte repositório à sua configuração de compilação 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'
        }
    }
}

Crie o TensorFlow Lite localmente

Em alguns casos, talvez você queira usar uma versão local do TensorFlow Lite. Por exemplo, você pode criar um binário personalizado que inclua operações selecionadas do TensorFlow ou fazer alterações locais no TensorFlow Lite.

Configurar o ambiente de compilação usando o 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 do 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 docker interativamente 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ê usar 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 adicionais do Android (observe que talvez seja 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 criar as bibliotecas, você pode copiá-las para /host_dir dentro do contêiner para poder acessá-las no host.

Configurar o ambiente de compilação sem o Docker

Instale o Bazel e os pré-requisitos do Android

O Bazel é o principal sistema de compilação do TensorFlow. Para construir com ele, você deve tê-lo 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 TensorFlow Lite nativo (C/C++). A versão atual recomendada é a 21e, que pode ser encontrada aqui .
  3. O Android SDK e as ferramentas de compilação podem ser obtidos aqui ou como parte do Android Studio . API de ferramentas de compilação >= 23 é a versão recomendada para criar o TensorFlow Lite.

Configurar WORKSPACE e .bazelrc

Esta é 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 compilações do 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 forem 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-r21e"
build --action_env ANDROID_NDK_API_LEVEL="26"
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 --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
  --define=android_dexmerger_tool=d8_dexmerger \
  --define=android_incremental_dexing_tool=d8_dexbuilder \
  //tensorflow/lite/java:tensorflow-lite

Isso gerará um arquivo AAR em bazel-bin/tensorflow/lite/java/ . Observe que isso cria um AAR "gordo" com várias 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 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 irá gerar o arquivo tensorflow-lite.aar e, opcionalmente, o arquivo tensorflow-lite-select-tf-ops.aar se um dos modelos estiver usando o Tensorflow ops. Para obter mais detalhes, consulte a seção Reduzir o tamanho binário do TensorFlow Lite .

Adicionar 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 de 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 fins de 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.