Partecipa al simposio Women in ML il 7 dicembre Registrati ora

Quantizzazione della gamma dinamica post-allenamento

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Visualizza su TensorFlow.org Esegui in Google Colab Visualizza la fonte su GitHub Scarica taccuino Vedi il modello del mozzo TF

Panoramica

Tensorflow Lite ora supporta la conversione di pesi a 8 bit di precisione come parte della conversione modello dalla graphdefs tensorflow nel formato di buffer piatto tensorflow Lite. La quantizzazione della gamma dinamica consente di ottenere una riduzione di 4 volte delle dimensioni del modello. Inoltre, TFLite supporta la quantizzazione e la dequantizzazione al volo delle attivazioni per consentire:

  1. Utilizzo di kernel quantizzati per un'implementazione più rapida quando disponibile.
  2. Miscelazione di kernel a virgola mobile con kernel quantizzati per diverse parti del grafico.

Le attivazioni sono sempre memorizzate in virgola mobile. Per le operazioni che supportano i kernel quantizzati, le attivazioni vengono quantizzate a 8 bit di precisione in modo dinamico prima dell'elaborazione e vengono dequantizzate per ottenere una precisione variabile dopo l'elaborazione. A seconda del modello da convertire, questo può dare un'accelerazione rispetto al calcolo in virgola mobile pura.

A differenza di quantizzazione di formazione a conoscenza , i pesi sono quantizzati formazione post e le attivazioni sono quantizzati in modo dinamico in deduzione in questo metodo. Pertanto, i pesi del modello non vengono riqualificati per compensare gli errori indotti dalla quantizzazione. È importante verificare l'accuratezza del modello quantizzato per garantire che il degrado sia accettabile.

Questo tutorial addestra da zero un modello MNIST, ne verifica l'accuratezza in TensorFlow e quindi converte il modello in un flatbuffer Tensorflow Lite con quantizzazione dell'intervallo dinamico. Infine, verifica l'accuratezza del modello convertito e lo confronta con il modello float originale.

Costruisci un modello MNIST

Impostare

import logging
logging.getLogger("tensorflow").setLevel(logging.DEBUG)

import tensorflow as tf
from tensorflow import keras
import numpy as np
import pathlib

Addestra un modello TensorFlow

# Load MNIST dataset
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# Normalize the input image so that each pixel value is between 0 to 1.
train_images = train_images / 255.0
test_images = test_images / 255.0

# Define the model architecture
model = keras.Sequential([
  keras.layers.InputLayer(input_shape=(28, 28)),
  keras.layers.Reshape(target_shape=(28, 28, 1)),
  keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation=tf.nn.relu),
  keras.layers.MaxPooling2D(pool_size=(2, 2)),
  keras.layers.Flatten(),
  keras.layers.Dense(10)
])

# Train the digit classification model
model.compile(optimizer='adam',
              loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])
model.fit(
  train_images,
  train_labels,
  epochs=1,
  validation_data=(test_images, test_labels)
)
1875/1875 [==============================] - 6s 2ms/step - loss: 0.3260 - accuracy: 0.9063 - val_loss: 0.1721 - val_accuracy: 0.9499
<keras.callbacks.History at 0x7fb7a1c4ed90>

Ad esempio, poiché hai addestrato il modello solo per una singola epoca, si allena solo con una precisione del 96% circa.

Converti in un modello TensorFlow Lite

Utilizzando il Python TFLiteConverter , è ora possibile convertire il modello di formazione in un modello tensorflow Lite.

Ora caricare il modello utilizzando il TFLiteConverter :

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
2021-11-02 11:23:32.211024: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/tmpua453ven/assets
2021-11-02 11:23:32.640259: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-11-02 11:23:32.640302: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.

Scrivilo in un file tflite:

tflite_models_dir = pathlib.Path("/tmp/mnist_tflite_models/")
tflite_models_dir.mkdir(exist_ok=True, parents=True)
tflite_model_file = tflite_models_dir/"mnist_model.tflite"
tflite_model_file.write_bytes(tflite_model)
84500

Per quantizzare il modello in materia di esportazione, impostare optimizations bandiera per ottimizzare per il formato:

converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()
tflite_model_quant_file = tflite_models_dir/"mnist_model_quant.tflite"
tflite_model_quant_file.write_bytes(tflite_quant_model)
INFO:tensorflow:Assets written to: /tmp/tmpaw0wsb_y/assets
INFO:tensorflow:Assets written to: /tmp/tmpaw0wsb_y/assets
2021-11-02 11:23:33.235475: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-11-02 11:23:33.235512: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
23904

Si noti come il file risultante, è pari a circa 1/4 della dimensione.

ls -lh {tflite_models_dir}
total 136K
-rw-rw-r-- 1 kbuilder kbuilder 83K Nov  2 11:23 mnist_model.tflite
-rw-rw-r-- 1 kbuilder kbuilder 24K Nov  2 11:23 mnist_model_quant.tflite
-rw-rw-r-- 1 kbuilder kbuilder 25K Nov  2 11:20 mnist_model_quant_16x8.tflite

Esegui i modelli TFLite

Eseguire il modello TensorFlow Lite utilizzando l'interprete Python TensorFlow Lite.

Carica il modello in un interprete

interpreter = tf.lite.Interpreter(model_path=str(tflite_model_file))
interpreter.allocate_tensors()
interpreter_quant = tf.lite.Interpreter(model_path=str(tflite_model_quant_file))
interpreter_quant.allocate_tensors()

Testare il modello su un'immagine

test_image = np.expand_dims(test_images[0], axis=0).astype(np.float32)

input_index = interpreter.get_input_details()[0]["index"]
output_index = interpreter.get_output_details()[0]["index"]

interpreter.set_tensor(input_index, test_image)
interpreter.invoke()
predictions = interpreter.get_tensor(output_index)
import matplotlib.pylab as plt

plt.imshow(test_images[0])
template = "True:{true}, predicted:{predict}"
_ = plt.title(template.format(true= str(test_labels[0]),
                              predict=str(np.argmax(predictions[0]))))
plt.grid(False)

png

Valuta i modelli

# A helper function to evaluate the TF Lite model using "test" dataset.
def evaluate_model(interpreter):
  input_index = interpreter.get_input_details()[0]["index"]
  output_index = interpreter.get_output_details()[0]["index"]

  # Run predictions on every image in the "test" dataset.
  prediction_digits = []
  for test_image in test_images:
    # Pre-processing: add batch dimension and convert to float32 to match with
    # the model's input data format.
    test_image = np.expand_dims(test_image, axis=0).astype(np.float32)
    interpreter.set_tensor(input_index, test_image)

    # Run inference.
    interpreter.invoke()

    # Post-processing: remove batch dimension and find the digit with highest
    # probability.
    output = interpreter.tensor(output_index)
    digit = np.argmax(output()[0])
    prediction_digits.append(digit)

  # Compare prediction results with ground truth labels to calculate accuracy.
  accurate_count = 0
  for index in range(len(prediction_digits)):
    if prediction_digits[index] == test_labels[index]:
      accurate_count += 1
  accuracy = accurate_count * 1.0 / len(prediction_digits)

  return accuracy
print(evaluate_model(interpreter))
0.9499

Ripetere la valutazione sul modello quantizzato in gamma dinamica per ottenere:

print(evaluate_model(interpreter_quant))
0.95

In questo esempio, il modello compresso non presenta differenze nell'accuratezza.

Ottimizzazione di un modello esistente

I Resnet con livelli di preattivazione (Resnet-v2) sono ampiamente utilizzati per le applicazioni di visione. Pre-addestrati grafico congelato per RESNET-v2-101 è accessibile tensorflow Hub .

È possibile convertire il grafico congelato in un flatbuffer TensorFLow Lite con quantizzazione tramite:

import tensorflow_hub as hub

resnet_v2_101 = tf.keras.Sequential([
  keras.layers.InputLayer(input_shape=(224, 224, 3)),
  hub.KerasLayer("https://tfhub.dev/google/imagenet/resnet_v2_101/classification/4")
])

converter = tf.lite.TFLiteConverter.from_keras_model(resnet_v2_101)
# Convert to TF Lite without quantization
resnet_tflite_file = tflite_models_dir/"resnet_v2_101.tflite"
resnet_tflite_file.write_bytes(converter.convert())
WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.
WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.
INFO:tensorflow:Assets written to: /tmp/tmpxtji1amp/assets
INFO:tensorflow:Assets written to: /tmp/tmpxtji1amp/assets
2021-11-02 11:23:57.616139: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-11-02 11:23:57.616201: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
178509352
# Convert to TF Lite with quantization
converter.optimizations = [tf.lite.Optimize.DEFAULT]
resnet_quantized_tflite_file = tflite_models_dir/"resnet_v2_101_quantized.tflite"
resnet_quantized_tflite_file.write_bytes(converter.convert())
WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.
WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.
INFO:tensorflow:Assets written to: /tmp/tmpg169iato/assets
INFO:tensorflow:Assets written to: /tmp/tmpg169iato/assets
2021-11-02 11:24:12.965799: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-11-02 11:24:12.965851: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
46256864
ls -lh {tflite_models_dir}/*.tflite
-rw-rw-r-- 1 kbuilder kbuilder  83K Nov  2 11:23 /tmp/mnist_tflite_models/mnist_model.tflite
-rw-rw-r-- 1 kbuilder kbuilder  24K Nov  2 11:23 /tmp/mnist_tflite_models/mnist_model_quant.tflite
-rw-rw-r-- 1 kbuilder kbuilder  25K Nov  2 11:20 /tmp/mnist_tflite_models/mnist_model_quant_16x8.tflite
-rw-rw-r-- 1 kbuilder kbuilder 171M Nov  2 11:23 /tmp/mnist_tflite_models/resnet_v2_101.tflite
-rw-rw-r-- 1 kbuilder kbuilder  45M Nov  2 11:24 /tmp/mnist_tflite_models/resnet_v2_101_quantized.tflite

La dimensione del modello si riduce da 171 MB a 43 MB. La precisione di questo modello sul IMAGEnet può essere valutata utilizzando gli script forniti per la misurazione accuratezza TFLite .

L'accuratezza top-1 del modello ottimizzato è 76,8, la stessa del modello in virgola mobile.