Esta página se ha traducido con Cloud Translation API.

Compile TensorFlow Lite para Android

Este documento describe cómo crear la biblioteca de Android TensorFlow Lite por su cuenta. Normalmente, no es necesario crear localmente la biblioteca de Android TensorFlow Lite. Si solo desea usarlo, consulte el inicio rápido de Android para obtener más detalles sobre cómo usarlos en sus proyectos de Android.

Utilice instantáneas nocturnas

Para usar instantáneas nocturnas, agregue el siguiente repositorio a su 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'
        }
    }
}

agregue instantáneas nocturnas a las dependencias (o edítelas según sea necesario) en su 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'
    ...
}
...

Compile TensorFlow Lite localmente

En algunos casos, es posible que desees utilizar una compilación local de TensorFlow Lite. Por ejemplo, es posible que esté creando un binario personalizado que incluya operaciones seleccionadas de TensorFlow , o tal vez desee realizar cambios locales en TensorFlow Lite.

Configurar el entorno de compilación usando Docker

Descargue el archivo Docker. Al descargar el archivo Docker, acepta que los siguientes términos de servicio rigen su uso del mismo:

Al hacer clic para aceptar, usted acepta que todo uso de Android Studio y del kit de desarrollo nativo de Android se regirá por el Acuerdo de licencia del kit de desarrollo de software de Android disponible en https://developer.android.com/studio/terms (dicha URL puede ser actualizado o modificado por Google de vez en cuando).

Debe aceptar los términos de servicio para descargar el archivo.

Opcionalmente, puede cambiar la versión del SDK o NDK de Android. Coloque el archivo Docker descargado en una carpeta vacía y cree su imagen de Docker ejecutando:

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

Inicie el contenedor acoplable de forma interactiva montando su carpeta actual en /host_dir dentro del contenedor (tenga en cuenta que /tensorflow_src es el repositorio de TensorFlow dentro del contenedor):

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

Si usa PowerShell en Windows, reemplace "$PWD" por "pwd".

Si desea utilizar un repositorio de TensorFlow en el host, monte ese directorio de host (-v hostDir:/host_dir).

Una vez que esté dentro del contenedor, puede ejecutar lo siguiente para descargar herramientas y bibliotecas de Android adicionales (tenga en cuenta que es posible que deba aceptar la licencia):

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

Ahora debe pasar a la sección Configurar ESPACIO DE TRABAJO y .bazelrc para configurar los ajustes de compilación.

Una vez que termine de crear las bibliotecas, puede copiarlas en /host_dir dentro del contenedor para poder acceder a ellas en el host.

Configurar el entorno de compilación sin Docker

Instalar Bazel y requisitos previos de Android

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

Instale la última versión del sistema de compilación Bazel .
Se requiere el NDK de Android para compilar el código nativo (C/C++) de TensorFlow Lite. La versión recomendada actualmente es la 25b, que se puede encontrar aquí .
El SDK de Android y las herramientas de compilación se pueden obtener aquí o, alternativamente, como parte de Android Studio . API de herramientas de compilación >= 23 es la versión recomendada para compilar TensorFlow Lite.

Configurar ESPACIO DE TRABAJO y .bazelrc

Este es un paso de configuración único que se requiere para crear las bibliotecas TF Lite. Ejecute el script ./configure en el directorio raíz de pago de TensorFlow y responda "Sí" cuando el script solicite configurar de forma interactiva las compilaciones ./WORKSPACE para Android. El script intentará configurar los ajustes utilizando las siguientes variables de entorno:

ANDROID_SDK_HOME
ANDROID_SDK_API_LEVEL
ANDROID_NDK_HOME
ANDROID_NDK_API_LEVEL

Si estas variables no están configuradas, se deben proporcionar de forma interactiva en el mensaje del script. Una configuración exitosa 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"

Construir e instalar

Una vez que Bazel esté configurado correctamente, puede compilar TensorFlow Lite AAR desde el directorio de pago raíz 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/ . Tenga en cuenta que esto crea un AAR "grueso" con varias arquitecturas diferentes; Si no los necesita todos, utilice el subconjunto apropiado para su entorno de implementación.

Puede crear archivos AAR más pequeños dirigidos únicamente 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

El script anterior generará el archivo tensorflow-lite.aar y, opcionalmente, el archivo tensorflow-lite-select-tf-ops.aar si uno de los modelos utiliza operaciones de Tensorflow. Para obtener más detalles, consulte la sección Reducir el tamaño binario de TensorFlow Lite .

Agregue AAR directamente al proyecto

Mueva el archivo tensorflow-lite.aar a un directorio llamado libs en su proyecto. Modifique el archivo build.gradle de su aplicación para hacer referencia al nuevo directorio y reemplace la dependencia existente de TensorFlow Lite con la nueva biblioteca local, por ejemplo:

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

Instale AAR en el repositorio local de Maven

Ejecute el siguiente comando desde su directorio raíz de pago:

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 build.gradle de tu aplicación, asegúrate de tener la dependencia mavenLocal() y reemplaza la dependencia estándar de TensorFlow Lite con la que admite operaciones seleccionadas 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'
}

Tenga en cuenta que la versión 0.1.100 aquí es únicamente para fines de prueba/desarrollo. Con el AAR local instalado, puede usar las API de inferencia Java estándar de TensorFlow Lite en el código de su aplicación.