लर्निंग रेट: सबसे महत्वपूर्ण हाइपरपैरामीटर
शिक्षार्थी लर्निंग-रेट सीमा परीक्षण चलाएँगे, हानि बनाम LR का प्लॉट बनाएँगे, सर्वोत्तम सीमा पहचानेंगे और ठहराव से बचने के लिए CosineAnnealingLR शेड्यूल लागू करेंगे।
लर्निंग रेट: सबसे महत्वपूर्ण हाइपरपैरामीटर, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
लर्निंग रेट सबसे अधिक महत्वपूर्ण क्यों है
लर्निंग रेट (LR) वह एकल हाइपरपैरामीटर है जो इस बात को सबसे अधिक प्रभावित करता है कि न्यूरल नेटवर्क सफलतापूर्वक प्रशिक्षित होगा या नहीं। यह नियंत्रित करता है कि ऑप्टिमाइज़र ऋणात्मक ग्रेडिएंट की दिशा में कितना बड़ा कदम उठाएगा। बहुत बड़ा होने पर मॉडल विचलित हो जाता है; बहुत छोटा होने पर प्रशिक्षण में अत्यधिक समय लगता है या वह अटक जाता है। आर्किटेक्चर के विकल्पों के विपरीत, डेटासेट, मॉडल का आकार या बैच का आकार बदलने पर लगभग हर बार LR को समायोजित करना पड़ता है।
import torch
import torch.nn as nn
import torch.optim as optim
model = nn.Linear(1, 1)
# Too large: diverges
optimizer_big = optim.SGD(model.parameters(), lr=10.0)
# Too small: barely moves
optimizer_small = optim.SGD(model.parameters(), lr=1e-6)
# Good: converges steadily
optimizer_good = optim.SGD(model.parameters(), lr=0.01)
print('LR comparison: 10.0, 1e-6, 0.01')हानि वक्रों पर LR का प्रभाव
अलग-अलग लर्निंग रेट हानि वक्र में पहचाने जा सकने वाले पैटर्न उत्पन्न करते हैं। बहुत अधिक: हानि बहुत अधिक दोलन करती है या कुछ चरणों के बाद बढ़ने लगती है। बहुत कम: हानि अत्यंत धीमी गति से घटती है और वक्र लगभग सपाट रहता है। उचित: हानि सुचारु और लगातार घटती है। लंबे प्रशिक्षण से पहले कुछ प्रतिनिधि LR मानों (जैसे 1e-4, 1e-3, 1e-2, 1e-1) के लिए बैच/युग के अनुसार हानि का आलेख बनाना एक मानक अभ्यास है।
import torch
import torch.nn as nn
import torch.optim as optim
def train_one_lr(lr, steps=50):
model = nn.Linear(1, 1)
opt = optim.SGD(model.parameters(), lr=lr)
X = torch.randn(100, 1)
y = 2 * X + 1
losses = []
for _ in range(steps):
opt.zero_grad()
loss = nn.MSELoss()(model(X), y)
loss.backward(); opt.step()
losses.append(loss.item())
return losses[-1]
for lr in [1e-4, 1e-2, 0.1, 1.0]:
final = train_one_lr(lr)
print(f'LR={lr:.4f}: final_loss={final:.4f}')लर्निंग रेट रेंज परीक्षण
LR रेंज परीक्षण (जिसे Leslie Smith ने लोकप्रिय बनाया) अपने-आप एक अच्छा LR खोजता है। बहुत छोटे LR से शुरू करें और हानि दर्ज करते हुए कई मिनी-बैचों में इसे घातांकीय रूप से बढ़ाएँ। पहले हानि घटती है, फिर LR बहुत बड़ा होने पर तेज़ी से बढ़ने लगती है। इष्टतम LR लगभग उस मान का 10 गुना छोटा होता है जहाँ हानि बढ़ना शुरू होती है। इस परीक्षण में केवल कुछ मिनट लगते हैं और LR पर महँगी ग्रिड खोज की आवश्यकता समाप्त हो जाती है।
import torch
import torch.nn as nn
import torch.optim as optim
import math
def lr_range_test(model, loader, criterion, start_lr=1e-7, end_lr=10, num_iter=100):
optimizer = optim.SGD(model.parameters(), lr=start_lr)
lrs, losses = [], []
mult = (end_lr / start_lr) ** (1 / num_iter)
lr = start_lr
for i, (X, y) in enumerate(loader):
if i >= num_iter: break
optimizer.zero_grad()
loss = criterion(model(X), y)
loss.backward(); optimizer.step()
lrs.append(lr)
losses.append(loss.item())
lr *= mult
for pg in optimizer.param_groups:
pg['lr'] = lr
return lrs, lossesवार्म-अप: छोटे से शुरू करके बढ़ाना
लर्निंग रेट वार्म-अप बहुत छोटे LR से प्रशिक्षण शुरू करता है और पहले कुछ सौ चरणों या युगों में इसे धीरे-धीरे लक्ष्य LR तक बढ़ाता है। इससे शुरुआत में बड़े अस्थिर अपडेट रुकते हैं, जब वेट यादृच्छिक रूप से आरंभ किए गए होते हैं और ग्रेडिएंट शोरयुक्त होते हैं। ट्रांसफ़ॉर्मर और बड़े बैच वाले प्रशिक्षण में वार्म-अप विशेष रूप से महत्वपूर्ण है, क्योंकि शुरुआती बड़े कदम मॉडल को हानि-परिदृश्य के ऐसे खराब क्षेत्र में पहुँचा सकते हैं जहाँ से निकलना कठिन होता है।
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
def warmup_lambda(current_step, warmup_steps=100):
if current_step < warmup_steps:
return current_step / warmup_steps
return 1.0
scheduler = optim.lr_scheduler.LambdaLR(
optimizer, lr_lambda=warmup_lambda
)
for step in range(5):
scheduler.step()
print(f'Step {step}: LR={optimizer.param_groups[0]["lr"]:.6f}')StepLR के साथ चरण-क्षय शेड्यूलिंग
StepLR प्रत्येक step_size युग के बाद लर्निंग रेट को एक गुणक gamma से घटाता है। उदाहरण के लिए, प्रत्येक 10 युग में LR को आधा करना (gamma=0.5, step_size=10) छवि वर्गीकरण के लिए एक सामान्य शेड्यूल है। चरण-क्षय को समझना सरल है और यह तब अच्छा काम करता है जब आपको मोटे तौर पर पता हो कि मॉडल को स्थिर होने में कितने युग लगेंगे। प्रत्येक युग में ऑप्टिमाइज़र चरण के बाद शेड्यूलर को कॉल करना आवश्यक है।
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = optim.lr_scheduler.StepLR(
optimizer, step_size=3, gamma=0.5
)
for epoch in range(9):
# (training happens here)
scheduler.step()
print(f'After epoch {epoch}: LR={optimizer.param_groups[0]["lr"]:.4f}')
# 0.1 -> 0.1 -> 0.1 -> 0.05 -> 0.05 -> 0.05 -> 0.025 ...कोसाइन एनीलिंग: शून्य तक सुचारु क्षय
CosineAnnealingLR T_max चरणों में प्रारंभिक LR से न्यूनतम मान (eta_min, डिफ़ॉल्ट 0) तक कोसाइन वक्र का अनुसरण करते हुए LR घटाता है। कोसाइन आकार शुरुआत में तेज़ कमी और शून्य के पास धीरे उतरने की सुविधा देता है। CosineAnnealingWarmRestarts आवधिक पुनःआरंभ जोड़ता है, जो स्थानीय न्यूनतम बिंदुओं से बाहर निकलने में मदद करते हैं और आरी-दाँत जैसा विशिष्ट LR पैटर्न बनाते हैं। आधुनिक डीप लर्निंग में कोसाइन शेड्यूल सबसे व्यापक रूप से उपयोग किए जाने वाले शेड्यूलों में हैं।
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.SGD(model.parameters(), lr=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(
optimizer, T_max=10, eta_min=1e-4
)
for epoch in range(10):
scheduler.step()
lr = optimizer.param_groups[0]['lr']
print(f'Epoch {epoch}: LR={lr:.5f}')
# Smoothly decays from 0.1 to 0.0001 over 10 epochsReduceLROnPlateau: अनुकूली शेड्यूलिंग
ReduceLROnPlateau किसी मेट्रिक (आमतौर पर सत्यापन हानि) पर नज़र रखता है और जब निर्दिष्ट संख्या में युगों (patience) तक उसमें सुधार नहीं होता, तो LR को एक गुणक से घटाता है। यह सबसे अनुकूली शेड्यूलर है, क्योंकि यह पहले से तय शेड्यूल के बजाय वास्तविक प्रशिक्षण गतिशीलता के अनुसार प्रतिक्रिया देता है। यह विशेष रूप से तब प्रभावी है जब आपको पता न हो कि प्रशिक्षण में कितने युग लगेंगे या प्रशिक्षण की प्रगति असमान हो।
import torch.optim as optim
import torch.nn as nn
model = nn.Linear(4, 2)
optimizer = optim.Adam(model.parameters(), lr=0.01)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
mode='min', # reduce when metric stops going down
factor=0.5, # multiply LR by 0.5
patience=3, # wait 3 epochs before reducing
min_lr=1e-6
)
# Each epoch, pass the validation loss
for epoch in range(10):
val_loss = 1.0 / (epoch + 1) # simulated decreasing loss
scheduler.step(val_loss)
print(f'Epoch {epoch}: LR={optimizer.param_groups[0]["lr"]}')बैच आकार और उसका LR से संबंध
बैच आकार और लर्निंग रेट का आपस में गहरा संबंध है। जब आप बैच आकार को दोगुना करते हैं, तो ग्रेडिएंट का औसत दोगुने नमूनों पर निकाला जाता है—इसलिए उनमें शोर कम होता है। सामान्यतः उपयोग किया जाने वाला एक अनुमान रैखिक स्केलिंग नियम है: बैच आकार जितने गुणा बढ़े, LR को भी उतने ही गुणा बढ़ाएँ। उदाहरण के लिए, बैच आकार को 64 से 128 करने पर LR को भी दोगुना करने का सुझाव मिलता है। यह नियम मध्यम परिस्थितियों में अच्छा काम करता है, लेकिन बहुत बड़े बैचों के लिए प्रभावी नहीं रहता।
# Linear scaling rule: if base LR=0.01 with batch_size=64
# and you change to batch_size=256 (4x larger):
base_lr = 0.01
base_batch = 64
new_batch = 256
scaled_lr = base_lr * (new_batch / base_batch)
print(f'Scaled LR: {scaled_lr}') # 0.04
# But use warm-up when scaling to very large batches
# to avoid instability at the start of trainingग्रेडिएंट क्लिपिंग: विस्फोटक ग्रेडिएंट रोकना
जब LR थोड़ा अधिक हो या ग्रेडिएंट स्वाभाविक रूप से बड़े हों (RNN में यह सामान्य है), तो ग्रेडिएंट क्लिपिंग पैरामीटर अपडेट को विनाशकारी रूप से बड़ा होने से रोकती है। torch.nn.utils.clip_grad_norm_ ग्रेडिएंट सदिश को इस प्रकार पुनःस्केल करता है कि उसका अधिकतम L2 मानक सीमित रहे। क्लिपिंग .backward() कॉल करने के बाद, लेकिन optimizer.step() से पहले की जाती है। आवर्ती नेटवर्क के लिए 1.0 का अधिकतम मानक एक सामान्य डिफ़ॉल्ट है।
import torch
import torch.nn as nn
import torch.optim as optim
model = nn.LSTM(4, 8, batch_first=True)
optimizer = optim.Adam(model.parameters(), lr=0.001)
x = torch.randn(16, 10, 4) # batch=16, seq=10, features=4
out, _ = model(x)
loss = out.sum()
loss.backward()
# Clip gradients before optimizer step
total_norm = nn.utils.clip_grad_norm_(
model.parameters(), max_norm=1.0
)
print(f'Gradient norm before clip: {total_norm:.4f}')
optimizer.step()PyTorch Lightning या मैन्युअल चक्र से LR खोजना
कई विशेषज्ञ PyTorch Lightning के अंतर्निर्मित LR खोजक का उपयोग करते हैं, जो LR रेंज परीक्षण को अपने-आप चलाता है। यदि आप मूल PyTorch का उपयोग कर रहे हैं, तो 100 मिनी-बैचों में LR को घातांकीय रूप से बढ़ाकर और लघुगणकीय पैमाने पर हानि बनाम LR का आलेख बनाकर रेंज परीक्षण मैन्युअल रूप से लागू करें। सबसे उपयुक्त क्षेत्र वह है जहाँ हानि सबसे तीव्रता से घटती है। सुविधा के लिए torch-lr-finder जैसे उपकरण इसे एकल फ़ंक्शन कॉल में समेट देते हैं।
# Manual LR finder sketch (pseudocode)
import math
# 1. Save initial model state
# torch.save(model.state_dict(), 'init.pt')
# 2. Sweep LR exponentially from 1e-7 to 1
start, end, steps = 1e-7, 1.0, 100
mult = (end / start) ** (1 / steps)
lr = start
for i, (X, y) in enumerate(train_loader):
if i >= steps: break
# train one step with current lr...
lr *= mult
# 3. Plot lrs vs losses on log-linear scale
# 4. Pick LR where loss drops fastest
# 5. Restore initial model stateLR सारांश और व्यावहारिक नियम
लर्निंग रेट के सबसे महत्वपूर्ण व्यावहारिक नियम: डिफ़ॉल्ट मान के रूप में Adam के लिए 1e-3 और SGD के लिए 0.01 से शुरू करें। नए डेटासेट या आर्किटेक्चर का उपयोग करते समय हमेशा एक त्वरित LR रेंज परीक्षण चलाएँ। बेहतर अभिसरण के लिए निश्चित LR के बजाय कोसाइन एनीलिंग या ReduceLROnPlateau का उपयोग करें। बैच आकार के साथ LR को रैखिक रूप से स्केल करें। RNN के लिए हमेशा ग्रेडिएंट क्लिपिंग का उपयोग करें। LR को समायोजित करने में लगाया गया प्रयास लगभग किसी भी अन्य अनुकूलन से अधिक लाभ देता है।
# Quick reference for default starting points
defaults = {
'SGD': {'lr': 0.01, 'momentum': 0.9},
'Adam': {'lr': 1e-3, 'betas': (0.9, 0.999)},
'AdamW': {'lr': 1e-3, 'weight_decay': 0.01},
'RMSprop': {'lr': 1e-4}
}
print('Default LR starting points:')
for opt, params in defaults.items():
print(f' {opt}: {params}')त्वरित जाँच
इस पाठ में दिए गए Python के साथ मशीन लर्निंग संबंधी अवधारणाओं की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: लर्निंग रेट सबसे महत्वपूर्ण हाइपरपैरामीटर है, जो अभिसरण की गति और स्थिरता को नियंत्रित करता है; LR रेंज परीक्षण छोटे से बड़े मानों तक जाँच करके और हानि में सबसे तीव्र कमी खोजकर जल्दी से अच्छा LR निर्धारित करता है; तथा CosineAnnealingLR और ReduceLROnPlateau जैसे शेड्यूलर बेहतर अंतिम प्रदर्शन के लिए प्रशिक्षण के दौरान LR को अपने-आप समायोजित करते हैं। आगे हम तेज़ और अधिक स्थिर प्रशिक्षण के लिए बैच सामान्यीकरण का अध्ययन करेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “लर्निंग रेट: सबसे महत्वपूर्ण हाइपरपैरामीटर” पाठ निःशुल्क है?
हाँ—“लर्निंग रेट: सबसे महत्वपूर्ण हाइपरपैरामीटर” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“लर्निंग रेट: सबसे महत्वपूर्ण हाइपरपैरामीटर” में मैं क्या सीखूँगा?
शिक्षार्थी लर्निंग-रेट सीमा परीक्षण चलाएँगे, हानि बनाम LR का प्लॉट बनाएँगे, सर्वोत्तम सीमा पहचानेंगे और ठहराव से बचने के लिए CosineAnnealingLR शेड्यूल लागू करेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“लर्निंग रेट: सबसे महत्वपूर्ण हाइपरपैरामीटर” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- लर्निंग रेट: सबसे महत्वपूर्ण हाइपरपैरामीटर
- बैच सामान्यीकरण: स्थिर और तेज़ प्रशिक्षण
- ओवरफिटिंग रोकने के लिए ड्रॉपआउट नियमितीकरण
- भार आरंभीकरण: Xavier और He आरंभीकरण