Selecciona operadores de TensorFlow

Dado que la biblioteca de operador integrada LiteRT solo admite un cantidad de operadores de TensorFlow, no todos los modelos son convertibles. Para obtener más información, consulta la compatibilidad con operadores.

Para permitir la conversión, los usuarios pueden habilitar el uso de determinados recursos de TensorFlow ops en su modelo LiteRT. Sin embargo, ejecutar Los modelos LiteRT con operaciones de TensorFlow requieren la extracción del núcleo. Es el entorno de ejecución de TensorFlow, que aumenta el tamaño del objeto binario del intérprete LiteRT. Para Android, puedes evitar esto si compilas de forma selectiva solo los TensorFlow necesarios ops. Para obtener más información, consulta Reduce los objetos binarios tamaño.

En este documento, se describe cómo convertir y ejecuta un modelo LiteRT que contenga operaciones de TensorFlow en un plataforma que elijas. También se analiza el rendimiento y el tamaño métricas y limitaciones conocidas.

Convierte un modelo

En el siguiente ejemplo, se muestra cómo generar un modelo LiteRT con la Ops 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 LiteRT ops.
  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

Inferencia de ejecución

Cuando se usa un modelo LiteRT que se convirtió y admite en operaciones de TensorFlow, el cliente también debe usar un entorno de ejecución LiteRT que incluye la biblioteca necesaria de operaciones de TensorFlow.

AAR de Android

Para reducir el tamaño del objeto binario, crea tus propios archivos AAR personalizados como se indica en la guía. la siguiente sección. Si el tamaño del objeto binario no es una una preocupación considerable, recomendamos usar las AAR precompiladas con las operaciones de TensorFlow alojado en MavenCentral.

Puedes especificar esto en tus dependencias de build.gradle si lo agregas junto el AAR estándar de LiteRT 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úrate de haber agregado Instantánea de Sonatype Cloud Storage.

Una vez que agregues la dependencia, se podrá ver el delegado necesario ops de TensorFlow de grafos se deben instalar automáticamente para grafos que requieren de ellos.

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

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

Cómo compilar el AAR de Android

Para reducir el tamaño del objeto binario u otros casos avanzados, también puedes compilar el biblioteca de forma manual. Una compilación LiteRT funcional , compila el AAR de Android con operaciones seleccionadas de TensorFlow como sigue:

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 Operaciones de LiteRT integradas y personalizadas y generar el archivo AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar para las operaciones de TensorFlow. Si si no tienes un entorno de compilación que funcione, también puedes crear archivos anteriores con Docker.

Desde allí, puedes importar los archivos AAR directamente a tu proyecto o Publica los archivos AAR personalizados en tu repositorio local de Maven:

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

Por último, en el build.gradle de tu app, asegúrate de tener el mavenLocal() y reemplaza la dependencia LiteRT estándar con la que es compatible con 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'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

Uso de CocoaPods

LiteRT proporciona CocoaPods seleccionado para operaciones de TF, que se precompila durante la noche, para arm64. en la que puedes confiar junto con TensorFlowLiteSwift o TensorFlowLiteObjC CocoaPods.

Nota: Si necesitas usar operaciones de TF seleccionadas en un simulador de x86_64, puedes compilar el framework de operaciones de selección. Consulta Cómo usar 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, debes proporcionarle una marca de vinculador adicional a Fuerza la carga del framework de operaciones de TF de selección en tu proyecto. En tu proyecto de Xcode, Ir a Build Settings -> Other Linker Flags y agrega lo siguiente:

Para versiones posteriores a la 2.9.0:

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

Para las versiones < 2.9.0:

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

Luego, podrás ejecutar cualquier modelo convertido con SELECT_TF_OPS en tu app para iOS. Por ejemplo, puedes modificar el código de Clasificación de imágenes para iOS app para probar la función de selección de operaciones de TF.

• Reemplaza el archivo de modelo por el que se convirtió con SELECT_TF_OPS habilitado.
• Agrega la dependencia TensorFlowLiteSelectTfOps a Podfile como se indica.
• Agrega la marca de vinculador adicional como se muestra arriba.
• Ejecuta la app de ejemplo y observa si el modelo funciona correctamente.

Cómo usar Bazel + Xcode

LiteRT con operaciones seleccionadas de TensorFlow para iOS se puede compilar con Bazel. Primero, sigue las instrucciones de compilación en iOS para configurar tu El espacio de trabajo y el archivo .bazelrc de Bazel correctamente.

Una vez que hayas configurado el lugar de trabajo con la compatibilidad con iOS habilitada, puedes usar la siguiente comando para compilar el framework del complemento de Operaciones de TF, que se puede agregar por encima del TensorFlowLiteC.framework regular. Ten en cuenta que las operaciones de TF framework no se puede compilar para la arquitectura i386, por lo que debes Proporcionar 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 framework en bazel-bin/tensorflow/lite/ios/ . Para agregar este nuevo marco de trabajo a tu proyecto Xcode, sigue estos pasos: pasos similares descritos en el proyecto Xcode Configuración en la Guía de compilación para iOS.

Después de agregar el framework al proyecto de tu app, se agregará una marca de vinculador adicional debe especificarse en el proyecto de tu app para forzar la carga de las operaciones seleccionadas de TF en un framework de aplicaciones. En tu proyecto de Xcode, ve a Build Settings -> Other Linker Flags y agrega lo siguiente:

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

C/C++

Si usas Bazel o CMake para compilar LiteRT intérprete, puedes habilitar el delegado de Flex vinculando un LiteRT Flex biblioteca compartida delegada. Puedes compilarlo con Bazel mediante 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

Ten en cuenta que el TfLiteDelegate necesario se instalará automáticamente cuando Crear el intérprete en el tiempo de ejecución, siempre que la biblioteca compartida esté vinculada Integra no es necesario instalar explícitamente la instancia delegada, como se suele con otros tipos de delegados.

Nota: Esta función está disponible a partir de la versión 2.7.

Python

LiteRT con operaciones seleccionadas de TensorFlow se instalará automáticamente con el paquete pip de TensorFlow. Puedes también puedes instalar únicamente el pip para intérpretes de LiteRT paquete.

Métricas

Rendimiento

Cuando se usa una combinación de operaciones de TensorFlow integradas y seleccionadas, Habrá optimizaciones de LiteRT y operaciones integradas optimizadas. que se puedan usar con el modelo convertido.

En la siguiente tabla, se 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 se crearon para Android con las siguientes marcas: --config=android_arm64 -c opt.

Tamaño de los objetos binarios

En la siguiente tabla, se describe el tamaño de objeto binario de LiteRT para cada compilación. Estos destinos se compilaron para Android con --config=android_arm -c opt.

(1) Estas bibliotecas se crean de forma selectiva para i3d-kinetics-400 modelo con 8 operaciones de TFLite integradas y 3 operaciones de TensorFlow. Para obtener más información, consulta la Sección Reduce el tamaño de los objetos binarios de LiteRT.

Limitaciones conocidas

• Tipos no admitidos: Ciertas operaciones de TensorFlow pueden no admitir el conjunto completo de que suelen estar disponibles en TensorFlow.

Actualizaciones

• Versión 2.6
  • Compatibilidad con operadores basados en atributos GraphDef y recursos HashTable las inicializaciones mejoradas.
• Versión 2.5
  • Puedes aplicar una optimización conocida como posterior al entrenamiento cuantización
• Versión 2.4
  • Se mejoró la compatibilidad con delegados acelerados por hardware