TensorFlow Lite के डेलिगेट

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

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

वहीं दूसरी ओर, ज़्यादातर आधुनिक मोबाइल फ़ोन में चिप होते हैं, जो भारी कामों के बीच बेहतर तरीके से काम करते हैं. न्यूरल नेटवर्क के ऑपरेशन के लिए इनका इस्तेमाल करने से इंतज़ार का समय और ऊर्जा की बचत करने में काफ़ी फ़ायदा होता है. उदाहरण के लिए, GPU, इंतज़ार के समय में पांच गुना स्पीडअप दे सकता है, जबकि Qualcomm® Hexagon DSP ने हमारे एक्सपेरिमेंट में ऊर्जा की खपत को 75% तक कम करने का तरीका दिखाया है.

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

जिन लोगों को आपके ईमेल खाते का ऐक्सेस दिया गया है उनके साथ रनटाइम

किसी प्रतिनिधि को चुनना

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

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

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

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

iOS

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

मॉडल टाइप के हिसाब से ऐक्सेस देने वाले लोग

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

मॉडल टाइप जीपीयू एनएनएपीआई हेक्सागन 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% आईएलएसवीआरसी इमेज क्लासिफ़िकेशन में टॉप-5 सुधार).

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

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

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

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

नीचे दिए गए उदाहरण में, इमेज की कैटगरी तय करने की प्रक्रिया के बारे में बताया गया है. इसमें Pixel 4 पर, NNAPI, Google के Edge-TPU का इस्तेमाल करता है:

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_nnapi=true \
  --nnapi_accelerator_name=google-edgetpu

अनुमानित आउटपुट, 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 के पास Inifence Diff टूल होता है. (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 से अलग होते हैं.

ध्यान दें कि इन संख्याओं को समझने के लिए, मॉडल की अच्छी समझ होनी चाहिए. साथ ही, हर आउटपुट टेंसर क्या बताता है. अगर यह एक आसान रिग्रेशन है, जिससे किसी तरह का स्कोर या एम्बेड करने का पता चलता है, तो अंतर कम होना चाहिए (नहीं तो यह डेलिगेट की गड़बड़ी की वजह है). हालांकि, एसएसडी मॉडल से मिले 'डिटेक्शन क्लास' जैसे आउटपुट को समझना थोड़ा मुश्किल होता है. मिसाल