Conversor do TensorFlow Lite

O conversor do TensorFlow Lite usa um modelo do TensorFlow e gera um modelo do TensorFlow Lite (um formato FlatBuffer otimizado identificado pela extensão de arquivo .tflite). Você tem duas opções para usar o conversor:

API Python (recomendado): facilita a conversão de modelos como parte do pipeline de desenvolvimento de modelos, aplicação de otimizações e adição de metadados, além de muitos outros recursos.
Linha de comando: só é compatível com a conversão de modelo básica.

Fluxo de trabalho do conversor do TFLite

API Python

Código auxiliar: para identificar a versão instalada do TensorFlow, execute print(tf.__version__) e, para saber mais sobre a API do conversor do TensorFlow Lite, execute print(help(tf.lite.TFLiteConverter)).

Se tiver instalado o TensorFlow 2.x, você terá estas duas opções (caso tenha instalado o TensorFlow 1.x., consulte o GitHub):

Converta um modelo do TensorFlow 2.x usando tf.lite.TFLiteConverter. Um modelo do TensorFlow 2.x é armazenado usando o formato SavedModel e é gerado usando as APIs tf.keras.* de alto nível (um modelo Keras) ou as APIs de baixo nível tf.* (de onde você gera funções concretas). Como resultado, você tem estas três opções (há exemplos nas próximas seções):
- tf.lite.TFLiteConverter.from_saved_model() (recomendado): converte um SavedModel.
- tf.lite.TFLiteConverter.from_keras_model(): converte um modelo Keras.
- tf.lite.TFLiteConverter.from_concrete_functions(): converte funções concretas.
Converta um modelo do TensorFlow 1.x usando tf.compat.v1.lite.TFLiteConverter (exemplos estão disponíveis no GitHub):
- tf.compat.v1.lite.TFLiteConverter.from_saved_model(): converte um SavedModel.
- tf.compat.v1.lite.TFLiteConverter.from_keras_model_file(): converte um modelo Keras.
- tf.compat.v1.lite.TFLiteConverter.from_session(): converte um GraphDef de uma sessão.
- tf.compat.v1.lite.TFLiteConverter.from_frozen_graph(): converte um GraphDef congelado de um arquivo. Se você tiver pontos de verificação, primeiro converta-os em um arquivo GraphDef congelado e depois use a API conforme mostrado aqui.

Converter um SavedModel (recomendado)

O exemplo a seguir mostra como converter um SavedModel em um modelo do 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)

Converter um modelo Keras

O exemplo a seguir mostra como converter um modelo Keras em um modelo do 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)

Converter funções concretas

O exemplo a seguir mostra como converter funções concretas em um modelo do 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)

Outros recursos

Aplique otimizações. Uma otimização comum usada é a quantização pós-treinamento, que pode reduzir ainda mais a latência e o tamanho do modelo com perda mínima de acurácia.
Adicione metadados para facilitar a criação de um código do wrapper específico da plataforma durante a implantação de modelos em dispositivos.

Erros de conversão

Veja erros de conversão comuns e as soluções para eles:

Erro: 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: ..., .., ...

Solução: o erro ocorre porque o modelo tem operações do TF que não possuem uma implementação do TFLite correspondente. Resolva isso usando a operação do TF no modelo do TFLite (recomendado). Se você quiser gerar um modelo somente com operações do TFLite, adicione uma solicitação para a operação do TFLite em falta no problema nº 21526 no GitHub (deixe um comentário caso sua solicitação ainda não tenha sido mencionada) ou crie uma operação do TFLite por conta própria.
Erro: .. is neither a custom op nor a flex op

Solução: depende da compatibilidade da operação do TF:
- Compatível com o TF: o erro ocorre porque a operação do TF não está na lista de permissões (uma lista completa de operações do TF compatíveis com o TFLite). Resolva isso da seguinte forma:
  1. Adicione as operações faltando à lista de permissões.
  2. Faça a conversão do modelo do TF para um modelo do TFLite e execute a inferência.
- Incompatível com o TF: o erro ocorre porque o TFLite não sabe sobre o operador personalizado do TF definido por você. Resolva isso da seguinte forma:
  1. Crie a operação do TF.
  2. Faça a conversão do modelo do TF para um modelo do TFLite.
  3. Crie a operação do TFLite e execute a inferência vinculando-a ao ambiente de execução do TFLite.

Ferramenta de linha de comando

É altamente recomendável usar a API Python acima, se possível.

Se você tiver instalado o TensorFlow 2.x do pip, use o comando tflite_convert da seguinte forma (se você tiver instalado o TensorFlow 2.x da origem será possível substituir "tflite_convert" por "bazel run //tensorflow/lite/python:tflite_convert --" nas seções a seguir e, se você tiver instalado o TensorFlow 1.x, consulte o GitHub (referência, exemplos))

tflite_convert: para visualizar todas as sinalizações disponíveis, use o seguinte 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.

Converter um SavedModel

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

Converter um modelo Keras H5

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

Próximas etapas

Use o interpretador do TensorFlow Lite para executar a inferência em um dispositivo cliente (por exemplo, dispositivo móvel, incorporado).