.tflite — TFLite मॉडल प्रारूप का सार, संरचना और अनुप्रयोग

.tflite प्रारूप क्या है

.tflite मशीन लर्निंग मॉडल का एक सीरियलाइज़्ड प्रतिनिधित्व है जो सीमित मेमोरी और कंप्यूटिंग शक्ति वाले उपकरणों पर इन्फ़रेंस के लिए अनुकूलित है। SavedModel प्रारूप के विपरीत, जो ग्राफ़ को protobuf में संग्रहीत करता है और लोड करने के लिए महत्वपूर्ण संसाधनों की आवश्यकता होती है, .tflite FlatBuffers का उपयोग करता है — बिना कॉपी किए डेटा तक पहुँच वाली एक सीरियलाइज़ेशन लाइब्रेरी।

.tflite प्रारूप मोबाइल प्लेटफ़ॉर्म विशेषताओं को ध्यान में रखकर डिज़ाइन किया गया है: लोड करने के दौरान न्यूनतम मेमोरी खपत, तेज़ स्टार्टअप और क्वांटाइज़्ड भार का समर्थन। .tflite फ़ाइल प्रशिक्षण का समर्थन नहीं करती — केवल इन्फ़रेंस। यह पूर्ण TensorFlow प्रारूपों से एक मूलभूत अंतर है, जो रनटाइम आकार को काफी कम करने की अनुमति देता है।

Google Research, 2024 के अनुसार, INT8 क्वांटाइज़ेशन वाले .tflite प्रारूप में मॉडल समान FP32 मॉडल की तुलना में 60% तेज़ी से लोड होते हैं और इन्फ़रेंस के दौरान 40% कम RAM की खपत करते हैं।

.tflite फ़ाइल की आंतरिक संरचना

.tflite फ़ाइल में FlatBuffers योजना के अनुसार व्यवस्थित कई अनुभाग होते हैं। मुख्य अनुभाग Model है, जिसमें गणना ग्राफ़ (SubGraph), संचालकों की सूची (OperatorCodes) और भार बफ़र होते हैं। प्रत्येक SubGraph में टेंसर, संचालक और इनपुट/आउटपुट इंडेक्स होते हैं।

OperatorCodes अनुभाग में मॉडल में उपयोग किए गए सभी संचालकों के पहचानकर्ता होते हैं — Conv2D, DepthwiseConv2D, FullyConnected, Softmax और अन्य। प्रत्येक संचालक का एक कोड पूर्वनिर्धारित BuiltinOperator सूची से होता है। यदि मॉडल में ऐसे संचालन हैं जो सूची में नहीं हैं, तो उन्हें Custom के रूप में चिह्नित किया जाता है और डेलिगेट या कस्टम संचालक के माध्यम से कार्यान्वयन की आवश्यकता होती है।

Buffers अनुभाग में मॉडल के भार का बाइनरी डेटा होता है। क्वांटाइज़ेशन मोड के आधार पर, भार FP32, FP16, INT8 या स्केलिंग पैरामीटर के साथ क्वांटाइज़्ड प्रारूप में संग्रहीत किए जा सकते हैं। बफ़र mmap के माध्यम से सीधे मेमोरी में मैप किए जाते हैं, जिससे अतिरिक्त कॉपी समाप्त हो जाती है।

.tflite फ़ाइल के मुख्य अनुभाग

क्वांटाइज़ेशन और प्रारूप अनुकूलन

.tflite तीन क्वांटाइज़ेशन मोड का समर्थन करता है। पूर्ण पूर्णांक INT8 क्वांटाइज़ेशन — भार और सक्रियण 8-बिट पूर्णांकों के रूप में दर्शाए जाते हैं। रूपांतरण के लिए सक्रियण रेंज को कैलिब्रेट करने हेतु एक प्रतिनिधि डेटासेट की आवश्यकता होती है। मॉडल का आकार 4 गुना कम हो जाता है।

FP16 क्वांटाइज़ेशन — भार को 16-बिट फ़्लोटिंग पॉइंट संख्याओं में बदला जाता है। इस मोड में कैलिब्रेशन की आवश्यकता नहीं होती और न्यूनतम सटीकता हानि होती है। सक्रियण FP32 में रहते हैं। मॉडल का आकार 2 गुना कम हो जाता है। GPU और NPU पर FP16 समर्थन वाले उपकरणों के लिए अनुशंसित।

डायनामिक क्वांटाइज़ेशन — भार INT8 में बदले जाते हैं लेकिन सक्रियण FP32 में गणना किए जाते हैं। मॉडल का आकार 4 गुना कम होता है जबकि सटीकता पूर्ण INT8 से अधिक रहती है। Google ML Performance Benchmarks के अनुसार, यह मोड NLP मॉडल और उच्च सटीकता संवेदनशीलता वाले मॉडल के लिए इष्टतम है।

TensorFlow मॉडल से .tflite बनाना

मॉडल को .tflite में बदलने के लिए TFLite Converter का उपयोग किया जाता है — Python API tf.lite.TFLiteConverter के माध्यम से उपलब्ध TensorFlow घटक। कनवर्टर तीन स्रोतों का समर्थन करता है: SavedModel, Keras H5 और ConcreteFunction। Keras मॉडल रूपांतरण का एक न्यूनतम उदाहरण:

import tensorflow as tf

# फ़ाइल से प्रशिक्षित Keras मॉडल लोड करें
model = tf.keras.models.load_model("my_model.h5")

# डायनामिक क्वांटाइज़ेशन के साथ .tflite में बदलें
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# रूपांतरित मॉडल को .tflite फ़ाइल में लिखें
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

पूर्ण INT8 क्वांटाइज़ेशन के साथ रूपांतरण के लिए एक कैलिब्रेशन डेटासेट की आवश्यकता होती है। सक्रियण रेंज निर्धारित करने के लिए representative_dataset प्रदान करें:

converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS_INT8
]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
tflite_quant_model = converter.convert()

.tflite के साथ काम करने के उपकरण

Google .tflite मॉडल के विश्लेषण और अनुकूलन के लिए उपकरणों का एक सेट प्रदान करता है। TFLite Benchmark Tool उपकरण पर इन्फ़रेंस समय मापता है और प्रत्येक संचालक के आँकड़े दिखाता है। TFLite Model Inspector गणना ग्राफ़ को विज़ुअलाइज़ करता है और टेंसर आकार दिखाता है।

Netron एक क्रॉस-प्लेटफ़ॉर्म मॉडल विज़ुअलाइज़र है जो ONNX, Core ML और PyTorch के साथ .tflite का समर्थन करता है। Netron ग्राफ़ संरचना, प्रत्येक संचालक के पैरामीटर और टेंसर के बीच कनेक्शन प्रदर्शित करता है। रूपांतरण के दौरान डिबगिंग के लिए उपयोगी।

TFLite Metadata API .tflite फ़ाइल में मेटाडेटा जोड़ने की अनुमति देती है: मॉडल विवरण, इनपुट डेटा प्रारूप, माप की इकाइयाँ, लेखक की जानकारी। मेटाडेटा का उपयोग Task Library द्वारा स्वचालित प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग कॉन्फ़िगरेशन के लिए किया जाता है।

.tflite लोड और निष्पादन उदाहरण

iOS पर Swift API के साथ .tflite मॉडल लोड करने का उदाहरण। TFLite Swift API बंडल से मॉडल लोड करने और इन्फ़रेंस चलाने के लिए Interpreter प्रदान करता है। Core ML Delegate के माध्यम से हार्डवेयर त्वरण के लिए एक डेलिगेट निर्दिष्ट करें:

import TensorFlowLite

guard let modelPath = Bundle.main.path(
    forResource: "model", ofType: "tflite"
) else { return }

let interpreter = try Interpreter.init(modelPath: modelPath)
try interpreter.allocateTensors()

// मॉडल के लिए इनपुट डेटा तैयार करें
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// मॉडल इन्फ़रेंस चलाएँ
try interpreter.invoke()

// आउटपुट टेंसर डेटा पढ़ें
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}