Profiler का उपयोग करके TensorFlow के प्रदर्शन को अनुकूलित करें

यह मार्गदर्शिका दर्शाती है कि अपने TensorFlow मॉडल के प्रदर्शन को ट्रैक करने के लिए TensorFlow Profiler के साथ उपलब्ध टूल का उपयोग कैसे करें। आप सीखेंगे कि कैसे समझें कि आपका मॉडल होस्ट (सीपीयू), डिवाइस (जीपीयू), या होस्ट और डिवाइस दोनों के संयोजन पर कैसा प्रदर्शन करता है।

प्रोफाइलिंग आपके मॉडल में विभिन्न TensorFlow संचालन (ऑप्स) के हार्डवेयर संसाधन खपत (समय और मेमोरी) को समझने में मदद करती है और प्रदर्शन बाधाओं को हल करती है और अंततः, मॉडल को तेजी से निष्पादित करती है।

यह मार्गदर्शिका आपको प्रोफाइलर को स्थापित करने के तरीके, उपलब्ध विभिन्न टूल्स, प्रोफाइलर प्रदर्शन डेटा एकत्र करने के विभिन्न तरीकों और मॉडल प्रदर्शन को अनुकूलित करने के लिए कुछ अनुशंसित सर्वोत्तम प्रथाओं के बारे में बताएगी।

यदि आप क्लाउड टीपीयू पर अपने मॉडल के प्रदर्शन को प्रोफाइल करना चाहते हैं, तो क्लाउड टीपीयू गाइड देखें।

प्रोफाइलर और जीपीयू पूर्वापेक्षाएँ स्थापित करें

TensorBoard के लिए pip के साथ Profiler प्लगइन स्थापित करें। ध्यान दें कि Profiler को TensorFlow और TensorBoard (>=2.2) के नवीनतम संस्करणों की आवश्यकता होती है।

pip install -U tensorboard_plugin_profile

GPU पर प्रोफाइल करने के लिए, आपको यह करना होगा:

1. TensorFlow GPU समर्थन सॉफ़्टवेयर आवश्यकताओं पर सूचीबद्ध NVIDIA® GPU ड्राइवरों और CUDA® टूलकिट आवश्यकताओं को पूरा करें।

2. सुनिश्चित करें कि NVIDIA® CUDA® प्रोफाइलिंग टूल इंटरफेस (CUPTI) पथ पर मौजूद है:

   /sbin/ldconfig -N -v $(sed 's/:/ /g' <<< $LD_LIBRARY_PATH) | \
   grep libcupti
   

यदि आपके पास पथ पर CUPTI नहीं है, तो इसकी स्थापना निर्देशिका को $LD_LIBRARY_PATH पर्यावरण चर में चलाकर पहले से जोड़ें:

export LD_LIBRARY_PATH=/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH

फिर, यह सत्यापित करने के लिए कि CUPTI लाइब्रेरी मिल गई है, ऊपर ldconfig कमांड को फिर से चलाएँ।

विशेषाधिकार मुद्दों को हल करें

जब आप डॉकर वातावरण में या लिनक्स पर CUDA® टूलकिट के साथ प्रोफाइलिंग चलाते हैं, तो आप अपर्याप्त CUPTI विशेषाधिकारों ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ) से संबंधित समस्याओं का सामना कर सकते हैं। आप Linux पर इन मुद्दों को कैसे हल कर सकते हैं, इसके बारे में अधिक जानने के लिए NVIDIA डेवलपर डॉक्स पर जाएं।

डॉकर वातावरण में CUPTI विशेषाधिकार मुद्दों को हल करने के लिए, चलाएँ

docker run option '--privileged=true'

प्रोफाइलर उपकरण

TensorBoard में प्रोफाइल टैब से प्रोफाइलर तक पहुंचें, जो आपके द्वारा कुछ मॉडल डेटा पर कब्जा करने के बाद ही प्रकट होता है।

प्रदर्शन विश्लेषण में सहायता के लिए प्रोफाइलर के पास उपकरणों का चयन है:

• अवलोकन पृष्ठ
• इनपुट पाइपलाइन विश्लेषक
• TensorFlow आँकड़े
• ट्रेस व्यूअर
• GPU कर्नेल आँकड़े
• मेमोरी प्रोफाइल टूल
• पॉड व्यूअर

अवलोकन पृष्ठ

ओवरव्यू पृष्ठ एक शीर्ष स्तरीय दृश्य प्रदान करता है कि आपके मॉडल ने प्रोफ़ाइल चलाने के दौरान कैसा प्रदर्शन किया। यह पृष्ठ आपको आपके होस्ट और सभी उपकरणों के लिए एक समग्र अवलोकन पृष्ठ और आपके मॉडल प्रशिक्षण प्रदर्शन को बेहतर बनाने के लिए कुछ सुझाव दिखाता है। आप होस्ट ड्रॉपडाउन में अलग-अलग होस्ट भी चुन सकते हैं।

अवलोकन पृष्ठ डेटा को निम्नानुसार प्रदर्शित करता है:

• प्रदर्शन सारांश : आपके मॉडल प्रदर्शन का एक उच्च-स्तरीय सारांश प्रदर्शित करता है। प्रदर्शन सारांश में दो भाग होते हैं:

  1. चरण-समय विश्लेषण: औसत चरण समय को कई श्रेणियों में विभाजित करता है जहां समय व्यतीत होता है:

     • संकलन: गुठली को संकलित करने में लगने वाला समय।
     • इनपुट: इनपुट डेटा पढ़ने में लगने वाला समय।
     • आउटपुट: आउटपुट डेटा पढ़ने में लगने वाला समय।
     • कर्नेल लॉन्च: होस्ट द्वारा कर्नेल लॉन्च करने में लगने वाला समय
     • होस्ट गणना समय ..
     • डिवाइस-टू-डिवाइस संचार समय।
     • ऑन-डिवाइस गणना समय।
     • पाइथन ओवरहेड सहित अन्य सभी।

  2. डिवाइस कंप्यूट प्रिसीशन - डिवाइस कंप्यूट समय के प्रतिशत की रिपोर्ट करता है जो 16 और 32-बिट कंप्यूटेशंस का उपयोग करता है।

• चरण-समय ग्राफ़ : नमूना किए गए सभी चरणों पर डिवाइस चरण समय (मिलीसेकंड में) का ग्राफ़ प्रदर्शित करता है। प्रत्येक चरण को कई श्रेणियों (विभिन्न रंगों के साथ) में विभाजित किया जाता है जहाँ समय व्यतीत होता है। लाल क्षेत्र चरण समय के उस हिस्से से मेल खाता है जब डिवाइस मेजबान से इनपुट डेटा की प्रतीक्षा में निष्क्रिय बैठे थे। हरा क्षेत्र दिखाता है कि उपकरण वास्तव में कितने समय से काम कर रहा था।

• डिवाइस पर शीर्ष 10 TensorFlow संचालन (जैसे GPU) : सबसे लंबे समय तक चलने वाले ऑन-डिवाइस ऑप्स को प्रदर्शित करता है।

  प्रत्येक पंक्ति एक ऑप का सेल्फ़ टाइम (सभी ऑप्स द्वारा लिए गए समय के प्रतिशत के रूप में), संचयी समय, श्रेणी और नाम प्रदर्शित करती है।

• रन एनवायरनमेंट : मॉडल रन एनवायरनमेंट का एक उच्च-स्तरीय सारांश प्रदर्शित करता है जिसमें शामिल हैं:

  • उपयोग किए गए मेजबानों की संख्या।
  • डिवाइस प्रकार (जीपीयू / टीपीयू)।
  • डिवाइस कोर की संख्या।

• अगले चरण के लिए सिफारिश : जब कोई मॉडल इनपुट बाउंड होता है तो रिपोर्ट करता है और उन उपकरणों की सिफारिश करता है जिनका उपयोग आप मॉडल प्रदर्शन बाधाओं का पता लगाने और उन्हें हल करने के लिए कर सकते हैं।

इनपुट पाइपलाइन विश्लेषक

जब एक TensorFlow प्रोग्राम किसी फ़ाइल से डेटा पढ़ता है तो यह TensorFlow ग्राफ़ के शीर्ष पर एक पाइपलाइन तरीके से शुरू होता है। पढ़ने की प्रक्रिया को श्रृंखला में जुड़े कई डेटा प्रोसेसिंग चरणों में विभाजित किया जाता है, जहां एक चरण का आउटपुट अगले चरण का इनपुट होता है। डेटा पढ़ने की इस प्रणाली को इनपुट पाइपलाइन कहा जाता है।

फाइलों से रिकॉर्ड पढ़ने के लिए एक विशिष्ट पाइपलाइन में निम्नलिखित चरण होते हैं:

1. फ़ाइल पढ़ना।
2. फ़ाइल प्रीप्रोसेसिंग (वैकल्पिक)।
3. होस्ट से डिवाइस में फ़ाइल स्थानांतरण।

एक अक्षम इनपुट पाइपलाइन आपके आवेदन को गंभीर रूप से धीमा कर सकती है। एक एप्लिकेशन को इनपुट बाउंड माना जाता है जब वह इनपुट पाइपलाइन में समय का एक महत्वपूर्ण हिस्सा खर्च करता है। इनपुट पाइपलाइन विश्लेषक से प्राप्त अंतर्दृष्टि का उपयोग यह समझने के लिए करें कि इनपुट पाइपलाइन कहाँ अक्षम है।

इनपुट पाइपलाइन विश्लेषक आपको तुरंत बताता है कि क्या आपका प्रोग्राम इनपुट बाध्य है और इनपुट पाइपलाइन में किसी भी स्तर पर प्रदर्शन बाधाओं को डीबग करने के लिए आपको डिवाइस- और होस्ट-साइड विश्लेषण के माध्यम से चलता है।

अपने डेटा इनपुट पाइपलाइनों को अनुकूलित करने के लिए अनुशंसित सर्वोत्तम प्रथाओं के लिए इनपुट पाइपलाइन प्रदर्शन पर मार्गदर्शन की जाँच करें।

इनपुट पाइपलाइन डैशबोर्ड

इनपुट पाइपलाइन विश्लेषक खोलने के लिए, प्रोफ़ाइल चुनें, फिर टूल ड्रॉपडाउन से input_pipeline_analyzer चुनें।

डैशबोर्ड में तीन खंड होते हैं:

1. सारांश : समग्र इनपुट पाइपलाइन को इस जानकारी के साथ सारांशित करता है कि क्या आपका आवेदन इनपुट बाध्य है और यदि हां, तो कितना।
2. डिवाइस-साइड विश्लेषण : डिवाइस-साइड विश्लेषण परिणाम प्रदर्शित करता है, जिसमें डिवाइस चरण-समय और प्रत्येक चरण में कोर में इनपुट डेटा की प्रतीक्षा में बिताए गए डिवाइस समय की सीमा शामिल है।
3. मेजबान पक्ष विश्लेषण : मेजबान पक्ष पर एक विस्तृत विश्लेषण दिखाता है, जिसमें मेजबान पर इनपुट प्रसंस्करण समय का टूटना भी शामिल है।

इनपुट पाइपलाइन सारांश

सारांश रिपोर्ट करता है कि क्या आपका प्रोग्राम होस्ट से इनपुट की प्रतीक्षा में बिताए गए डिवाइस समय का प्रतिशत प्रस्तुत करके इनपुट बाउंड है। यदि आप एक मानक इनपुट पाइपलाइन का उपयोग कर रहे हैं जिसे इंस्ट्रूमेंट किया गया है, तो टूल रिपोर्ट करता है कि अधिकांश इनपुट प्रोसेसिंग समय कहाँ व्यतीत होता है।

डिवाइस-साइड विश्लेषण

डिवाइस-साइड विश्लेषण डिवाइस पर खर्च किए गए समय बनाम होस्ट पर और होस्ट से इनपुट डेटा की प्रतीक्षा में कितना डिवाइस समय व्यतीत किया गया था, इस पर अंतर्दृष्टि प्रदान करता है।

1. चरण संख्या के विरुद्ध प्लॉट किया गया चरण समय : नमूना किए गए सभी चरणों पर डिवाइस चरण समय (मिलीसेकंड में) का ग्राफ़ प्रदर्शित करता है। प्रत्येक चरण को कई श्रेणियों (विभिन्न रंगों के साथ) में विभाजित किया जाता है जहाँ समय व्यतीत होता है। लाल क्षेत्र चरण समय के उस हिस्से से मेल खाता है जब डिवाइस मेजबान से इनपुट डेटा की प्रतीक्षा में निष्क्रिय बैठे थे। हरा क्षेत्र दिखाता है कि उपकरण वास्तव में कितने समय से काम कर रहा था।
2. चरण समय आँकड़े : उपकरण चरण समय के औसत, मानक विचलन और सीमा ([न्यूनतम, अधिकतम]) की रिपोर्ट करता है।

मेजबान-पक्ष विश्लेषण

होस्ट-साइड विश्लेषण कई श्रेणियों में होस्ट पर इनपुट प्रोसेसिंग समय ( tf.data API ops पर बिताया गया समय) के टूटने की रिपोर्ट करता है:

• मांग पर फाइलों से डेटा पढ़ना : कैशिंग, प्रीफेचिंग और इंटरलीविंग के बिना फाइलों से डेटा पढ़ने में लगने वाला समय।
• फ़ाइलों से डेटा को पहले से पढ़ना : कैशिंग, प्रीफ़ेचिंग और इंटरलीविंग सहित फ़ाइलों को पढ़ने में लगने वाला समय।
• डेटा प्रीप्रोसेसिंग : प्रीप्रोसेसिंग ऑप्स, जैसे इमेज डीकंप्रेसन पर लगने वाला समय।
• डिवाइस में स्थानांतरित किए जाने वाले डेटा को कतारबद्ध करना: डिवाइस में डेटा स्थानांतरित करने से पहले डेटा को एक फ़ीड कतार में डालने में लगने वाला समय।

निष्पादन समय के अनुसार अलग-अलग इनपुट ऑप्स और उनकी श्रेणियों के आंकड़ों का निरीक्षण करने के लिए इनपुट ऑप सांख्यिकी का विस्तार करें।

निम्नलिखित जानकारी वाली प्रत्येक प्रविष्टि के साथ एक स्रोत डेटा तालिका दिखाई देगी:

1. इनपुट सेशन : इनपुट सेशन का TensorFlow op नाम दिखाता है।
2. गणना : प्रोफाइलिंग अवधि के दौरान सेशन निष्पादन के उदाहरणों की कुल संख्या को दर्शाता है।
3. कुल समय (एमएस में) : उन उदाहरणों में से प्रत्येक पर खर्च किए गए कुल समय को दर्शाता है।
4. कुल समय% : इनपुट प्रोसेसिंग में खर्च किए गए कुल समय के एक अंश के रूप में एक ऑप पर खर्च किए गए कुल समय को दर्शाता है।
5. कुल सेल्फ़ टाइम (ms में) : इनमें से प्रत्येक उदाहरण पर बिताए गए सेल्फ़ टाइम का संचयी योग दिखाता है। यहां सेल्फ टाइम फंक्शन बॉडी के अंदर बिताए गए समय को मापता है, फंक्शन में बिताए गए समय को छोड़कर।
6. कुल स्व समय% । इनपुट प्रोसेसिंग पर खर्च किए गए कुल समय के एक अंश के रूप में कुल स्व-समय को दर्शाता है।
7. श्रेणी । इनपुट सेशन की प्रोसेसिंग कैटेगरी दिखाता है।

TensorFlow आँकड़े

TensorFlow Stats टूल प्रत्येक TensorFlow op (op) के प्रदर्शन को प्रदर्शित करता है जिसे एक प्रोफाइलिंग सत्र के दौरान होस्ट या डिवाइस पर निष्पादित किया जाता है।

उपकरण दो पैन में प्रदर्शन जानकारी प्रदर्शित करता है:

• ऊपरी फलक अधिकतम चार पाई चार्ट प्रदर्शित करता है:

  1. मेजबान पर प्रत्येक सेशन के स्व-निष्पादन समय का वितरण।
  2. मेजबान पर प्रत्येक ऑप प्रकार के स्व-निष्पादन समय का वितरण।
  3. डिवाइस पर प्रत्येक ऑप के स्व-निष्पादन समय का वितरण।
  4. डिवाइस पर प्रत्येक ऑप प्रकार के स्व-निष्पादन समय का वितरण।

• निचला फलक एक तालिका दिखाता है जो प्रत्येक ऑप के लिए एक पंक्ति और प्रत्येक प्रकार के डेटा के लिए एक कॉलम के साथ TensorFlow ops के बारे में डेटा की रिपोर्ट करता है (कॉलम के शीर्षक पर क्लिक करके कॉलम सॉर्ट करें)। इस तालिका से डेटा को CSV फ़ाइल के रूप में निर्यात करने के लिए ऊपरी फलक के दाईं ओर CSV के रूप में निर्यात करें बटन पर क्लिक करें।

  ध्यान दें कि:

  • अगर किसी ऑप्स में चाइल्ड ऑप्स हैं:

    • किसी ऑप के कुल "संचित" समय में चाइल्ड ऑप्स के अंदर बिताया गया समय शामिल होता है।
    • किसी ऑप के कुल "स्वयं" समय में चाइल्ड ऑप्स के अंदर बिताया गया समय शामिल नहीं होता है।

  • यदि कोई ऑप होस्ट पर निष्पादित होता है:

    • ऑप द्वारा किए गए डिवाइस पर कुल सेल्फ़-टाइम का प्रतिशत 0 होगा।
    • इस ऑप तक और इसमें शामिल डिवाइस पर कुल सेल्फ़-टाइम का संचयी प्रतिशत 0 होगा।

  • यदि कोई ऑप डिवाइस पर निष्पादित होता है:

    • इस ऑप द्वारा किए गए होस्ट पर कुल सेल्फ़-टाइम का प्रतिशत 0 होगा।
    • होस्ट तक और इस ऑप को शामिल करने पर कुल सेल्फ़-टाइम का संचयी प्रतिशत 0 होगा।

आप पाई चार्ट और तालिका में निष्क्रिय समय को शामिल या बहिष्कृत करना चुन सकते हैं।

ट्रेस व्यूअर

ट्रेस व्यूअर एक समयरेखा प्रदर्शित करता है जो दिखाता है:

• आपके TensorFlow मॉडल द्वारा निष्पादित किए गए ऑप्स की अवधि
• सिस्टम के किस हिस्से (होस्ट या डिवाइस) ने एक सेशन को अंजाम दिया। आमतौर पर, होस्ट इनपुट संचालन को निष्पादित करता है, प्रशिक्षण डेटा को प्रीप्रोसेस करता है और इसे डिवाइस में स्थानांतरित करता है, जबकि डिवाइस वास्तविक मॉडल प्रशिक्षण को निष्पादित करता है।

ट्रेस व्यूअर आपको अपने मॉडल में प्रदर्शन समस्याओं की पहचान करने की अनुमति देता है, फिर उन्हें हल करने के लिए कदम उठाता है। उदाहरण के लिए, उच्च स्तर पर, आप यह पहचान सकते हैं कि इनपुट या मॉडल प्रशिक्षण में अधिकांश समय लग रहा है या नहीं। नीचे ड्रिल करके, आप पहचान सकते हैं कि कौन से ऑप्स को निष्पादित करने में सबसे अधिक समय लगता है। ध्यान दें कि ट्रेस व्यूअर प्रति डिवाइस 1 मिलियन ईवेंट तक सीमित है।

ट्रेस व्यूअर इंटरफ़ेस

जब आप ट्रेस व्यूअर खोलते हैं, तो यह आपका सबसे हाल का रन प्रदर्शित करता हुआ दिखाई देता है:

इस स्क्रीन में निम्नलिखित मुख्य तत्व हैं:

1. टाइमलाइन पेन : ऑप्स दिखाता है कि डिवाइस और होस्ट समय के साथ निष्पादित होते हैं।
2. विवरण फलक : टाइमलाइन फलक में चयनित ऑप्स के लिए अतिरिक्त जानकारी दिखाता है।

टाइमलाइन फलक में निम्नलिखित तत्व होते हैं:

1. टॉप बार : इसमें विभिन्न सहायक नियंत्रण होते हैं।
2. समय अक्ष : ट्रेस की शुरुआत के सापेक्ष समय दिखाता है।
3. अनुभाग और ट्रैक लेबल : प्रत्येक अनुभाग में एकाधिक ट्रैक होते हैं और बाईं ओर एक त्रिभुज होता है जिसे आप अनुभाग को विस्तृत और संक्षिप्त करने के लिए क्लिक कर सकते हैं। सिस्टम में हर प्रोसेसिंग एलिमेंट के लिए एक सेक्शन होता है।
4. टूल चयनकर्ता : ट्रेस व्यूअर के साथ बातचीत करने के लिए ज़ूम, पैन, सेलेक्ट और टाइमिंग जैसे विभिन्न टूल शामिल हैं। समय अंतराल को चिह्नित करने के लिए टाइमिंग टूल का उपयोग करें।
5. ईवेंट : ये उस समय को दिखाते हैं जिसके दौरान एक ऑप निष्पादित किया गया था या मेटा-इवेंट की अवधि, जैसे प्रशिक्षण चरण।

अनुभाग और ट्रैक

ट्रेस व्यूअर में निम्नलिखित खंड होते हैं:

• प्रत्येक डिवाइस नोड के लिए एक अनुभाग , जिसे डिवाइस चिप की संख्या और चिप के भीतर डिवाइस नोड के साथ लेबल किया गया है (उदाहरण के लिए, /device:GPU:0 (pid 0) )। प्रत्येक डिवाइस नोड अनुभाग में निम्नलिखित ट्रैक होते हैं:
  • चरण : डिवाइस पर चल रहे प्रशिक्षण चरणों की अवधि दिखाता है
  • TensorFlow Ops : डिवाइस पर निष्पादित ऑप्स दिखाता है
  • XLA Ops : डिवाइस पर चलने वाले XLA संचालन (ऑप्स) को दिखाता है यदि XLA उपयोग किया गया कंपाइलर है (प्रत्येक TensorFlow op का अनुवाद एक या कई XLA ऑप्स में किया जाता है। XLA कंपाइलर XLA ऑप्स को डिवाइस पर चलने वाले कोड में अनुवादित करता है)।
• होस्ट मशीन के सीपीयू पर चलने वाले थ्रेड्स के लिए एक सेक्शन, जिसे "होस्ट थ्रेड्स" लेबल किया जाता है। अनुभाग में प्रत्येक CPU थ्रेड के लिए एक ट्रैक होता है। ध्यान दें कि आप अनुभाग लेबल के साथ प्रदर्शित जानकारी को अनदेखा कर सकते हैं।

आयोजन

समयरेखा के भीतर की घटनाओं को अलग-अलग रंगों में प्रदर्शित किया जाता है; रंगों का स्वयं कोई विशेष अर्थ नहीं होता है।

ट्रेस व्यूअर आपके TensorFlow प्रोग्राम में Python फ़ंक्शन कॉल के निशान भी प्रदर्शित कर सकता है। यदि आप tf.profiler.experimental.start API का उपयोग करते हैं, तो आप प्रोफाइलिंग शुरू करते समय ProfilerOptions nametuple का उपयोग करके पायथन ट्रेसिंग को सक्षम कर सकते हैं। वैकल्पिक रूप से, यदि आप प्रोफाइलिंग के लिए सैंपलिंग मोड का उपयोग करते हैं, तो आप कैप्चर प्रोफाइल डायलॉग में ड्रॉपडाउन विकल्पों का उपयोग करके ट्रेसिंग के स्तर का चयन कर सकते हैं।

GPU कर्नेल आँकड़े

यह उपकरण प्रत्येक GPU त्वरित कर्नेल के लिए प्रदर्शन आँकड़े और आरंभिक ऑप दिखाता है।

उपकरण दो पैन में जानकारी प्रदर्शित करता है:

• ऊपरी फलक एक पाई चार्ट प्रदर्शित करता है जो CUDA कर्नेल को दिखाता है जिसमें उच्चतम कुल समय बीत चुका है।

• निचला फलक प्रत्येक अद्वितीय कर्नेल-ऑप जोड़ी के लिए निम्न डेटा वाली तालिका प्रदर्शित करता है:

  • कर्नेल-ऑप जोड़ी द्वारा समूहीकृत कुल बीता हुआ GPU अवधि के अवरोही क्रम में एक रैंक।
  • लॉन्च किए गए कर्नेल का नाम।
  • कर्नेल द्वारा उपयोग किए जाने वाले GPU रजिस्टरों की संख्या।
  • बाइट्स में उपयोग की जाने वाली साझा (स्थिर + गतिशील साझा) मेमोरी का कुल आकार।
  • ब्लॉक आयाम को blockDim.x, blockDim.y, blockDim.z रूप में व्यक्त किया जाता है।
  • ग्रिड आयाम को gridDim.x, gridDim.y, gridDim.z रूप में व्यक्त किया जाता है।
  • क्या op Tensor Cores का उपयोग करने के योग्य है।
  • क्या कर्नेल में Tensor Core निर्देश हैं।
  • इस कर्नेल को लॉन्च करने वाले ऑप का नाम।
  • इस कर्नेल-ऑप जोड़ी की घटनाओं की संख्या।
  • माइक्रोसेकंड में कुल बीता हुआ GPU समय।
  • माइक्रोसेकंड में औसत बीता हुआ GPU समय।
  • माइक्रोसेकंड में न्यूनतम बीता हुआ GPU समय।
  • माइक्रोसेकंड में अधिकतम बीता हुआ GPU समय।

मेमोरी प्रोफाइल टूल

मेमोरी प्रोफाइल टूल प्रोफाइलिंग अंतराल के दौरान आपके डिवाइस के मेमोरी उपयोग की निगरानी करता है। आप इस उपकरण का उपयोग इसके लिए कर सकते हैं:

• मेमोरी (ओओएम) के चरम मेमोरी उपयोग और TensorFlow ops के लिए संबंधित मेमोरी आवंटन को इंगित करके डिबग आउट ऑफ़ मेमोरी (OOM) समस्याएँ। आप OOM समस्याओं को भी डीबग कर सकते हैं जो आपके द्वारा बहु-किरायेदारी अनुमान चलाने पर उत्पन्न हो सकती हैं।
• डीबग मेमोरी फ़्रेग्मेंटेशन समस्याएँ।

मेमोरी प्रोफाइल टूल तीन खंडों में डेटा प्रदर्शित करता है:

1. मेमोरी प्रोफाइल सारांश
2. मेमोरी टाइमलाइन ग्राफ
3. मेमोरी ब्रेकडाउन टेबल

मेमोरी प्रोफाइल सारांश

यह खंड आपके TensorFlow प्रोग्राम की मेमोरी प्रोफाइल का एक उच्च-स्तरीय सारांश प्रदर्शित करता है जैसा कि नीचे दिखाया गया है:

मेमोरी प्रोफाइल सारांश में छह क्षेत्र हैं:

1. मेमोरी आईडी : ड्रॉपडाउन जो सभी उपलब्ध डिवाइस मेमोरी सिस्टम को सूचीबद्ध करता है। ड्रॉपडाउन से वह मेमोरी सिस्टम चुनें जिसे आप देखना चाहते हैं।
2. #आवंटन : प्रोफाइलिंग अंतराल के दौरान किए गए स्मृति आवंटन की संख्या।
3. #Deallocation : प्रोफाइलिंग अंतराल में मेमोरी डीलोकेशन की संख्या
4. मेमोरी क्षमता : आपके द्वारा चुने गए मेमोरी सिस्टम की कुल क्षमता (जीआईबी में)।
5. पीक हीप यूसेज : जब से मॉडल चलना शुरू हुआ है, तब से पीक मेमोरी यूसेज (जीआईबी में)।
6. पीक मेमोरी यूसेज : प्रोफाइलिंग इंटरवल में पीक मेमोरी यूसेज (जीआईबी में)। इस फ़ील्ड में निम्नलिखित उप-फ़ील्ड हैं:
   1. टाइमस्टैम्प : टाइमलाइन ग्राफ़ पर उस समय का टाइमस्टैम्प जब पीक मेमोरी उपयोग हुआ।
   2. स्टैक आरक्षण : स्टैक पर आरक्षित मेमोरी की मात्रा (जीआईबी में)।
   3. ढेर आवंटन : ढेर पर आवंटित स्मृति की मात्रा (जीआईबी में)।
   4. फ्री मेमोरी : फ्री मेमोरी की मात्रा (जीआईबी में)। मेमोरी कैपेसिटी स्टैक रिजर्वेशन, हीप एलोकेशन और फ्री मेमोरी का कुल योग है।
   5. विखंडन : विखंडन का प्रतिशत (कम बेहतर है)। इसकी गणना प्रतिशत के रूप में की जाती है (1 - Size of the largest chunk of free memory / Total free memory) ।

मेमोरी टाइमलाइन ग्राफ

यह खंड स्मृति उपयोग (जीआईबी में) और विखंडन का प्रतिशत बनाम समय (एमएस में) का एक प्लॉट प्रदर्शित करता है।

X-अक्ष रूपरेखा अंतराल की समयरेखा (ms में) का प्रतिनिधित्व करता है। बाईं ओर वाई-अक्ष स्मृति उपयोग (जीआईबी में) का प्रतिनिधित्व करता है और दाईं ओर वाई-अक्ष विखंडन के प्रतिशत का प्रतिनिधित्व करता है। एक्स-अक्ष पर समय के प्रत्येक बिंदु पर, कुल मेमोरी को तीन श्रेणियों में विभाजित किया जाता है: स्टैक (लाल रंग में), हीप (नारंगी में), और मुक्त (हरे रंग में)। स्मृति आवंटन/डीलोकेशन घटनाओं के बारे में विवरण देखने के लिए एक विशिष्ट टाइमस्टैम्प पर होवर करें, जैसा कि नीचे दिया गया है:

पॉप-अप विंडो निम्नलिखित जानकारी प्रदर्शित करती है:

• टाइमस्टैम्प (एमएस) : टाइमलाइन पर चयनित घटना का स्थान।
• घटना : घटना का प्रकार (आवंटन या डीलोकेशन)।
• request_size(GiBs) : अनुरोधित मेमोरी की मात्रा। यह डीललोकेशन इवेंट के लिए एक ऋणात्मक संख्या होगी।
• आवंटन_साइज (जीआईबी) : आवंटित स्मृति की वास्तविक मात्रा। यह डीललोकेशन इवेंट के लिए एक ऋणात्मक संख्या होगी।
• tf_op : TensorFlow op जो आवंटन/डीलोकेशन का अनुरोध करता है।
• step_id : प्रशिक्षण चरण जिसमें यह घटना हुई।
• क्षेत्र_प्रकार : डेटा इकाई प्रकार जिसके लिए यह आवंटित मेमोरी है। संभावित मान temp के लिए अस्थायी हैं, सक्रियण और ग्रेडिएंट के लिए output , और वज़न और स्थिरांक के लिए persist / dynamic हैं।
• data_type : टेंसर तत्व प्रकार (उदाहरण के लिए, 8-बिट अहस्ताक्षरित पूर्णांक के लिए uint8)।
• tensor_shape : टेंसर का आकार आवंटित/निरस्त किया जा रहा है।
• memory_in_use(GiBs) : कुल मेमोरी जो इस समय उपयोग में है।

मेमोरी ब्रेकडाउन टेबल

यह तालिका प्रोफाइलिंग अंतराल में अधिकतम स्मृति उपयोग के बिंदु पर सक्रिय स्मृति आवंटन दिखाती है।

प्रत्येक TensorFlow Op के लिए एक पंक्ति होती है और प्रत्येक पंक्ति में निम्नलिखित कॉलम होते हैं:

• Op Name : TensorFlow op का नाम।
• आवंटन आकार (जीआईबी) : इस ऑप को आवंटित स्मृति की कुल मात्रा।
• अनुरोधित आकार (GiBs) : इस ऑपरेशन के लिए अनुरोधित मेमोरी की कुल मात्रा।
• घटनाएँ : इस ऑप के लिए आवंटन की संख्या।
• क्षेत्र प्रकार : डेटा इकाई प्रकार जिसके लिए यह आवंटित मेमोरी है। संभावित मान temp के लिए अस्थायी हैं, सक्रियण और ग्रेडिएंट के लिए output , और वज़न और स्थिरांक के लिए persist / dynamic हैं।
• डेटा प्रकार : टेंसर तत्व प्रकार।
• आकार : आवंटित टेंसर का आकार।

पॉड व्यूअर

पॉड व्यूअर टूल सभी कर्मचारियों के प्रशिक्षण चरण के टूटने को दिखाता है।

• चरण संख्या का चयन करने के लिए ऊपरी फलक में एक स्लाइडर होता है।
• निचला फलक एक स्टैक्ड कॉलम चार्ट प्रदर्शित करता है। यह एक-दूसरे के ऊपर रखी गई चरण-समय की टूटी-फूटी श्रेणियों का एक उच्च स्तरीय दृश्य है। प्रत्येक स्टैक्ड कॉलम एक अद्वितीय कार्यकर्ता का प्रतिनिधित्व करता है।
• जब आप किसी स्टैक्ड कॉलम पर होवर करते हैं, तो बाईं ओर का कार्ड स्टेप ब्रेकडाउन के बारे में अधिक विवरण दिखाता है।

tf.डेटा अड़चन विश्लेषण

tf.data अड़चन विश्लेषण उपकरण स्वचालित रूप से आपके प्रोग्राम में tf.data इनपुट पाइपलाइनों में बाधाओं का पता लगाता है और उन्हें ठीक करने के तरीके के बारे में सिफारिशें प्रदान करता है। यह प्लेटफॉर्म (CPU/GPU/TPU) की परवाह किए बिना tf.data का उपयोग करके किसी भी प्रोग्राम के साथ काम करता है। इसका विश्लेषण और सिफारिशें इस गाइड पर आधारित हैं।

यह इन चरणों का पालन करके एक अड़चन का पता लगाता है:

1. सबसे अधिक इनपुट बाउंड होस्ट खोजें।
2. tf.data इनपुट पाइपलाइन का सबसे धीमा निष्पादन खोजें।
3. प्रोफाइलर ट्रेस से इनपुट पाइपलाइन ग्राफ का पुनर्निर्माण करें।
4. इनपुट पाइपलाइन ग्राफ़ में क्रांतिक पथ ज्ञात कीजिए।
5. एक अड़चन के रूप में महत्वपूर्ण पथ पर सबसे धीमे परिवर्तन की पहचान करें।

UI को तीन खंडों में विभाजित किया गया है: प्रदर्शन विश्लेषण सारांश , सभी इनपुट पाइपलाइनों का सारांश और इनपुट पाइपलाइन ग्राफ़ ।

प्रदर्शन विश्लेषण सारांश

यह खंड विश्लेषण का सारांश प्रदान करता है। यह प्रोफ़ाइल में पाई गई धीमी tf.data इनपुट पाइपलाइनों पर रिपोर्ट करता है। यह खंड सबसे अधिक इनपुट बाउंड होस्ट और अधिकतम विलंबता के साथ इसकी सबसे धीमी इनपुट पाइपलाइन को भी दिखाता है। सबसे महत्वपूर्ण बात यह है कि यह पहचानता है कि इनपुट पाइपलाइन का कौन सा हिस्सा अड़चन है और इसे कैसे ठीक किया जाए। अड़चन की जानकारी इटरेटर प्रकार और उसके लंबे नाम के साथ प्रदान की जाती है।

tf.data इटरेटर का लंबा नाम कैसे पढ़ें

एक लंबा नाम Iterator::<Dataset_1>::...::<Dataset_n> के रूप में स्वरूपित किया गया है। लंबे नाम में, <Dataset_n> पुनरावर्तक प्रकार से मेल खाता है और लंबे नाम के अन्य डेटासेट डाउनस्ट्रीम परिवर्तनों का प्रतिनिधित्व करते हैं।

उदाहरण के लिए, निम्नलिखित इनपुट पाइपलाइन डेटासेट पर विचार करें:

dataset = tf.data.Dataset.range(10).map(lambda x: x).repeat(2).batch(5)

उपरोक्त डेटासेट से इटरेटर्स के लिए लंबे नाम होंगे:

सभी इनपुट पाइपलाइनों का सारांश

यह खंड सभी मेजबानों में सभी इनपुट पाइपलाइनों का सारांश प्रदान करता है। आमतौर पर एक इनपुट पाइपलाइन होती है। वितरण रणनीति का उपयोग करते समय, एक होस्ट इनपुट पाइपलाइन होती है जो प्रोग्राम के tf.data कोड को चलाती है और कई डिवाइस इनपुट पाइपलाइन होस्ट इनपुट पाइपलाइन से डेटा प्राप्त करती है और इसे डिवाइस में स्थानांतरित करती है।

प्रत्येक इनपुट पाइपलाइन के लिए, यह इसके निष्पादन समय के आंकड़े दिखाता है। यदि कॉल 50 μs से अधिक समय लेती है, तो उसे धीमे के रूप में गिना जाता है।

इनपुट पाइपलाइन ग्राफ

यह खंड निष्पादन समय की जानकारी के साथ इनपुट पाइपलाइन ग्राफ दिखाता है। आप किस होस्ट और इनपुट पाइपलाइन को देखने के लिए चुनने के लिए "होस्ट" और "इनपुट पाइपलाइन" का उपयोग कर सकते हैं। इनपुट पाइपलाइन के निष्पादन को निष्पादन समय के अनुसार अवरोही क्रम में क्रमबद्ध किया जाता है जिसे आप रैंक ड्रॉपडाउन का उपयोग करके चुन सकते हैं।

क्रिटिकल पाथ पर नोड्स में बोल्ड आउटलाइन हैं। अड़चन नोड, जो कि महत्वपूर्ण पथ पर सबसे लंबे समय तक सेल्फ टाइम वाला नोड है, की रूपरेखा लाल होती है। अन्य गैर-महत्वपूर्ण नोड्स में धूसर धराशायी रूपरेखा होती है।

प्रत्येक नोड में, प्रारंभ समय निष्पादन के प्रारंभ समय को इंगित करता है। एक ही नोड को कई बार निष्पादित किया जा सकता है, उदाहरण के लिए, यदि इनपुट पाइपलाइन में Batch ऑप है। यदि इसे कई बार निष्पादित किया जाता है, तो यह पहले निष्पादन का प्रारंभ समय है।

कुल अवधि निष्पादन की दीवार का समय है। यदि इसे कई बार निष्पादित किया जाता है, तो यह सभी निष्पादनों के दीवार समय का योग है।

सेल्फ़ टाइम अपने तत्काल चाइल्ड नोड्स के साथ ओवरलैप किए गए समय के बिना कुल समय है।

"# कॉल" इनपुट पाइपलाइन निष्पादित होने की संख्या है।

प्रदर्शन डेटा एकत्र करें

TensorFlow Profiler आपके TensorFlow मॉडल की होस्ट गतिविधियों और GPU के निशान एकत्र करता है। आप प्रोग्रामेटिक मोड या सैंपलिंग मोड के माध्यम से प्रदर्शन डेटा एकत्र करने के लिए प्रोफाइलर को कॉन्फ़िगर कर सकते हैं।

प्रोफाइलिंग एपीआई

प्रोफाइलिंग करने के लिए आप निम्नलिखित एपीआई का उपयोग कर सकते हैं।

• TensorBoard Keras Callback ( tf.keras.callbacks.TensorBoard ) का उपयोग करके प्रोग्रामेटिक मोड

  # Profile from batches 10 to 15
  tb_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
                                               profile_batch='10, 15')
  
  # Train the model and use the TensorBoard Keras callback to collect
  # performance profiling data
  model.fit(train_data,
            steps_per_epoch=20,
            epochs=5,
            callbacks=[tb_callback])
  

• tf.profiler फ़ंक्शन API का उपयोग करके प्रोग्रामेटिक मोड

  tf.profiler.experimental.start('logdir')
  # Train the model here
  tf.profiler.experimental.stop()
  

• संदर्भ प्रबंधक का उपयोग करके प्रोग्रामेटिक मोड

  with tf.profiler.experimental.Profile('logdir'):
      # Train the model here
      pass
  

• नमूनाकरण मोड: अपने TensorFlow मॉडल रन के साथ gRPC सर्वर शुरू करने के लिए tf.profiler.experimental.server.start का उपयोग करके ऑन-डिमांड प्रोफाइलिंग करें। जीआरपीसी सर्वर शुरू करने और अपना मॉडल चलाने के बाद, आप TensorBoard प्रोफ़ाइल प्लगइन में कैप्चर प्रोफ़ाइल बटन के माध्यम से एक प्रोफ़ाइल कैप्चर कर सकते हैं। यदि यह पहले से नहीं चल रहा है, तो TensorBoard इंस्टेंस लॉन्च करने के लिए ऊपर प्रोफाइलर स्थापित करें अनुभाग में स्क्रिप्ट का उपयोग करें।

  उदाहरण के तौर पे,

  # Start a profiler server before your model runs.
  tf.profiler.experimental.server.start(6009)
  # (Model code goes here).
  #  Send a request to the profiler server to collect a trace of your model.
  tf.profiler.experimental.client.trace('grpc://localhost:6009',
                                        'gs://your_tb_logdir', 2000)
  

  एकाधिक श्रमिकों की रूपरेखा के लिए एक उदाहरण:

  # E.g. your worker IP addresses are 10.0.0.2, 10.0.0.3, 10.0.0.4, and you
  # would like to profile for a duration of 2 seconds.
  tf.profiler.experimental.client.trace(
      'grpc://10.0.0.2:8466,grpc://10.0.0.3:8466,grpc://10.0.0.4:8466',
      'gs://your_tb_logdir',
      2000)
  

निर्दिष्ट करने के लिए कैप्चर प्रोफ़ाइल संवाद का उपयोग करें:

• प्रोफ़ाइल सेवा URL या TPU नामों की अल्पविराम-सीमांकित सूची।
• एक प्रोफाइलिंग अवधि।
• डिवाइस, होस्ट और पायथन फ़ंक्शन कॉल ट्रेसिंग का स्तर।
• यदि आप पहली बार में असफल होते हैं तो आप कितनी बार चाहते हैं कि प्रोफाइलर प्रोफाइल कैप्चर करने का पुनः प्रयास करे।

प्रोफाइलिंग कस्टम प्रशिक्षण लूप

अपने TensorFlow कोड में कस्टम ट्रेनिंग लूप को प्रोफाइल करने के लिए, प्रोफाइलर के लिए चरण सीमाओं को चिह्नित करने के लिए tf.profiler.experimental.Trace API के साथ ट्रेनिंग लूप को इंस्ट्रूमेंट करें।

name तर्क का उपयोग चरण नामों के लिए उपसर्ग के रूप में किया जाता है, चरण नामों में step_num कीवर्ड तर्क जोड़ा जाता है, और _r कीवर्ड तर्क इस ट्रेस घटना को प्रोफाइलर द्वारा एक चरण घटना के रूप में संसाधित करता है।

उदाहरण के तौर पे,

for step in range(NUM_STEPS):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_data = next(dataset)
        train_step(train_data)

यह Profiler के चरण-आधारित प्रदर्शन विश्लेषण को सक्षम करेगा और चरण ईवेंट को ट्रेस व्यूअर में दिखाने का कारण बनेगा।

सुनिश्चित करें कि आप इनपुट पाइपलाइन के सटीक विश्लेषण के लिए tf.profiler.experimental.Trace संदर्भ में डेटासेट इटरेटर को शामिल करते हैं।

नीचे दिया गया कोड स्निपेट एक विरोधी पैटर्न है:

for step, train_data in enumerate(dataset):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_step(train_data)

प्रोफाइलिंग उपयोग के मामले

प्रोफाइलर चार अलग-अलग कुल्हाड़ियों के साथ कई उपयोग के मामलों को कवर करता है। कुछ संयोजन वर्तमान में समर्थित हैं और अन्य भविष्य में जोड़े जाएंगे। कुछ उपयोग के मामले हैं:

• स्थानीय बनाम रिमोट प्रोफाइलिंग : ये आपके प्रोफाइलिंग वातावरण को स्थापित करने के दो सामान्य तरीके हैं। स्थानीय प्रोफाइलिंग में, प्रोफाइलिंग एपीआई को उसी मशीन पर बुलाया जाता है जिसे आपका मॉडल निष्पादित कर रहा है, उदाहरण के लिए, जीपीयू के साथ एक स्थानीय वर्कस्टेशन। रिमोट प्रोफाइलिंग में, प्रोफाइलिंग एपीआई को एक अलग मशीन पर बुलाया जाता है जहां से आपका मॉडल निष्पादित हो रहा है, उदाहरण के लिए, क्लाउड टीपीयू पर।
• कई कर्मचारियों की प्रोफाइलिंग : आप TensorFlow की वितरित प्रशिक्षण क्षमताओं का उपयोग करते समय कई मशीनों को प्रोफाइल कर सकते हैं।
• हार्डवेयर प्लेटफॉर्म : प्रोफाइल सीपीयू, जीपीयू और टीपीयू।

नीचे दी गई तालिका ऊपर बताए गए TensorFlow- समर्थित उपयोग मामलों का एक त्वरित अवलोकन प्रदान करती है:

इष्टतम मॉडल प्रदर्शन के लिए सर्वोत्तम अभ्यास

इष्टतम प्रदर्शन प्राप्त करने के लिए अपने TensorFlow मॉडल के लिए लागू निम्नलिखित अनुशंसाओं का उपयोग करें।

सामान्य तौर पर, डिवाइस पर सभी परिवर्तन करें और सुनिश्चित करें कि आप अपने प्लेटफॉर्म के लिए cuDNN और Intel MKL जैसे पुस्तकालयों के नवीनतम संगत संस्करण का उपयोग करते हैं।

इनपुट डेटा पाइपलाइन का अनुकूलन करें

अपने डेटा इनपुट पाइपलाइन को अनुकूलित करने के लिए [#input_pipeline_analyzer] से डेटा का उपयोग करें। एक कुशल डेटा इनपुट पाइपलाइन डिवाइस के निष्क्रिय समय को कम करके आपके मॉडल निष्पादन की गति में अत्यधिक सुधार कर सकती है। अपने डेटा इनपुट पाइपलाइन को अधिक कुशल बनाने के लिए tf.data API गाइड और नीचे के साथ बेहतर प्रदर्शन में विस्तृत सर्वोत्तम प्रथाओं को शामिल करने का प्रयास करें।

• सामान्य तौर पर, किसी भी ऑप्स को समानांतर करना जिसे क्रमिक रूप से निष्पादित करने की आवश्यकता नहीं है, डेटा इनपुट पाइपलाइन को महत्वपूर्ण रूप से अनुकूलित कर सकता है।

• कई मामलों में, यह कुछ कॉलों के क्रम को बदलने या तर्कों को इस तरह ट्यून करने में मदद करता है कि यह आपके मॉडल के लिए सबसे अच्छा काम करता है। इनपुट डेटा पाइपलाइन का अनुकूलन करते समय, प्रशिक्षण के बिना केवल डेटा लोडर को बेंचमार्क करें और अनुकूलन के प्रभाव को स्वतंत्र रूप से मापने के लिए बैकप्रोपेगेशन कदम उठाएं।

• इनपुट पाइपलाइन एक प्रदर्शन बाधा है या नहीं यह जांचने के लिए सिंथेटिक डेटा के साथ अपना मॉडल चलाने का प्रयास करें।

• बहु-जीपीयू प्रशिक्षण के लिए tf.data.Dataset.shard का उपयोग करें। सुनिश्चित करें कि आप थ्रूपुट में कटौती को रोकने के लिए इनपुट लूप में बहुत जल्दी शार्प करते हैं। TFRecords के साथ काम करते समय, सुनिश्चित करें कि आपने TFRecords की सूची को शार्प किया है न कि TFRecords की सामग्री को।

• num_parallel_calls का उपयोग करके tf.data.AUTOTUNE के मान को गतिशील रूप से सेट करके कई ऑप्स को समानांतर करें।

• tf.data.Dataset.from_generator के उपयोग को सीमित करने पर विचार करें क्योंकि यह शुद्ध TensorFlow ops की तुलना में धीमा है।

• tf.py_function के उपयोग को सीमित करने पर विचार करें क्योंकि इसे क्रमबद्ध नहीं किया जा सकता है और वितरित TensorFlow में चलाने के लिए समर्थित नहीं है।

• इनपुट पाइपलाइन में स्थिर अनुकूलन को नियंत्रित करने के लिए tf.data.Options का उपयोग करें।

अपनी इनपुट पाइपलाइन को अनुकूलित करने के बारे में अधिक मार्गदर्शन के लिए tf.data प्रदर्शन विश्लेषण मार्गदर्शिका भी पढ़ें।

डेटा वृद्धि का अनुकूलन करें

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

NVIDIA® डाली का उपयोग करें

कुछ उदाहरणों में, जैसे कि जब आपके पास एक उच्च GPU से CPU अनुपात वाला सिस्टम होता है, तो उपरोक्त सभी अनुकूलन CPU चक्रों की सीमाओं के कारण डेटा लोडर में बाधाओं को समाप्त करने के लिए पर्याप्त नहीं हो सकते हैं।

यदि आप कंप्यूटर विज़न और ऑडियो डीप लर्निंग एप्लिकेशन के लिए NVIDIA® GPU का उपयोग कर रहे हैं, तो डेटा पाइपलाइन में तेजी लाने के लिए डेटा लोडिंग लाइब्रेरी ( DALI ) का उपयोग करने पर विचार करें।

समर्थित DALI ऑप्स की सूची के लिए NVIDIA® DALI: संचालन दस्तावेज़ीकरण देखें।

थ्रेडिंग और समानांतर निष्पादन का उपयोग करें

उन्हें तेजी से निष्पादित करने के लिए tf.config.threading API के साथ कई CPU थ्रेड्स पर ऑप्स चलाएं।

TensorFlow डिफ़ॉल्ट रूप से स्वचालित रूप से समानांतरवाद थ्रेड्स की संख्या सेट करता है। TensorFlow ops चलाने के लिए उपलब्ध थ्रेड पूल उपलब्ध CPU थ्रेड्स की संख्या पर निर्भर करता है।

tf.config.threading.set_intra_op_parallelism_threads का उपयोग करके एकल ऑप के लिए अधिकतम समानांतर गति को नियंत्रित करें। ध्यान दें कि यदि आप समानांतर में एकाधिक ऑप्स चलाते हैं, तो वे सभी उपलब्ध थ्रेड पूल साझा करेंगे।

यदि आपके पास स्वतंत्र गैर-अवरुद्ध ऑप्स हैं (ग्राफ़ पर उनके बीच कोई निर्देशित पथ नहीं है), तो उपलब्ध थ्रेड पूल का उपयोग करके उन्हें समवर्ती रूप से चलाने के लिए tf.config.threading.set_inter_op_parallelism_threads का उपयोग करें।

विविध

NVIDIA® GPU पर छोटे मॉडल के साथ काम करते समय, आप tf.compat.v1.ConfigProto.force_gpu_compatible=True सेट कर सकते हैं ताकि सभी CPU टेंसर को CUDA पिन की गई मेमोरी के साथ आवंटित किया जा सके ताकि मॉडल के प्रदर्शन को महत्वपूर्ण बढ़ावा मिल सके। हालांकि, अज्ञात/बहुत बड़े मॉडल के लिए इस विकल्प का उपयोग करते समय सावधानी बरतें क्योंकि यह होस्ट (सीपीयू) के प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है।

डिवाइस के प्रदर्शन में सुधार

ऑन-डिवाइस TensorFlow मॉडल प्रदर्शन को अनुकूलित करने के लिए यहां और GPU प्रदर्शन अनुकूलन मार्गदर्शिका में विस्तृत सर्वोत्तम प्रथाओं का पालन करें।

यदि आप NVIDIA GPU का उपयोग कर रहे हैं, तो GPU और मेमोरी उपयोग को CSV फ़ाइल में चलाकर लॉग इन करें:

nvidia-smi
--query-gpu=utilization.gpu,utilization.memory,memory.total,
memory.free,memory.used --format=csv

डेटा लेआउट कॉन्फ़िगर करें

चैनल जानकारी (जैसे छवियों) वाले डेटा के साथ काम करते समय, डेटा लेआउट प्रारूप को अंतिम चैनल पसंद करने के लिए अनुकूलित करें (एनसीएचडब्ल्यू पर एनएचडब्ल्यूसी)।

चैनल-अंतिम डेटा प्रारूप टेंसर कोर उपयोग में सुधार करते हैं और विशेष रूप से एएमपी के साथ युग्मित होने पर विशेष रूप से दृढ़ मॉडल में महत्वपूर्ण प्रदर्शन सुधार प्रदान करते हैं। NCHW डेटा लेआउट अभी भी Tensor Cores द्वारा संचालित किए जा सकते हैं, लेकिन स्वचालित ट्रांसपोज़ ऑप्स के कारण अतिरिक्त ओवरहेड पेश करते हैं।

आप tf.keras.layers.Conv2D , tf.keras.layers.Conv3D , और tf.keras.layers.RandomRotation जैसी परतों के लिए data_format="channels_last" सेट करके NHWC लेआउट को प्राथमिकता देने के लिए डेटा लेआउट को अनुकूलित कर सकते हैं।

केरस बैकएंड एपीआई के लिए डिफ़ॉल्ट डेटा लेआउट प्रारूप सेट करने के लिए tf.keras.backend.set_image_data_format का उपयोग करें।

L2 कैश को अधिकतम करें

When working with NVIDIA® GPUs, execute the code snippet below before the training loop to max out the L2 fetch granularity to 128 bytes.

import ctypes

_libcudart = ctypes.CDLL('libcudart.so')
# Set device limit on the current device
# cudaLimitMaxL2FetchGranularity = 0x05
pValue = ctypes.cast((ctypes.c_int*1)(), ctypes.POINTER(ctypes.c_int))
_libcudart.cudaDeviceSetLimit(ctypes.c_int(0x05), ctypes.c_int(128))
_libcudart.cudaDeviceGetLimit(pValue, ctypes.c_int(0x05))
assert pValue.contents.value == 128

Configure GPU thread usage

The GPU thread mode decides how GPU threads are used.

Set the thread mode to gpu_private to make sure that preprocessing does not steal all the GPU threads. This will reduce the kernel launch delay during training. You can also set the number of threads per GPU. Set these values using environment variables.

import os

os.environ['TF_GPU_THREAD_MODE']='gpu_private'
os.environ['TF_GPU_THREAD_COUNT']='1'

Configure GPU memory options

In general, increase the batch size and scale the model to better utilize GPUs and get higher throughput. Note that increasing the batch size will change the model's accuracy so the model needs to be scaled by tuning hyperparameters like the learning rate to meet the target accuracy.

Also, use tf.config.experimental.set_memory_growth to allow GPU memory to grow to prevent all the available memory from being fully allocated to ops that require only a fraction of the memory. This allows other processes which consume GPU memory to run on the same device.

To learn more, check out the Limiting GPU memory growth guidance in the GPU guide to learn more.

Miscellaneous

• Increase the training mini-batch size (number of training samples used per device in one iteration of the training loop) to the maximum amount that fits without an out of memory (OOM) error on the GPU. Increasing the batch size impacts the model's accuracy—so make sure you scale the model by tuning hyperparameters to meet the target accuracy.

• Disable reporting OOM errors during tensor allocation in production code. Set report_tensor_allocations_upon_oom=False in tf.compat.v1.RunOptions .

• For models with convolution layers, remove bias addition if using batch normalization. Batch normalization shifts values by their mean and this removes the need to have a constant bias term.

• Use TF Stats to find out how efficiently on-device ops run.

• Use tf.function to perform computations and optionally, enable the jit_compile=True flag ( tf.function(jit_compile=True ). To learn more, go to Use XLA tf.function .

• Minimize host Python operations between steps and reduce callbacks. Calculate metrics every few steps instead of at every step.

• Keep the device compute units busy.

• Send data to multiple devices in parallel.

• Consider using 16-bit numerical representations , such as fp16 —the half-precision floating point format specified by IEEE—or the Brain floating-point bfloat16 format.

अतिरिक्त संसाधन

• The TensorFlow Profiler: Profile model performance tutorial with Keras and TensorBoard where you can apply the advice in this guide.
• The Performance profiling in TensorFlow 2 talk from the TensorFlow Dev Summit 2020.
• The TensorFlow Profiler demo from the TensorFlow Dev Summit 2020.

Known limitations

Profiling multiple GPUs on TensorFlow 2.2 and TensorFlow 2.3

TensorFlow 2.2 and 2.3 support multiple GPU profiling for single host systems only; multiple GPU profiling for multi-host systems is not supported. To profile multi-worker GPU configurations, each worker has to be profiled independently. From TensorFlow 2.4 multiple workers can be profiled using the tf.profiler.experimental.client.trace API.

CUDA® Toolkit 10.2 or later is required to profile multiple GPUs. As TensorFlow 2.2 and 2.3 support CUDA® Toolkit versions only up to 10.1, you need to create symbolic links to libcudart.so.10.1 and libcupti.so.10.1 :

sudo ln -s /usr/local/cuda/lib64/libcudart.so.10.2 /usr/local/cuda/lib64/libcudart.so.10.1
sudo ln -s /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.2 /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.1