प्रशिक्षण के बाद पूर्णांक परिमाणीकरण int16 सक्रियण के साथ

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

अवलोकन

TensorFlow लाइट अब सक्रियण TensorFlow लाइट के फ्लैट बफर प्रारूप करने के लिए TensorFlow से मॉडल रूपांतरण के दौरान मान पूर्णांक 8 बिट करने के लिए 16-बिट पूर्णांक मूल्यों और वजन में परिवर्तित करने का समर्थन करता है। हम इस मोड को "16x8 क्वांटिज़ेशन मोड" के रूप में संदर्भित करते हैं। यह मोड मात्रात्मक मॉडल की सटीकता में काफी सुधार कर सकता है, जब सक्रियण परिमाणीकरण के प्रति संवेदनशील होते हैं, जबकि अभी भी मॉडल आकार में लगभग 3-4x की कमी प्राप्त कर रहे हैं। इसके अलावा, यह पूरी तरह से परिमाणित मॉडल पूर्णांक-केवल हार्डवेयर त्वरक द्वारा उपभोग किया जा सकता है।

प्रशिक्षण के बाद के परिमाणीकरण के इस तरीके से लाभान्वित होने वाले मॉडलों के कुछ उदाहरणों में शामिल हैं:

  • सुपर-रिज़ॉल्यूशन,
  • ऑडियो सिग्नल प्रोसेसिंग जैसे शोर रद्द करना और बीम बनाना,
  • इमेज डी-शोरिंग,
  • एकल छवि से एचडीआर पुनर्निर्माण

इस ट्यूटोरियल में, आप एक MNIST मॉडल को स्क्रैच से प्रशिक्षित करते हैं, TensorFlow में इसकी सटीकता की जांच करते हैं, और फिर इस मोड का उपयोग करके मॉडल को Tensorflow Lite फ्लैटबफ़र में परिवर्तित करते हैं। अंत में आप परिवर्तित मॉडल की सटीकता की जांच करते हैं और इसकी तुलना मूल फ्लोट 32 मॉडल से करते हैं। ध्यान दें कि यह उदाहरण इस मोड के उपयोग को दर्शाता है और TensorFlow Lite में अन्य उपलब्ध परिमाणीकरण तकनीकों पर लाभ नहीं दिखाता है।

एक एमएनआईएसटी मॉडल बनाएं

सेट अप

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

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

जांचें कि 16x8 परिमाणीकरण मोड उपलब्ध है

tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8
<OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8: 'EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8'>

मॉडल को प्रशिक्षित और निर्यात करें

# 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)
)
2021-09-12 11:14:10.127487: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_SYSTEM_DRIVER_MISMATCH: system has unsupported display driver / cuda driver combination
2021-09-12 11:14:10.127636: E tensorflow/stream_executor/cuda/cuda_diagnostics.cc:313] kernel version 470.57.2 does not match DSO version 470.63.1 -- cannot find working devices in this configuration
1875/1875 [==============================] - 10s 5ms/step - loss: 0.2675 - accuracy: 0.9250 - val_loss: 0.1118 - val_accuracy: 0.9679
<keras.callbacks.History at 0x7f67d972ddd0>

उदाहरण के लिए, आपने मॉडल को केवल एक युग के लिए प्रशिक्षित किया है, इसलिए यह केवल ~96% सटीकता के लिए प्रशिक्षित करता है।

एक TensorFlow लाइट मॉडल में कनवर्ट करें

अजगर का उपयोग करना TFLiteConverter , अब आप एक TensorFlow लाइट मॉडल में प्रशिक्षित मॉडल बदल सकते हैं।

अब, मॉडल का उपयोग कर परिवर्तित TFliteConverter डिफ़ॉल्ट float32 प्रारूप में:

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
2021-09-12 11:14:21.178121: 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/tmpvxhwo_ax/assets
2021-09-12 11:14:21.627612: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-09-12 11:14:21.627654: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.

एक करने के लिए इसे बाहर लिखें .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

बजाय 16x8 परिमाणीकरण मोड के लिए मॉडल quantize के लिए, पहले सेट optimizations करने के लिए उपयोग डिफ़ॉल्ट अनुकूलन झंडा। फिर निर्दिष्ट करें कि लक्ष्य विनिर्देश में 16x8 परिमाणीकरण मोड आवश्यक समर्थित संचालन है:

converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8]

Int8 बाद प्रशिक्षण परिमाणीकरण के मामले में के रूप में, यह कनवर्टर विकल्पों की स्थापना करके एक पूरी तरह से पूर्णांक मात्रा निर्धारित मॉडल का उत्पादन संभव है inference_input(output)_type tf.int16 करने के लिए।

अंशांकन डेटा सेट करें:

mnist_train, _ = tf.keras.datasets.mnist.load_data()
images = tf.cast(mnist_train[0], tf.float32) / 255.0
mnist_ds = tf.data.Dataset.from_tensor_slices((images)).batch(1)
def representative_data_gen():
  for input_value in mnist_ds.take(100):
    # Model has only one input so each data point has one element.
    yield [input_value]
converter.representative_dataset = representative_data_gen

अंत में, मॉडल को हमेशा की तरह रूपांतरित करें। ध्यान दें, डिफ़ॉल्ट रूप से परिवर्तित मॉडल अभी भी आमंत्रण सुविधा के लिए फ्लोट इनपुट और आउटपुट का उपयोग करेगा।

tflite_16x8_model = converter.convert()
tflite_model_16x8_file = tflite_models_dir/"mnist_model_quant_16x8.tflite"
tflite_model_16x8_file.write_bytes(tflite_16x8_model)
INFO:tensorflow:Assets written to: /tmp/tmp02ui82cp/assets
INFO:tensorflow:Assets written to: /tmp/tmp02ui82cp/assets
2021-09-12 11:14:22.649577: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-09-12 11:14:22.649619: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
24768

ध्यान दें कि कैसे परिणामी फ़ाइल लगभग है 1/3 आकार।

ls -lh {tflite_models_dir}
total 180K
-rw-rw-r-- 1 kbuilder kbuilder 83K Sep 12 11:14 mnist_model.tflite
-rw-rw-r-- 1 kbuilder kbuilder 24K Sep 12 11:13 mnist_model_quant.tflite
-rw-rw-r-- 1 kbuilder kbuilder 25K Sep 12 11:14 mnist_model_quant_16x8.tflite
-rw-rw-r-- 1 kbuilder kbuilder 44K Sep 12 11:11 mnist_model_quant_f16.tflite

TensorFlow Lite मॉडल चलाएँ

Python TensorFlow Lite Interpreter का उपयोग करके TensorFlow Lite मॉडल चलाएँ।

मॉडल को दुभाषियों में लोड करें

interpreter = tf.lite.Interpreter(model_path=str(tflite_model_file))
interpreter.allocate_tensors()
interpreter_16x8 = tf.lite.Interpreter(model_path=str(tflite_model_16x8_file))
interpreter_16x8.allocate_tensors()

एक छवि पर मॉडल का परीक्षण करें

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)

पीएनजी

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

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

interpreter_16x8.set_tensor(input_index, test_image)
interpreter_16x8.invoke()
predictions = interpreter_16x8.get_tensor(output_index)
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)

पीएनजी

मॉडलों का मूल्यांकन करें

# 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.9679

16x8 परिमाणित मॉडल पर मूल्यांकन दोहराएं:

# NOTE: This quantization mode is an experimental post-training mode,
# it does not have any optimized kernels implementations or
# specialized machine learning hardware accelerators. Therefore,
# it could be slower than the float interpreter.
print(evaluate_model(interpreter_16x8))
0.9679

इस उदाहरण में, आपने एक मॉडल को 16x8 पर परिमाणित किया है, जिसमें सटीकता में कोई अंतर नहीं है, लेकिन 3x कम आकार के साथ है।