O Dia da Comunidade de ML é dia 9 de novembro! Junte-nos para atualização de TensorFlow, JAX, e mais Saiba mais

Compilar TensorFlow Lite para Android

Este documento descreve como criar 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ê só quer usá-lo, a maneira mais fácil é usar o TensorFlow Lite AAR hospedado no MavenCentral . Veja Android iniciar rapidamente para obter mais detalhes sobre como usá-los em seus projetos de Android.

Use instantâneos noturnos

Para usar instantâneos noturnos, adicione o seguinte repo à sua configuração raiz de compilação do Gradle.

allprojects {
    repositories {      // should be already there
        mavenCentral()  // should be already there
        maven {         // add this repo to use snapshots
          name 'ossrh-snapshot'
          url 'http://oss.sonatype.org/content/repositories/snapshots'
        }
    }
}

Crie o TensorFlow Lite localmente

Em alguns casos, você pode querer usar uma compilação local do TensorFlow Lite. Por exemplo, você pode ser a construção de um binário personalizado que inclui operações seleccionadas a partir TensorFlow , ou você pode querer fazer mudanças locais para 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 Kit de desenvolvimento Android Studio e Android nativo será regido pelo Acordo de Licença de Software Android 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. Reconhecer

  • 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 do docker de forma interativa montando sua pasta atual em / host_dir dentro do contêiner (observe que / tensorflow_src é o repositório 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 quiser usar um repositório 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):
android update sdk --no-ui -a --filter tools,platform-tools,android-${ANDROID_API_LEVEL},build-tools-${ANDROID_BUILD_TOOLS_VERSION}

Agora você deve proceder ao Configurar área de trabalho e .bazelrc seção para configurar 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 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 Bazel .
  2. O Android NDK é necessário para construir o código TensorFlow Lite nativo (C / C ++). A versão recomendada atual é 19c, que pode ser encontrada aqui .
  3. O Android SDK e ferramentas de compilação podem ser obtidos aqui , ou, alternativamente, como parte do Android Estúdio . Build tools API> = 23 é a versão recomendada para a construção do TensorFlow Lite.

Configure a ESPAÇO DE TRABALHO e .bazelrc

Esta é uma etapa de configuração única necessária para construir as bibliotecas TF Lite. Executar o ./configure script no diretório de checkout TensorFlow raiz, e responda "Sim" quando o script pede para configurar interativamente o ./WORKSPACE para compilações 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. Configuração bem-sucedida deve render entradas semelhantes à seguinte no .tf_configure.bazelrc arquivo na pasta raiz:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r19c"
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.

Você pode construir 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

Acima script irá gerar o tensorflow-lite.aar arquivo e, opcionalmente, o tensorflow-lite-select-tf-ops.aar arquivo se um dos modelos está usando ops Tensorflow. Para mais detalhes, consulte o tamanho do binário TensorFlow Lite Reduzir seção.

Adicionar AAR diretamente ao projeto

Mova o tensorflow-lite.aar arquivo em um diretório chamado libs em seu projeto. Modificar do seu aplicativo build.gradle arquivo para fazer referência ao novo diretório e substituir a dependência TensorFlow Lite existente com a nova biblioteca local, por exemplo:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'http://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 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

Em de seu aplicativo build.gradle , garantir que tem o mavenLocal() dependência e substituir a dependência padrão TensorFlow Lite com o que tem suporte para selecionar ops TensorFlow:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'http://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
}

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