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

Guía de API de Python Converter

Esta página proporciona ejemplos sobre cómo usar el convertidor TensorFlow Lite usando la API de Python.

API de Python

La API de Python para convertir modelos TensorFlow a TensorFlow Lite es tf.lite.TFLiteConverter . TFLiteConverter proporciona los siguientes métodos de clase para convertir un modelo basado en el formato del modelo original:

Este documento contiene ejemplos de uso de la API e instrucciones sobre cómo ejecutar las diferentes versiones de TensorFlow.

Ejemplos

Convertir un modelo guardado

El siguiente ejemplo muestra cómo convertir un modelo guardado en un FlatBuffer TensorFlow Lite.

 import tensorflow as tf

# Construct a basic model.
root = tf.train.Checkpoint()
root.v1 = tf.Variable(3.)
root.v2 = tf.Variable(2.)
root.f = tf.function(lambda x: root.v1 * root.v2 * x)

# Save the model in SavedModel format.
export_dir = "/tmp/test_saved_model"
input_data = tf.constant(1., shape=[1, 1])
to_save = root.f.get_concrete_function(input_data)
tf.saved_model.save(root, export_dir, to_save)

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

# Save the TF Lite model.
with tf.io.gfile.GFile('model.tflite', 'wb') as f:
  f.write(tflite_model)
 

Esta API no tiene la opción de especificar la forma de entrada de ninguna matriz de entrada. Si su modelo requiere especificar la forma de entrada, utilice el from_concrete_functions clase from_concrete_functions su lugar. El código es similar al siguiente:

 model = tf.saved_model.load(export_dir)
concrete_func = model.signatures[
  tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
concrete_func.inputs[0].set_shape([1, 256, 256, 3])
converter = TFLiteConverter.from_concrete_functions([concrete_func])
 

Convertir un modelo de Keras

El siguiente ejemplo muestra cómo convertir un modelo tf.keras en un TensorFlow Lite FlatBuffer .

 import tensorflow as tf

# Create a simple Keras model.
x = [-1, 0, 1, 2, 3, 4]
y = [-3, -1, 1, 3, 5, 7]

model = tf.keras.models.Sequential(
    [tf.keras.layers.Dense(units=1, input_shape=[1])])
model.compile(optimizer='sgd', loss='mean_squared_error')
model.fit(x, y, epochs=50)

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

# Save the TF Lite model.
with tf.io.gfile.GFile('model.tflite', 'wb') as f:
  f.write(tflite_model)
 

Si su modelo requiere especificar la forma de entrada, use tf.keras.layers.Input o tf.keras.layers.InputLayer para crear un modelo Keras con una forma de entrada fija como se ve a continuación o use el from_concrete_functions clase from_concrete_functions como se muestra en la sección anterior para establece la forma de las matrices de entrada antes de la conversión.

 input = tf.keras.layers.Input(shape=(1), batch_size=1)
dense_layer = tf.keras.layers.Dense(units=1, input_shape=[1])
model = tf.keras.Model(input, dense_layer(input))
 
 model = tf.keras.models.Sequential(
    [tf.keras.layers.InputLayer(input_shape=(1), batch_size=1),
     tf.keras.layers.Dense(units=1, input_shape=[1])])
 

Convertir una función concreta

El siguiente ejemplo muestra cómo convertir una función concreta TensorFlow en un TensorFlow Lite FlatBuffer .

 import tensorflow as tf

# Construct a basic model.
root = tf.train.Checkpoint()
root.v1 = tf.Variable(3.)
root.v2 = tf.Variable(2.)
root.f = tf.function(lambda x: root.v1 * root.v2 * x)

# Create the concrete function.
input_data = tf.constant(1., shape=[1, 1])
concrete_func = root.f.get_concrete_function(input_data)

# Convert the model.
#
# `from_concrete_function` takes in a list of concrete functions, however,
# currently only supports converting one function at a time. Converting multiple
# functions is under development.
converter = tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
tflite_model = converter.convert()

# Save the TF Lite model.
with tf.io.gfile.GFile('model.tflite', 'wb') as f:
  f.write(tflite_model)
 

Conversión de extremo a extremo de MobileNet

El siguiente ejemplo muestra cómo convertir y ejecutar inferencia en un modelo tf.keras previamente entrenado a TensorFlow Lite. Compara los resultados del modelo TensorFlow y TensorFlow Lite en datos aleatorios. Para cargar el modelo desde el archivo, use model_path lugar de model_content .

 import numpy as np
import tensorflow as tf

# Load the MobileNet tf.keras model.
model = tf.keras.applications.MobileNetV2(
    weights="imagenet", input_shape=(224, 224, 3))

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

# Load TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()

# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Test the TensorFlow Lite model on random input data.
input_shape = input_details[0]['shape']
input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)

interpreter.invoke()

# The function `get_tensor()` returns a copy of the tensor data.
# Use `tensor()` in order to get a pointer to the tensor.
tflite_results = interpreter.get_tensor(output_details[0]['index'])

# Test the TensorFlow model on random input data.
tf_results = model(tf.constant(input_data))

# Compare the result.
for tf_result, tflite_result in zip(tf_results, tflite_results):
  np.testing.assert_almost_equal(tf_result, tflite_result, decimal=5)
 

Metadatos de TensorFlow Lite

Los metadatos de TensorFlow Lite proporcionan un estándar para las descripciones de modelos. Los metadatos son una fuente importante de conocimiento sobre lo que hace el modelo y su información de entrada / salida. Esto facilita que otros desarrolladores comprendan las mejores prácticas y que los generadores de código creen un código contenedor específico de la plataforma. Para obtener más información, consulte la sección Metadatos de TensorFlow Lite .

Instalación de TensorFlow

Instalar el TensorFlow todas las noches

El TensorFlow nocturno se puede instalar con el siguiente comando:

 pip install tf-nightly
 

Construir desde el código fuente

Para ejecutar la última versión de la API de Python del convertidor TensorFlow Lite, instale la compilación nocturna con pip (recomendado) o Docker , o cree el paquete pip desde la fuente .

Operaciones personalizadas en el nuevo convertidor experimental

Hay un cambio de comportamiento en la forma en que los modelos que contienen operaciones personalizadas (aquellos para los que los usuarios configuraron anteriormente allow_custom_ops antes) se manejan en el nuevo convertidor .

Opción incorporada de TensorFlow

Si está convirtiendo un modelo con una operación de TensorFlow incorporada que no existe en TensorFlow Lite, debe establecer el atributo allow_custom_ops (igual que antes), explicado aquí .

Operaciones personalizadas en TensorFlow

Si está convirtiendo un modelo con una operación personalizada de TensorFlow, se recomienda que escriba un núcleo TensorFlow y un núcleo TensorFlow Lite . Esto garantiza que el modelo funcione de principio a fin, desde TensorFlow y TensorFlow Lite. Esto también requiere establecer el atributo allow_custom_ops .

Uso avanzado de operaciones personalizadas (no recomendado)

Si lo anterior no es posible, aún puede convertir un modelo TensorFlow que contiene una operación personalizada sin un kernel correspondiente. Deberá pasar el OpDef de la operación personalizada en TensorFlow utilizando el indicador --custom_opdefs , siempre que tenga la OpDef correspondiente registrada en el registro de operaciones globales de TensorFlow. Esto garantiza que el modelo TensorFlow sea válido (es decir, que el tiempo de ejecución TensorFlow pueda cargarlo).

Si la operación personalizada no es parte del registro global de operaciones TensorFlow, entonces la OpDef correspondiente debe especificarse mediante el indicador --custom_opdefs . Esta es una lista de un protocolo OpDef en cadena que debe registrarse adicionalmente. A continuación se muestra un ejemplo de un TFLiteAwesomeCustomOp con 2 entradas, 1 salida y 2 atributos:

 converter.custom_opdefs="""name: 'TFLiteAwesomeCustomOp' input_arg: { name: 'InputA'
type: DT_FLOAT } input_arg: { name: ‘InputB' type: DT_FLOAT }
output_arg: { name: 'Output' type: DT_FLOAT } attr : { name: 'Attr1' type:
'float'} attr : { name: 'Attr2' type: 'list(float)'}"""