সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

প্রশিক্ষণ পরবর্তী পূর্ণসংখ্যার পরিমাণ

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

ওভারভিউ

ইন্টিজার কোয়ান্টাইজেশন হল একটি অপ্টিমাইজেশান কৌশল যা 32-বিট ফ্লোটিং-পয়েন্ট নম্বরগুলিকে (যেমন ওজন এবং অ্যাক্টিভেশন আউটপুট) নিকটতম 8-বিট ফিক্সড-পয়েন্ট সংখ্যায় রূপান্তর করে। এবং একটি ছোট মডেল এই ফলাফল বর্ধিত inferencing গতি, যা যেমন নিম্ন শক্তি ডিভাইসের জন্য মূল্যবান মাইক্রোকন্ট্রোলারের । এই ডেটা বিন্যাস এছাড়াও দ্বারা প্রয়োজন বোধ করা হয় পূর্ণসংখ্যা শুধুমাত্র যেমন accelerators এজ নমনীয়

এই টিউটোরিয়াল, আপনি স্ক্র্যাচ থেকে একটি MNIST মডেল প্রশিক্ষন দেবো, এটা একটা Tensorflow লাইট ফাইলে রূপান্তর, এবং ব্যবহার করে এটি quantize পোস্ট প্রশিক্ষণ quantization । অবশেষে, আপনি রূপান্তরিত মডেলের যথার্থতা পরীক্ষা করবেন এবং এটি মূল ফ্লোট মডেলের সাথে তুলনা করবেন।

আপনি একটি মডেলের পরিমাণ কতটা করতে চান তার জন্য আপনার কাছে আসলে বেশ কয়েকটি বিকল্প রয়েছে। এই টিউটোরিয়ালে, আপনি "সম্পূর্ণ পূর্ণসংখ্যার পরিমাপ" সম্পাদন করবেন, যা সমস্ত ওজন এবং সক্রিয়করণ আউটপুটকে 8-বিট পূর্ণসংখ্যা ডেটাতে রূপান্তরিত করে — যেখানে অন্যান্য কৌশলগুলি ফ্লোটিং-পয়েন্টে কিছু পরিমাণ ডেটা রেখে যেতে পারে।

বিভিন্ন quantization কৌশল, সম্পর্কে পড়তে সম্পর্কে আরো জানতে TensorFlow লাইট মডেল অপ্টিমাইজেশান

সেটআপ

ইনপুট এবং আউটপুট টেনসর উভয়ের পরিমাপ করার জন্য, আমাদের TensorFlow r2.3 এ যুক্ত API ব্যবহার করতে হবে:

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

import tensorflow as tf
import numpy as np
assert float(tf.__version__[:3]) >= 2.3

একটি টেনসরফ্লো মডেল তৈরি করুন

আমরা থেকে শ্রেণীভুক্ত নম্বরে একটি সহজ মডেল নির্মান করব MNIST ডেটা সেটটি

এই প্রশিক্ষণটি বেশি সময় নেবে না কারণ আপনি মডেলটিকে মাত্র 5 যুগের জন্য প্রশিক্ষণ দিচ্ছেন, যা প্রায় ~98% নির্ভুলতার প্রশিক্ষণ দেয়।

# Load MNIST dataset
mnist = tf.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.astype(np.float32) / 255.0
test_images = test_images.astype(np.float32) / 255.0

# Define the model architecture
model = tf.keras.Sequential([
  tf.keras.layers.InputLayer(input_shape=(28, 28)),
  tf.keras.layers.Reshape(target_shape=(28, 28, 1)),
  tf.keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
  tf.keras.layers.Flatten(),
  tf.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=5,
  validation_data=(test_images, test_labels)
)
Epoch 1/5
1875/1875 [==============================] - 5s 2ms/step - loss: 0.2519 - accuracy: 0.9311 - val_loss: 0.1106 - val_accuracy: 0.9664
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0984 - accuracy: 0.9724 - val_loss: 0.0828 - val_accuracy: 0.9743
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0746 - accuracy: 0.9785 - val_loss: 0.0640 - val_accuracy: 0.9795
Epoch 4/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0620 - accuracy: 0.9814 - val_loss: 0.0620 - val_accuracy: 0.9793
Epoch 5/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0540 - accuracy: 0.9837 - val_loss: 0.0624 - val_accuracy: 0.9795
<keras.callbacks.History at 0x7fb44c988c90>

একটি টেনসরফ্লো লাইট মডেলে রূপান্তর করুন

এখন আপনি ব্যবহার TensorFlow লাইট ফর্ম্যাটে প্রশিক্ষিত মডেল রূপান্তর করতে পারেন TFLiteConverter এপিআই, এবং quantization ডিগ্রী তারতম্য প্রয়োগ করুন।

সতর্ক থাকুন যে পরিমাণ নির্ধারণের কিছু সংস্করণ ফ্লোট বিন্যাসে কিছু ডেটা রেখে যায়। সুতরাং নিম্নলিখিত বিভাগগুলি ক্রমবর্ধমান পরিমাণে পরিমাপের সাথে প্রতিটি বিকল্প দেখায়, যতক্ষণ না আমরা একটি মডেল পাই যা সম্পূর্ণরূপে int8 বা uint8 ডেটা। (লক্ষ্য করুন আমরা প্রতিটি বিভাগে কিছু কোড নকল করেছি যাতে আপনি প্রতিটি বিকল্পের জন্য সমস্ত পরিমাণ নির্ধারণের ধাপ দেখতে পারেন।)

প্রথমত, এখানে কোন পরিমাপ ছাড়াই একটি রূপান্তরিত মডেল রয়েছে:

converter = tf.lite.TFLiteConverter.from_keras_model(model)

tflite_model = converter.convert()
2021-10-30 12:04:56.623151: 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/tmp3os2tr3n/assets
2021-10-30 12:04:57.031317: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-10-30 12:04:57.031355: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.

এটি এখন একটি টেনসরফ্লো লাইট মডেল, কিন্তু এটি এখনও সমস্ত প্যারামিটার ডেটার জন্য 32-বিট ফ্লোট মান ব্যবহার করছে।

গতিশীল পরিসীমা পরিমাপ ব্যবহার করে রূপান্তর করুন

এখন আসুন ডিফল্ট সক্ষম optimizations (যেমন ওজন হিসাবে) সব সংশোধন করা হয়েছে পরামিতি quantize পতাকা:

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

tflite_model_quant = converter.convert()
INFO:tensorflow:Assets written to: /tmp/tmpi7xibvaj/assets
INFO:tensorflow:Assets written to: /tmp/tmpi7xibvaj/assets
2021-10-30 12:04:57.597982: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-10-30 12:04:57.598020: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.

মডেলটি এখন কোয়ান্টাইজড ওজনের সাথে কিছুটা ছোট, তবে অন্যান্য পরিবর্তনশীল ডেটা এখনও ফ্লোট ফর্ম্যাটে রয়েছে।

ফ্লোট ফলব্যাক কোয়ান্টাইজেশন ব্যবহার করে রূপান্তর করুন

(যেমন মডেল ইনপুট / আউটপুট এবং স্তর মধ্যে intermediates হিসাবে) ভেরিয়েবলের তথ্য quantize, আপনি একটি প্রদান করতে RepresentativeDataset । এটি একটি জেনারেটর ফাংশন যা ইনপুট ডেটার একটি সেট সরবরাহ করে যা সাধারণ মানগুলিকে উপস্থাপন করার জন্য যথেষ্ট বড়। এটি রূপান্তরকারীকে সমস্ত পরিবর্তনশীল ডেটার জন্য একটি গতিশীল পরিসর অনুমান করতে দেয়। (প্রশিক্ষণ বা মূল্যায়ন ডেটাসেটের তুলনায় ডেটাসেটটি অনন্য হওয়ার প্রয়োজন নেই।) একাধিক ইনপুট সমর্থন করার জন্য, প্রতিটি প্রতিনিধি ডেটা পয়েন্ট একটি তালিকা এবং তালিকার উপাদানগুলি তাদের সূচক অনুসারে মডেলকে খাওয়ানো হয়।

def representative_data_gen():
  for input_value in tf.data.Dataset.from_tensor_slices(train_images).batch(1).take(100):
    # Model has only one input so each data point has one element.
    yield [input_value]

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_data_gen

tflite_model_quant = converter.convert()
INFO:tensorflow:Assets written to: /tmp/tmp3gwloj7n/assets
INFO:tensorflow:Assets written to: /tmp/tmp3gwloj7n/assets
2021-10-30 12:04:58.159142: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-10-30 12:04:58.159181: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
fully_quantize: 0, inference_type: 6, input_inference_type: 0, output_inference_type: 0

এখন সমস্ত ওজন এবং পরিবর্তনশীল ডেটা পরিমাপ করা হয়েছে এবং মডেলটি আসল টেনসরফ্লো লাইট মডেলের তুলনায় উল্লেখযোগ্যভাবে ছোট।

যাইহোক, ঐতিহ্যগতভাবে ফ্লোট মডেল ইনপুট এবং আউটপুট টেনসর ব্যবহার করে এমন অ্যাপ্লিকেশনগুলির সাথে সামঞ্জস্য বজায় রাখতে, টেনসরফ্লো লাইট কনভার্টার মডেল ইনপুট এবং আউটপুট টেনসরগুলিকে ফ্লোটে রেখে দেয়:

interpreter = tf.lite.Interpreter(model_content=tflite_model_quant)
input_type = interpreter.get_input_details()[0]['dtype']
print('input: ', input_type)
output_type = interpreter.get_output_details()[0]['dtype']
print('output: ', output_type)
input:  <class 'numpy.float32'>
output:  <class 'numpy.float32'>

এটি সাধারণত সামঞ্জস্যের জন্য ভাল, তবে এটি এমন ডিভাইসগুলির সাথে সামঞ্জস্যপূর্ণ হবে না যা শুধুমাত্র পূর্ণসংখ্যা-ভিত্তিক ক্রিয়াকলাপগুলি সম্পাদন করে, যেমন এজ TPU৷

অতিরিক্তভাবে, উপরের প্রক্রিয়াটি ফ্লোট ফর্ম্যাটে একটি অপারেশন ছেড়ে যেতে পারে যদি TensorFlow Lite সেই অপারেশনের জন্য একটি পরিমাপকৃত বাস্তবায়ন অন্তর্ভুক্ত না করে। এই কৌশলটি রূপান্তর সম্পূর্ণ করার অনুমতি দেয় যাতে আপনার কাছে একটি ছোট এবং আরও দক্ষ মডেল থাকে, কিন্তু আবার, এটি শুধুমাত্র পূর্ণসংখ্যার হার্ডওয়্যারের সাথে সামঞ্জস্যপূর্ণ হবে না। (এই MNIST মডেলের সমস্ত অপারেশনের একটি পরিমাপযুক্ত বাস্তবায়ন রয়েছে।)

তাই একটি এন্ড-টু-এন্ড পূর্ণসংখ্যা-শুধুমাত্র মডেল নিশ্চিত করতে, আপনার আরও কয়েকটি পরামিতি প্রয়োজন...

শুধুমাত্র পূর্ণসংখ্যার পরিমাপ ব্যবহার করে রূপান্তর করুন

ইনপুট এবং আউটপুট টেনসরের পরিমাপ করতে, এবং কনভার্টারটিকে একটি ত্রুটি থ্রো করতে যদি এটি এমন কোনো অপারেশনের সম্মুখীন হয় যে এটি কোয়ান্টাইজ করতে পারে না, কিছু অতিরিক্ত পরামিতি সহ মডেলটিকে আবার রূপান্তর করুন:

def representative_data_gen():
  for input_value in tf.data.Dataset.from_tensor_slices(train_images).batch(1).take(100):
    yield [input_value]

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_data_gen
# Ensure that if any ops can't be quantized, the converter throws an error
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
# Set the input and output tensors to uint8 (APIs added in r2.3)
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8

tflite_model_quant = converter.convert()
INFO:tensorflow:Assets written to: /tmp/tmp8ygc2_3y/assets
INFO:tensorflow:Assets written to: /tmp/tmp8ygc2_3y/assets
2021-10-30 12:04:59.308505: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-10-30 12:04:59.308542: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
fully_quantize: 0, inference_type: 6, input_inference_type: 3, output_inference_type: 3
WARNING:absl:For model inputs containing unsupported operations which cannot be quantized, the `inference_input_type` attribute will default to the original type.

অভ্যন্তরীণ পরিমাপ উপরের মতই রয়ে গেছে, কিন্তু আপনি দেখতে পাচ্ছেন ইনপুট এবং আউটপুট টেনসর এখন পূর্ণসংখ্যার বিন্যাস:

interpreter = tf.lite.Interpreter(model_content=tflite_model_quant)
input_type = interpreter.get_input_details()[0]['dtype']
print('input: ', input_type)
output_type = interpreter.get_output_details()[0]['dtype']
print('output: ', output_type)
input:  <class 'numpy.uint8'>
output:  <class 'numpy.uint8'>

এখন আপনি একটি পূর্ণসংখ্যা নিরবচ্ছিন্ন মডেল আছে মডেলের ইনপুট এবং আউটপুট tensors জন্য তথ্য পূর্ণসংখ্যা ব্যবহার করে, তাই এটা যেমন পূর্ণসংখ্যা শুধুমাত্র হার্ডওয়্যার সঙ্গে সামঞ্জস্যপূর্ণ এজ নমনীয়

ফাইল হিসাবে মডেল সংরক্ষণ করুন

আপনি একটি প্রয়োজন হবে .tflite অন্য ডিভাইসে আপনার মডেল স্থাপন করা ফাইল। সুতরাং আসুন রূপান্তরিত মডেলগুলি ফাইলগুলিতে সংরক্ষণ করি এবং তারপরে যখন আমরা নীচের অনুমানগুলি চালাই তখন সেগুলি লোড করি।

import pathlib

tflite_models_dir = pathlib.Path("/tmp/mnist_tflite_models/")
tflite_models_dir.mkdir(exist_ok=True, parents=True)

# Save the unquantized/float model:
tflite_model_file = tflite_models_dir/"mnist_model.tflite"
tflite_model_file.write_bytes(tflite_model)
# Save the quantized model:
tflite_model_quant_file = tflite_models_dir/"mnist_model_quant.tflite"
tflite_model_quant_file.write_bytes(tflite_model_quant)
24280

TensorFlow Lite মডেলগুলি চালান

এখন আমরা TensorFlow লাইট ব্যবহার মতামতে উপনীত রান করব Interpreter মডেল accuracies তুলনা।

প্রথমে, আমাদের এমন একটি ফাংশন দরকার যা একটি প্রদত্ত মডেল এবং চিত্রগুলির সাথে অনুমান চালায় এবং তারপরে ভবিষ্যদ্বাণী প্রদান করে:

# Helper function to run inference on a TFLite model
def run_tflite_model(tflite_file, test_image_indices):
  global test_images

  # Initialize the interpreter
  interpreter = tf.lite.Interpreter(model_path=str(tflite_file))
  interpreter.allocate_tensors()

  input_details = interpreter.get_input_details()[0]
  output_details = interpreter.get_output_details()[0]

  predictions = np.zeros((len(test_image_indices),), dtype=int)
  for i, test_image_index in enumerate(test_image_indices):
    test_image = test_images[test_image_index]
    test_label = test_labels[test_image_index]

    # Check if the input type is quantized, then rescale input data to uint8
    if input_details['dtype'] == np.uint8:
      input_scale, input_zero_point = input_details["quantization"]
      test_image = test_image / input_scale + input_zero_point

    test_image = np.expand_dims(test_image, axis=0).astype(input_details["dtype"])
    interpreter.set_tensor(input_details["index"], test_image)
    interpreter.invoke()
    output = interpreter.get_tensor(output_details["index"])[0]

    predictions[i] = output.argmax()

  return predictions

একটি ছবিতে মডেল পরীক্ষা করুন

এখন আমরা ফ্লোট মডেল এবং কোয়ান্টাইজড মডেলের কর্মক্ষমতা তুলনা করব:

  • tflite_model_file ফ্লোটিং পয়েন্ট ডেটার সাথে মূল TensorFlow লাইট মডেল।
  • tflite_model_quant_file গত মডেল আমরা পূর্ণসংখ্যা শুধুমাত্র quantization ব্যবহার রূপান্তরিত হয় (এটা ইনপুট এবং আউটপুট জন্য uint8 ডেটা ব্যবহার করে)।

আমাদের ভবিষ্যদ্বাণী প্রিন্ট করার জন্য আরেকটি ফাংশন তৈরি করা যাক:

import matplotlib.pylab as plt

# Change this to test a different image
test_image_index = 1

## Helper function to test the models on one image
def test_model(tflite_file, test_image_index, model_type):
  global test_labels

  predictions = run_tflite_model(tflite_file, [test_image_index])

  plt.imshow(test_images[test_image_index])
  template = model_type + " Model \n True:{true}, Predicted:{predict}"
  _ = plt.title(template.format(true= str(test_labels[test_image_index]), predict=str(predictions[0])))
  plt.grid(False)

এখন ফ্লোট মডেল পরীক্ষা করুন:

test_model(tflite_model_file, test_image_index, model_type="Float")

png

এবং কোয়ান্টাইজড মডেল পরীক্ষা করুন:

test_model(tflite_model_quant_file, test_image_index, model_type="Quantized")

png

সমস্ত ছবির মডেল মূল্যায়ন

এখন এই টিউটোরিয়ালের শুরুতে লোড করা সমস্ত পরীক্ষামূলক চিত্র ব্যবহার করে উভয় মডেলই চালানো যাক:

# Helper function to evaluate a TFLite model on all images
def evaluate_model(tflite_file, model_type):
  global test_images
  global test_labels

  test_image_indices = range(test_images.shape[0])
  predictions = run_tflite_model(tflite_file, test_image_indices)

  accuracy = (np.sum(test_labels== predictions) * 100) / len(test_images)

  print('%s model accuracy is %.4f%% (Number of test samples=%d)' % (
      model_type, accuracy, len(test_images)))

ফ্লোট মডেল মূল্যায়ন করুন:

evaluate_model(tflite_model_file, model_type="Float")
Float model accuracy is 97.9500% (Number of test samples=10000)

কোয়ান্টাইজড মডেল মূল্যায়ন করুন:

evaluate_model(tflite_model_quant_file, model_type="Quantized")
Quantized model accuracy is 97.9300% (Number of test samples=10000)

সুতরাং আপনার কাছে এখন ফ্লোট মডেলের তুলনায় নির্ভুলতার প্রায় কোন পার্থক্য নেই এমন একটি মডেলের পরিমাপ করা হয়েছে।

অন্যান্য quantization কৌশল, সম্পর্কে পড়তে সম্পর্কে আরো জানতে TensorFlow লাইট মডেল অপ্টিমাইজেশান