Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

Construye TensorFlow Lite para Android

Este documento describe cómo compilar la biblioteca de Android TensorFlow Lite por su cuenta. Normalmente, no es necesario compilar localmente la biblioteca de Android TensorFlow Lite. Si lo que desea es utilizar, la forma más fácil es usar el TensorFlow Lite AAR alojado en MavenCentral . Ver Android QuickStart para más detalles sobre cómo utilizarlos 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 'http://oss.sonatype.org/content/repositories/snapshots'
        }
    }
}

Compila TensorFlow Lite de forma local

En algunos casos, es posible que desee utilizar una compilación local de TensorFlow Lite. Por ejemplo, puede ser la construcción de un sistema binario personalizado que incluye las operaciones seleccionadas de TensorFlow , o puede que desee hacer cambios locales en TensorFlow Lite.

Configurar el entorno de compilación con Docker

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

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

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

  • Opcionalmente, puede cambiar la versión de Android SDK o NDK. Coloque el archivo de 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 de la ventana 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 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):
android update sdk --no-ui -a --filter tools,platform-tools,android-${ANDROID_API_LEVEL},build-tools-${ANDROID_BUILD_TOOLS_VERSION}

Ahora se debe proceder a la Configuración del espacio de trabajo y .bazelrc sección para definir la configuración de generación.

Una vez que haya terminado 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 construir con él, debe tenerlo y el NDK y SDK de Android instalados en su sistema.

  1. Instalar la última versión del sistema de construcción Basel .
  2. Se requiere el NDK de Android para compilar el código nativo (C / C ++) de TensorFlow Lite. La versión actual recomendado es 19c, que se puede encontrar aquí .
  3. El SDK de Android y herramientas de construcción se pueden obtener aquí , o, alternativamente, como parte de Android Studio . La API de herramientas de compilación> = 23 es la versión recomendada para compilar TensorFlow Lite.

Configurar WORKSPACE y .bazelrc

Este es un paso de configuración de una sola vez que se requiere para construir las bibliotecas TF Lite. Ejecutar el ./configure script en el directorio de la caja TensorFlow raíz, y la respuesta "Sí" cuando se le pregunta el guión para configurar de forma interactiva la ./WORKSPACE para Android construye. 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 símbolo del sistema. Configuración correcta debe producir entradas similares a lo siguiente en el .tf_configure.bazelrc archivo en la carpeta raíz:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r19c"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="28.0.3"
build --action_env ANDROID_SDK_API_LEVEL="23"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Construir e instalar

Una vez que Bazel esté configurado correctamente, puede compilar el AAR de TensorFlow Lite desde el directorio raíz de pago 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 \
  //tensorflow/lite/java:tensorflow-lite

Esto generará un archivo de AAR en bazel-bin/tensorflow/lite/java/ . Tenga en cuenta que esto crea un AAR "gordo" 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 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

Por encima de la escritura generará el tensorflow-lite.aar archivo y opcionalmente el tensorflow-lite-select-tf-ops.aar archivo si uno de los modelos es el uso de operaciones Tensorflow. Para más detalles, ver el tamaño binario TensorFlow Lite Reducir sección.

Agregar AAR directamente al proyecto

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

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'http://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 su aplicación build.gradle , asegurarse de tener la mavenLocal() dependencia y sustituir la dependencia estándar TensorFlow Lite con el que cuenta con el apoyo para ciertas operaciones TensorFlow:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'http://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
}

Tenga en cuenta que la 0.1.100 versión aquí es puramente por el bien de las pruebas / desarrollo. Con la AAR local instalado, puede utilizar los estándares API de inferencia TensorFlow Lite Java en el código de aplicación.