Obtén más información sobre nuestros anuncios de Google AI Edge de I/O.

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

Selecciona 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 detalles, consulta la compatibilidad con operadores.

Para permitir la conversión, los usuarios pueden habilitar el uso de ciertas operaciones de TensorFlow en su modelo de TensorFlow Lite. Sin embargo, para ejecutar modelos de TensorFlow Lite con operaciones de TensorFlow, es necesario extraer el entorno de ejecución principal de TensorFlow, lo que aumenta el tamaño del objeto binario del intérprete de TensorFlow Lite. Para Android, puedes evitar esto si compilas de forma selectiva solo las operaciones necesarias de TensorFlow. Para obtener más información, consulta Cómo reducir el tamaño de los objetos binarios.

En este documento, se describe cómo convertir y run un modelo de TensorFlow Lite que contiene operaciones de TensorFlow en la plataforma que elijas. También se analizan las métricas de rendimiento y tamaño y las limitaciones conocidas.

Convierte un modelo

En el siguiente ejemplo, se muestra cómo generar un modelo de 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)

Inferencia de ejecución

Cuando usas un modelo de TensorFlow Lite que se convirtió y admite algunas operaciones de TensorFlow, el cliente también debe usar un entorno de ejecución de TensorFlow Lite que incluya la biblioteca necesaria de operaciones de TensorFlow.

AAR de Android

Para reducir el tamaño del objeto binario, compila tus propios archivos AAR personalizados como se indica en la siguiente sección. Si el tamaño del objeto binario no es un problema considerable, te recomendamos usar las AAR precompiladas con las operaciones de TensorFlow alojadas en MavenCentral.

Para especificar esto en tus dependencias de build.gradle, agrégalo 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úrate de haber agregado el repositorio de instantáneas de Sonatype.

Una vez que hayas agregado la dependencia, el delegado necesario para controlar las operaciones de TensorFlow del grafo debería instalarse automáticamente para los grafos que los requieran.

Nota: La dependencia de operaciones de TensorFlow es relativamente grande, por lo que probablemente te convenga filtrar las ABI x86 innecesarias en el archivo .gradle mediante la configuración de abiFilters.

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

Cómo compilar el AAR de Android

Para reducir el tamaño del objeto binario y otros casos avanzados, también puedes compilar la biblioteca de forma manual. Suponiendo un entorno de compilación de TensorFlow Lite que funcione, compila 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 el archivo AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar para las operaciones de TensorFlow. Si no tienes un entorno de compilación que funcione, también puedes compilar arriba de los archivos con docker.

Desde allí, puedes importar los archivos AAR directamente a tu proyecto o publicar los archivos AAR personalizados en tu 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

Por último, en el archivo build.gradle de tu app, asegúrate de tener la dependencia mavenLocal() y reemplaza la dependencia estándar de TensorFlow Lite por 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 selectos durante la noche para operaciones de TF, compilados previamente durante la noche, para arm64, de los que puedes confiar junto con los CocoaPods de TensorFlowLiteSwift o TensorFlowLiteObjC.

Nota: Si necesitas usar operaciones seleccionadas de TF en un simulador de x86_64, puedes compilar el framework de operaciones seleccionadas por tu cuenta. Consulta la sección Usa 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 proporcionar una marca de vinculador adicional para forzar la carga del framework de operaciones de TF seleccionado en tu proyecto. En el proyecto de Xcode, ve 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 versiones anteriores a la 2.9.0:

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

Luego, deberías poder ejecutar cualquier modelo convertido con SELECT_TF_OPS en tu app para iOS. Por ejemplo, puedes modificar la app de clasificación de imágenes para iOS para probar la función seleccionada 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

TensorFlow Lite con operaciones seleccionadas de TensorFlow para iOS se puede compilar con Bazel. Primero, sigue las instrucciones de compilación para iOS para configurar el lugar de trabajo de Bazel y el archivo .bazelrc de forma correcta.

Una vez que hayas configurado el lugar de trabajo con la compatibilidad con iOS habilitada, puedes usar el siguiente comando para compilar el framework del complemento de operaciones de TF, que se puede agregar además del TensorFlowLiteC.framework normal. Ten en cuenta que el framework de operaciones de TF seleccionado no se puede compilar para la arquitectura i386, por lo que debes proporcionar de forma explícita 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 el directorio bazel-bin/tensorflow/lite/ios/. Puedes agregar este framework nuevo a tu proyecto de Xcode con los pasos similares que se describen en la sección Configuración del proyecto de Xcode de la guía de compilación de iOS.

Después de agregar el framework al proyecto de tu app, se debe especificar una marca de vinculador adicional en el proyecto de la app para forzar la carga del framework de operaciones de TF seleccionado. 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 el intérprete de TensorFlow Lite, puedes habilitar el delegado de Flex vinculando una biblioteca compartida de delegado de TensorFlow Lite Flex. 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.

Plataforma	Nombre de la biblioteca
Linux	`libtensorflowlite_flex.so`
macOS	`libtensorflowlite_flex.dylib`
Windows	`tensorflowlite_flex.dll`

Ten en cuenta que el TfLiteDelegate necesario se instalará automáticamente cuando se cree el intérprete en el tiempo de ejecución, siempre que la biblioteca compartida esté vinculada. No es necesario instalar de manera explícita la instancia de delegado, como suele ser necesario con otros tipos de delegado.

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

Python

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

Métricas

Rendimiento

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

En la siguiente tabla, se describe el tiempo promedio que se tarda en ejecutar inferencias en MobileNet en un Pixel 2. Los tiempos enumerados son un promedio de 100 ejecuciones. Estos destinos se compilaron para Android con las marcas --config=android_arm64 -c opt.

Desarrollo	Tiempo (milisegundos)
Solo operaciones integradas (`TFLITE_BUILTIN`)	260,7
Usa solo operaciones de TF (`SELECT_TF_OPS`)	264,5

Tamaño de los objetos binarios

En la siguiente tabla, se describe el tamaño de los objetos binarios de TensorFlow Lite para cada compilación. Estos destinos se compilaron para Android con --config=android_arm -c opt.

Desarrollo	Tamaño de los objetos binarios de C++	Tamaño del APK de Android
Solo operaciones integradas	796 KB	561 KB
Operaciones integradas + ops de TF	23.0 MB	8.0 MB
Operaciones integradas + Operaciones de TF (1)	4.1 MB	1.8 MB

(1) Estas bibliotecas se compilan de forma selectiva para el modelo i3d-kinetics-400 con 8 operaciones integradas de TFLite y 3 ops de TensorFlow. Para obtener más información, consulta la sección Reduce el tamaño del objeto binario de TensorFlow Lite.

Limitaciones conocidas

Tipos no admitidos: Es posible que algunas operaciones de TensorFlow no admitan el conjunto completo de tipos de entrada y salida que suelen estar disponibles en TensorFlow.

Actualizaciones

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