Conozca lo último en aprendizaje automático, IA generativa y más en el Simposio WiML 2023.

Se usó la API de Cloud Translation para traducir esta página.

Compilación de TensorFlow Lite para Android

Este documento describe cómo compilar la biblioteca de Android TensorFlow Lite por su cuenta. Normalmente, no necesita compilar 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.

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

Cree TensorFlow Lite localmente

En algunos casos, es posible que desee 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 que desee realizar cambios locales en TensorFlow Lite.

Configurar el entorno de compilación con Docker

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

Al hacer clic para aceptar, usted acepta que todo uso de Android Studio y el 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 cambiado por Google de vez en cuando).

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

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

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

Inicie el contenedor docker 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" con "pwd".

Si desea utilizar un repositorio de TensorFlow en el host, monte ese directorio de host en su lugar (-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 proceder 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 los requisitos previos de Bazel y Android

Bazel es el sistema de compilación principal de TensorFlow. Para compilar con él, debe tenerlo y 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 TensorFlow Lite nativo (C/C++). La versión actual recomendada es la 21e, 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 . Build tools API >= 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 construir las bibliotecas TF Lite. Ejecute la secuencia de ./configure en el directorio raíz de pago de TensorFlow y responda "Sí" cuando la secuencia de comandos solicite configurar de forma interactiva las compilaciones de ./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, deben proporcionarse de forma interactiva en el indicador del script. La 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-r21e"
build --action_env ANDROID_NDK_API_LEVEL="26"
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é correctamente configurado, puede compilar TensorFlow Lite AAR desde el directorio de pago raíz de la siguiente manera:

bazel build -c opt --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
  --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, use el subconjunto apropiado para su entorno de implementación.

Puede crear archivos AAR más pequeños dirigidos 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, opcionalmente, el archivo tensorflow-lite-select-tf-ops.aar si uno de los modelos usa Tensorflow ops. Para obtener más detalles, consulte la sección Reducir el tamaño binario de TensorFlow Lite .

Agregar 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 que haga 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 su aplicación, asegúrese de tener la dependencia mavenLocal() y reemplace 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 puramente 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.