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

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

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

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

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

TensorFlow ML की कार्रवाइयों या ops की कुछ सीमाएं हैं, जो TensorFlow Lite जीपीयू डेलिगेट के ज़रिए की जा सकती हैं. डेलिगेट, नीचे दिए गए ऑपरेशन 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 पर काम करते हैं. संख्या तय करने की सुविधा चालू करने से सही वर्शन चालू हो जाते हैं, उदाहरण के लिए, v2 जोड़ें.

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

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

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

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

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

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

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

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

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

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

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

जीपीयू के लिए बेहतर सहायता

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

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

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

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

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

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

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

  • जीपीयू प्रोग्राम में इनपुट और आउटपुट, अगर 8-बिट की संख्या को मापा जाता है, तो हर अनुमान के लिए उनकी संख्या को कम और क्वांट किया जाता है. यह कार्रवाई CPU पर, 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 जैसी लाइब्रेरी का इस्तेमाल करके, मॉडल डेटा से फ़िंगरप्रिंट जनरेट करके, मॉडल टोकन का हिसाब लगाया जा सकता है.