TensorFlow Lite के लिए जीपीयू प्रतिनिधि

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

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

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

जीपीयू एमएल ऑपरेशन से जुड़ी सहायता

TensorFlow ML जीपीयू का इस्तेमाल करके, 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.

जीपीयू से जुड़ी सहायता में आने वाली समस्याएं हल करना

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

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

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

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

नीचे दिए गए मॉडल, TensorFlow Lite की मदद से जीपीयू से तेज़ी से आगे बढ़ने के लिए बनाए गए हैं. इन्हें रेफ़रंस और जांच करने के लिए उपलब्ध कराया गया है:

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

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

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

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

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

जीपीयू से जुड़ी बेहतर सुविधा

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

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

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

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

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

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

  • कॉन्सटेंट टेंसर (जैसे कि वेट/बायस) को जीपीयू मेमोरी में एक बार डी-क्वांटेशन से हटा दिया जाता है. यह कार्रवाई तब होती है, जब TensorFlow Lite के लिए डेलिगेट को चालू किया गया हो.

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

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

जीपीयू प्रतिनिधि के ज़रिए इस सुविधा को चालू करने के बारे में जानकारी के लिए, यहां दी गई चीज़ें देखें:

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

जीपीयू डेलिगेट की सुविधा से, पहले से कंपाइल किए गए कर्नेल कोड और मॉडल के डेटा को क्रम से लोड किया जा सकता है. साथ ही, पिछली बार चलाए गए डेटा को डिस्क पर सेव किया जा सकता है. यह तरीका फिर से कंपाइल करने से बचता है और स्टार्टअप में लगने वाले समय को 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 जैसी लाइब्रेरी का इस्तेमाल करना होगा.