Compila con TensorFlow Lite para Android

En este documento, se describe cómo compilar la biblioteca de Android para TensorFlow Lite por tu cuenta. Por lo general, no es necesario compilar de forma local la biblioteca de Android para TensorFlow Lite. Si solo deseas usarlos, consulta la guía de inicio rápido de Android para obtener más detalles sobre cómo usarlos en tus proyectos de Android.

Usar instantáneas nocturnas

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

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

agregar instantáneas nocturnas a las dependencias (o editarlas según sea necesario) a tu build.gradle

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

Compila de forma local con TensorFlow Lite

En algunos casos, es posible que quieras usar una compilación local de TensorFlow Lite. Por ejemplo, puedes compilar un objeto binario personalizado que incluya operaciones seleccionadas de TensorFlow o realizar cambios locales en TensorFlow Lite.

Configura el entorno de compilación con Docker

  • Descarga el archivo de Docker. Si descargas el archivo de Docker, aceptas que las siguientes Condiciones del Servicio rigen tu uso del mismo:

Si haces clic en Aceptar, aceptas que todo el uso de Android Studio y del kit de desarrollo nativo de Android se regirá por el Contrato de licencia del kit de desarrollo de software de Android, disponible en https://developer.android.com/studio/terms (Google podría actualizar o cambiar dicha URL ocasionalmente).

Debes aceptar 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 lo siguiente:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Inicia el contenedor de Docker de manera interactiva mediante la activación de 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 lo siguiente 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 ir a la sección Configurar WORKSPACE y .bazelrc para establecer los parámetros de configuración de la compilación.

Cuando termines 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 los requisitos previos de Bazel y Android

Bazel es el sistema de compilación principal para TensorFlow. Para compilar con ella, debes tener el NDK y el SDK de Android instalados en tu sistema.

  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 TensorFlow Lite. La versión recomendada actual es la 25b, que puedes encontrar aquí.
  3. 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 TensorFlow Lite.

Configura WORKSPACE y .bazelrc

Este es un paso de configuración único que se requiere para compilar las bibliotecas de TF Lite. Ejecuta la secuencia de comandos ./configure en el directorio raíz de confirmación de la compra de TensorFlow y responde "Sí" cuando se solicite configurar de forma interactiva el ./WORKSPACE para compilaciones de Android. La secuencia de comandos intentará establecer la 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 establecen estas variables, deben proporcionarse de manera interactiva en la solicitud de secuencia de comandos. Una configuración correcta debería generar entradas similares a las siguientes en el archivo .tf_configure.bazelrc en 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"

Compila e instala

Una vez que Bazel esté configurado correctamente, puedes compilar el AAR de TensorFlow Lite desde el 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/. Ten en cuenta que esto crea un AAR “completo” con varias arquitecturas diferentes. Si no las necesitas a todas, usa el subconjunto adecuado para tu entorno de implementación.

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

Agrega 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 directorio nuevo y reemplazar la dependencia existente de TensorFlow Lite 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 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 la build.gradle de tu app, asegúrate de tener la dependencia mavenLocal() y reemplaza la dependencia estándar de TensorFlow Lite por la que es compatible con ciertas 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 la versión de 0.1.100 que se muestra aquí solo es para realizar pruebas o desarrollo. Con el AAR local instalado, puedes usar las APIs de inferencia de Java para TensorFlow Lite en el código de tu app.