LiteRT के लिए, जीपीयू डेलिगेट

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

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

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

जीपीयू पर एमएल ऑपरेशन करने की सुविधा

LiteRT GPU डेलिगेट की मदद से, TensorFlow ML के कुछ ops को ही तेज़ी से प्रोसेस किया जा सकता है. डेलिगेट, 16-बिट और 32-बिट फ़्लोट प्रिसिशन में इन ऑपरेशनों के साथ काम करता है:

  • ADD
  • AVERAGE_POOL_2D
  • CONCATENATION
  • CONV_2D
  • DEPTHWISE_CONV_2D v1-2
  • EXP
  • FULLY_CONNECTED
  • LOGICAL_AND
  • LOGISTIC
  • LSTM v2 (Basic LSTM only)
  • MAX_POOL_2D
  • MAXIMUM
  • MINIMUM
  • MUL
  • PAD
  • PRELU
  • RELU
  • RELU6
  • RESHAPE
  • RESIZE_BILINEAR v1-3
  • SOFTMAX
  • STRIDED_SLICE
  • SUB
  • TRANSPOSE_CONV

डिफ़ॉल्ट रूप से, सभी ऑप सिर्फ़ वर्शन 1 पर काम करते हैं. क्वांटाइज़ेशन की सुविधा चालू करने पर, सही वर्शन चालू हो जाते हैं. उदाहरण के लिए, ADD v2.

जीपीयू सपोर्ट से जुड़ी समस्या हल करना

अगर कुछ ऑप्स, GPU डेलिगेट के साथ काम नहीं करते हैं, तो फ़्रेमवर्क, ग्राफ़ के सिर्फ़ एक हिस्से को GPU पर और बाकी हिस्से को CPU पर चलाएगा. सीपीयू/जीपीयू सिंक्रनाइज़ेशन की ज़्यादा लागत की वजह से, इस तरह के स्प्लिट एक्ज़ीक्यूशन मोड से अक्सर परफ़ॉर्मेंस धीमी हो जाती है. ऐसा तब होता है, जब पूरे नेटवर्क को सिर्फ़ सीपीयू पर चलाया जाता है. इस मामले में, ऐप्लिकेशन इस तरह की चेतावनी जनरेट करता है:

WARNING: op code #42 cannot be handled by this delegate.

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

मॉडल के उदाहरण

यहां दिए गए उदाहरण मॉडल, LiteRT के साथ जीपीयू ऐक्सेलरेटर का फ़ायदा पाने के लिए बनाए गए हैं. इन्हें सिर्फ़ रेफ़रंस और टेस्टिंग के लिए उपलब्ध कराया गया है:

जीपीयू के लिए ऑप्टिमाइज़ करना

LiteRT GPU डेलिगेट का इस्तेमाल करके, जीपीयू हार्डवेयर पर मॉडल चलाने के दौरान बेहतर परफ़ॉर्मेंस पाने के लिए, इन तकनीकों का इस्तेमाल किया जा सकता है:

  • रीशेप ऑपरेशन - कुछ ऐसे ऑपरेशन होते हैं जो सीपीयू पर तेज़ी से पूरे हो जाते हैं. हालांकि, मोबाइल डिवाइसों पर जीपीयू के लिए इनकी लागत ज़्यादा हो सकती है. रीशेप ऑपरेशन को चलाने में ज़्यादा समय लगता है. इनमें BATCH_TO_SPACE, SPACE_TO_BATCH, SPACE_TO_DEPTH वगैरह शामिल हैं. आपको रीशेप करने की कार्रवाइयों के इस्तेमाल की बारीकी से जांच करनी चाहिए. साथ ही, यह ध्यान रखना चाहिए कि इन्हें सिर्फ़ डेटा एक्सप्लोर करने या मॉडल के शुरुआती वर्शन के लिए लागू किया गया हो. इन्हें हटाने से, परफ़ॉर्मेंस में काफ़ी सुधार हो सकता है.

  • इमेज डेटा चैनल - जीपीयू पर, टेंसर डेटा को चार चैनलों में बांटा जाता है. इसलिए, [B,H,W,5] शेप वाले टेंसर पर की गई कैलकुलेशन, [B,H,W,8] शेप वाले टेंसर पर की गई कैलकुलेशन के बराबर होती है. हालांकि, यह [B,H,W,4] से काफ़ी कम होती है. अगर इस्तेमाल किया जा रहा कैमरा हार्डवेयर, RGBA में इमेज फ़्रेम के साथ काम करता है, तो चार चैनल वाला इनपुट देने की प्रोसेस काफ़ी तेज़ होती है. ऐसा इसलिए, क्योंकि इससे तीन चैनल वाले RGB से चार चैनल वाले RGBX में मेमोरी कॉपी करने की ज़रूरत नहीं पड़ती.

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

ऐडवांस जीपीयू सपोर्ट

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

क्वांटाइज़ किए गए मॉडल का इस्तेमाल करना

इस सेक्शन में बताया गया है कि जीपीयू डेलिगेट, 8-बिट क्वॉन्टाइज़्ड मॉडल को कैसे तेज़ करता है. इसमें यह भी शामिल है:

बेहतर परफ़ॉर्मेंस के लिए, ऐसे मॉडल इस्तेमाल करें जिनमें फ़्लोटिंग-पॉइंट इनपुट और आउटपुट टेंसर, दोनों हों.

यह कैसे काम करता है?

जीपीयू बैकएंड सिर्फ़ फ़्लोटिंग-पॉइंट एक्ज़ीक्यूशन के साथ काम करता है. इसलिए, हम क्वांटाइज़ किए गए मॉडल को ओरिजनल मॉडल का ‘फ़्लोटिंग-पॉइंट व्यू’ देकर चलाते हैं. बड़े लेवल पर, इसमें ये चरण शामिल होते हैं:

  • कॉन्स्टेंट टेंसर (जैसे कि वज़न/बायस) को GPU मेमोरी में एक बार डी-क्वांटाइज़ किया जाता है. यह कार्रवाई तब होती है, जब LiteRT के लिए डेलिगेट चालू होता है.

  • अगर जीपीयू प्रोग्राम के इनपुट और आउटपुट को 8-बिट में क्वांटाइज़ किया गया है, तो हर अनुमान के लिए उन्हें डी-क्वांटाइज़ और क्वांटाइज़ किया जाता है. यह कार्रवाई, LiteRT के ऑप्टिमाइज़ किए गए कर्नल का इस्तेमाल करके सीपीयू पर की जाती है.

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

जीपीयू डेलिगेट के साथ इस सुविधा को चालू करने के बारे में जानकारी के लिए, यहां जाएं:

सीरियलाइज़ेशन की मदद से, शुरू होने में लगने वाला समय कम करना

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

C++

    TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default();
    options.experimental_flags |= TFLITE_GPU_EXPERIMENTAL_FLAGS_ENABLE_SERIALIZATION;
    options.serialization_dir = kTmpDir;
    options.model_token = kModelToken;

    auto* delegate = TfLiteGpuDelegateV2Create(options);
    if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;

Java

    GpuDelegate delegate = new GpuDelegate(
      new GpuDelegate.Options().setSerializationParams(
        /* serializationDir= */ serializationDir,
        /* modelToken= */ modelToken));

    Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);

सीरियलाइज़ेशन की सुविधा का इस्तेमाल करते समय, पक्का करें कि आपका कोड लागू करने से जुड़े इन नियमों का पालन करता हो:

  • सीरियलाइज़ेशन डेटा को ऐसी डायरेक्ट्री में सेव करें जिसे अन्य ऐप्लिकेशन ऐक्सेस न कर पाएं. Android डिवाइसों पर, getCodeCacheDir() का इस्तेमाल करें. यह मौजूदा ऐप्लिकेशन के लिए निजी जगह की जानकारी देता है.
  • मॉडल टोकन, डिवाइस के लिए यूनीक होना चाहिए. farmhash::Fingerprint64 जैसी लाइब्रेरी का इस्तेमाल करके, मॉडल के डेटा से फ़िंगरप्रिंट जनरेट करके मॉडल टोकन का हिसाब लगाया जा सकता है.