Esta página foi traduzida pela API Cloud Translation.
Switch to English

Compilar TensorFlow Lite para Android

Este documento descreve como construir a biblioteca TensorFlow Lite do Android por conta própria. Normalmente, você não precisa criar localmente a biblioteca TensorFlow Lite do Android. Se você quiser apenas usá-lo, a maneira mais fácil é usar o TensorFlow Lite AAR hospedado no JCenter . Consulte o início rápido do Android para obter mais detalhes sobre como usá-los em seus projetos Android.

Crie o TensorFlow Lite localmente

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

Configure o ambiente de compilação usando o Docker

  • Baixe o arquivo Docker. Ao fazer o download do 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 aceitar os termos de serviço para baixar o arquivo. Reconhecer

  • 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 / tmp dentro do contêiner (observe que / tensorflow_src é o repositório TensorFlow dentro do contêiner):
docker run -it -v $PWD:/tmp tflite-builder bash

Se você usa o PowerShell no Windows, substitua "$ PWD" por "pwd".

Se você quiser usar um repositório TensorFlow no host, monte esse diretório do host (-v hostDir: / tmp).

  • 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):
android update sdk --no-ui -a --filter tools,platform-tools,android-${ANDROID_API_LEVEL},build-tools-${ANDROID_BUILD_TOOLS_VERSION}

Agora você pode prosseguir para a seção "Construir e instalar". Depois de terminar de construir as bibliotecas, você pode copiá-las para / tmp dentro do contêiner para que possa acessá-las no host.

Configure o ambiente de compilação sem Docker

Instale os pré-requisitos do Bazel e do Android

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

  1. Instale a versão mais recente do sistema de compilação do Bazel .
  2. O Android NDK é necessário para construir o código TensorFlow Lite nativo (C / C ++). A versão recomendada atual é 17c, 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 . Build tools API> = 23 é a versão recomendada para a construção do TensorFlow Lite.

Configure WORKSPACE e .bazelrc

Execute o script ./configure no diretório raiz de verificação do TensorFlow e responda "Sim" quando o script pedir para configurar interativamente o ./WORKSPACE para versõ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 devem ser fornecidas interativamente no prompt do script. A configuração bem-sucedida deve produzir entradas semelhantes às seguintes no arquivo .tf_configure.bazelrc na pasta raiz:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r17c"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="28.0.3"
build --action_env ANDROID_SDK_API_LEVEL="23"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Construir e instalar

Depois que o Bazel estiver configurado corretamente, você pode criar o TensorFlow Lite AAR a partir do diretório de verificação 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 \
  //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 várias arquiteturas diferentes; se você não precisar de todos eles, use o subconjunto apropriado para seu ambiente de implementação.

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 Tensorflow. Para mais detalhes, consulte a seção Reduzir o tamanho do 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 substituir a dependência existente do TensorFlow Lite pela nova biblioteca local, por exemplo:

allprojects {
    repositories {
        jcenter()
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}

Instale o AAR no repositório Maven local

Execute o seguinte comando no diretório raiz de verificação:

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 {
        jcenter()
        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 do TensorFlow Lite Java padrão no código do seu aplicativo.