En este documento, se describe cómo compilar la biblioteca LiteRT de Android en tu por sí solas. Por lo general, no necesitas compilar localmente la biblioteca LiteRT de Android. Si solo quieres usarla, consulta la Guía de inicio rápido de Android para obtener más detalles sobre su uso en tus proyectos de Android.
Cómo usar instantáneas nocturnas
Para usar resúmenes nocturnos, agrega el siguiente repositorio a tu compilación raíz de Gradle. config.
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'
}
}
}
Agrega instantáneas nocturnas a las dependencias (o edítalas según sea necesario) a tu 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'
...
}
...
Compila LiteRT de forma local
En algunos casos, es posible que desees usar una compilación local de LiteRT. Para Por ejemplo, podrías crear un objeto binario personalizado que incluya operaciones seleccionadas de TensorFlow, o implementar cambios locales en LiteRT.
Configura un entorno de compilación con Docker
- Descarga el archivo de Docker. Al descargar el archivo Docker, acepta que el siguientes condiciones del servicio rigen su uso del mismo:
Al hacer clic en Aceptar, acepta que todo uso de los componentes de Android Studio y El kit de desarrollo nativo de Android se regirá por el software de Android. El Contrato de licencia del kit para desarrollo está disponible en https://developer.android.com/studio/terms (es posible que esa URL se actualice o cambie). que Google proporciona cada tanto).
Debes aceptar las Condiciones del Servicio para descargar las .- Si lo deseas, puedes cambiar la versión del SDK o NDK de Android. Coloca los archivos descargados archivo de Docker en una carpeta vacía y ejecuta el siguiente comando para compilar tu imagen de Docker:
docker build . -t tflite-builder -f tflite-android.Dockerfile
- Inicia el contenedor de Docker de forma interactiva activando tu carpeta actual en /host_dir dentro del contenedor (ten en cuenta que /tensorflow_src es el repositorio dentro del contenedor):
docker run -it -v $PWD:/host_dir tflite-builder bash
Si usas PowerShell en Windows, reemplaza "$PWD" con “pwd”.
Si quieres usar un repositorio de TensorFlow en el host, actívalo (-v hostDir:/host_dir).
- Cuando estés dentro del contenedor, puedes ejecutar lo siguiente para descargar herramientas y bibliotecas adicionales de Android (ten en cuenta que es posible que debas aceptar las licencia):
sdkmanager \
"build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
"platform-tools" \
"platforms;android-${ANDROID_API_LEVEL}"
Ahora debes ir a la sección Configura WORKSPACE y .bazelrc para configurar los parámetros de compilación.
Cuando termines de compilar las bibliotecas, puedes copiarlas en /host_dir dentro del contenedor para poder acceder a ellos en el host.
Configura el entorno de compilación sin Docker
Instala los requisitos previos de Bazel y Android
Bazel es el sistema de compilación principal de TensorFlow. Para compilar con él, debes tenerlo instalado y el NDK y SDK de Android en tu sistema.
- Instala la versión más reciente del sistema de compilación de Bazel.
- Se requiere el NDK de Android para compilar el LiteRT nativo (C/C++) código. La versión recomendada actual es la 25b, pero puedes consultarla aquí.
- Se pueden obtener el SDK de Android y las herramientas de compilación aquí de forma alternativa como parte Android Studio Compilación La API de Tools >= 23 es la versión recomendada para compilar LiteRT.
Configura WORKSPACE y .bazelrc
Este es un paso de configuración único necesario para compilar LiteRT.
bibliotecas. Ejecuta la secuencia de comandos ./configure
en el resultado de la raíz de TensorFlow.
y responde "Sí". cuando la secuencia de comandos solicite configurar de forma interactiva el ./WORKSPACE
para compilaciones de Android. La secuencia de comandos intentará establecer la configuración con el
las siguientes variables de entorno:
ANDROID_SDK_HOME
ANDROID_SDK_API_LEVEL
ANDROID_NDK_HOME
ANDROID_NDK_API_LEVEL
Si no estableces estas variables, se deben proporcionar de forma interactiva en la secuencia de comandos
mensaje. Si la configuración es exitosa, deberías obtener entradas similares a las siguientes:
En el archivo .tf_configure.bazelrc
de la carpeta raíz:
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"
Compilación e instalación
Una vez que Bazel esté configurado correctamente, podrás compilar el AAR de LiteRT a partir del directorio raíz de confirmación de la compra de la siguiente manera:
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
Esto generará un archivo AAR en bazel-bin/tensorflow/lite/java/
. Nota
que esto crea una “grasa” AAR con varias arquitecturas diferentes si no
si necesita todos, use el subconjunto adecuado
para su entorno de implementación.
Puedes compilar archivos AAR más pequeños segmentados solo para un conjunto de modelos de la siguiente manera:
bash tensorflow/lite/tools/build_aar.sh \
--input_models=model1,model2 \
--target_archs=x86,x86_64,arm64-v8a,armeabi-v7a
La secuencia de comandos anterior generará el archivo tensorflow-lite.aar
y, opcionalmente, el
tensorflow-lite-select-tf-ops.aar
si uno de los modelos usa
Operaciones de TensorFlow. Para obtener más información, consulta la
Sección Reduce el tamaño de los objetos binarios de LiteRT.
Cómo agregar AAR directamente al proyecto
Mueve el archivo tensorflow-lite.aar
a un directorio llamado libs
en tu
en un proyecto final. Modifica el archivo build.gradle
de tu app para hacer referencia al directorio nuevo
y reemplazar la dependencia LiteRT existente por la nueva 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')
}
Instala AAR en el repositorio local de Maven
Ejecuta el siguiente comando desde tu directorio raíz de confirmación de la 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
En el build.gradle
de tu app, asegúrate de tener la dependencia mavenLocal()
y
Reemplaza la dependencia de LiteRT estándar con la que tiene compatibilidad.
para algunas operaciones de 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'
}
Ten en cuenta que, en este caso, la versión de 0.1.100
es solo para fines de
las pruebas y el desarrollo. Una vez que haya instalado las AAR locales, podrá usar la configuración
API de inferencia de LiteRT de Java en el código de tu app.