Crie o TensorFlow Lite para Android

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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.

Usar instantâneos noturnos

Para usar instantâneos noturnos, adicione o seguinte repositório à 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, 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 do TensorFlow ou pode querer fazer alterações locais no TensorFlow Lite.

Configurar o ambiente de compilação usando o Docker

  • Baixe o arquivo Docker. Ao baixar o arquivo do 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. Reconhecer

  • Opcionalmente, você pode alterar a versão do Android SDK ou do 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 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).

  • Quando estiver dentro do contêiner, você pode executar o seguinte para baixar ferramentas e bibliotecas adicionais do Android (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 Configure WORKSPACE e .bazelrc para definir as configurações de compilação.

Depois de concluir a construção das 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 os pré-requisitos do Bazel e do Android

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 nativo (C/C++) do TensorFlow Lite. A versão atual recomendada é a 19c, que pode ser encontrada aqui .
  3. O SDK do Android e as ferramentas de compilação podem ser obtidos aqui ou como parte do Android Studio . A API de ferramentas de compilação >= 23 é a versão recomendada para compilar o TensorFlow Lite.

Configurar WORKSPACE e .bazelrc

Esta é uma etapa de configuração única que é 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 pedir para configurar interativamente as ./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 devem 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-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ê poderá criar o AAR do TensorFlow Lite no 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 \
  //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 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 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 .

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 {
        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 local do Maven

Execute o seguinte comando do 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, verifique se você tem a dependência mavenLocal() e substitua a dependência padrão do TensorFlow Lite por aquela que tem suporte para determinadas operações 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.