ग्रेडिएंट क्लिपिंग: एक्सप्लोडिंग ग्रेडिएंट्स को कैसे रोकें

डीप न्यूरल नेटवर्क को ट्रेन करते समय आपने कितनी बार NaN लॉस वैल्यू देखी है?

घंटों के प्रशिक्षण के बाद लॉस कर्व ठीक दिखती है, और फिर अचानक अनंत तक उछल जाती है। इसका कारण आमतौर पर एक्सप्लोडिंग ग्रेडिएंट्स होते हैं — ऐसे ग्रेडिएंट मान जो बैकप्रोपेगेशन के दौरान इतने बड़े हो जाते हैं कि पैरामीटर अपडेट अस्थिर हो जाते हैं और मॉडल टूट जाता है। यह समस्या रिकरेंट नेटवर्क्स में सबसे ज्यादा दिखती है, लेकिन ट्रांसफॉर्मर्स और डीप फीडफॉरवर्ड नेटवर्क्स में भी दिखाई देती है।

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

इस लेख में, मैं ग्रेडिएंट क्लिपिंग के पीछे की सहज समझ, इसके दो मुख्य तरीकों, थ्रेशोल्ड कैसे चुनें, और इसे PyTorch व TensorFlow में कैसे लागू करें — इन सब पर चर्चा करूंगा।

लेकिन डेटा साइंस में लॉस वास्तव में है क्या? हमारा Loss Function in Machine Learning ब्लॉग पोस्ट पढ़कर जानें।

ग्रेडिएंट क्लिपिंग क्या है?

ग्रेडिएंट क्लिपिंग एक तकनीक है जो प्रशिक्षण के दौरान ग्रेडिएंट्स की परिमाण को सीमित करती है, ताकि पैरामीटर अपडेट अस्थिर न हों।

जब कोई ग्रेडिएंट बहुत बड़ा हो जाता है, तो ऑप्टिमाइज़र पैरामीटर स्पेस में बहुत बड़ा कदम लेता है और वेट्स को ऐसी जगह धकेल देता है जहां लॉस फट पड़ता है। क्लिपिंग इस कदम के आकार को पहले से ही सीमाबद्ध कर देती है, ताकि नुकसान होने से रोका जा सके।

यह ध्यान रखना महत्वपूर्ण है कि ग्रेडिएंट क्लिपिंग मॉडल आर्किटेक्चर को प्रभावित नहीं करती। आप न तो लेयर जोड़ते हैं, न ही एक्टिवेशन फंक्शंस बदलते हैं। यह सिर्फ ट्रेनिंग प्रोसेस को संशोधित करती है — बैकप्रोपेगेशन और ऑप्टिमाइज़र स्टेप के बीच ग्रेडिएंट्स को इंटरसेप्ट करके।

इसे आज़माना सस्ता है और हटाना आसान। जैसा कि आप आगे देखेंगे, इसके लिए सिर्फ एक लाइन कोड पर्याप्त है।

ग्रेडिएंट क्लिपिंग कैसे काम करती है

मैकेनिक्स सरल हैं। क्लिपिंग ऑपरेशन आपके बैकवर्ड पास और ऑप्टिमाइज़र स्टेप के बीच रखा जाता है, और हर इटरेशन में वही चार चरणों का पालन करता है।

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

अधिकांश समय आपके ग्रेडिएंट्स इस सीमा से नीचे रहते हैं और प्रशिक्षण वैसा ही चलता है जैसा क्लिपिंग के बिना चलता। जब कोई स्पाइक आता है, तो ऑप्टिमाइज़र के प्रतिक्रिया देने से पहले क्लिपिंग उसे पकड़ लेती है।

बस इतना ही।

आम ग्रेडिएंट क्लिपिंग तरीके

ग्रेडिएंट्स को क्लिप करने के दो तरीके हैं, और अंतर इस बात पर निर्भर करता है कि आप क्या मापते हैं और क्या स्केल करते हैं।

वैल्यू के आधार पर क्लिप करें

वैल्यू के आधार पर क्लिप करना हर ग्रेडिएंट एलिमेंट को अलग-अलग सीमाबद्ध करता है।

आप एक रेंज चुनते हैं, मान लें [-1.0, 1.0], और इस रेंज के बाहर आने वाला कोई भी ग्रेडिएंट मान निकटतम सीमा पर राउंड कर दिया जाता है। 2.5 का ग्रेडिएंट 1.0 बन जाता है। -2.5 का ग्रेडिएंट -1.0 बन जाता है। जो मान पहले से रेंज के भीतर हैं, वे अपरिवर्तित रहते हैं।

वैल्यू के आधार पर क्लिप करने का उदाहरण

आकर्षण इसकी सादगी है। मिन/मैक्स ऑपरेशन से आगे कोई गणित नहीं, और यह तेज़ चलता है।

लेकिन इस दृष्टिकोण की एक कमी है। व्यक्तिगत मानों को क्लिप करना ग्रेडिएंट वेक्टर की दिशा बदल देता है। यदि एक घटक क्लिप हो जाए और अन्य न हों, तो अपडेटेड वेक्टर अब उस दिशा में नहीं रहता जहां बैकप्रोपेगेशन ने बताया था। आपका ऑप्टिमाइज़र थोड़ा गलत दिशा में कदम उठा सकता है।

इसीलिए व्यवहार में वैल्यू-आधारित क्लिपिंग कम सामान्य है।

नॉर्म के आधार पर क्लिप करें

नॉर्म के आधार पर क्लिप करना तब पूरे ग्रेडिएंट वेक्टर को स्केल करता है जब उसका कुल परिमाण किसी थ्रेशोल्ड से अधिक हो जाए।

व्यक्तिगत मानों को देखने के बजाय, यह सभी ग्रेडिएंट्स का एक साथ नॉर्म (आमतौर पर L2 नॉर्म) निकालता है और उसे अधिकतम मान से तुलना करता है। यदि नॉर्म थ्रेशोल्ड से नीचे है, तो कुछ नहीं होता। यदि ऊपर है, तो हर ग्रेडिएंट को समान स्केलिंग फैक्टर से गुणा किया जाता है ताकि नॉर्म को वापस सीमा तक लाया जा सके।

नॉर्म के आधार पर क्लिप करने का उदाहरण

लाभ है दिशा का संरक्षण। क्योंकि हर घटक समान फैक्टर से छोटा होता है, ग्रेडिएंट वेक्टर मूल दिशा में ही इशारा करता रहता है। आप सिर्फ कदम की लंबाई घटा रहे हैं, दिशा नहीं बदल रहे।

इसीलिए नॉर्म-आधारित क्लिपिंग मानक बन गई है। PyTorch का clip_grad_norm_ और TensorFlow का clipnorm दोनों यही तरीका लागू करते हैं, और अधिकांश आधुनिक ट्रेनिंग पाइपलाइंस इसे डिफ़ॉल्ट रूप से उपयोग करती हैं।

एक्सप्लोडिंग ग्रेडिएंट्स बनाम वैनिशिंग ग्रेडिएंट्स

एक्सप्लोडिंग और वैनिशिंग ग्रेडिएंट्स दोनों डीप लर्निंग में आम समस्याएं हैं, लेकिन ग्रेडिएंट क्लिपिंग सिर्फ एक को हल करती है।

एक्सप्लोडिंग ग्रेडिएंट्स

एक्सप्लोडिंग ग्रेडिएंट्स तब होते हैं जब बैकप्रोपेगेशन के दौरान ग्रेडिएंट मान बहुत बड़े हो जाते हैं।

यह आमतौर पर डीप नेटवर्क्स या रिकरेंट आर्किटेक्चर्स में दिखता है, जहां ग्रेडिएंट्स कई लेयर्स या टाइम स्टेप्स में गुणित होते जाते हैं। यदि ये गुणन गलत दिशा में बढ़ते हैं, तो ग्रेडिएंट का परिमाण उछल जाता है। तब ऑप्टिमाइज़र बहुत बड़ा पैरामीटर अपडेट कर देता है, वेट्स अतिशय मानों तक पहुंच जाते हैं, और लॉस अक्सर NaN या Inf बन जाता है।

आप इसे अचानक लॉस स्पाइक्स के रूप में या कहीं से भी डाइवर्ज होने वाले मॉडल के रूप में देखेंगे।

वैनिशिंग ग्रेडिएंट्स

वैनिशिंग ग्रेडिएंट्स विपरीत समस्या हैं। ग्रेडिएंट मान नेटवर्क में पीछे की ओर जाते-जाते शून्य की ओर सिकुड़ते जाते हैं।

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

LSTM और GRU के आने से पहले लंबी सीक्वेंसेज़ पर RNNs के संघर्ष का यह प्रमुख कारण था।

ग्रेडिएंट क्लिपिंग कहां फिट बैठती है

ग्रेडिएंट क्लिपिंग एक्सप्लोडिंग ग्रेडिएंट्स को संबोधित करती है, वैनिशिंग ग्रेडिएंट्स को नहीं।

क्लिपिंग बड़े ग्रेडिएंट्स को छोटा करती है, लेकिन छोटे ग्रेडिएंट्स पर कुछ नहीं करती। वैनिशिंग ग्रेडिएंट्स के लिए बेहतर वेट इनिशियलाइज़ेशन, रेज़िडुअल कनेक्शंस, बैच नॉर्मलाइज़ेशन, या ऐसे आर्किटेक्चर चाहिए जो ग्रेडिएंट फ्लो को संरक्षित रखें।

नॉर्म द्वारा ग्रेडिएंट क्लिपिंग समझाया गया

नॉर्म द्वारा क्लिपिंग वही तरीका है जिसकी तलाश अधिकांश पाठक ग्रेडिएंट क्लिपिंग खोजते समय करते हैं।

प्रक्रिया तीन चरणों की है। पहले, सभी ग्रेडिएंट्स का संयुक्त नॉर्म निकालें। दूसरे, उस नॉर्म की तुलना आपके चुने हुए थ्रेशोल्ड से करें। तीसरे, यदि नॉर्म बहुत बड़ा है तो ग्रेडिएंट्स को पुनः स्केल करें।

नॉर्म आम तौर पर L2 नॉर्म होता है, यानी हर ग्रेडिएंट मान का वर्ग करें, उन्हें जोड़ें, और वर्गमूल लें। यदि आपके पास सभी मॉडल पैरामीटर्स पर ग्रेडिएंट्स g_1, g_2, ..., g_n हैं, तो L2 नॉर्म यह है:

नॉर्म द्वारा क्लिपिंग का सूत्र

जब आपके पास नॉर्म आ जाए, तो आप उसे अपने थ्रेशोल्ड c से तुलना करते हैं। यदि ||g|| <= c है, तो ग्रेडिएंट्स अपरिवर्तित गुजर जाते हैं। यदि ||g|| > c है, तो हर ग्रेडिएंट को स्केलिंग फैक्टर c / ||g|| से गुणा किया जाता है। इससे नया नॉर्म ठीक c तक आ जाता है।

यह इसलिए मायने रखता है क्योंकि हर घटक समान फैक्टर से सिकुड़ता है। ग्रेडिएंट मानों के आपसी अनुपात अपरिवर्तित रहते हैं, यानी वेक्टर मूल दिशा में ही इशारा करता रहता है। आप ऑप्टिमाइज़र के कदम को छोटा कर रहे हैं, मंज़िल नहीं बदल रहे।

यही दिशा-संरक्षण गुण नॉर्म क्लिपिंग को डिफ़ॉल्ट विकल्प बनाता है। वैल्यू-आधारित क्लिपिंग ग्रेडिएंट वेक्टर को नई दिशा में मोड़ सकती है। नॉर्म-आधारित क्लिपिंग उसकी सिर्फ लंबाई बदलती है।

PyTorch का clip_grad_norm_ और TensorFlow का clipnorm बिल्कुल यही करते हैं। जब कोई कहता है, "मैं ग्रेडिएंट क्लिपिंग इस्तेमाल कर रहा/रही हूं," तो वे लगभग हमेशा नॉर्म द्वारा क्लिपिंग का मतलब लेते हैं।

ग्रेडिएंट क्लिपिंग थ्रेशोल्ड चुनना

थ्रेशोल्ड एक हाइपरपैरामीटर है, यानी ऐसा कोई सार्वभौमिक मान नहीं जो हर मॉडल के लिए काम करे।

यदि आप इसे बहुत ऊंचा रखते हैं, तो क्लिपिंग लगभग कभी सक्रिय नहीं होगी। आपके ग्रेडिएंट्स लगभग हमेशा सीमा से नीचे रहेंगे, इसलिए सुरक्षा जाल कुछ नहीं पकड़ेगा। प्रशिक्षण ऐसे ही चलेगा जैसे क्लिपिंग हो ही नहीं, और ग्रेडिएंट्स के फटते ही आप लॉस स्पाइक्स देखेंगे।

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

एक सामान्य शुरुआती बिंदु 1.0 है, जो कई आर्किटेक्चर्स के लिए अच्छा काम करता है। 0.5 से 5.0 के बीच के मान अधिकांश व्यावहारिक उपयोग मामलों को कवर करते हैं।

बेहतर तरीका है प्रशिक्षण के दौरान अपने ग्रेडिएंट नॉर्म्स की मॉनिटरिंग करना। हर स्टेप पर अनक्लिप्ड नॉर्म लॉग करें और वितरण देखें। यदि अधिकांश नॉर्म्स लगभग 0.3 के आसपास हैं और कभी-कभी 50 तक स्पाइक करते हैं, तो थ्रेशोल्ड को विशिष्ट रेंज से ऊपर लेकिन स्पाइक्स से काफी नीचे सेट करें — यहां 2.0 या 3.0 उचित रहेंगे।

इसे किसी भी अन्य हाइपरपैरामीटर की तरह ट्रीट करें। 1.0 से शुरुआत करें, परिणाम देखें, और प्रशिक्षण के व्यवहार के आधार पर समायोजित करें।

रिकरेंट न्यूरल नेटवर्क्स में ग्रेडिएंट क्लिपिंग

RNNs वह जगह हैं जहां ग्रेडिएंट क्लिपिंग पहली बार एक मानक तकनीक बनी।

कारण है कि RNNs समय के साथ ग्रेडिएंट्स को कैसे प्रवाहित करते हैं। बैकप्रोपेगेशन थ्रू टाइम समान वेट मैट्रिसेज़ को कई टाइम स्टेप्स में बार-बार गुणा करता है, और ये दोहराए गए गुणन बहुत बड़े मानों में बदल सकते हैं। लंबी सीक्वेंसेज़ समस्या को और बढ़ा देती हैं।

LSTM और GRU ने अपनी गेटिंग मेकैनिज़्म के साथ समस्या को कम किया, लेकिन खत्म नहीं किया। दोनों आर्किटेक्चर्स अभी भी क्लिपिंग से लाभान्वित होते हैं — खासकर लंबी सीक्वेंसेज़ पर प्रशिक्षण या उच्च लर्निंग रेट्स के साथ।

RNN प्रशिक्षण के लिए, नॉर्म द्वारा क्लिपिंग और 1.0 से 5.0 के बीच का थ्रेशोल्ड सामान्य डिफ़ॉल्ट है। यदि आप PyTorch के nn.LSTM या nn.GRU का उपयोग कर रहे हैं और प्रशिक्षण के दौरान लॉस फट रहा है, तो clip_grad_norm_ जोड़ना आमतौर पर सबसे पहले आज़माने वाली चीज़ है।

आधुनिक डीप लर्निंग में ग्रेडिएंट क्लिपिंग

जब ट्रांसफॉर्मर्स ने RNNs की जगह ली, तब भी ग्रेडिएंट क्लिपिंग गायब नहीं हुई।

GPT और BERT जैसे बड़े भाषा मॉडल्स प्रीट्रेनिंग और फाइन-ट्यूनिंग के दौरान क्लिपिंग का उपयोग करते हैं। यही बात विज़न ट्रांसफॉर्मर्स, डिफ्यूज़न मॉडल्स, और सैकड़ों लेयर्स वाले अधिकांश डीप आर्किटेक्चर्स पर लागू होती है। Adam और AdamW जैसे ऑप्टिमाइज़र्स, जो आधुनिक प्रशिक्षण पर हावी हैं, अक्सर लगभग 1.0 के थ्रेशोल्ड पर नॉर्म क्लिपिंग के साथ पेयर किए जाते हैं।

कारण वही है जो RNNs के लिए था। डीप नेटवर्क्स कई लेयर्स में ग्रेडिएंट्स को गुणित करते हैं, और बड़े बैच साइज़ तथा उच्च लर्निंग रेट्स का संयोजन कभी-कभी ग्रेडिएंट स्पाइक्स पैदा कर सकता है। क्लिपिंग इन स्पाइक्स को संभाल लेती है, बिना सामान्य ट्रेनिंग स्टेप्स को प्रभावित किए।

अधिकांश रेफरेंस इम्प्लीमेंटेशंस में डिफ़ॉल्ट रूप से क्लिपिंग शामिल होती है। Hugging Face का Trainer, PyTorch Lightning, और DeepSpeed — सभी क्लिपिंग को एक मानक कॉन्फ़िग विकल्प के रूप में एक्सपोज़ करते हैं। यदि आप किसी छोटे टॉय मॉडल से बड़ा कुछ भी ट्रेन कर रहे हैं, तो क्लिपिंग लगभग निश्चित रूप से पाइपलाइन का हिस्सा है।

यह एक पंक्ति का जोड़ है, जिसकी लागत लगभग कुछ नहीं और जो घंटों की कम्प्यूट के बाद ट्रेनिंग रन के क्रैश होने से बचाता है। यही वजह है कि यह टिका रहा।

PyTorch में ग्रेडिएंट क्लिपिंग

PyTorch ग्रेडिएंट क्लिपिंग को एक ही यूटिलिटी फंक्शन से संभालता है: torch.nn.utils.clip_grad_norm_।

क्लिपिंग कॉल loss.backward() और optimizer.step() के बीच आता है। बैकप्रोपेगेशन पहले ग्रेडिएंट्स भरता है, फिर ज़रूरत होने पर क्लिपिंग उन्हें छोटा करती है, और फिर ऑप्टिमाइज़र अपडेट लागू करता है। कॉल को कहीं और रखने से काम नहीं चलेगा।

यहां एक पूरा, रन करने योग्य ट्रेनिंग स्क्रिप्ट है जो सिंथेटिक रिग्रेशन डेटा पर एक छोटा MLP ट्रेन्ड करती है, जिसमें ग्रेडिएंट क्लिपिंग सक्षम है:

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(42)

# Synthetic regression data
n_samples = 1000
n_features = 20
inputs = torch.randn(n_samples, n_features)
targets = (inputs.sum(dim=1, keepdim=True) * 2.0 + torch.randn(n_samples, 1) * 0.1)

dataset = TensorDataset(inputs, targets)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# Small feedforward network
model = nn.Sequential(
    nn.Linear(n_features, 64),
    nn.ReLU(),
    nn.Linear(64, 64),
    nn.ReLU(),
    nn.Linear(64, 1),
)

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.MSELoss()

# Training loop with gradient clipping
n_epochs = 5
max_grad_norm = 1.0

for epoch in range(n_epochs):
    epoch_loss = 0.0
    for batch_inputs, batch_targets in dataloader:
        optimizer.zero_grad()

        predictions = model(batch_inputs)
        loss = loss_fn(predictions, batch_targets)
        loss.backward()

        # Gradient clipping
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=max_grad_norm)

        optimizer.step()
        epoch_loss += loss.item()

    print(f"Epoch {epoch + 1}: loss = {epoch_loss / len(dataloader):.4f}")

PyTorch आउटपुट

clip_grad_norm_ फंक्शन दो मुख्य आर्ग्युमेंट्स लेता है:

• parameters: वे मॉडल पैरामीटर्स जिनके ग्रेडिएंट्स आप क्लिप करना चाहते हैं। पूरे मॉडल को कवर करने के लिए model.parameters() पास करें।

• max_norm: ग्रेडिएंट नॉर्म का थ्रेशोल्ड। 1.0 शुरुआती बिंदु के रूप में आम है।

एक वैकल्पिक norm_type आर्ग्युमेंट भी है, जिसका डिफ़ॉल्ट 2.0 (L2 नॉर्म) है। आपको इसे शायद ही बदलने की जरूरत पड़ेगी।

clip_grad_norm_ में अंतिम अंडरस्कोर इन-प्लेस ऑपरेशन का संकेत देता है। यह फंक्शन प्रत्येक पैरामीटर के .grad एट्रिब्यूट के अंदर सीधे ग्रेडिएंट्स को संशोधित करता है, इसलिए आपको रिटर्न वैल्यू संभालने की जरूरत नहीं। यह क्लिपिंग से पहले ग्रेडिएंट्स का कुल नॉर्म लौटाता है, जो लॉगिंग के लिए उपयोगी है।

वैल्यू-आधारित (नॉर्म की जगह) क्लिपिंग के लिए, PyTorch में torch.nn.utils.clip_grad_value_ है:

torch.nn.utils.clip_grad_value_(model.parameters(), clip_value=0.5)

लेकिन जैसा कि पहले चर्चा हुई, आप इसे शायद ही (कभी) उपयोग करेंगे।

यही पूरा सेटअप है। आपके ट्रेनिंग लूप में बस दो पंक्तियां जोड़ना।

TensorFlow में ग्रेडिएंट क्लिपिंग

TensorFlow क्लिपिंग को अलग फंक्शन कॉल के बजाय ऑप्टिमाइज़र स्तर पर संभालता है।

जब आप ऑप्टिमाइज़र बनाते हैं, तो clipnorm या clipvalue आर्ग्युमेंट के रूप में पास करते हैं। ऑप्टिमाइज़र हर स्टेप के दौरान आंतरिक रूप से क्लिपिंग लागू करता है, इसलिए आपको अपने ट्रेनिंग लूप में कोई बदलाव करने की जरूरत नहीं।

यहां Keras API का उपयोग करते हुए सिंथेटिक रिग्रेशन डेटा पर एक पूरा वर्किंग उदाहरण है:

import numpy as np
import tensorflow as tf

tf.random.set_seed(42)
np.random.seed(42)

# Synthetic regression data
n_samples = 1000
n_features = 20
x_train = np.random.randn(n_samples, n_features).astype(np.float32)
y_train = (x_train.sum(axis=1, keepdims=True) * 2.0
           + np.random.randn(n_samples, 1).astype(np.float32) * 0.1)

# Small feedforward network
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation="relu", input_shape=(n_features,)),
    tf.keras.layers.Dense(64, activation="relu"),
    tf.keras.layers.Dense(1),
])

# Optimizer with gradient clipping by norm
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3, clipnorm=1.0)

model.compile(optimizer=optimizer, loss="mse")
model.fit(x_train, y_train, epochs=5, batch_size=32)

TensorFlow आउटपुट

दोनों आर्ग्युमेंट अलग-अलग काम करते हैं:

• clipnorm हर ग्रेडिएंट टेंसर के L2 नॉर्म के आधार पर क्लिप करता है। यदि नॉर्म थ्रेशोल्ड से अधिक है, तो टेंसर को समानुपात में स्केल डाउन किया जाता है।

• clipvalue हर ग्रेडिएंट एलिमेंट को अलग-अलग क्लिप करता है। थ्रेशोल्ड से ऊपर का कोई भी मान थ्रेशोल्ड पर क्लैम्प हो जाता है, और नेगेटिव थ्रेशोल्ड से नीचे का कोई भी मान नेगेटिव थ्रेशोल्ड पर क्लैम्प हो जाता है।

नॉर्म क्लिपिंग से वैल्यू क्लिपिंग पर स्विच करने के लिए बस आर्ग्युमेंट बदलें:

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3, clipvalue=0.5)

दोनों आर्ग्युमेंट हर Keras ऑप्टिमाइज़र (Adam, SGD, RMSprop, AdamW, आदि) के साथ काम करते हैं। एक global_clipnorm आर्ग्युमेंट भी है जो प्रति-टेंसर के बजाय सभी ग्रेडिएंट्स के संयुक्त नॉर्म के आधार पर क्लिप करता है। यह PyTorch के डिफ़ॉल्ट व्यवहार से अधिक मेल खाता है।

यदि आप tf.GradientTape के साथ कस्टम ट्रेनिंग लूप लिख रहे हैं, तो apply_gradients कॉल करने पर ऑप्टिमाइज़र अब भी क्लिपिंग संभालता है:

for epoch in range(5):
    for batch_x, batch_y in zip(np.array_split(x_train, 32), np.array_split(y_train, 32)):
        with tf.GradientTape() as tape:
            predictions = model(batch_x, training=True)
            loss = tf.reduce_mean(tf.square(predictions - batch_y))

        gradients = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(gradients, model.trainable_variables))

यही दोनों फ्रेमवर्क्स के बीच का अंतर है। PyTorch क्लिपिंग को लूप के अंदर आपके हाथ में देता है। TensorFlow इसे ऑप्टिमाइज़र में धकेलता है। आधारभूत तर्क समान है।

ग्रेडिएंट क्लिपिंग बनाम अन्य स्थिरीकरण तकनीकें

ग्रेडिएंट क्लिपिंग प्रशिक्षण को स्थिर करने का एकमात्र तरीका नहीं है, और यह हमेशा हर काम के लिए सही उपकरण भी नहीं है।

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

बैच नॉर्मलाइज़ेशन

बैच नॉर्मलाइज़ेशन प्रशिक्षण के दौरान हर मिनी-बैच के भीतर एक्टिवेशंस को नॉर्मलाइज़ करता है।

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

लेकिन बैच नॉर्म सीधे ग्रेडिएंट विस्फोटों को नहीं रोकता। यह उनकी आवृत्ति कम करता है, न कि जब वे हों तो क्या करना है। इसी वजह से कई मॉडल बैच नॉर्म को ग्रेडिएंट क्लिपिंग के साथ जोड़ते हैं।

रेज़िडुअल कनेक्शंस

रेज़िडुअल कनेक्शंस शॉर्टकट पाथ्स जोड़ते हैं जो एक या अधिक लेयर्स को स्किप करते हैं, जिससे ग्रेडिएंट्स बाद की लेयर्स से सीधे पहले की लेयर्स तक बह पाते हैं।

यह डीप नेटवर्क्स में वैनिशिंग ग्रेडिएंट समस्या को हल करता है। रेज़िडुअल कनेक्शंस के बिना, 20–30 लेयर्स से अधिक गहरे नेटवर्क्स को ट्रेन करना मुश्किल हो जाता है क्योंकि ग्रेडिएंट्स पीछे जाते-जाते शून्य के करीब पहुंच जाते हैं। इनके साथ, सैकड़ों लेयर्स वाले नेटवर्क्स भी बिना समस्या के ट्रेन होते हैं।

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

सावधानीपूर्वक वेट इनिशियलाइज़ेशन

आपके वेट्स के शुरुआती मान एक्टिवेशंस और ग्रेडिएंट्स के प्रारंभिक परिमाण तय करते हैं। खराब इनिशियलाइज़ेशन पहले ही स्टेप से ग्रेडिएंट्स को एक्सप्लोड या वैनिश कर सकता है।

Xavier और He इनिशियलाइज़ेशन जैसी विधियां लेयर साइज़ के आधार पर शुरुआती वेट्स को स्केल करती हैं। इससे प्रशिक्षण की शुरुआत में लेयर्स में एक्टिवेशन वैरिएंस स्थिर रहते हैं, जो कई ग्रेडिएंट समस्याओं को पहले ही रोक देते हैं।

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

ये साथ में कैसे फिट होते हैं

ये तकनीकें विकल्प नहीं हैं। ये पूरक औज़ार हैं जो एक ही समग्र समस्या के अलग-अलग हिस्सों को हल करते हैं।

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

निष्कर्ष

ग्रेडिएंट क्लिपिंग डीप लर्निंग की सबसे सरल सुधारों में से एक है, और यह ऐसी समस्या हल करती है जो एक ही स्टेप में घंटों के प्रशिक्षण को बेकार कर सकती है।

अच्छी खबर यह है कि आपको अपना मॉडल आर्किटेक्चर बदलने या ट्रेनिंग कोड फिर से लिखने की ज़रूरत नहीं। PyTorch में एक पंक्ति या TensorFlow में एक आर्ग्युमेंट ग्रेडिएंट क्लिपिंग लागू करने के लिए पर्याप्त है।

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

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

ग्रेडिएंट क्लिपिंग कई ऐसे शब्दों में से एक है, जिन्हें हर मशीन लर्निंग इंजीनियर को जानना चाहिए। यदि आप बाकी सीखना चाहते हैं और 2026 में नौकरी-तैयार होना चाहते हैं, तो आज ही हमारे Machine Learning Engineer ट्रैक में नामांकन करें।