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

Início rápido do Android

Para começar a usar o TensorFlow Lite no Android, recomendamos explorar o exemplo a seguir.

Exemplo de classificação de imagem do Android

Leia a classificação de imagem do TensorFlow Lite para Android para obter uma explicação do código-fonte.

Este aplicativo de exemplo usa a classificação de imagens para classificar continuamente o que vê na câmera traseira do dispositivo. O aplicativo pode ser executado no dispositivo ou emulador.

A inferência é realizada usando a API Java TensorFlow Lite e a Biblioteca de suporte Android TensorFlow Lite . O aplicativo demo classifica os quadros em tempo real, exibindo as principais classificações mais prováveis. Ele permite que o usuário escolha entre um ponto flutuante ou modelo quantizado , selecione a contagem de threads e decida se deseja executar na CPU, GPU ou via NNAPI .

Construir no Android Studio

Para criar o exemplo no Android Studio, siga as instruções em README.md .

Crie seu próprio aplicativo para Android

Para começar a escrever rapidamente seu próprio código Android, recomendamos usar nosso exemplo de classificação de imagem para Android como ponto de partida.

As seções a seguir contêm algumas informações úteis para trabalhar com o TensorFlow Lite no Android.

Use a biblioteca de suporte do Android TensorFlow Lite

A Biblioteca de suporte Android TensorFlow Lite facilita a integração de modelos em seu aplicativo. Ele fornece APIs de alto nível que ajudam a transformar dados de entrada brutos no formato exigido pelo modelo e interpretar a saída do modelo, reduzindo a quantidade de código padrão necessário.

Ele suporta formatos de dados comuns para entradas e saídas, incluindo imagens e matrizes. Ele também fornece unidades de pré e pós-processamento que executam tarefas como redimensionar e cortar imagens.

Para começar, siga as instruções na biblioteca de suporte do Android TensorFlow Lite README.md .

Use o TensorFlow Lite AAR do JCenter

Para usar o TensorFlow Lite em seu aplicativo Android, recomendamos o uso do AAR do TensorFlow Lite hospedado no JCenter .

Você pode especificar isso em suas dependências build.gradle da seguinte maneira:

 dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly'
}
 

Este AAR inclui binários para todas as ABIs do Android . Você pode reduzir o tamanho do binário do seu aplicativo incluindo apenas as ABIs necessárias para o suporte.

Recomendamos que a maioria dos desenvolvedores omita as arm32 x86 , x86_64 e arm32. Isso pode ser alcançado com a seguinte configuração Gradle, que inclui especificamente apenas armeabi-v7a e arm64-v8a , que devem abranger a maioria dos dispositivos Android modernos.

 android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}
 

Para saber mais sobre os abiFilters , consulte NdkOptions na documentação do Android Gradle.

Crie o TensorFlow Lite localmente

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

Configurar o ambiente de construção usando o Docker

  • Faça o download do 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 (esse URL pode ser atualizado ou alterado pelo Google periodicamente).

Você deve reconhecer os termos de serviço para fazer download do 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 construa sua imagem do Docker executando:
 docker build . -t tflite-builder -f tflite-android.Dockerfile
 
  • Inicie o contêiner do docker interativamente montando sua pasta atual em / tmp dentro do contêiner (observe que / tensorflow_src é o repositório do 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ê deseja 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 "Build and Install". Após concluir a construção das bibliotecas, você pode copiá-las para / tmp dentro do contêiner para poder acessá-las no host.

Configurar o ambiente de construção sem o Docker

Instalar pré-requisitos do Bazel e Android

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

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

Execute o script ./configure no diretório de verificação raiz do TensorFlow e responda "Sim" quando o script solicitar a configuração interativa das ./WORKSPACE do ./WORKSPACE for 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-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"
 

Construa e instale

Depois que o Bazel estiver configurado corretamente, você poderá criar o AAR do TensorFlow Lite a partir do diretório raiz da verificação geral 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 o seu ambiente de implementação. A partir daí, existem várias abordagens que você pode adotar para usar o .aar no seu projeto do Android Studio.

Adicione o 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 referenciar o novo diretório e substitua 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 local do Maven

Execute o seguinte comando no diretório raiz do checkout:

 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 uma que tenha 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 Java padrão do TensorFlow Lite no código do seu aplicativo.

Crie um aplicativo Android usando C ++

Existem duas maneiras de usar o TFLite por meio do C ++ se você criar seu aplicativo com o NDK:

Use a API TFLite C

Essa é a abordagem recomendada . Faça o download do AAR do TensorFlow Lite hospedado no JCenter , renomeie-o para tensorflow-lite-*.zip e descompacte-o. Você deve incluir os quatro arquivos de headers/tensorflow/lite/ nas pastas headers/tensorflow/lite/ e headers/tensorflow/lite/c/ e a biblioteca dinâmica libtensorflowlite_jni.so relevante na pasta jni/ no seu projeto NDK.

O arquivo de cabeçalho c_api.h contém documentação básica sobre o uso da API TFLite C.

Use a API TFLite C ++

Se você deseja usar o TFLite por meio da API C ++, é possível criar as bibliotecas compartilhadas em C ++:

Armeabi-v7a de 32 bits:

 bazel build -c opt --config=android_arm //tensorflow/lite:libtensorflowlite.so
 

64bit arm64-v8a:

 bazel build -c opt --config=android_arm64 //tensorflow/lite:libtensorflowlite.so
 

Atualmente, não há uma maneira direta de extrair todos os arquivos de cabeçalho necessários; portanto, você deve incluir todos os arquivos de cabeçalho no tensorflow/lite/ do repositório TensorFlow. Além disso, você precisará de arquivos de cabeçalho do FlatBuffers e Abseil .