प्रशिक्षण के बाद फ्लोट16 परिमाणीकरण

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

अवलोकन

TensorFlow लाइट अब TensorFlow लाइट के फ्लैट बफर प्रारूप करने के लिए TensorFlow से मॉडल रूपांतरण के दौरान 16-बिट चल बिन्दु मूल्यों के वजन को परिवर्तित करने का समर्थन करता है। इसके परिणामस्वरूप मॉडल आकार में 2x की कमी आती है। कुछ हार्डवेयर, जैसे GPU, इस कम सटीक अंकगणित में मूल रूप से गणना कर सकते हैं, पारंपरिक फ़्लोटिंग पॉइंट निष्पादन पर एक गति का एहसास कर सकते हैं। Tensorflow Lite GPU प्रतिनिधि को इस तरह से चलाने के लिए कॉन्फ़िगर किया जा सकता है। हालांकि, फ्लोट16 वज़न में परिवर्तित मॉडल अभी भी अतिरिक्त संशोधन के बिना सीपीयू पर चल सकता है: फ्लोट16 वज़न को पहले अनुमान से पहले फ्लोट32 में बदल दिया जाता है। यह विलंबता और सटीकता के न्यूनतम प्रभावों के बदले में मॉडल आकार में महत्वपूर्ण कमी की अनुमति देता है।

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

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

सेट अप

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

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

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

# 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)
)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
11501568/11490434 [==============================] - 0s 0us/step
1875/1875 [==============================] - 13s 2ms/step - loss: 0.2655 - accuracy: 0.9244 - val_loss: 0.1237 - val_accuracy: 0.9654
<keras.callbacks.History at 0x7f3f8428e6d0>

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

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

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

अब का उपयोग कर मॉडल लोड TFLiteConverter :

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
2021-12-14 12:18:07.073783: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/tmpm1s3vkrd/assets
2021-12-14 12:18:07.876066: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:363] Ignored output_format.
2021-12-14 12:18:07.876112: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:366] Ignored drop_control_dependency.
WARNING:absl:Buffer deduplication procedure will be skipped when flatbuffer library is not properly loaded

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

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

converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]

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

tflite_fp16_model = converter.convert()
tflite_model_fp16_file = tflite_models_dir/"mnist_model_quant_f16.tflite"
tflite_model_fp16_file.write_bytes(tflite_fp16_model)
INFO:tensorflow:Assets written to: /tmp/tmpvjt9l68i/assets
INFO:tensorflow:Assets written to: /tmp/tmpvjt9l68i/assets
2021-12-14 12:18:08.810262: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:363] Ignored output_format.
2021-12-14 12:18:08.810303: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:366] Ignored drop_control_dependency.
WARNING:absl:Buffer deduplication procedure will be skipped when flatbuffer library is not properly loaded
44384

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

ls -lh {tflite_models_dir}
total 128K
-rw-rw-r-- 1 kbuilder kbuilder 83K Dec 14 12:18 mnist_model.tflite
-rw-rw-r-- 1 kbuilder kbuilder 44K Dec 14 12:18 mnist_model_quant_f16.tflite

TensorFlow Lite मॉडल चलाएँ

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

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

interpreter = tf.lite.Interpreter(model_path=str(tflite_model_file))
interpreter.allocate_tensors()
interpreter_fp16 = tf.lite.Interpreter(model_path=str(tflite_model_fp16_file))
interpreter_fp16.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_fp16.get_input_details()[0]["index"]
output_index = interpreter_fp16.get_output_details()[0]["index"]

interpreter_fp16.set_tensor(input_index, test_image)
interpreter_fp16.invoke()
predictions = interpreter_fp16.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.9654

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

# NOTE: Colab runs on server CPUs. At the time of writing this, TensorFlow Lite
# doesn't have super optimized server CPU kernels. For this reason this may be
# slower than the above float interpreter. But for mobile CPUs, considerable
# speedup can be observed.
print(evaluate_model(interpreter_fp16))
0.9654

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

GPU पर fp16 परिमाणित मॉडल का मूल्यांकन करना भी संभव है। कम सटीक मूल्यों के साथ सभी अंकगणित को निष्पादित करने के लिए, बनाने के लिए सुनिश्चित हो TfLiteGPUDelegateOptions अपने अनुप्रयोग और सेट में struct precision_loss_allowed को 1 इस तरह,:

//Prepare GPU delegate.
const TfLiteGpuDelegateOptions options = {
  .metadata = NULL,
  .compile_options = {
    .precision_loss_allowed = 1,  // FP16
    .preferred_gl_object_type = TFLITE_GL_OBJECT_TYPE_FASTEST,
    .dynamic_batch_enabled = 0,   // Not fully functional yet
  },
};

TFLite GPU प्रतिनिधि और कैसे अपने आवेदन में इसका इस्तेमाल करने के बारे में विस्तृत प्रलेखन पाया जा सकता है यहां