प्रशिक्षण के बाद गतिशील रेंज परिमाणीकरण

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

अवलोकन

TensorFlow लाइट अब TensorFlow लाइट के फ्लैट बफर प्रारूप करने के लिए tensorflow graphdefs से मॉडल रूपांतरण के भाग के रूप 8 बिट परिशुद्धता के लिए वजन परिवर्तित करने का समर्थन करता है। डायनामिक रेंज क्वांटिज़ेशन मॉडल आकार में 4x की कमी प्राप्त करता है। इसके अलावा, टीएफलाइट निम्नलिखित के लिए अनुमति देने के लिए फ्लाई क्वांटिज़ेशन और सक्रियणों के डीक्वांटिज़ेशन का समर्थन करता है:

  1. उपलब्ध होने पर तेजी से कार्यान्वयन के लिए मात्रात्मक कर्नेल का उपयोग करना।
  2. ग्राफ के विभिन्न भागों के लिए मात्रात्मक कर्नेल के साथ फ्लोटिंग-पॉइंट कर्नेल का मिश्रण।

सक्रियण हमेशा फ़्लोटिंग पॉइंट में संग्रहीत होते हैं। ऑप्स के लिए जो मात्राबद्ध कर्नेल का समर्थन करते हैं, सक्रियण को प्रसंस्करण से पहले गतिशील रूप से 8 बिट परिशुद्धता के लिए मात्राबद्ध किया जाता है और प्रसंस्करण के बाद सटीक फ्लोट करने के लिए डी-मात्राबद्ध किया जाता है। परिवर्तित किए जा रहे मॉडल के आधार पर, यह शुद्ध फ्लोटिंग पॉइंट गणना पर गति प्रदान कर सकता है।

के विपरीत परिमाणीकरण बारे में पता प्रशिक्षण , वजन मात्रा निर्धारित पद प्रशिक्षण कर रहे हैं और सक्रियण इस पद्धति में निष्कर्ष पर गतिशील quantized कर रहे हैं। इसलिए, परिमाणीकरण प्रेरित त्रुटियों के लिए क्षतिपूर्ति करने के लिए मॉडल वज़न को फिर से प्रशिक्षित नहीं किया जाता है। यह सुनिश्चित करने के लिए कि गिरावट स्वीकार्य है, परिमाणित मॉडल की सटीकता की जांच करना महत्वपूर्ण है।

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

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

सेट अप

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

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

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>

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

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

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

अब का उपयोग कर मॉडल लोड 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.

इसे एक 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

निर्यात पर मॉडल quantize करने के लिए, सेट optimizations आकार के लिए अनुकूलन करने के लिए झंडा:

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

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

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

TFlite मॉडल चलाएँ

Python TensorFlow Lite दुभाषिया का उपयोग करके TensorFlow Lite मॉडल चलाएँ।

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

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()

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

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)

पीएनजी

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

# 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

प्राप्त करने के लिए गतिशील रेंज परिमाणित मॉडल पर मूल्यांकन दोहराएं:

print(evaluate_model(interpreter_quant))
0.95

इस उदाहरण में, संपीड़ित मॉडल की सटीकता में कोई अंतर नहीं है।

मौजूदा मॉडल का अनुकूलन

पूर्व-सक्रियण परतों वाले रेसनेट (Resnet-v2) का व्यापक रूप से दृष्टि अनुप्रयोगों के लिए उपयोग किया जाता है। के लिए पूर्व प्रशिक्षित जमे हुए ग्राफ resnet-v2-101 पर उपलब्ध है Tensorflow हब

आप फ़्रीज़ किए गए ग्राफ़ को परिमाणीकरण के साथ एक TensorFlow लाइट फ़्लैटबफ़र में परिवर्तित कर सकते हैं:

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

मॉडल का आकार 171 एमबी से घटकर 43 एमबी हो गया है। Imagenet पर इस मॉडल की सटीकता के लिए प्रदान की स्क्रिप्ट का उपयोग कर मूल्यांकन किया जा सकता TFLite सटीकता माप

अनुकूलित मॉडल टॉप-1 सटीकता 76.8 है, जो फ़्लोटिंग पॉइंट मॉडल के समान है।