RSVP pour votre événement TensorFlow Everywhere local dès aujourd'hui!
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Exemple de formation prenant en charge la quantification dans Keras

Voir sur TensorFlow.org Exécuter dans Google Colab Afficher la source sur GitHub Télécharger le carnet

Aperçu

Bienvenue dans un exemple de bout en bout de formation prenant en compte la quantification .

Autres pages

Pour une introduction à la formation prenant en charge la quantification et pour déterminer si vous devez l'utiliser (y compris ce qui est pris en charge), consultez la page de présentation.

Pour trouver rapidement les API dont vous avez besoin pour votre cas d'utilisation (au-delà de la quantification complète d'un modèle avec 8 bits), consultez le guide complet .

Sommaire

Dans ce tutoriel, vous allez:

  1. Former un modèle tf.keras pour MNIST à partir de zéro.
  2. Affinez le modèle en appliquant l'API d'entraînement prenant en charge la quantification, voyez la précision et exportez un modèle prenant en charge la quantification.
  3. Utilisez le modèle pour créer un modèle réellement quantifié pour le backend TFLite.
  4. Voyez la persistance de la précision dans TFLite et un modèle 4x plus petit. Pour voir les avantages de la latence sur mobile, essayez les exemples TFLite dans le référentiel d'applications TFLite .

Installer

 pip uninstall -y tensorflow
 pip install -q tf-nightly
 pip install -q tensorflow-model-optimization
import tempfile
import os

import tensorflow as tf

from tensorflow import keras

Former un modèle pour MNIST sans formation consciente de la quantification

# 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='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=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(
  train_images,
  train_labels,
  epochs=1,
  validation_split=0.1,
)
1688/1688 [==============================] - 8s 4ms/step - loss: 0.5175 - accuracy: 0.8544 - val_loss: 0.1275 - val_accuracy: 0.9648

<tensorflow.python.keras.callbacks.History at 0x7f37f03b39e8>

Cloner et affiner le modèle pré-entraîné avec une formation prenant en charge la quantification

Définir le modèle

Vous allez appliquer une formation prenant en charge la quantification à l'ensemble du modèle et le voir dans le résumé du modèle. Toutes les couches sont désormais préfixées par "quant".

Notez que le modèle résultant est sensible à la quantification mais pas quantifié (par exemple, les poids sont float32 au lieu de int8). Les sections suivantes montrent comment créer un modèle quantifié à partir du modèle prenant en charge la quantification.

Dans le guide complet , vous pouvez voir comment quantifier certaines couches pour améliorer la précision du modèle.

import tensorflow_model_optimization as tfmot

quantize_model = tfmot.quantization.keras.quantize_model

# q_aware stands for for quantization aware.
q_aware_model = quantize_model(model)

# `quantize_model` requires a recompile.
q_aware_model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

q_aware_model.summary()
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
quantize_layer (QuantizeLaye (None, 28, 28)            3         
_________________________________________________________________
quant_reshape (QuantizeWrapp (None, 28, 28, 1)         1         
_________________________________________________________________
quant_conv2d (QuantizeWrappe (None, 26, 26, 12)        147       
_________________________________________________________________
quant_max_pooling2d (Quantiz (None, 13, 13, 12)        1         
_________________________________________________________________
quant_flatten (QuantizeWrapp (None, 2028)              1         
_________________________________________________________________
quant_dense (QuantizeWrapper (None, 10)                20295     
=================================================================
Total params: 20,448
Trainable params: 20,410
Non-trainable params: 38
_________________________________________________________________

Former et évaluer le modèle par rapport à la ligne de base

Pour démontrer le réglage fin après l'entraînement du modèle pour une seule époque, ajustez-le avec un entraînement sensible à la quantification sur un sous-ensemble des données d'apprentissage.

train_images_subset = train_images[0:1000] # out of 60000
train_labels_subset = train_labels[0:1000]

q_aware_model.fit(train_images_subset, train_labels_subset,
                  batch_size=500, epochs=1, validation_split=0.1)
2/2 [==============================] - 1s 167ms/step - loss: 0.1298 - accuracy: 0.9571 - val_loss: 0.1671 - val_accuracy: 0.9600

<tensorflow.python.keras.callbacks.History at 0x7f376c6db7b8>

Pour cet exemple, il y a une perte de précision de test minime ou nulle après un entraînement prenant en charge la quantification, par rapport à la ligne de base.

_, baseline_model_accuracy = model.evaluate(
    test_images, test_labels, verbose=0)

_, q_aware_model_accuracy = q_aware_model.evaluate(
   test_images, test_labels, verbose=0)

print('Baseline test accuracy:', baseline_model_accuracy)
print('Quant test accuracy:', q_aware_model_accuracy)
Baseline test accuracy: 0.9609000086784363
Quant test accuracy: 0.9628999829292297

Créer un modèle quantifié pour le backend TFLite

Après cela, vous avez un modèle réellement quantifié avec des poids int8 et des activations uint8.

converter = tf.lite.TFLiteConverter.from_keras_model(q_aware_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]

quantized_tflite_model = converter.convert()
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:109: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:109: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/tmpoct8ii0p/assets

Voir la persistance de la précision de TF à TFLite

Définissez une fonction d'assistance pour évaluer le modèle TF Lite sur l'ensemble de données de test.

import numpy as np

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 i, test_image in enumerate(test_images):
    if i % 1000 == 0:
      print('Evaluated on {n} results so far.'.format(n=i))
    # 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)

  print('\n')
  # Compare prediction results with ground truth labels to calculate accuracy.
  prediction_digits = np.array(prediction_digits)
  accuracy = (prediction_digits == test_labels).mean()
  return accuracy

Vous évaluez le modèle quantifié et constatez que la précision de TensorFlow persiste dans le backend TFLite.

interpreter = tf.lite.Interpreter(model_content=quantized_tflite_model)
interpreter.allocate_tensors()

test_accuracy = evaluate_model(interpreter)

print('Quant TFLite test_accuracy:', test_accuracy)
print('Quant TF test accuracy:', q_aware_model_accuracy)
Evaluated on 0 results so far.
Evaluated on 1000 results so far.
Evaluated on 2000 results so far.
Evaluated on 3000 results so far.
Evaluated on 4000 results so far.
Evaluated on 5000 results so far.
Evaluated on 6000 results so far.
Evaluated on 7000 results so far.
Evaluated on 8000 results so far.
Evaluated on 9000 results so far.


Quant TFLite test_accuracy: 0.963
Quant TF test accuracy: 0.9628999829292297

Voir un modèle 4x plus petit à partir de la quantification

Vous créez un modèle TFLite flottant, puis vous constatez que le modèle TFLite quantifié est 4x plus petit.

# Create float TFLite model.
float_converter = tf.lite.TFLiteConverter.from_keras_model(model)
float_tflite_model = float_converter.convert()

# Measure sizes of models.
_, float_file = tempfile.mkstemp('.tflite')
_, quant_file = tempfile.mkstemp('.tflite')

with open(quant_file, 'wb') as f:
  f.write(quantized_tflite_model)

with open(float_file, 'wb') as f:
  f.write(float_tflite_model)

print("Float model in Mb:", os.path.getsize(float_file) / float(2**20))
print("Quantized model in Mb:", os.path.getsize(quant_file) / float(2**20))
INFO:tensorflow:Assets written to: /tmp/tmpy0445k6u/assets

INFO:tensorflow:Assets written to: /tmp/tmpy0445k6u/assets

Float model in Mb: 0.08053970336914062
Quantized model in Mb: 0.02339935302734375

Conclusion

Dans ce didacticiel, vous avez vu comment créer des modèles prenant en charge la quantification avec l'API TensorFlow Model Optimization Toolkit, puis des modèles quantifiés pour le backend TFLite.

Vous avez vu un avantage de compression de taille de modèle 4x pour un modèle pour MNIST, avec une différence de précision minimale. Pour voir les avantages de la latence sur mobile, essayez les exemples TFLite dans le référentiel d'applications TFLite .

Nous vous encourageons à essayer cette nouvelle fonctionnalité, qui peut être particulièrement importante pour le déploiement dans des environnements à ressources limitées.