TensorFlow 14 মে Google I/O-তে ফিরে এসেছে! এখন নিবন্ধন করুন

এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

প্রশিক্ষণ পরবর্তী 16 টি সক্রিয়করণ সহ পূর্ণসংখ্যার কোয়ান্টাইজেশন

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

ওভারভিউ

TensorFlow লাইট এখন সক্রিয়করণব্যবস্থা TensorFlow লাইট এর ফ্ল্যাট বাফার ফর্ম্যাটে TensorFlow থেকে মডেল রূপান্তর সময় মান পূর্ণসংখ্যা 8-বিট 16 বিট পূর্ণসংখ্যা মান এবং ওজন রূপান্তর সমর্থন করে। আমরা এই মোডটিকে "16x8 কোয়ান্টাইজেশন মোড" হিসাবে উল্লেখ করি। এই মোডটি কোয়ান্টাইজড মডেলের যথার্থতা উল্লেখযোগ্যভাবে উন্নত করতে পারে, যখন অ্যাক্টিভেশনগুলি কোয়ান্টাইজেশনের প্রতি সংবেদনশীল হয়, যখন এখনও মডেলের আকারে প্রায় 3-4x হ্রাস অর্জন করে। তাছাড়া, এই সম্পূর্ণ কোয়ান্টাইজড মডেলটি শুধুমাত্র পূর্ণসংখ্যার হার্ডওয়্যার এক্সিলারেটর দ্বারা গ্রাস করা যেতে পারে।

প্রশিক্ষণ-পরবর্তী পরিমাপকরণের এই মোড থেকে উপকৃত মডেলের কিছু উদাহরণের মধ্যে রয়েছে:

সুপার-রেজোলিউশন,
অডিও সিগন্যাল প্রসেসিং যেমন নয়েজ ক্যান্সেলিং এবং বিমফর্মিং,
ইমেজ de-noising,
একটি একক চিত্র থেকে HDR পুনর্গঠন

এই টিউটোরিয়ালে, আপনি স্ক্র্যাচ থেকে একটি MNIST মডেলকে প্রশিক্ষণ দিন, TensorFlow-এ এর যথার্থতা পরীক্ষা করুন এবং তারপর এই মোড ব্যবহার করে মডেলটিকে একটি Tensorflow Lite ফ্ল্যাটবাফারে রূপান্তর করুন। শেষে আপনি রূপান্তরিত মডেলের যথার্থতা পরীক্ষা করুন এবং এটি মূল float32 মডেলের সাথে তুলনা করুন। মনে রাখবেন যে এই উদাহরণটি এই মোডের ব্যবহার প্রদর্শন করে এবং TensorFlow Lite-এ অন্যান্য উপলব্ধ কোয়ান্টাইজেশন কৌশলগুলির তুলনায় সুবিধাগুলি দেখায় না৷

একটি MNIST মডেল তৈরি করুন

সেটআপ

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% নির্ভুলতার জন্য প্রশিক্ষণ দেয়৷

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

পাইথন ব্যবহার 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)

পরিবর্তে 16x8 quantization মোডে মডেল 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 পোস্ট প্রশিক্ষণ quantization ক্ষেত্রে, এটা কনভার্টার অপশন সেট করে একটি সম্পূর্ণরূপে পূর্ণসংখ্যা নিরবচ্ছিন্ন মডেল উত্পাদন করা সম্ভব 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)

png

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)

png

মডেলগুলি মূল্যায়ন করুন

# 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 কম আকারের সাথে।