Conversor de TensorFlow Lite

El conversor de TensorFlow Lite toma un modelo de TensorFlow y genera un modelo de TensorFlow Lite (un formato FlatBuffer optimizado que se puede identificar mediante la extensión de archivo .tflite). Para usar el conversor, tienes dos opciones:

API de Python (recomendada): Facilita las tareas de convertir modelos como parte de la canalización del desarrollo de modelos, aplicar optimizaciones, agregar metadatos y muchas otras funciones.
Línea de comandos: Solo admite la conversión básica de modelos.

Flujo de trabajo del conversor de TFLite

API de Python

Código de ayuda: Para identificar la versión instalada de TensorFlow, ejecuta print(tf.__version__). Si deseas obtener más información sobre la API del conversor de TensorFlow Lite, ejecuta print(help(tf.lite.TFLiteConverter)).

Si instalaste TensorFlow 2.x, tienes las dos siguientes opciones (Si instalaste TensorFlow 1.x, consulta GitHub):

Convierte un modelo de TensorFlow 2.x con tf.lite.TFLiteConverter. Un modelo de TensorFlow 2.x se almacena con el formato de modelo guardado y se genera mediante las API de alto nivel tf.keras.* (un modelo Keras) o las API de bajo nivel tf.* (desde las que generas funciones concretas). Como resultado, tienes las siguientes tres opciones (los ejemplos se encuentran en las secciones de más abajo):
- tf.lite.TFLiteConverter.from_saved_model() (recomendado): Convierte un modelo guardado.
- tf.lite.TFLiteConverter.from_keras_model(): Convierte un modelo de Keras.
- tf.lite.TFLiteConverter.from_concrete_functions(): Convierte funciones concretas.
Convierte un modelo de TensorFlow 1.x mediante tf.compat.v1.lite.TFLiteConverter (consulta los ejemplos en GitHub):
- tf.compat.v1.lite.TFLiteConverter.from_saved_model(): Convierte un modelo guardado.
- tf.compat.v1.lite.TFLiteConverter.from_keras_model_file(): Convierte un modelo de Keras.
- tf.compat.v1.lite.TFLiteConverter.from_session(): Convierte un GraphDef desde una sesión.
- tf.compat.v1.lite.TFLiteConverter.from_frozen_graph(): Convierte un GraphDef congelado desde un archivo. Si tienes puntos de control, convierte primero el archivo en un GraphDef congelado y usa esta API como se muestra aquí.

Convierte un modelo guardado (recomendado)

En el siguiente ejemplo, se muestra cómo convertir un modelo guardado en un modelo de TensorFlow Lite.

import tensorflow as tf

# Convert the model
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir) # path to the SavedModel directory
tflite_model = converter.convert()

# Save the model.
with open('model.tflite', 'wb') as f:
  f.write(tflite_model)

Convierte un modelo de Keras

En el siguiente ejemplo, se muestra cómo convertir un modelo de Keras en un modelo de TensorFlow Lite.

import tensorflow as tf

# Create a model using high-level tf.keras.* APIs
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(units=1, input_shape=[1]),
    tf.keras.layers.Dense(units=16, activation='relu'),
    tf.keras.layers.Dense(units=1)
])
model.compile(optimizer='sgd', loss='mean_squared_error') # compile the model
model.fit(x=[-1, 0, 1], y=[-3, -1, 1], epochs=5) # train the model
# (to generate a SavedModel) tf.saved_model.save(model, "saved_model_keras_dir")

# Convert the model.
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

# Save the model.
with open('model.tflite', 'wb') as f:
  f.write(tflite_model)

Convierte funciones concretas

En el siguiente ejemplo, se muestra cómo convertir funciones concretas en un modelo de TensorFlow Lite.

import tensorflow as tf

# Create a model using low-level tf.* APIs
class Squared(tf.Module):
  @tf.function(input_signature=[tf.TensorSpec(shape=[None], dtype=tf.float32)])
  def __call__(self, x):
    return tf.square(x)
model = Squared()
# (ro run your model) result = Squared(5.0) # This prints "25.0"
# (to generate a SavedModel) tf.saved_model.save(model, "saved_model_tf_dir")
concrete_func = model.__call__.get_concrete_function()

# Convert the model.
# Notes that for the versions earlier than TensorFlow 2.7, the
# from_concrete_functions API is able to work when there is only the first
# argument given:
# > converter = tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
converter = tf.lite.TFLiteConverter.from_concrete_functions([concrete_func],
                                                            model)
tflite_model = converter.convert()

# Save the model.
with open('model.tflite', 'wb') as f:
  f.write(tflite_model)

Otras funciones

Aplica optimizaciones. La cuantización posterior al entrenamiento es una optimización que se usa con frecuencia y que puede reducir aún más la latencia y el tamaño del modelo con una pérdida mínima de exactitud.
Agrega metadatos, ya que facilitan la creación de código del wrapper específico de la plataforma cuando se implementan modelos en dispositivos.

Errores de conversión

Los siguientes son errores de conversión comunes y las formas de solucionarlos:

Error: Some ops are not supported by the native TFLite runtime, you can enable TF kernels fallback using TF Select. See instructions: <a href="https://www.tensorflow.org/lite/guide/ops_select">https://www.tensorflow.org/lite/guide/ops_select</a> TF Select ops: ..., .., ...

Solución: El error ocurre porque tu modelo tiene operaciones de TF que no cuentan con la implementación de TFLite correspondiente. Puedes resolverlo mediante la operación de TF en el modelo de TFLite (recomendada). Si quieres generar un modelo únicamente con operaciones de TFLite, puedes agregar una solicitud para las operaciones de TFLite faltantes en el error de GitHub #21526 (deja un comentario si aún no se mencionó tu solicitud) o crear la operación de TFLite.
Error: .. is neither a custom op nor a flex op

Solución si la operación de TF:
- Se admite en TF: El error ocurre porque la operación de TF no se encuentra incluida en la lista de entidades permitidas (una lista exhaustiva de operaciones de TF admitidas en TFLite). Puedes resolverlo de la siguiente manera:
  1. Agrega operaciones faltantes en la lista de entidades permitidas.
  2. Convierte el modelo de TF en un modelo de TFLite y ejecuta la inferencia.
- No se admite en TF: El error ocurre porque TFLite no reconoce el operador de TF personalizado que definiste. Puedes resolverlo de la siguiente manera:
  1. Crea la operación de TF.
  2. Convierte el modelo de TF en un modelo de TFLite.
  3. Crea la operación de TFLite y ejecuta la inferencia mediante la vinculación con el tiempo de ejecución de TFLite.

Herramienta de línea de comandos

Se recomienda que uses la API de Python mencionada anteriormente, de ser posible.

Si instalaste TensorFlow 2.x desde pip, usa el comando tflite_convert de la siguiente manera (si instalaste TensorFlow 2.x desde el código fuente, puedes reemplazar "tflite_convert" por "bazel run //tensorflow/lite/python:tflite_convert --" en las secciones subsiguientes, y si instalaste TensorFlow 1.x, consulta GitHub: referencia, ejemplos).

tflite_convert: Para ver todas las marcas disponibles, usa el siguiente comando:

$ tflite_convert --help

`--output_file`. Type: string. Full path of the output file.
`--saved_model_dir`. Type: string. Full path to the SavedModel directory.
`--keras_model_file`. Type: string. Full path to the Keras H5 model file.
`--enable_v1_converter`. Type: bool. (default False) Enables the converter and flags used in TF 1.x instead of TF 2.x.

You are required to provide the `--output_file` flag and either the `--saved_model_dir` or `--keras_model_file` flag.

Cómo convertir un modelo guardado

tflite_convert \
  --saved_model_dir=/tmp/mobilenet_saved_model \
  --output_file=/tmp/mobilenet.tflite

Cómo convertir un modelo de Keras H5

tflite_convert \
  --keras_model_file=/tmp/mobilenet_keras_model.h5 \
  --output_file=/tmp/mobilenet.tflite

Próximos pasos

Usa el intérprete de TensorFlow Lite para ejecutar la inferencia en un dispositivo cliente (p. ej., dispositivo móvil, incorporado).