Introducing LiteRT: El entorno de ejecución de alto rendimiento de Google para la IA integrada en el dispositivo, antes conocido como TensorFlow Lite.

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

Cómo compilar LiteRT para Android

En este documento, se describe cómo compilar la biblioteca LiteRT de Android en tu por sí solas. Por lo general, no necesitas compilar localmente la biblioteca LiteRT de Android.

Cómo usar instantáneas nocturnas

Para usar resúmenes nocturnos, agrega el siguiente repositorio a tu compilación raíz de Gradle. config.

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 edítalas según sea necesario) a tu 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. Para Por ejemplo, podrías crear un objeto binario personalizado que incluya operaciones seleccionadas de TensorFlow, o implementar cambios locales en LiteRT.

Configura un entorno de compilación con Docker

Descarga el archivo de Docker. Al descargar el archivo Docker, acepta que el siguientes condiciones del servicio rigen su uso del mismo:

Al hacer clic en Aceptar, acepta que todo uso de los componentes de Android Studio y El kit de desarrollo nativo de Android se regirá por el software de Android. El Contrato de licencia del kit para desarrollo está disponible en https://developer.android.com/studio/terms (es posible que esa URL se actualice o cambie). que Google proporciona cada tanto).

Debes aceptar las Condiciones del Servicio para descargar las .

Si lo deseas, puedes cambiar la versión del SDK o NDK de Android. Coloca los archivos descargados archivo de Docker en una carpeta vacía y ejecuta el siguiente comando para compilar tu imagen de Docker:

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 dentro del contenedor):

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

Si usas PowerShell en Windows, reemplaza "$PWD" con “pwd”.

Si quieres usar un repositorio de TensorFlow en el host, actívalo (-v hostDir:/host_dir).

Cuando 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 las licencia):

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

Ahora debes ir a la sección Configura WORKSPACE y .bazelrc para configurar los parámetros de compilación.

Cuando termines de compilar las bibliotecas, puedes copiarlas en /host_dir dentro del contenedor para poder acceder a ellos 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 de TensorFlow. Para compilar con él, debes tenerlo instalado y el NDK y SDK de Android en tu sistema.

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

Configura WORKSPACE y .bazelrc

Este es un paso de configuración único necesario para compilar LiteRT. bibliotecas. Ejecuta la secuencia de comandos ./configure en el resultado de la raíz de TensorFlow. y responde "Sí". cuando la secuencia de comandos solicite configurar de forma interactiva el ./WORKSPACE para compilaciones de Android. La secuencia de comandos intentará establecer la configuración con el las siguientes variables de entorno:

ANDROID_SDK_HOME
ANDROID_SDK_API_LEVEL
ANDROID_NDK_HOME
ANDROID_NDK_API_LEVEL

Si no estableces estas variables, se deben proporcionar de forma interactiva en la secuencia de comandos mensaje. Si la configuración es exitosa, deberías obtener 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, podrás compilar el AAR de LiteRT a partir del 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/. Nota que esto crea una “grasa” AAR con varias arquitecturas diferentes si no si necesita todos, use el subconjunto adecuado para su entorno de implementación.

Puedes compilar archivos AAR más pequeños segmentados 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, opcionalmente, el tensorflow-lite-select-tf-ops.aar si uno de los modelos usa Operaciones de TensorFlow. Para obtener más información, consulta la Sección Reduce el tamaño de los objetos binarios de LiteRT.

Cómo agregar AAR directamente al proyecto

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

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 el build.gradle de tu app, asegúrate de tener la dependencia mavenLocal() y Reemplaza la dependencia de LiteRT estándar con la que tiene compatibilidad. para algunas 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, en este caso, la versión de 0.1.100 es solo para fines de las pruebas y el desarrollo. Una vez que haya instalado las AAR locales, podrá usar la configuración API de inferencia de LiteRT de Java en el código de tu app.