 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)
)
1875/1875 [==============================] - 6s 2ms/step - loss: 0.2797 - accuracy: 0.9224 - val_loss: 0.1224 - val_accuracy: 0.9641 <keras.callbacks.History at 0x7f6f19eff210>
उदाहरण के लिए, आपने मॉडल को केवल एक युग के लिए प्रशिक्षित किया है, इसलिए यह केवल ~96% सटीकता के लिए प्रशिक्षित करता है।
एक TensorFlow लाइट मॉडल में कनवर्ट करें
अजगर का उपयोग करना TFLiteConverter , अब आप एक TensorFlow लाइट मॉडल में प्रशिक्षित मॉडल बदल सकते हैं।
अब, मॉडल का उपयोग कर परिवर्तित TFliteConverter डिफ़ॉल्ट float32 प्रारूप में:
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
2021-10-30 11:55:42.971843: 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/tmpbriefkal/assets 2021-10-30 11:55:43.402148: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format. 2021-10-30 11:55:43.402187: 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/tmpfxn_2jql/assets INFO:tensorflow:Assets written to: /tmp/tmpfxn_2jql/assets 2021-10-30 11:55:44.514461: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format. 2021-10-30 11:55:44.514507: 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 136K -rw-rw-r-- 1 kbuilder kbuilder 83K Oct 30 11:55 mnist_model.tflite -rw-rw-r-- 1 kbuilder kbuilder 24K Oct 30 11:54 mnist_model_quant.tflite -rw-rw-r-- 1 kbuilder kbuilder 25K Oct 30 11:55 mnist_model_quant_16x8.tflite
TensorFlow Lite मॉडल चलाएँ
Python TensorFlow Lite दुभाषिया का उपयोग करके 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.9641
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.964
इस उदाहरण में, आपने एक मॉडल को 16x8 पर परिमाणित किया है जिसमें सटीकता में कोई अंतर नहीं है, लेकिन 3x कम आकार के साथ है।
,| 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)
)
1875/1875 [==============================] - 6s 2ms/step - loss: 0.2797 - accuracy: 0.9224 - val_loss: 0.1224 - val_accuracy: 0.9641 <keras.callbacks.History at 0x7f6f19eff210>
उदाहरण के लिए, आपने मॉडल को केवल एक युग के लिए प्रशिक्षित किया है, इसलिए यह केवल ~96% सटीकता के लिए प्रशिक्षित करता है।
एक TensorFlow लाइट मॉडल में कनवर्ट करें
अजगर का उपयोग करना TFLiteConverter , अब आप एक TensorFlow लाइट मॉडल में प्रशिक्षित मॉडल बदल सकते हैं।
अब, मॉडल का उपयोग कर परिवर्तित TFliteConverter डिफ़ॉल्ट float32 प्रारूप में:
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
2021-10-30 11:55:42.971843: 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/tmpbriefkal/assets 2021-10-30 11:55:43.402148: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format. 2021-10-30 11:55:43.402187: 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/tmpfxn_2jql/assets INFO:tensorflow:Assets written to: /tmp/tmpfxn_2jql/assets 2021-10-30 11:55:44.514461: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format. 2021-10-30 11:55:44.514507: 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 136K -rw-rw-r-- 1 kbuilder kbuilder 83K Oct 30 11:55 mnist_model.tflite -rw-rw-r-- 1 kbuilder kbuilder 24K Oct 30 11:54 mnist_model_quant.tflite -rw-rw-r-- 1 kbuilder kbuilder 25K Oct 30 11:55 mnist_model_quant_16x8.tflite
TensorFlow Lite मॉडल चलाएँ
Python TensorFlow Lite दुभाषिया का उपयोग करके 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.9641
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.964
इस उदाहरण में, आपने एक मॉडल को 16x8 पर परिमाणित किया है जिसमें सटीकता में कोई अंतर नहीं है, लेकिन 3x कम आकार के साथ है।