 TensorFlow.org এ দেখুন |  Google Colab-এ চালান |  GitHub-এ উৎস দেখুন |  নোটবুক ডাউনলোড করুন |
ওভারভিউ
TensorFlow লাইট এখন TensorFlow লাইট এর ফ্ল্যাট বাফার ফর্ম্যাটে TensorFlow থেকে মডেল রূপান্তর সময় 16 বিট ফ্লোটিং পয়েন্ট মান ওজন রূপান্তর সমর্থন করে। এর ফলে মডেলের আকার 2x কমে যায়। কিছু হার্ডওয়্যার, যেমন জিপিইউ, এই হ্রাসকৃত নির্ভুলতা গাণিতিকের মধ্যে স্থানীয়ভাবে গণনা করতে পারে, ঐতিহ্যগত ফ্লোটিং পয়েন্ট এক্সিকিউশনের তুলনায় গতি বৃদ্ধি করে। Tensorflow Lite GPU প্রতিনিধি এইভাবে চালানোর জন্য কনফিগার করা যেতে পারে। যাইহোক, float16 ওজনে রূপান্তরিত একটি মডেল অতিরিক্ত পরিবর্তন ছাড়াই এখনও CPU-তে চলতে পারে: প্রথম অনুমানের আগে float16 ওজনগুলিকে float32-এ আপস্যাম্পল করা হয়। এটি বিলম্ব এবং নির্ভুলতার ন্যূনতম প্রভাবের বিনিময়ে মডেলের আকারে উল্লেখযোগ্য হ্রাসের অনুমতি দেয়।
এই টিউটোরিয়ালে, আপনি স্ক্র্যাচ থেকে একটি MNIST মডেলকে প্রশিক্ষণ দিন, TensorFlow-এ এর যথার্থতা পরীক্ষা করুন এবং তারপর float16 কোয়ান্টাইজেশন সহ মডেলটিকে টেনসরফ্লো লাইট ফ্ল্যাটবাফারে রূপান্তর করুন। অবশেষে, রূপান্তরিত মডেলের যথার্থতা পরীক্ষা করুন এবং এটি মূল float32 মডেলের সাথে তুলনা করুন।
একটি MNIST মডেল তৈরি করুন
সেটআপ
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% নির্ভুলতার জন্য প্রশিক্ষণ দেয়৷
একটি টেনসরফ্লো লাইট মডেলে রূপান্তর করুন
পাইথন ব্যবহার TFLiteConverter , আপনি এখন একটি TensorFlow লাইট মডেল মধ্যে প্রশিক্ষিত মডেল রূপান্তর করতে পারেন।
Now ব্যবহার করা মডেল লোড 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 ব্যবহার ডিফল্ট অপ্টিমাইজেশন পতাকা। তারপর নির্দিষ্ট করুন যে float16 টার্গেট প্ল্যাটফর্মে সমর্থিত প্রকার:
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
প্রাপ্ত করার জন্য float16 কোয়ান্টাইজড মডেলের মূল্যায়ন পুনরাবৃত্তি করুন:
# 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
এই উদাহরণে, আপনি নির্ভুলতার কোন পার্থক্য ছাড়াই float16 করার জন্য একটি মডেলের পরিমাণ নির্ধারণ করেছেন।
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 জিপিইউ প্রতিনিধি এবং কিভাবে আপনার অ্যাপ্লিকেশনের মধ্যে এটি ব্যবহার করতে বিশদ ডকুমেন্টেশন পাওয়া যাবে এখানে