Cómo compilar LiteRT para Android

En este documento, se describe cómo compilar la biblioteca de Android de LiteRT por tu cuenta. Por lo general, no es necesario compilar localmente la biblioteca de LiteRT para Android.

Cómo usar las instantáneas nocturnas

Para usar instantáneas nocturnas, agrega el siguiente repo a la configuración de compilación de Gradle raíz.

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 edita según sea necesario) en tu archivo 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. Por ejemplo, es posible que estés compilando un archivo binario personalizado que incluya operaciones seleccionadas de TensorFlow, o bien que desees realizar cambios locales en LiteRT.

Configura el entorno de compilación con Docker

  • Descarga el archivo de Docker. Si descargas el archivo de Docker, aceptas que los siguientes términos del servicio rigen tu uso del archivo:

Al hacer clic para aceptar, usted acepta que todo uso de Android Studio y del Android Native Development Kit se regirá por el Acuerdo de Licencia del Kit de Desarrollo de Software de Android disponible en https://developer.android.com/studio/terms (Google puede actualizar o cambiar esta URL ocasionalmente).

Debes confirmar que aceptas las condiciones del servicio para descargar el archivo.

  • De manera opcional, puedes cambiar la versión del SDK o NDK de Android. Coloca el archivo de Docker descargado en una carpeta vacía y compila tu imagen de Docker ejecutando el siguiente comando:
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 de TensorFlow dentro del contenedor):
docker run -it -v $PWD:/host_dir tflite-builder bash

Si usas PowerShell en Windows, reemplaza "$PWD" por "pwd".

Si quieres usar un repositorio de TensorFlow en el host, activa ese directorio del host en su lugar (-v hostDir:/host_dir).

  • Una vez que estés dentro del contenedor, puedes ejecutar el siguiente comando para descargar herramientas y bibliotecas adicionales de Android (ten en cuenta que es posible que debas aceptar la licencia):
sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Ahora debes continuar con la sección Configura WORKSPACE y .bazelrc para configurar los parámetros de configuración de la compilación.

Después de terminar de compilar las bibliotecas, puedes copiarlas en /host_dir dentro del contenedor para poder acceder a ellas en el host.

Configura el entorno de compilación sin Docker

Instala Bazel y los requisitos previos de Android

Bazel es el sistema de compilación principal de TensorFlow. Para compilar con él, debes tenerlo instalado en tu sistema, junto con el NDK y el SDK de Android.

  1. Instala la versión más reciente del sistema de compilación de Bazel.
  2. Se requiere el NDK de Android para compilar el código nativo (C/C++) de LiteRT. La versión recomendada actual es la 25b, que puedes encontrar aquí.
    1. El SDK de Android y las herramientas de compilación se pueden obtener aquí o, como alternativa, como parte de Android Studio. La API de herramientas de compilación >= 23 es la versión recomendada para compilar LiteRT.

Configura WORKSPACE y .bazelrc

Este es un paso de configuración único que se requiere para compilar las bibliotecas de LiteRT. Ejecuta la secuencia de comandos ./configure en el directorio raíz de la confirmación de extracción de TensorFlow y responde "Sí" cuando la secuencia de comandos te solicite que configures de forma interactiva ./WORKSPACE para las compilaciones de Android. La secuencia de comandos intentará configurar los parámetros de configuración con las siguientes variables de entorno:

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

Si no se configuran estas variables, se deben proporcionar de forma interactiva en la solicitud de la secuencia de comandos. La configuración correcta debería generar 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, puedes compilar el AAR de LiteRT desde el directorio raíz de la confirmación de extracción 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/. Ten en cuenta que esto compila un AAR "grueso" con varias arquitecturas diferentes. Si no las necesitas todas, usa el subconjunto adecuado para tu entorno de implementación.

Puedes compilar archivos AAR más pequeños que se segmenten 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, de manera opcional, el archivo tensorflow-lite-select-tf-ops.aar si uno de los modelos usa operaciones de TensorFlow. Para obtener más detalles, consulta la sección Reduce el tamaño del binario de LiteRT.

Cómo agregar la AAR directamente al proyecto

Mueve el archivo tensorflow-lite.aar a un directorio llamado libs en tu proyecto. Modifica el archivo build.gradle de tu app para hacer referencia al nuevo directorio y reemplazar la dependencia existente de LiteRT por la nueva biblioteca local, p.ej.:

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 el AAR en el repositorio local de Maven

Ejecuta el siguiente comando desde el directorio raíz de la confirmación:

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 archivo build.gradle de tu app, asegúrate de tener la dependencia mavenLocal() y reemplaza la dependencia estándar de LiteRT por la que admite las operaciones de TensorFlow seleccionadas:

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 la versión de 0.1.100 que se muestra aquí es solo para fines de prueba o desarrollo. Con el AAR local instalado, puedes usar las APIs de inferencia de LiteRT en Java estándar en el código de tu app.