TensorFlow Lite के डेलिगेट

डेलिगेट, जीपीयू और डिजिटल सिग्नल प्रोसेसर (डीएसपी) जैसे डिवाइस पर मौजूद ऐक्सेलरेटर का इस्तेमाल करके, TensorFlow Lite मॉडल के हार्डवेयर से तेज़ी लाने की सुविधा चालू करते हैं.

डिफ़ॉल्ट रूप से, TensorFlow Lite, ऐसे सीपीयू कर्नेल का इस्तेमाल करता है जिन्हें ARM Neon वाले निर्देश सेट के लिए ऑप्टिमाइज़ किया गया है. सीपीयू, कई तरह के कामों में इस्तेमाल होने वाला प्रोसेसर है. इसे आम तौर पर मशीन लर्निंग मॉडल में मिलने वाले भारी अंकगणित के लिए ऑप्टिमाइज़ नहीं किया जाता है. उदाहरण के लिए, कॉन्वलूशन और डेंसिटी लेयर वाला मैट्रिक्स गणित.

दूसरी ओर, ज़्यादातर आधुनिक मोबाइल फ़ोन में ऐसे चिप होते हैं जो इन मुश्किल कामों को बेहतर तरीके से करते हैं. न्यूरल नेटवर्क ऑपरेशन के लिए इनका इस्तेमाल करने से देर की बचत और बिजली की बचत करने में काफ़ी फ़ायदे मिलते हैं. उदाहरण के लिए, जीपीयू, इंतज़ार के समय में पांच गुना स्पीडअप तक कर सकते हैं.

इनमें से हर एक ऐक्सेलरेटर में ऐसे एपीआई होते हैं जो मोबाइल जीपीयू के लिए, OpenCL या OpenGL ES जैसे कस्टम कंप्यूटेशन चालू करते हैं. आम तौर पर, इन इंटरफ़ेस से न्यूरल नेटवर्क चलाने के लिए, आपको बहुत सारे कस्टम कोड लिखने होंगे. जब आपको लगता है कि हर एक्सेलरेटर के अपने फ़ायदे और नुकसान हैं, तो चीज़ें और भी मुश्किल हो जाती हैं. साथ ही, न्यूरल नेटवर्क में हर ऑपरेशन को अंजाम नहीं दिया जा सकता. TensorFlow Lite's Delegate API, TFLite रनटाइम और इन लोअर-लेवल एपीआई के बीच पुल का काम करता है. इससे यह समस्या हल हो जाती है.

डेलिगेट के वोटों का रनटाइम

प्रतिनिधि चुनना

TensorFlow Lite में कई डेलिगेट के वोट होते हैं और इनमें से हर एक को कुछ खास प्लैटफ़ॉर्म और खास तरह के मॉडल के हिसाब से ऑप्टिमाइज़ किया जाता है. आम तौर पर, आपके इस्तेमाल के उदाहरण में कई डेलिगेट के वोट पड़ सकते हैं. ये दो मुख्य शर्तों पर निर्भर करते हैं: टारगेट किया गया प्लैटफ़ॉर्म (Android या iOS?) और मॉडल-टाइप (फ़्लोटिंग-पॉइंट या क्वांटाइज़्ड?)

प्लैटफ़ॉर्म के हिसाब से, संपर्कों का ऐक्सेस देने वाले लोगों की संख्या

क्रॉस-प्लैटफ़ॉर्म (Android और iOS)

  • GPU डेलिगेट - जीपीयू डेलिगेट का इस्तेमाल Android और iOS, दोनों पर किया जा सकता है. जहां जीपीयू उपलब्ध है, वहां इसे 32-बिट और 16-बिट फ़्लोट आधारित मॉडल पर चलने के लिए ऑप्टिमाइज़ किया गया है. यह 8-बिट वाले क्वांटाइज़्ड मॉडल के साथ भी काम करता है. साथ ही, यह फ़्लोट वर्शन की तरह ही जीपीयू की परफ़ॉर्मेंस भी देता है. जीपीयू डेलिगेट के बारे में जानकारी के लिए, GPU पर TensorFlow Lite देखें.

iOS

  • नए iPhone और iPad के लिए कोर एमएल डेलिगेट - नए iPhone और iPad के लिए जहां Neural Engine उपलब्ध है, वहां 32-बिट या 16-बिट फ़्लोटिंग-पॉइंट मॉडल के लिए अनुमान बढ़ाने के लिए, Core ML डेलिगेट का इस्तेमाल किया जा सकता है. न्यूरल इंजन, A12 SoC या उसके बाद के वर्शन वाले Apple मोबाइल डिवाइसों पर उपलब्ध है. Core ML डेलिगेट की खास जानकारी पाने और सिलसिलेवार निर्देशों के लिए, TensorFlow Lite Core ML डेलिगेट को देखें.

मॉडल टाइप के हिसाब से डेलिगेट

हर एक्सेलरेटर को डेटा की कुछ खास चौड़ाई को ध्यान में रखकर डिज़ाइन किया गया है. अगर आपने ऐसे प्रतिनिधि को फ़्लोटिंग-पॉइंट मॉडल उपलब्ध कराया है जो सिर्फ़ 8-बिट क्वांटाइज़्ड ऑपरेशन के साथ काम करता है, तो वह अपने सभी ऑपरेशन को अस्वीकार कर देगा और मॉडल पूरी तरह से सीपीयू पर चलेगा. ऐसी समस्याओं से बचने के लिए, नीचे दी गई टेबल में, मॉडल टाइप के आधार पर सहायता देने वाले लोगों या कंपनियों की खास जानकारी दी गई है:

मॉडल टाइप GPU CoreML
फ़्लोटिंग-पॉइंट (32 बिट) हां हां
ट्रेनिंग के बाद फ़्लोट 16 की संख्या का पता लगाना हां हां
ट्रेनिंग के बाद डाइनैमिक रेंज क्वांटाइज़ेशन हां नहीं
ट्रेनिंग के बाद पूर्णांक की संख्या बढ़ाना हां नहीं
क्वांटाइज़ेशन अवेयर ट्रेनिंग हां नहीं

परफ़ॉर्मेंस की पुष्टि की जा रही है

इस सेक्शन में दी गई जानकारी, उन डेलिगेट को चुनने के लिए एक शुरुआती दिशा-निर्देश के तौर पर काम करती है जो आपके आवेदन को बेहतर बना सकते हैं. हालांकि, यह ध्यान रखना ज़रूरी है कि हर प्रतिनिधि के पास उसके लिए पहले से तय किए गए ऑपरेशन होते हैं. साथ ही, मॉडल और डिवाइस के आधार पर यह अलग-अलग तरीके से परफ़ॉर्म कर सकता है. इसलिए, आम तौर पर हमारा सुझाव है कि आप कुछ मानदंडों का इस्तेमाल करें, ताकि यह पता लगाया जा सके कि कोई प्रतिनिधि आपकी ज़रूरतों के हिसाब से कितना काम का है. इससे TensorFlow Lite रनटाइम में किसी डेलिगेट को अटैच करने से जुड़ी बाइनरी साइज़ में बढ़ोतरी को सही ठहराने में भी मदद मिलती है.

TensorFlow Lite में, परफ़ॉर्मेंस और सटीक होने का आकलन करने वाले बड़े टूल मौजूद हैं. इनकी मदद से डेवलपर, अपने ऐप्लिकेशन में लोगों का भरोसा जीत सकते हैं. अगले सेक्शन में इन टूल के बारे में बताया गया है.

आकलन करने के लिए टूल

लेटेंसी और मेमोरी फ़ुटप्रिंट

TensorFlow Lite के मानदंड टूल का इस्तेमाल, मॉडल की परफ़ॉर्मेंस का अनुमान लगाने के लिए सही पैरामीटर के साथ किया जा सकता है. जैसे, इंतज़ार का औसत समय, शुरू करने का ओवरहेड, मेमोरी फ़ुटप्रिंट वगैरह. यह टूल आपके मॉडल के लिए सबसे सही डेलिगेट कॉन्फ़िगरेशन का पता लगाने के लिए, एक से ज़्यादा फ़्लैग की सुविधा देता है. उदाहरण के लिए, --gpu_backend=gl को --use_gpu की मदद से तय किया जा सकता है, ताकि OpenGL के साथ जीपीयू का इस्तेमाल मापा जा सके. साथ काम करने वाले डेलिगेट पैरामीटर की पूरी सूची ब्यौरे वाले दस्तावेज़ में दी गई है.

यहां adb के ज़रिए जीपीयू के साथ क्वांटाइज़ किए गए मॉडल के लिए रन का उदाहरण दिया गया है:

adb shell /data/local/tmp/benchmark_model \
  --graph=/data/local/tmp/mobilenet_v1_224_quant.tflite \
  --use_gpu=true

Android के लिए, इस टूल का पहले से बनाया गया वर्शन 64-बिट ARM आर्किटेक्चर से डाउनलोड किया जा सकता है. यहां (ज़्यादा जानकारी) देखें.

सटीक और सटीक जानकारी

आम तौर पर, डेलिगेट के सीपीयू से अलग-अलग सटीक तरीके से कंप्यूटेशन किया जाता है. इस वजह से, हार्डवेयर से तेज़ी लाने के लिए किसी डेलिगेट का इस्तेमाल करने से चीज़ों को बहुत ज़्यादा सटीक (आम तौर पर) सटीक नहीं पता चलता है. ध्यान दें कि यह हमेशा सही नहीं होता.उदाहरण के लिए, क्योंकि जीपीयू, क्वांटाइज़ किए गए मॉडल को चलाने के लिए फ़्लोटिंग-पॉइंट प्रिसिज़न का इस्तेमाल करता है. इसलिए, सटीक होने में थोड़ा सुधार हो सकता है (उदाहरण के लिए, <1% - ILSVRC इमेज क्लासिफ़िकेशन में टॉप-5 सुधार).

TensorFlow Lite में दो तरह के टूल मौजूद हैं, जिनकी मदद से यह मेज़र किया जा सकता है कि कोई प्रतिनिधि किसी मॉडल के लिए कितना सटीक व्यवहार कर रहा है: टास्क पर आधारित और टास्क-एग्नोस्टिक. इस सेक्शन में बताए गए सभी टूल, ऐडवांस डेलिगेशन पैरामीटर के साथ काम करते हैं. इन पैरामीटर का इस्तेमाल पिछले सेक्शन में मानदंड टूल करता है. ध्यान दें कि नीचे दिए गए सब-सेक्शन, मॉडल इवैलुएशन (क्या मॉडल अपने-आप टास्क के लिए अच्छा है?) के बजाय, डेलिगेशन इवैलुएशन पर फ़ोकस करता है (क्या डेलिगेट की प्रोसेस, सीपीयू की तरह ही है?).

टास्क के हिसाब से आकलन करना

TensorFlow Lite में, इमेज पर आधारित दो टास्क के सटीक होने का आकलन करने के लिए टूल मौजूद हैं:

इन टूल (Android, 64-बिट ARM आर्किटेक्चर) की पहले से बनी बाइनरी और दस्तावेज़ यहां देखे जा सकते हैं:

नीचे दिए गए उदाहरण में, Pixel 4 पर जीपीयू के साथ इमेज की कैटगरी तय करने की प्रोसेस के बारे में बताया गया है:

adb shell /data/local/tmp/run_eval \
  --model_file=/data/local/tmp/mobilenet_quant_v1_224.tflite \
  --ground_truth_images_path=/data/local/tmp/ilsvrc_images \
  --ground_truth_labels=/data/local/tmp/ilsvrc_validation_labels.txt \
  --model_output_labels=/data/local/tmp/model_output_labels.txt \
  --output_file_path=/data/local/tmp/accuracy_output.txt \
  --num_images=0 # Run on all images. \
  --use_gpu=true

अनुमानित आउटपुट 1 से 10 तक की टॉप-K मेट्रिक की सूची में शामिल हो सकता है:

Top-1 Accuracy: 0.733333
Top-2 Accuracy: 0.826667
Top-3 Accuracy: 0.856667
Top-4 Accuracy: 0.87
Top-5 Accuracy: 0.89
Top-6 Accuracy: 0.903333
Top-7 Accuracy: 0.906667
Top-8 Accuracy: 0.913333
Top-9 Accuracy: 0.92
Top-10 Accuracy: 0.923333

टास्क-एग्नास्टिक इवैलुएशन

जिन टास्क के लिए डिवाइस पर आकलन करने वाला टूल मौजूद नहीं है या अगर कस्टम मॉडल को आज़माया जा रहा है, तब TensorFlow Lite में अनुमान लगाने में अंतर टूल मौजूद होता है. (Android, 64-बिट ARM बाइनरी आर्किटेक्चर बाइनरी बाइनरी, यहां दिए गए हैं)

अनुमान का अंतर, TensorFlow Lite के एक्ज़ीक्यूशन की तुलना दो सेटिंग में करता है: इंतज़ार का समय और आउटपुट-वैल्यू में आने वाले उतार-चढ़ाव की तुलना:

  • सिंगल-थ्रेड वाले सीपीयू का अनुमान
  • उपयोगकर्ता का तय किया गया अनुमान - इन पैरामीटर से तय किया जाता है

ऐसा करने के लिए, यह टूल किसी भी क्रम में गॉसियन डेटा जनरेट करता है और उसे दो TFLite इंटरप्रेटर के ज़रिए पास करता है - एक सिंगल-थ्रेड वाले सीपीयू कर्नेल इस्तेमाल करता है और दूसरा उपयोगकर्ता के आर्ग्युमेंट के मुताबिक पैरामीटर किया जाता है.

यह सुविधा, दोनों एलिमेंट की इंतज़ार के समय को मापती है. साथ ही, हर एलिमेंट के आउटपुट टेंसर के बीच के कुल अंतर को भी मापती है.

एक आउटपुट टेंसर वाले मॉडल के लिए, आउटपुट ऐसा दिख सकता है:

Num evaluation runs: 50
Reference run latency: avg=84364.2(us), std_dev=12525(us)
Test run latency: avg=7281.64(us), std_dev=2089(us)
OutputDiff[0]: avg_error=1.96277e-05, std_dev=6.95767e-06

इसका मतलब यह है कि इंडेक्स 0 के आउटपुट टेंसर के लिए, सीपीयू आउटपुट के एलिमेंट, डेलिगेट आउटपुट से औसतन 1.96e-05 अलग होते हैं.

ध्यान दें कि इन संख्याओं को समझने के लिए मॉडल की अच्छी जानकारी होनी चाहिए. साथ ही, यह भी जानना ज़रूरी है कि हर आउटपुट टेंसर क्या बताता है. अगर यह एक सिंपल रिग्रेशन है, जिससे किसी खास तरह का स्कोर या एम्बेड करने का तरीका तय होता है, तो अंतर कम होना चाहिए. ऐसा न होने पर, डेलिगेट की ओर से शेयर किए गए स्कोर में कोई गड़बड़ी होगी. हालांकि, एसएसडी मॉडल से मिले 'पहचान की क्लास' जैसे आउटपुट को समझना मुश्किल होता है. उदाहरण के लिए, इस टूल का इस्तेमाल करने में अंतर दिख सकता है, लेकिन इसका यह मतलब नहीं हो सकता कि डेलिगेट के लिए कोई गड़बड़ी है: "टीवी (आईडी: 10)", "मॉनिटर (आईडी:20)" - अगर कोई डेलिगेट, सबसे अहम जानकारी से थोड़ा अलग है और टीवी के बजाय मॉनिटर दिखाता है, तो इस टेंसर का आउटपुट अंतर 20-1 जितना ज़्यादा हो सकता है.