Conheça o LiteRT: o ambiente de execução de alto desempenho do Google para IA no dispositivo, antes conhecido como TensorFlow Lite.

Esta página foi traduzida pela API Cloud Translation.

Criar LiteRT para Android

Este documento descreve como criar a biblioteca LiteRT Android no seu por conta própria. Normalmente, você não precisa criar a biblioteca LiteRT do Android localmente.

Usar snapshots noturnos

Para usar snapshots noturnos, adicione o seguinte repositório ao build raiz do Gradle configuração

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'
        }
    }
}

adicionar snapshots noturnos às dependências (ou editar conforme necessário) ao build.gradle.

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

Criar o LiteRT localmente

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

Configurar o ambiente de build usando o Docker

Faça o download do arquivo Docker. Ao fazer o download do arquivo Docker, você concorda que o seguintes termos de serviço regem o uso dos mesmos:

Ao clicar para aceitar, você concorda que todo o uso dos recursos do Android Studio e O Kit de desenvolvimento nativo do Android será regido pelos Termos de Serviço do Contrato de Licença do Kit de Desenvolvimento disponível em https://developer.android.com/studio/terms (esse URL pode ser atualizado ou modificado) pelo Google periodicamente).

Você precisa aceitar os Termos de Serviço para fazer o download do .

Também é possível mudar a versão do SDK ou do NDK do Android. Coloque o arquivo baixado arquivo Docker em uma pasta vazia e crie sua imagem Docker executando:

docker build . -t tflite-builder -f tflite-android.Dockerfile

Inicie o contêiner do Docker de maneira interativa montando sua pasta atual em /host_dir no contêiner (observe que /tensorflow_src é o nome repositório de dados no contêiner):

docker run -it -v $PWD:/host_dir tflite-builder bash

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

Para usar um repositório do TensorFlow no host, ative-o em vez disso (-v hostDir:/host_dir).

Dentro do contêiner, execute o seguinte comando para fazer o download ferramentas e bibliotecas adicionais do Android (pode ser necessário aceitar os licença):

sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Prossiga para a seção Configure WORKSPACE and .bazelrc para definir as configurações do build.

Quando terminar de criar as bibliotecas, você poderá copiá-las para /host_dir dentro do contêiner para que você possa acessá-los no host.

Configurar o ambiente de build sem o Docker

Instalar os pré-requisitos do Bazel e do Android

O Bazel é o sistema de build principal do TensorFlow. Para criar com ele, é preciso tê-lo e o Android NDK e o SDK instalados no sistema.

Instale a versão mais recente do sistema de build do Bazel.
O Android NDK é necessário para criar o LiteRT nativo (C/C++) o código-fonte é alterado. A versão atual recomendada é a 25b, que pode ser encontrada aqui.
O SDK do Android e as ferramentas de build podem ser obtidos aqui ou como parte Android Studio Criação a API de ferramentas >= 23 é a versão recomendada para criar o LiteRT.

Configurar o ESPAÇO DE TRABALHO e o .bazelrc

Essa é uma etapa única de configuração necessária para criar o LiteRT bibliotecas. Execute o script ./configure na saída raiz do TensorFlow e a resposta "Yes" quando o script pede para configurar interativamente o ./WORKSPACE para builds do Android. O script tentará definir as configurações usando o variáveis de ambiente a seguir:

ANDROID_SDK_HOME
ANDROID_SDK_API_LEVEL
ANDROID_NDK_HOME
ANDROID_NDK_API_LEVEL

Se essas variáveis não forem definidas, elas precisarão ser fornecidas de maneira interativa no script. prompt de comando. A configuração bem-sucedida deve gerar entradas semelhantes às seguintes no arquivo .tf_configure.bazelrc da pasta raiz:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r25b"
build --action_env ANDROID_NDK_API_LEVEL="21"
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"

Criar e instalar

Depois que o Bazel estiver configurado corretamente, você vai poder criar o AAR LiteRT com base diretório raiz de checkout da seguinte maneira:

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm64 \
  --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --define=android_dexmerger_tool=d8_dexmerger \
  --define=android_incremental_dexing_tool=d8_dexbuilder \
  //tensorflow/lite/java:tensorflow-lite

Isso gera um arquivo AAR em bazel-bin/tensorflow/lite/java/. Observação que isso cria uma "gordura" AAR com várias arquiteturas diferentes Se você não precisar de todos eles, use o subconjunto apropriado para seu ambiente de implantação.

É possível criar arquivos AAR menores segmentando 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 gera o arquivo tensorflow-lite.aar e, opcionalmente, a Arquivo tensorflow-lite-select-tf-ops.aar se um dos modelos estiver usando Operações do TensorFlow. Para mais detalhes, consulte a Seção Reduzir o tamanho do binário LiteRT.

Adicionar AARs diretamente ao projeto

Mova o arquivo tensorflow-lite.aar para um diretório chamado libs no seu projeto. Modifique o arquivo build.gradle do app para fazer referência ao novo diretório. e substituir a dependência LiteRT existente pela nova biblioteca local, e.g.:

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')
}

Instalar o AAR no repositório Maven local

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

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 app, verifique se você tem a dependência mavenLocal() e substitua a dependência LiteRT padrão por uma que seja compatível 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 do 0.1.100 apresentada aqui é meramente para fins de testes/desenvolvimento. Com o AAR local instalado, você pode usar o APIs de inferência do LiteRT Java (em inglês) no código do app.