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.