LiteRT डेलिगेट

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

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

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

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

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

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

प्लैटफ़ॉर्म के हिसाब से डेलिगेट

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

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

iOS

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

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

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

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

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

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

इवैलुएशन के लिए टूल

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

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

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

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

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

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

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

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

टास्क के आधार पर आकलन

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

• टॉप-के ऐक््यूरेसी के साथ ILSVRC 2012 (इमेज क्लासिफ़िकेशन)

• COCO ऑब्जेक्ट डिटेक्शन (बाउंडिंग बॉक्स के साथ) मीडियन ऐवरेज प्रेसिज़न (एमएपी) के साथ

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

• ImageNet इमेज क्लासिफ़िकेशन (ज़्यादा जानकारी) * COCO ऑब्जेक्ट डिटेक्शन (ज़्यादा जानकारी)

नीचे दिए गए उदाहरण में, 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 तक की टॉप-के मेट्रिक की सूची है:

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

टास्क से जुड़ी जानकारी के बिना आकलन करना

जिन कामों के लिए डिवाइस पर जांच करने वाला कोई टूल उपलब्ध नहीं है या अगर आपको कस्टम मॉडल के साथ एक्सपेरिमेंट करना है, तो LiteRT में Inference Diff टूल उपलब्ध है. (Android, 64-बिट ARM बाइनरी आर्किटेक्चर बाइनरी यहां)

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

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

इसके लिए, टूल रैंडम गॉसियन डेटा जनरेट करता है और इसे दो 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-10 = 10 जितना ज़्यादा हो सकता है.