Gradient Accumulation
यह क्यों मायने रखता है
यह उन रोज़मर्रा के tools में से एक है जो consumer hardware पर fine-tuning को संभव बनाते हैं। यह लगभग हर training config में gradient_accumulation_steps के नाम से दिखता है। Training के व्यवहार के लिए जो मात्रा मायने रखती है, वह है effective batch size:
effective batch size = per-step batch size × accumulation steps × GPUs की संख्या
जब कोई guide "batch size 32" कहती है, तो उसका मतलब effective वाला होता है। यह जानकर आप बड़े GPU के लिए बनी recipe को छोटे GPU पर दोहरा सकते हैं।
गहन अध्ययन
Training आम तौर पर एक loop में चलती है: examples का एक batch लीजिए, gradients निकालिए, weights update कीजिए, और दोहराइए। बड़े batches ज़्यादा smooth और भरोसेमंद gradients देते हैं, लेकिन batch का हर example GPU memory लेता है। अगर आपके GPU में सिर्फ़ 4 examples आते हैं और recipe 32 माँगती है, तो आपके सामने एक समस्या है।
Gradient accumulation इसे हल करता है। 4 का एक batch process कीजिए, उसके gradients निकालिए, लेकिन अभी update मत कीजिए। 4 और process कीजिए और नए gradients को पुराने में जोड़ दीजिए। ऐसे 8 mini-batches के बाद जुड़े हुए gradients वही होते हैं जो 32 का एक batch देता। अब weights update कीजिए और reset कीजिए। Memory का इस्तेमाल 4 examples के स्तर पर ही रहता है।
Code में यह कैसा दिखता है
PyTorch में gradients default रूप से तब तक जुड़ते रहते हैं जब तक आप उन्हें साफ़ न करें, इसलिए accumulation बस इस बात का मामला है कि आप optimizer को कब call करते हैं:
for i, batch in enumerate(loader):
loss = model(batch).loss / accum_steps # scale so the sum is an average
loss.backward() # gradients accumulate
if (i + 1) % accum_steps == 0:
optimizer.step()
optimizer.zero_grad()
Hugging Face Transformers जैसी libraries यह काम आपके लिए कर देती हैं जब आप gradient_accumulation_steps set करते हैं।
इसकी कीमत क्या है
Accumulation memory बचाता है, समय नहीं। 32 examples अब भी model से गुज़रते हैं, बस एक बार में 4। जिस hardware पर 32 का असली batch आ जाता, वहाँ असली batch तेज़ होता है क्योंकि वह GPU की parallelism का बेहतर इस्तेमाल करता है।
वे बारीकियाँ जिनमें लोग उलझ जाते हैं
- Steps का मतलब updates है। Accumulation के साथ optimizer का एक step कई mini-batches को cover करता है। Learning rate schedules, warmup और logging आम तौर पर optimizer steps गिनते हैं, इसलिए एक epoch में ये कम होते हैं।
- Batch normalization। जो layers batch पर statistics निकालती हैं, वे अब भी सिर्फ़ छोटा batch ही देखती हैं। Transformers layer normalization इस्तेमाल करते हैं, जिस पर कोई असर नहीं पड़ता।
- Contrastive learning। जो तरीके batch के हर example की तुलना बाकी हर example से करते हैं, जैसे CLIP या embedding training में, उन्हें accumulation से कुछ नहीं मिलता, क्योंकि अलग-अलग mini-batches के examples कभी आपस में नहीं मिलते।
- बचे हुए batches। अगर dataset का size accumulation की गिनती का गुणज नहीं है, तो आखिरी अधूरे group को संभालना पड़ता है।
Values चुनना
Per-step batch size उतना ऊँचा रखिए जितना memory आने दे, फिर accumulation से अपने लक्ष्य के effective batch size तक पहुँचिए। LLMs की LoRA fine-tuning के लिए 16 से 64 के effective batch sizes आम हैं। Accumulation memory बचाने वाली बाकी तरकीबों के साथ अच्छी तरह जुड़ता है: gradient checkpointing, mixed precision और QLoRA की तरह quantized base models।