बड़े Batches के लिए Gradient Accumulation
छोटे GPUs पर बड़े batches का अनुकरण करें
बड़े Batches के लिए Gradient Accumulation, CoddyKit पर Deep Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Deep Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Deep Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
बड़े Batch की समस्या
बड़े batches से training अक्सर अधिक सुचारु होती है, लेकिन उन्हें बहुत अधिक GPU memory चाहिए। छोटा card एक बार में बहुत बड़ा batch नहीं रख सकता।
मुख्य युक्ति
Gradient accumulation एक बड़े batch को छोटे हिस्सों में बाँटता है। आप उनके gradients जोड़कर केवल एक बार update करते हैं, मानो पूरा batch एक साथ चला हो।
Gradients पहले से संचित होते हैं
PyTorch हर backward pass को बदलने के बजाय .grad में जोड़ता है। यह डिफ़ॉल्ट व्यवहार accumulation की नींव है।
Accumulation की संख्या चुनें
तय करें कि कितने mini-batches से एक update बनेगा। accum_steps का मान चार होने पर चार छोटे batches, चार गुना बड़े एक batch की तरह काम करते हैं।
accum_steps = 4हर Step पर शून्य न करें
मुख्य बदलाव समय का है: zero_grad को हर mini-batch के बाद नहीं, बल्कि accumulation cycle की शुरुआत में ही चलाएँ।
if step % accum_steps == 0:
optimizer.zero_grad()Loss को स्केल करें
backward से पहले प्रत्येक mini-batch के loss को accum_steps से भाग दें। इससे average gradient वही रहता है जो पूरा batch एक साथ चलाने पर मिलता।
loss = loss_fn(model(x), y) / accum_steps
loss.backward()पूरा होने पर ही Step करें
पर्याप्त mini-batches जमा हो जाने पर optimizer.step कॉल करें। अब संचित gradients पूरे बड़े batch को दर्शाते हैं।
if (step + 1) % accum_steps == 0:
optimizer.step()पूरा तरीका
सबको साथ रखें: loss को scale करें, हर step पर backward करें, लेकिन प्रत्येक cycle में केवल एक बार step and zero करें। loop सरल बना रहता है।
for step, (x, y) in enumerate(loader):
loss = loss_fn(model(x), y) / accum_steps
loss.backward()
if (step + 1) % accum_steps == 0:
optimizer.step()
optimizer.zero_grad()Memory कम रहती है
आप एक समय में memory में केवल एक mini-batch रखते हैं। इसी कारण सामान्य GPU अपनी वास्तविक क्षमता से कई गुना बड़े batch जैसा काम कर सकता है।
समझौता
Accumulation memory के बदले समय लेता है: हर update में अधिक forward और backward passes होने से प्रत्येक प्रभावी batch पूरा होने में थोड़ा अधिक समय लेता है।
Batch Norm का ध्यान रखें
Batch norm को अब भी केवल छोटा mini-batch दिखता है, इसलिए उसके statistics वास्तविक बड़े batch से मिलने वाले statistics की तुलना में अधिक अस्थिर होते हैं। इसे ध्यान में रखें।
त्वरित जाँच
आप 4 mini-batches पर accumulation कर रहे हैं। optimizer.step() कब कॉल करना चाहिए?
पुनरावृत्ति
बड़े batch को हिस्सों में बाँटें, loss को accum_steps से भाग दें, हर हिस्से पर backward करें और छोटे memory में बड़े batch जैसा प्रभाव पाने के लिए प्रत्येक cycle में केवल एक बार step करें। 🧮
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “बड़े Batches के लिए Gradient Accumulation” पाठ निःशुल्क है?
हाँ—“बड़े Batches के लिए Gradient Accumulation” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Deep Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Deep Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“बड़े Batches के लिए Gradient Accumulation” में मैं क्या सीखूँगा?
छोटे GPUs पर बड़े batches का अनुकरण करें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Deep Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Deep Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Deep Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।
“बड़े Batches के लिए Gradient Accumulation” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Deep Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Deep Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- autocast और GradScaler के साथ Mixed Precision
- बड़े Batches के लिए Gradient Accumulation
- Bottleneck की Profiling करें
- GPU Memory Usage घटाएँ