TensorFlow Profiler के साथ TensorFlow GPU के प्रदर्शन को अनुकूलित करें

अवलोकन

यह मार्गदर्शिका आपको बताएगी कि अपने GPU में अंतर्दृष्टि प्राप्त करने और अधिकतम प्रदर्शन प्राप्त करने के लिए TensorBoard के साथ TensorFlow Profiler का उपयोग कैसे करें, और जब आपके एक या अधिक GPU का उपयोग कम हो जाए तो डीबग करें।

यदि आप प्रोफाइलर के लिए नए हैं:

ध्यान रखें कि GPU को ऑफ़लोडिंग कंप्यूटेशंस हमेशा फायदेमंद नहीं हो सकता है, खासकर छोटे मॉडल के लिए। इसके कारण ओवरहेड हो सकता है:

  • होस्ट (सीपीयू) और डिवाइस (जीपीयू) के बीच डेटा ट्रांसफर; तथा
  • विलंबता शामिल होने के कारण जब होस्ट GPU कर्नेल लॉन्च करता है।

प्रदर्शन अनुकूलन कार्यप्रवाह

यह मार्गदर्शिका बताती है कि एकल GPU से शुरू होने वाली प्रदर्शन समस्याओं को कैसे डिबग करना है, फिर एकाधिक GPU के साथ एकल होस्ट पर जाना है।

निम्नलिखित क्रम में प्रदर्शन समस्याओं को डीबग करने की अनुशंसा की जाती है:

  1. एक GPU पर प्रदर्शन को ऑप्टिमाइज़ और डीबग करें:
    1. जांचें कि क्या इनपुट पाइपलाइन एक अड़चन है।
    2. एक GPU के प्रदर्शन को डीबग करें।
    3. मिश्रित परिशुद्धता (साथ सक्षम fp16 (float16)) और वैकल्पिक रूप से सक्षम XLA
  2. मल्टी-जीपीयू सिंगल होस्ट पर प्रदर्शन को ऑप्टिमाइज़ और डीबग करें।

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

GPUs पर performant कोड प्राप्त करने के लिए एक आधार रेखा के रूप में, इस गाइड आप पहले से ही उपयोग कर रहे हैं मान लिया गया tf.function । Keras Model.compile और Model.fit एपीआई का उपयोग करेंगे tf.function हुड के नीचे स्वचालित रूप से। जब साथ एक कस्टम प्रशिक्षण पाश लिख tf.GradientTape , का उल्लेख tf.function के साथ बेहतर प्रदर्शन कैसे सक्षम करने के लिए पर tf.function रों।

अगले खंड प्रदर्शन बाधाओं को पहचानने और ठीक करने में मदद करने के लिए उपरोक्त प्रत्येक परिदृश्य के लिए सुझाए गए दृष्टिकोणों पर चर्चा करते हैं।

1. एक GPU पर प्रदर्शन का अनुकूलन करें

एक आदर्श मामले में, आपके प्रोग्राम में उच्च GPU उपयोग, न्यूनतम CPU (होस्ट) से GPU (डिवाइस) संचार होना चाहिए, और इनपुट पाइपलाइन से कोई ओवरहेड नहीं होना चाहिए।

प्रदर्शन का विश्लेषण करने में पहला कदम एक GPU के साथ चलने वाले मॉडल के लिए एक प्रोफ़ाइल प्राप्त करना है।

TensorBoard के प्रोफाइलर अवलोकन पृष्ठ -which की कैसे अपने मॉडल एक प्रोफ़ाइल के दौरान प्रदर्शन एक शीर्ष स्तर देखने से पता चलता है कि कैसे दूर अपने कार्यक्रम आदर्श परिदृश्य से है की एक विचार रन कर सकते हैं प्रदान करते हैं।

TensorFlow Profiler Overview Page

सिंहावलोकन पृष्ठ पर ध्यान देने योग्य प्रमुख संख्याएँ हैं:

  1. वास्तविक डिवाइस निष्पादन से कितना चरण समय है
  2. डिवाइस बनाम होस्ट पर रखे गए ऑप्स का प्रतिशत
  3. कितने कर्नेल का उपयोग fp16

इष्टतम प्रदर्शन प्राप्त करने का अर्थ है इन तीनों मामलों में इन संख्याओं को अधिकतम करना। अपने कार्यक्रम के बारे में गहराई से समझने के लिए, आप TensorBoard के प्रोफाइलर से परिचित होने की आवश्यकता होगी ट्रेस दर्शक । नीचे दिए गए अनुभाग कुछ सामान्य ट्रेस व्यूअर पैटर्न दिखाते हैं जिन्हें आपको प्रदर्शन बाधाओं का निदान करते समय देखना चाहिए।

नीचे एक GPU पर चल रहे मॉडल ट्रेस व्यू की एक छवि है। TensorFlow नाम स्कोप और TensorFlow ऑप्स वर्गों से, आप फॉरवर्ड पास, नुकसान समारोह, पिछड़े पास / ढाल गणना, और अनुकूलक वजन अद्यतन की तरह मॉडल के विभिन्न भागों की पहचान कर सकते हैं। तुम भी ऑप्स प्रत्येक स्ट्रीम के बगल में GPU पर चल रहा है, जो उल्लेख CUDA धाराओं को हो सकता है। प्रत्येक स्ट्रीम का उपयोग विशिष्ट कार्यों के लिए किया जाता है। इस का पता लगाने में, स्ट्रीम # 118 गणना कर्नेल और डिवाइस करने वाली डिवाइस कॉपी लांच करने के लिए प्रयोग किया जाता है। स्ट्रीम # 119 मेजबान करने वाली डिवाइस से कॉपी के लिए प्रयोग किया जाता है और स्ट्रीम # 120 मेजबान प्रतिलिपि करने के लिए डिवाइस के लिए।

नीचे दिया गया ट्रेस एक निष्पादक मॉडल की सामान्य विशेषताओं को दर्शाता है।

image

उदाहरण के लिए, GPU गणना समय (स्ट्रीम # 118) बहुत कम अंतराल के साथ "व्यस्त" लग रहा है। वहाँ उपकरण के लिए मेजबान से कम से कम प्रतियां (स्ट्रीम # 119) और डिवाइस से मेजबान (स्ट्रीम # 120) के लिए, साथ ही चरणों के बीच कम से कम अंतराल हैं। जब आप अपने प्रोग्राम के लिए प्रोफाइलर चलाते हैं, तो हो सकता है कि आप अपने ट्रेस व्यू में इन आदर्श विशेषताओं की पहचान करने में सक्षम न हों। इस गाइड के बाकी हिस्सों में सामान्य परिदृश्य शामिल हैं और उन्हें कैसे ठीक किया जाए।

1. इनपुट पाइपलाइन डीबग करें

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

image

यदि आपकी इनपुट-पाइपलाइन चरणबद्ध समय में महत्वपूर्ण योगदान देती है तो आप निम्नलिखित संभावित कार्रवाई कर सकते हैं:

  • आप उपयोग कर सकते हैं tf.data विशिष्ट गाइड कैसे अपने इनपुट पाइपलाइन डिबग करने के लिए सीखने के लिए।
  • यह जांचने का एक और त्वरित तरीका है कि क्या इनपुट पाइपलाइन अड़चन है, बेतरतीब ढंग से उत्पन्न इनपुट डेटा का उपयोग करना है जिसे किसी पूर्व-प्रसंस्करण की आवश्यकता नहीं है। यहाँ एक उदाहरण है एक ResNet मॉडल के लिए इस तकनीक का उपयोग करने का। यदि इनपुट पाइपलाइन इष्टतम है, तो आपको वास्तविक डेटा और जेनरेट किए गए यादृच्छिक/सिंथेटिक डेटा के साथ समान प्रदर्शन का अनुभव करना चाहिए। सिंथेटिक डेटा मामले में एकमात्र ओवरहेड इनपुट डेटा कॉपी के कारण होगा जिसे फिर से प्रीफ़ेच और अनुकूलित किया जा सकता है।

इसके अलावा, का उल्लेख इनपुट डेटा पाइपलाइन अनुकूलित करने

2. एक GPU के प्रदर्शन को डीबग करें

ऐसे कई कारक हैं जो कम GPU उपयोग में योगदान कर सकते हैं। नीचे कुछ परिदृश्यों सामान्यतः मनाया जब पर देख रहे हैं पता लगाने दर्शक और संभावित समाधानों।

1. चरणों के बीच अंतराल का विश्लेषण करें

जब आपका प्रोग्राम बेहतर तरीके से नहीं चल रहा होता है तो एक सामान्य अवलोकन प्रशिक्षण चरणों के बीच अंतराल होता है। नीचे दिए गए ट्रेस दृश्य की छवि में, चरण 8 और 9 के बीच एक बड़ा अंतर है, जिसका अर्थ है कि उस समय के दौरान GPU निष्क्रिय है।

image

यदि आपका ट्रेस व्यूअर चरणों के बीच बड़े अंतराल दिखाता है, तो यह इस बात का संकेत हो सकता है कि आपका प्रोग्राम इनपुट बाउंड है। उस स्थिति में यदि आपने पहले से ऐसा नहीं किया है तो आपको अपनी इनपुट पाइपलाइन डीबग करने पर पिछले अनुभाग का संदर्भ लेना चाहिए।

हालांकि, एक अनुकूलित इनपुट पाइपलाइन के साथ भी, सीपीयू थ्रेड विवाद के कारण आप अभी भी एक चरण के अंत और दूसरे की शुरुआत के बीच अंतराल प्राप्त कर सकते हैं। tf.data पाइपलाइन प्रसंस्करण parallelize करने पृष्ठभूमि धागे का उपयोग करता है। ये थ्रेड प्रत्येक चरण की शुरुआत में होने वाली GPU होस्ट-साइड गतिविधि में हस्तक्षेप कर सकते हैं, जैसे डेटा कॉपी करना या GPU संचालन शेड्यूल करना।

आप जो कार्यक्रम GPU पर इन ऑप्स मेजबान की ओर, पर बड़े अंतराल नोटिस, तो आप वातावरण चर सेट कर सकते हैं TF_GPU_THREAD_MODE=gpu_private । यह सुनिश्चित करता है कि GPU कर्नेल अपनी समर्पित धागे से शुरू किया जाता है, और पीछे कतारबद्ध नहीं मिलता tf.data काम करते हैं।

चरणों के बीच अंतराल को भी बाहर का मीट्रिक गणना, Keras कॉलबैक, या ऑप्स के कारण हो सकता tf.function कि मेजबान पर रन। इन ऑप्स का प्रदर्शन उतना अच्छा नहीं है जितना कि TensorFlow ग्राफ़ के अंदर ऑप्स का। इसके अतिरिक्त, इनमें से कुछ ऑप सीपीयू पर चलते हैं और जीपीयू से आगे और पीछे टेंसर कॉपी करते हैं।

यदि अपनी इनपुट पाइपलाइन को ऑप्टिमाइज़ करने के बाद भी आपको ट्रेस व्यूअर में चरणों के बीच अंतराल दिखाई देता है, तो आपको चरणों के बीच मॉडल कोड को देखना चाहिए और जांचना चाहिए कि क्या कॉलबैक/मेट्रिक्स को अक्षम करने से प्रदर्शन में सुधार होता है। इन ऑप्स के कुछ विवरण ट्रेस व्यूअर (डिवाइस और होस्ट साइड दोनों) पर भी हैं। इस परिदृश्य में सिफारिश प्रत्येक चरण के बजाय निश्चित संख्या में चरणों के बाद निष्पादित करके इन ऑप्स के ओवरहेड को परिशोधित करना है। का उपयोग करते समय compile में विधि tf.keras एपीआई, की स्थापना experimental_steps_per_execution यह स्वचालित रूप से करता है झंडा। कस्टम प्रशिक्षण छोरों, उपयोग के लिए tf.while_loop

2. उच्च उपकरण उपयोग प्राप्त करें

1. छोटे GPU कर्नेल और होस्ट कर्नेल लॉन्च में देरी

होस्ट GPU पर चलाने के लिए कर्नेल को कतारबद्ध करता है, लेकिन GPU पर वास्तव में कर्नेल निष्पादित होने से पहले एक विलंबता (लगभग 20-40 μs) शामिल होती है। एक आदर्श स्थिति में, होस्ट GPU पर पर्याप्त कर्नेल इस तरह से लगाता है कि GPU अपना अधिकांश समय निष्पादित करने में व्यतीत करता है, बजाय इसके कि होस्ट पर अधिक कर्नेल लगाने के लिए प्रतीक्षा की जाए।

प्रोफाइलर के अवलोकन पृष्ठ TensorBoard शो पर कितना समय GPU वजह से लांच कर्नेल के लिए मेजबान पर इंतजार करने के लिए बेकार था। नीचे दी गई छवि में, GPU कर्नेल के लॉन्च होने की प्रतीक्षा में लगभग 10% चरण समय के लिए निष्क्रिय है।

image

ट्रेस दर्शक इस एक ही कार्यक्रम से पता चलता है कर्नेल जहां मेजबान GPU पर व्यस्त शुभारंभ कर्नेल है के बीच छोटे अंतराल के लिए।

image

GPU पर बहुत सारे छोटे ऑप्स लॉन्च करके (उदाहरण के लिए, स्केलर ऐड की तरह), हो सकता है कि होस्ट GPU के साथ तालमेल न बिठाए। TensorFlow आँकड़े 2.77 सेकंड लेने के एक ही प्रोफ़ाइल शो 126,224 एमयूएल के संचालन के लिए TensorBoard में उपकरण। इस प्रकार, प्रत्येक कर्नेल लगभग २१.९ μs है, जो बहुत छोटा है (लगभग उसी समय के रूप में लॉन्च विलंबता के रूप में) और संभावित रूप से होस्ट कर्नेल लॉन्च विलंब में परिणाम हो सकता है।

image

यदि आपका ट्रेस दर्शक शो कई छोटे, आप कर सकते हैं छवि में ऊपर की तरह GPU पर ऑप्स के बीच अंतराल:

  • छोटे टेंसरों को संयोजित करें और वेक्टरकृत ऑप्स का उपयोग करें या प्रत्येक लॉन्च किए गए कर्नेल को अधिक काम करने के लिए बड़े बैच आकार का उपयोग करें, जो GPU को अधिक समय तक व्यस्त रखेगा।
  • सुनिश्चित करें कि आप उपयोग कर रहे हैं tf.function TensorFlow रेखांकन बनाने के लिए, ताकि आप एक शुद्ध उत्सुक मोड में ऑप्स नहीं चल रहे हैं। आप उपयोग कर रहे हैं Model.fit (के रूप में के साथ एक कस्टम प्रशिक्षण पाश करने का विरोध tf.GradientTape , तो) tf.keras.Model.compile स्वचालित रूप से आप के लिए यह करना होगा।
  • फ्यूज के साथ XLA का उपयोग कर कर्नेल tf.function(jit_compile=True) या ऑटो क्लस्टरिंग। अधिक जानकारी के लिए जाने के लिए मिश्रित परिशुद्धता और XLA सक्षम नीचे उच्च प्रदर्शन प्राप्त करने के XLA सक्षम करने के लिए कैसे जानने के लिए अनुभाग। यह सुविधा उच्च डिवाइस उपयोग को जन्म दे सकती है।
2. TensorFlow op प्लेसमेंट

प्रोफाइलर अवलोकन पृष्ठ से पता चलता है आप डिवाइस बनाम मेजबान पर रखा ऑप्स का प्रतिशत (आप भी देख कर विशिष्ट ऑप्स की नियुक्ति की पुष्टि कर सकते ट्रेस दर्शक नीचे छवि में। की तरह, आप मेजबान पर ऑप्स का प्रतिशत चाहते हैं डिवाइस की तुलना में बहुत छोटा होना।

image

आदर्श रूप से, अधिकांश कंप्यूट इंटेंसिव ऑप्स को GPU पर रखा जाना चाहिए।

पता लगाने के लिए उपकरणों के संचालन और अपने मॉडल के tensors के लिए, सेट आवंटित कर रहे हैं tf.debugging.set_log_device_placement(True) अपने कार्यक्रम के पहले बयान के रूप में।

ध्यान दें कि कुछ मामलों में, आप एक सेशन से किसी विशेष उपकरण, इसके कार्यान्वयन इस हालत को ओवरराइड हो सकता है पर रखा जा करने के लिए निर्दिष्ट भले ही (उदाहरण: tf.unique )। यहां तक कि एक GPU प्रशिक्षण के लिए, इस तरह के रूप में एक वितरण रणनीति, निर्दिष्ट करने tf.distribute.OneDeviceStrategy , अपने डिवाइस पर ऑप्स के अधिक नियतात्मक नियुक्ति हो सकती है।

GPU पर अधिकांश ऑप्स रखने का एक कारण होस्ट और डिवाइस के बीच अत्यधिक मेमोरी कॉपी को रोकना है (होस्ट और डिवाइस के बीच मॉडल इनपुट/आउटपुट डेटा के लिए मेमोरी कॉपी अपेक्षित हैं)। अत्यधिक नकल का एक उदाहरण GPU पर नीचे का पता लगाने दृश्य में दर्शाया गया है # 167 धाराओं, # 168 और # 169।

image

ये प्रतियां कभी-कभी प्रदर्शन को नुकसान पहुंचा सकती हैं यदि वे GPU कर्नेल को निष्पादित करने से रोकती हैं। मेमोरी में आपरेशन कॉपी ट्रेस दर्शक ऑप्स है कि इन की नकल की tensors के स्रोत हैं के बारे में अधिक जानकारी नहीं है, लेकिन यह हमेशा एक सेशन के साथ एक memCopy संबद्ध करने के लिए आसान नहीं हो सकता है। इन मामलों में, यह जांचने के लिए आस-पास के ऑप्स को देखना मददगार होता है कि मेमोरी कॉपी हर चरण में एक ही स्थान पर होती है या नहीं।

3. GPU पर अधिक कुशल गुठली

एक बार जब आपके प्रोग्राम का GPU उपयोग स्वीकार्य हो जाता है, तो अगला कदम Tensor Cores या फ़्यूज़िंग ऑप्स का उपयोग करके GPU कर्नेल की दक्षता बढ़ाने पर विचार करना है।

1. टेंसर कोर का उपयोग करें

आधुनिक NVIDIA® GPUs विशेषज्ञता हासिल टेन्सर कोर कि काफी पात्र कर्नेल के प्रदर्शन में सुधार कर सकते हैं।

आप TensorBoard के उपयोग कर सकते हैं GPU गिरी आँकड़े कल्पना करने के लिए जो GPU कर्नेल टेन्सर कोर-पात्र हैं, और जो कर्नेल टेन्सर कोर का उपयोग कर रहे हैं। सक्षम करने से fp16 (नीचे मिश्रित प्रेसिजन अनुभाग को सक्षम करने से देखें) अपने कार्यक्रम के जनरल मैट्रिक्स गुणा बनाने के लिए एक ही रास्ता है (GEMM) कर्नेल (matmul ऑप्स) टेन्सर कोर का उपयोग करें। GPU कर्नेल कुशलतापूर्वक टेन्सर कोर का उपयोग करते परिशुद्धता fp16 है और इनपुट / आउटपुट टेन्सर आयाम 8 या 16 (के लिए विभाजित कर रहे हैं int8 )।

कैसे बनाने के लिए GPUs के लिए कुशल कर्नेल पर अन्य विस्तृत अनुशंसाओं के लिए, का उल्लेख गहरी प्रदर्शन सीखने NVIDIA® गाइड।

2. फ्यूज ऑप्स

उपयोग tf.function(jit_compile=True) छोटे ऑप्स फ्यूज करने के लिए बड़ा कर्नेल उल्लेखनीय निष्पादन लाभ के लिए अग्रणी के रूप में। अधिक जानकारी के लिए का उल्लेख XLA गाइड।

3. मिश्रित परिशुद्धता और XLA सक्षम करें

उपरोक्त चरणों का पालन करने के बाद, मिश्रित परिशुद्धता और XLA सक्षम करना दो वैकल्पिक कदम हैं जिन्हें आप प्रदर्शन को और बेहतर बनाने के लिए उठा सकते हैं। सुझाया गया दृष्टिकोण उन्हें एक-एक करके सक्षम करना और यह सत्यापित करना है कि प्रदर्शन लाभ अपेक्षित हैं।

1. मिश्रित परिशुद्धता सक्षम करें

TensorFlow मिश्रित परिशुद्धता गाइड से पता चलता है कि कैसे सक्षम करने के लिए fp16 GPUs पर सटीक। सक्षम एएमपी NVIDIA® GPUs पर टेन्सर कोर का उपयोग करें और 3x समग्र speedups अप करने के लिए एहसास जब बस के उपयोग की तुलना करने के लिए fp32 वोल्टा और नए GPU आर्किटेक्चर पर (float32) परिशुद्धता।

सुनिश्चित करें कि मैट्रिक्स/टेंसर आयाम टेन्सर कोर का उपयोग करने वाले कर्नेल को कॉल करने के लिए आवश्यकताओं को पूरा करते हैं। जब सटीकता fp16 होती है और इनपुट/आउटपुट आयाम 8 या 16 (int8 के लिए) से विभाज्य होते हैं तो GPU कर्नेल टेंसर कोर का कुशलता से उपयोग करते हैं।

ध्यान दें कि cuDNN v7.6.3 और बाद के संस्करण के साथ, जहां टेंसर कोर का लाभ उठाने के लिए आवश्यक है, वहां कनवल्शन आयामों को स्वचालित रूप से पैड किया जाएगा।

नीचे के प्रदर्शन लाभ को अधिकतम करने के लिए सर्वोत्तम प्रथाओं का पालन करें fp16 परिशुद्धता।

1. इष्टतम fp16 गुठली का प्रयोग करें

साथ fp16 सक्षम होने पर आपका कार्यक्रम के मैट्रिक्स गुणा (GEMM) कर्नेल, इसी का उपयोग करना चाहिए fp16 संस्करण टेन्सर कोर का इस्तेमाल करता है। हालांकि, कुछ मामलों में, ऐसा नहीं होता है और आप को सक्षम करने से उम्मीद speedup का अनुभव नहीं है fp16 , के रूप में अपने कार्यक्रम वापस अक्षम कार्यान्वयन के लिए बजाय गिर जाता है।

image

GPU गिरी आँकड़े पेज दिखाती है कि कौन ऑप्स टेन्सर कोर पात्र और जो कर्नेल हैं वास्तव में कुशल टेन्सर कोर का उपयोग कर रहे हैं। गहरी सीखने के प्रदर्शन पर NVIDIA® गाइड कैसे टेन्सर कोर लाभ उठाने के लिए पर अतिरिक्त सुझाव शामिल हैं। साथ ही, उपयोग कर के लाभ fp16 भी कर्नेल कि पहले बाध्य स्मृति थे में दिखाने के रूप में अब ऑप्स आधा समय लगेगा होगा।

2. गतिशील बनाम स्थिर हानि स्केलिंग

का उपयोग करते समय घटाने स्केलिंग के लिए आवश्यक है fp16 कम परिशुद्धता के कारण अधःप्रवाह को रोकने के लिए। वहाँ जो दोनों के में अधिक से अधिक विस्तार से वर्णन किया नुकसान स्केलिंग, गतिशील और स्थिर के दो प्रकार के हैं, मिश्रित प्रेसिजन गाइड । आप उपयोग कर सकते हैं mixed_float16 स्वचालित रूप से Keras अनुकूलक के भीतर नुकसान स्केलिंग सक्षम करने के लिए नीति।

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

2. XLA को tf.function(jit_compile=True) या ऑटो-क्लस्टरिंग के साथ सक्षम करें

एकल GPU के साथ सर्वश्रेष्ठ प्रदर्शन प्राप्त करने के अंतिम चरण के रूप में, आप XLA को सक्षम करने के साथ प्रयोग कर सकते हैं, जो ऑप्स को जोड़ देगा और बेहतर डिवाइस उपयोग और कम मेमोरी फ़ुटप्रिंट की ओर ले जाएगा। कैसे के साथ अपने कार्यक्रम में XLA सक्षम करने के लिए पर जानकारी के लिए tf.function(jit_compile=True) या ऑटो क्लस्टरिंग, का उल्लेख XLA गाइड।

आप करने के लिए वैश्विक JIT स्तर सेट कर सकते हैं -1 (बंद), 1 , या 2 । एक उच्च स्तर अधिक आक्रामक होता है और समानता को कम कर सकता है और अधिक स्मृति का उपयोग कर सकता है। करने के लिए मान सेट करें 1 आप स्मृति प्रतिबंध है। ध्यान दें कि XLA चर इनपुट टेंसर आकार वाले मॉडल के लिए अच्छा प्रदर्शन नहीं करता है क्योंकि XLA कंपाइलर को जब भी नई आकृतियों का सामना करना पड़ता है, तो उसे कर्नेल को संकलित करते रहना होगा।

2. मल्टी-जीपीयू सिंगल होस्ट पर प्रदर्शन का अनुकूलन करें

tf.distribute.MirroredStrategy एपीआई एक एकल मेजबान पर कई GPUs के लिए एक GPU से पैमाने पर मॉडल प्रशिक्षण के लिए इस्तेमाल किया जा सकता है। (, कैसे TensorFlow के साथ वितरित करने के लिए प्रशिक्षण के बारे में अधिक जानने के लिए का उल्लेख TensorFlow साथ वितरित प्रशिक्षण , उपयोग एक GPU , और उपयोग tpus गाइड और Keras साथ वितरित प्रशिक्षण ट्यूटोरियल।)

हालांकि एक जीपीयू से कई जीपीयू में संक्रमण आदर्श रूप से बॉक्स से बाहर स्केलेबल होना चाहिए, आप कभी-कभी प्रदर्शन के मुद्दों का सामना कर सकते हैं।

एक ही मेजबान पर एक ही जीपीयू के साथ कई जीपीयू के साथ प्रशिक्षण से जाने पर, आदर्श रूप से आपको केवल ढाल संचार के अतिरिक्त ओवरहेड और मेजबान थ्रेड उपयोग में वृद्धि के साथ प्रदर्शन स्केलिंग का अनुभव करना चाहिए। इस ओवरहेड के कारण, उदाहरण के लिए, यदि आप 1 से 2 GPU तक ले जाते हैं, तो आपके पास सटीक 2x स्पीडअप नहीं होगा।

नीचे दिया गया ट्रेस दृश्य एकाधिक GPU पर प्रशिक्षण के दौरान अतिरिक्त संचार ओवरहेड का एक उदाहरण दिखाता है। ग्रेडिएंट्स को जोड़ने, उन्हें प्रतिकृतियों में संप्रेषित करने और वज़न अपडेट करने से पहले उन्हें विभाजित करने के लिए कुछ ओवरहेड है।

image

मल्टी-जीपीयू परिदृश्य में प्रदर्शन को अनुकूलित करते समय निम्नलिखित चेकलिस्ट आपको बेहतर प्रदर्शन प्राप्त करने में मदद करेगी:

  1. बैच आकार को अधिकतम करने का प्रयास करें, जिससे डिवाइस का अधिक उपयोग होगा और कई GPU में संचार की लागत का परिशोधन होगा। का उपयोग करते हुए स्मृति प्रोफाइलर कितने करीब अपने कार्यक्रम शिखर मेमोरी उपयोग करने के लिए है की भावना प्राप्त कर सकें। ध्यान दें कि उच्च बैच आकार अभिसरण को प्रभावित कर सकता है, यह आमतौर पर प्रदर्शन लाभों से अधिक होता है।
  2. एकल GPU से कई GPU में जाने पर, उसी होस्ट को अब बहुत अधिक इनपुट डेटा संसाधित करना होगा। इसलिए, (1) के बाद, इनपुट पाइपलाइन के प्रदर्शन की फिर से जाँच करने और यह सुनिश्चित करने की सिफारिश की जाती है कि यह कोई अड़चन नहीं है।
  3. किसी भी अनावश्यक AllReduce कॉल के लिए अपने प्रोग्राम के ट्रेस व्यू में GPU टाइमलाइन की जाँच करें, क्योंकि इससे सभी डिवाइस में एक सिंक्रोनाइज़ेशन होता है। दृश्य का पता लगाने ऊपर दिखाए गए, AllReduce माध्यम से किया जाता NCCL गिरी, और वहाँ हर कदम पर ढ़ाल के लिए प्रत्येक GPU पर केवल एक ही NCCL कॉल है।
  4. अनावश्यक D2H, H2D और D2D कॉपी संचालन की जाँच करें जिन्हें कम किया जा सकता है।
  5. यह सुनिश्चित करने के लिए चरण समय की जाँच करें कि प्रत्येक प्रतिकृति समान कार्य कर रही है। उदाहरण के लिए, यह हो सकता है कि एक GPU (आमतौर पर, GPU0 ) अभिदान है क्योंकि मेजबान गलती से उस पर और अधिक काम डाल समाप्त होता है।
  6. अंत में, क्रमिक रूप से निष्पादित होने वाले किसी भी ऑप्स के लिए अपने ट्रेस व्यू में सभी GPU के प्रशिक्षण चरण की जाँच करें। यह आमतौर पर तब होता है जब आपके प्रोग्राम में एक GPU से दूसरे GPU पर नियंत्रण निर्भरताएँ शामिल होती हैं। अतीत में, इस स्थिति में प्रदर्शन को डीबग करना मामला-दर-मामला आधार पर हल किया गया है। यदि आप अपने कार्यक्रम में इस व्यवहार को देखें, तो एक GitHub मुद्दे फाइल अपने निशान को देखने की छवियों के साथ।

1. ऑप्टिमाइज़ ग्रेडिएंट AllReduce

एक तुल्यकालिक रणनीति के साथ प्रशिक्षण के दौरान, प्रत्येक डिवाइस को इनपुट डेटा का एक हिस्सा प्राप्त होता है।

आगे और पीछे की गणना मॉडल के माध्यम से गुजरती है, प्रत्येक डिवाइस पर गणना किए गए ग्रेडिएंट को एकत्रित और कम करने की आवश्यकता होती है। यह ढाल AllReduce प्रत्येक डिवाइस पर ढाल गणना के बाद होता है, और अनुकूलक से पहले अद्यतन करता है मॉडल वेट।

प्रत्येक GPU पहले मॉडल परतों में ढ़ाल concatenates का उपयोग कर GPU के पार उन्हें संचार tf.distribute.CrossDeviceOps ( tf.distribute.NcclAllReduce डिफ़ॉल्ट है), और फिर परत प्रति कमी के बाद ढ़ाल देता है।

ऑप्टिमाइज़र आपके मॉडल के वज़न को अपडेट करने के लिए इन घटे हुए ग्रेडिएंट्स का उपयोग करेगा। आदर्श रूप से, यह प्रक्रिया किसी भी ओवरहेड को रोकने के लिए सभी GPU पर एक ही समय में होनी चाहिए।

AllReduce का समय लगभग समान होना चाहिए:

(number of parameters * 4bytes)/ (communication bandwidth)

यह गणना यह समझने के लिए एक त्वरित जांच के रूप में उपयोगी है कि वितरित प्रशिक्षण कार्य चलाते समय आपका प्रदर्शन अपेक्षित है, या यदि आपको आगे प्रदर्शन डिबगिंग करने की आवश्यकता है। आप से अपने मॉडल में पैरामीटर की संख्या प्राप्त कर सकते हैं Model.summary

ध्यान दें कि प्रत्येक मॉडल पैरामीटर के बाद से TensorFlow का उपयोग करता है आकार में 4 बाइट्स fp32 (float32) ढ़ाल संवाद करने के लिए। यहां तक कि जब आप है fp16 सक्षम, NCCL AllReduce का इस्तेमाल करता fp32 मानकों।

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

2. GPU होस्ट थ्रेड विवाद

कई GPU चलाते समय, CPU का काम सभी उपकरणों को कुशलतापूर्वक GPU कर्नेल लॉन्च करके सभी उपकरणों को व्यस्त रखना है।

हालाँकि, जब बहुत सारे स्वतंत्र संचालन होते हैं जो CPU एक GPU पर शेड्यूल कर सकता है, तो CPU एक GPU को व्यस्त रखने के लिए अपने बहुत सारे होस्ट थ्रेड्स का उपयोग करने का निर्णय ले सकता है, और फिर गैर-निर्धारक क्रम में दूसरे GPU पर कर्नेल लॉन्च कर सकता है। . यह तिरछा या नकारात्मक स्केलिंग का कारण बन सकता है, जो प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है।

ट्रेस दर्शक शो नीचे भूमि के ऊपर जब अकुशलता से सीपीयू डगमगाता GPU गिरी की शुरूआत, के रूप में GPU1 निष्क्रिय है और उसके बाद ऑप्स चलाने के बाद शुरू होता है GPU2 शुरू कर दिया है।

image

मेजबान शो के लिए पता लगाने का मानना है कि मेजबान पर कर्नेल लॉन्च कर रहा है GPU2 पर उन्हें शुरू करने से पहले GPU1 (ध्यान दें कि नीचे tf_Compute* ऑप्स सीपीयू धागे का संकेत नहीं हैं)।

image

यदि आप अपने प्रोग्राम के ट्रेस व्यू में GPU कर्नेल के इस तरह के चौंका देने वाले अनुभव का अनुभव करते हैं, तो अनुशंसित कार्रवाई है:

  • TensorFlow वातावरण चर सेट TF_GPU_THREAD_MODE को gpu_private । यह पर्यावरण चर मेजबान को एक GPU निजी के लिए थ्रेड रखने के लिए कहेगा।
  • डिफ़ॉल्ट रूप से, TF_GPU_THREAD_MODE=gpu_private 2 को धागे की संख्या है, जो ज्यादातर मामलों में पर्याप्त है निर्धारित करता है। हालांकि, उस नंबर TensorFlow वातावरण चर सेट करके बदला जा सकता है TF_GPU_THREAD_COUNT धागे की वांछित संख्या के लिए।