Seleccionar operadores de TensorFlow

Dado que la biblioteca de operadores integrada de TensorFlow Lite solo admite una cantidad limitada de operadores de TensorFlow, no todos los modelos son convertibles. Para obtener más información, consulte la compatibilidad del operador .

Para permitir la conversión, los usuarios pueden habilitar el uso de ciertas operaciones de TensorFlow en su modelo TensorFlow Lite. Sin embargo, ejecutar modelos de TensorFlow Lite con operaciones de TensorFlow requiere incorporar el tiempo de ejecución principal de TensorFlow, lo que aumenta el tamaño binario del intérprete de TensorFlow Lite. Para Android, puede evitar esto creando selectivamente solo las operaciones de Tensorflow requeridas. Para obtener más información, consulte reducir el tamaño binario .

Este documento describe cómo convertir y ejecutar un modelo de TensorFlow Lite que contiene operaciones de TensorFlow en una plataforma de su elección. También analiza las métricas de rendimiento y tamaño y las limitaciones conocidas .

Convertir un modelo

El siguiente ejemplo muestra cómo generar un modelo TensorFlow Lite con operaciones seleccionadas de TensorFlow.

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops = [
  tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops.
  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

Ejecutar inferencia

Cuando se usa un modelo de TensorFlow Lite que se ha convertido con soporte para operaciones seleccionadas de TensorFlow, el cliente también debe usar un tiempo de ejecución de TensorFlow Lite que incluye la biblioteca necesaria de operaciones de TensorFlow.

RAA de Android

Para reducir el tamaño binario, cree sus propios archivos AAR personalizados como se indica en la siguiente sección . Si el tamaño binario no es una preocupación considerable, recomendamos usar el AAR preconstruido con TensorFlow ops alojado en MavenCentral .

Puede especificar esto en sus dependencias de build.gradle agregándolo junto con el AAR estándar de TensorFlow Lite de la siguiente manera:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    // This dependency adds the necessary TF op support.
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.0.0-nightly-SNAPSHOT'
}

Para usar instantáneas nocturnas, asegúrese de haber agregado el repositorio de instantáneas de Sonatype .

Una vez que haya agregado la dependencia, el delegado necesario para manejar las operaciones de TensorFlow del gráfico debe instalarse automáticamente para los gráficos que lo requieran.

Nota: La dependencia de operaciones de TensorFlow es relativamente grande, por lo que probablemente querrá filtrar las ABI x86 innecesarias en su archivo .gradle configurando sus abiFilters .

android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

Construyendo el AAR de Android

Para reducir el tamaño binario u otros casos avanzados, también puede crear la biblioteca manualmente. Suponiendo un entorno de compilación TensorFlow Lite en funcionamiento , cree el AAR de Android con operaciones seleccionadas de TensorFlow de la siguiente manera:

sh tensorflow/lite/tools/build_aar.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

Esto generará el archivo AAR bazel-bin/tmp/tensorflow-lite.aar para las operaciones integradas y personalizadas de TensorFlow Lite; y genere el archivo AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar para TensorFlow ops. Si no tiene un entorno de compilación que funcione, también puede compilar los archivos anteriores con docker .

Desde allí, puede importar los archivos AAR directamente a su proyecto o publicar los archivos AAR personalizados en su repositorio Maven local:

mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar
mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite-select-tf-ops -Dversion=0.1.100 -Dpackaging=aar

Finalmente, en el 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'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

Uso de CocoaPods

TensorFlow Lite proporciona CocoaPods de TF ops prediseñados todas las noches para arm64 , en los que puede confiar junto con TensorFlowLiteSwift o TensorFlowLiteObjC CocoaPods.

Nota: Si necesita usar operaciones TF seleccionadas en un simulador x86_64 , puede crear el marco de operaciones seleccionadas usted mismo. Consulte la sección Uso de Bazel + Xcode para obtener más detalles.

# In your Podfile target:
  pod 'TensorFlowLiteSwift'   # or 'TensorFlowLiteObjC'
  pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'

Después de ejecutar pod install , debe proporcionar un indicador de vinculación adicional para forzar la carga del marco de operaciones de TF seleccionado en su proyecto. En su proyecto Xcode, vaya a Build Settings -> Other Linker Flags y agregue:

Para versiones >= 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.xcframework/ios-arm64/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Para versiones < 2.9.0:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

Entonces debería poder ejecutar cualquier modelo convertido con SELECT_TF_OPS en su aplicación iOS. Por ejemplo, puede modificar la aplicación Clasificación de imágenes de iOS para probar la función de operaciones TF seleccionadas.

• Reemplace el archivo del modelo con el convertido con SELECT_TF_OPS habilitado.
• Agregue la dependencia de TensorFlowLiteSelectTfOps al Podfile como se indica.
• Agregue la bandera del enlazador adicional como se indica arriba.
• Ejecute la aplicación de ejemplo y vea si el modelo funciona correctamente.

Usando Bazel + Xcode

TensorFlow Lite con operaciones seleccionadas de TensorFlow para iOS se puede crear con Bazel. Primero, siga las instrucciones de compilación de iOS para configurar su espacio de trabajo de Bazel y el archivo .bazelrc correctamente.

Una vez que haya configurado el espacio de trabajo con la compatibilidad con iOS habilitada, puede usar el siguiente comando para crear el marco adicional de operaciones de TF seleccionado, que se puede agregar encima del TensorFlowLiteC.framework normal. Tenga en cuenta que el marco de operaciones de TF seleccionado no se puede compilar para la arquitectura i386 , por lo que debe proporcionar explícitamente la lista de arquitecturas de destino, excepto i386 .

bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
  //tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework

Esto generará el marco en el bazel-bin/tensorflow/lite/ios/ . Puede agregar este nuevo marco a su proyecto Xcode siguiendo pasos similares descritos en la sección de configuración del proyecto Xcode en la guía de compilación de iOS.

Después de agregar el marco a su proyecto de aplicación, se debe especificar un indicador de vinculación adicional en su proyecto de aplicación para forzar la carga del marco de operaciones de TF seleccionado. En su proyecto Xcode, vaya a Build Settings -> Other Linker Flags y agregue:

-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>

C/C++

Si usa Bazel o CMake para compilar el intérprete de TensorFlow Lite, puede habilitar el delegado de Flex vinculando una biblioteca compartida de delegado de TensorFlow Lite Flex. Puedes construirlo con Bazel como el siguiente comando.

bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex

Este comando genera la siguiente biblioteca compartida en bazel-bin/tensorflow/lite/delegates/flex .

Plataforma	nombre de la biblioteca
linux	libtensorflowlite_flex.so
Mac OS	libtensorflowlite_flex.dylib
ventanas	tensorflowlite_flex.dll

Tenga en cuenta que el TfLiteDelegate necesario se instalará automáticamente al crear el intérprete en tiempo de ejecución siempre que la biblioteca compartida esté vinculada. No es necesario instalar explícitamente la instancia de delegado como suele ser necesario con otros tipos de delegados.

Nota: Esta función está disponible desde la versión 2.7.

Pitón

TensorFlow Lite con operaciones seleccionadas de TensorFlow se instalará automáticamente con el paquete pip de TensorFlow . También puede elegir instalar solo el paquete pip de TensorFlow Lite Interpreter .

Nota: TensorFlow Lite con operaciones seleccionadas de TensorFlow están disponibles en la versión del paquete pip de TensorFlow desde 2.3 para Linux y 2.4 para otros entornos.

Métrica

Actuación

Cuando se usa una combinación de operaciones integradas y seleccionadas de TensorFlow, todas las mismas optimizaciones de TensorFlow Lite y operaciones integradas optimizadas estarán disponibles y se podrán usar con el modelo convertido.

La siguiente tabla describe el tiempo promedio que se tarda en ejecutar la inferencia en MobileNet en un Pixel 2. Los tiempos enumerados son un promedio de 100 ejecuciones. Estos objetivos se crearon para Android usando las banderas: --config=android_arm64 -c opt .

Construir	Tiempo (milisegundos)
Solo operaciones integradas ( TFLITE_BUILTIN )	260.7
Usando solo operaciones TF ( SELECT_TF_OPS )	264.5

Tamaño binario

La siguiente tabla describe el tamaño binario de TensorFlow Lite para cada compilación. Estos objetivos se crearon para Android mediante --config=android_arm -c opt .

Construir	Tamaño binario de C++	Tamaño de APK de Android
Solo operaciones integradas	796KB	561KB
Operaciones integradas + operaciones TF	23,0 MB	8,0 MB
Operaciones integradas + operaciones TF (1)	4,1 MB	1,8 MB

(1) Estas bibliotecas se crean de forma selectiva para el modelo i3d-kinetics-400 con 8 operaciones integradas TFLite y 3 operaciones Tensorflow. Para obtener más detalles, consulte la sección Reducir el tamaño binario de TensorFlow Lite .

Limitaciones conocidas

• Tipos no admitidos: es posible que ciertas operaciones de TensorFlow no admitan el conjunto completo de tipos de entrada/salida que normalmente están disponibles en TensorFlow.

Actualizaciones

• Versión 2.6
  • Se ha mejorado la compatibilidad con los operadores basados ​​en atributos de GraphDef y las inicializaciones de recursos de HashTable.
• Versión 2.5
  • Puede aplicar una optimización conocida como cuantificación posterior al entrenamiento.
• Versión 2.4
  • Se ha mejorado la compatibilidad con los delegados acelerados por hardware.