फ़ाइन-ट्यूनिंग: परतों को खोलना और कम लर्निंग रेट
शिक्षार्थी प्रारंभिक हेड प्रशिक्षण के बाद पहले की परतों को खोलेंगे, पूर्व-प्रशिक्षित विशेषताओं को नष्ट होने से बचाने के लिए कम लर्निंग रेट लागू करेंगे और सटीकता में वृद्धि देखेंगे।
फ़ाइन-ट्यूनिंग: परतों को खोलना और कम लर्निंग रेट, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
फीचर निष्कर्षण के बाद फ़ाइन-ट्यून क्यों करें?
फीचर निष्कर्षण केवल वर्गीकरण हेड को अनुकूलित करता है और बैकबोन को स्थिर रखता है। फ़ाइन-ट्यूनिंग इससे आगे जाकर बैकबोन की कुछ या सभी लेयर्स को भी अपडेट करती है, जिससे मॉडल अपनी अभिव्यक्तियों को आपके विशिष्ट डेटा वितरण के अनुसार ढाल सकता है।
फ़ाइन-ट्यूनिंग तब सबसे अधिक लाभदायक होती है जब आपका डोमेन ImageNet से अलग हो—जैसे उपग्रह चित्र, मेडिकल स्कैन या औद्योगिक दोषों की तस्वीरें। ImageNet के फीचर्स आंशिक रूप से ट्रांसफ़र होते हैं, लेकिन उन्हें अनुकूलित करने से सटीकता मापने योग्य रूप से बढ़ती है। इसका जोखिम विनाशकारी विस्मरण है: यदि आप ऊँचे लर्निंग रेट के साथ फ़ाइन-ट्यून करते हैं, तो नया डेटा सावधानी से पहले सीखे गए फीचर्स को ओवरराइट कर देता है और प्रदर्शन अचानक गिर जाता है।
दो-चरणीय फ़ाइन-ट्यूनिंग रणनीति
फ़ाइन-ट्यूनिंग की मानक विधि में दो चरण होते हैं। चरण 1: बैकबोन को पूरी तरह स्थिर रखें और कई युगों तक केवल नए वर्गीकरण हेड को प्रशिक्षित करें, जब तक कि वह अभिसरित न हो जाए। इससे बैकबोन के ग्रेडिएंट शामिल होने से पहले हेड एक उचित स्थिति से शुरू होता है।
चरण 2: बैकबोन की सभी या कुछ लेयर्स को अनफ़्रीज़ करें और बहुत कम लर्निंग रेट के साथ प्रशिक्षण जारी रखें (आमतौर पर चरण 1 से 10–100 गुना कम)। इससे पहले से सीखे गए फीचर्स नष्ट हुए बिना धीरे-धीरे आपके डोमेन की ओर अनुकूलित होते हैं। चरण 1 को छोड़कर शुरुआत से ही ऊँचे LR के साथ फ़ाइन-ट्यून करना खराब परिणाम देने वाली सबसे सामान्य गलती है।
import torchvision.models as models
import torch.nn as nn
import torch.optim as optim
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
# --- Phase 1: Freeze backbone, train head ---
for param in model.parameters():
param.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, num_classes)
optimizer = optim.Adam(model.fc.parameters(), lr=1e-3)
# Train for 5-10 epochs...
# --- Phase 2: Unfreeze and fine-tune with low LR ---
for param in model.parameters():
param.requires_grad = True
optimizer = optim.Adam(model.parameters(), lr=1e-5) # 100x lowerचयनित अनफ़्रीज़िंग: लेयर-दर-लेयर
पूरे बैकबोन को एक साथ अनफ़्रीज़ करने के बजाय, आप आउटपुट के सबसे निकट वाले ऊपरी भाग से शुरू करके इसे लेयर-दर-लेयर अनफ़्रीज़ कर सकते हैं। ऐसा इसलिए है क्योंकि बाद की लेयर्स में कार्य-विशिष्ट फीचर्स होते हैं, जबकि शुरुआती लेयर्स सार्वभौमिक फीचर्स (किनारे, टेक्सचर) सीखती हैं, जिन्हें आमतौर पर अपडेट करने की आवश्यकता नहीं होती।
ResNet-50 के लिए चयनित अनफ़्रीज़िंग का सामान्य क्रम है: (1) fc (पहले से ट्रेन करने योग्य), (2) layer4, (3) layer3, और अंत में (4) आवश्यकता होने पर layer1 तथा layer2। प्रत्येक चरण में यह जाँचना आवश्यक है कि अतिरिक्त अनफ़्रीज़िंग से सत्यापन सटीकता सुधरती है या नहीं, क्योंकि अधिक ट्रेन करने योग्य पैरामीटर छोटे डेटासेट पर ओवरफ़िटिंग का जोखिम बढ़ाते हैं।
import torchvision.models as models
import torch.nn as nn
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
# Freeze everything first
for param in model.parameters():
param.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, num_classes)
# After phase 1 training, selectively unfreeze layer4
for param in model.layer4.parameters():
param.requires_grad = True
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'Trainable (fc + layer4): {trainable:,}')
# Much fewer parameters to fine-tune than the full 25Mअलग-अलग लर्निंग रेट
अलग-अलग लर्निंग रेट नेटवर्क के अलग-अलग हिस्सों के लिए अलग लर्निंग रेट निर्धारित करते हैं। नया हेड सबसे ऊँचे रेट (1e-3) के साथ प्रशिक्षित होता है, हाल ही में अनफ़्रीज़ की गई बैकबोन लेयर्स मध्यम रेट (1e-4) के साथ, और शुरुआती बैकबोन लेयर्स सबसे कम रेट (1e-5) के साथ या पूरी तरह स्थिर रखी जाती हैं।
PyTorch का ऑप्टिमाइज़र पैरामीटर समूहों की एक सूची स्वीकार करता है, जिनमें से प्रत्येक का अपना lr होता है। यह ट्रांसफर लर्निंग के शोध में मानक तकनीक है और fast.ai के भेदात्मक लर्निंग रेट में उपयोग की जाती है। इसका तर्क यह है कि अधिक सामान्य फीचर्स वाले नेटवर्क के हिस्सों को कार्य-विशिष्ट लेयर्स की तुलना में कम समायोजन की आवश्यकता होती है।
import torch.optim as optim
import torchvision.models as models
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
model.fc = nn.Linear(model.fc.in_features, num_classes)
# Unfreeze everything
for p in model.parameters():
p.requires_grad = True
# Differential learning rates per layer group
optimizer = optim.Adam([
{'params': model.fc.parameters(), 'lr': 1e-3}, # Head: highest LR
{'params': model.layer4.parameters(), 'lr': 1e-4}, # Top block
{'params': model.layer3.parameters(), 'lr': 5e-5}, # Middle
{'params': list(model.layer1.parameters()) +
list(model.layer2.parameters()), 'lr': 1e-5} # Early layers
])विनाशकारी विस्मरण पर नज़र रखना
विनाशकारी विस्मरण तब होता है जब बड़े लर्निंग रेट के साथ फ़ाइन-ट्यूनिंग करने पर पहले से सीखे गए फीचर्स ओवरराइट हो जाते हैं और सत्यापन सटीकता फीचर निष्कर्षण के आधार-परिणाम से भी नीचे चली जाती है। आपको चरण 2 की शुरुआत में प्रशिक्षण हानि में तेज़ उछाल दिखाई देगा, जिसके बाद धीरे-धीरे सुधार होगा।
इसे रोकने के लिए: (1) चरण 2 की शुरुआत हमेशा बहुत कम लर्निंग रेट से करें, (2) हर युग में सत्यापन सटीकता पर नज़र रखें और यदि वह चरण 1 के सर्वोत्तम परिणाम से नीचे जाए तो तुरंत रोक दें, (3) ऐसे लर्निंग रेट शेड्यूलर का उपयोग करें जो बैकबोन LR को धीरे-धीरे बढ़ाए, और (4) चरण 1 के दौरान सर्वोत्तम मॉडल चेकपॉइंट सुरक्षित रखें, ताकि चरण 2 विफल होने पर उसे पुनर्स्थापित किया जा सके।
import torch
best_val_acc = 0.0
best_state = None
for epoch in range(20):
train_one_epoch(model, train_loader, optimizer, criterion, device)
val_acc = evaluate(model, val_loader, device)
if val_acc > best_val_acc:
best_val_acc = val_acc
best_state = {k: v.clone() for k, v in model.state_dict().items()}
# Stop if validation drops more than 2% below best
if val_acc < best_val_acc - 0.02:
print('Early stop: possible catastrophic forgetting')
model.load_state_dict(best_state) # Restore best
breakफ़ाइन-ट्यूनिंग के लिए लर्निंग रेट शेड्यूलर
पूरी फ़ाइन-ट्यूनिंग के दौरान स्थिर लर्निंग रेट शायद ही कभी सर्वोत्तम होता है। लर्निंग रेट शेड्यूलर अभिसरण बेहतर करने के लिए प्रशिक्षण के दौरान LR को समायोजित करते हैं। फ़ाइन-ट्यूनिंग के लिए दो शेड्यूलर विशेष रूप से अच्छे हैं: CosineAnnealingLR कोसाइन वक्र का अनुसरण करते हुए LR को प्रारंभिक मान से लगभग शून्य तक धीरे-धीरे घटाता है, और ReduceLROnPlateau तब LR कम करता है जब सत्यापन मेट्रिक में सुधार रुक जाता है।
patience=2 के साथ ReduceLROnPlateau एक सुरक्षित डिफ़ॉल्ट है: यदि लगातार 2 युगों तक सत्यापन हानि में सुधार नहीं होता, तो LR को factor=0.1 से गुणा किया जाता है। प्रशिक्षण के रुक जाने पर इससे प्रगति अक्सर फिर शुरू हो जाती है।
import torch.optim as optim
from torch.optim.lr_scheduler import ReduceLROnPlateau, CosineAnnealingLR
optimizer = optim.Adam(model.parameters(), lr=1e-4)
# Option 1: Reduce on plateau
scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.1,
patience=2, verbose=True)
# Call after each validation: scheduler.step(val_acc)
# Option 2: Cosine annealing over T_max epochs
scheduler = CosineAnnealingLR(optimizer, T_max=20, eta_min=1e-7)
# Call after each epoch: scheduler.step()
print('Initial LR:', optimizer.param_groups[0]['lr'])फ़ाइन-ट्यूनिंग के दौरान बैच आकार और नियमितीकरण
बड़े बैच आकार के साथ फ़ाइन-ट्यूनिंग करने पर ग्रेडिएंट का शोर कम होता है, जो पहले से सीखे गए फीचर्स में छोटे समायोजन करते समय लाभदायक है। हालांकि, बहुत बड़े बैच फ़ाइन-ट्यूनिंग के दौरान सामान्यीकरण को खराब कर सकते हैं (‘तीक्ष्ण न्यूनतम’ समस्या)। 32–64 का बैच आकार एक अच्छा शुरुआती विकल्प है।
ऑप्टिमाइज़र में वेट डिके (L2 नियमितीकरण) जोड़ें: optim.Adam(model.parameters(), lr=1e-4, weight_decay=1e-4)। वेट डिके किसी एक वेट को बहुत बड़ा होने से रोकता है। यह फ़ाइन-ट्यूनिंग में विशेष रूप से महत्वपूर्ण है, क्योंकि पहले से प्रशिक्षित weights का परिमाण पहले ही उचित होता है और हम उन्हें बहुत आक्रामक ढंग से बदलना नहीं चाहते।
import torch.optim as optim
# Fine-tuning optimiser with weight decay
optimizer = optim.AdamW(
model.parameters(),
lr=1e-4,
weight_decay=1e-4 # L2 regularisation
)
# AdamW separates weight decay from gradient adaptation
# (standard Adam incorrectly applies decay to adaptive gradient scaling)
# AdamW is preferred for fine-tuning transformer models especially
print('Optimizer:', optimizer)फ़ाइन-ट्यूनिंग के दौरान डेटा ऑग्मेंटेशन
डेटा ऑग्मेंटेशन प्रत्येक युग में प्रशिक्षण इमेज पर यादृच्छिक रूपांतरण लागू करता है, जिससे डेटासेट का आकार प्रभावी रूप से कई गुना बढ़ जाता है। जब आपके पास प्रति वर्ग कम इमेज हों, तब फ़ाइन-ट्यूनिंग के दौरान यह विशेष रूप से महत्वपूर्ण होता है। प्राकृतिक इमेज के सामान्य ऑग्मेंटेशन हैं: यादृच्छिक क्षैतिज फ़्लिप, यादृच्छिक रोटेशन (±15°), यादृच्छिक क्रॉप और रंग में यादृच्छिक बदलाव (ब्राइटनेस, कॉन्ट्रास्ट, सैचुरेशन)।
ऑग्मेंटेशन केवल प्रशिक्षण के दौरान लागू करें, सत्यापन या अनुमान के दौरान नहीं। सत्यापन सेट के लिए अलग transform का उपयोग करें, जो केवल नियतात्मक प्रीप्रोसेसिंग (रीसाइज़, बीच से क्रॉप और नॉर्मलाइज़) लागू करे। PyTorch का transforms.Compose इसे आसानी से प्रबंधित करने देता है।
from torchvision import transforms
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224, scale=(0.7, 1.0)),
transforms.RandomHorizontalFlip(p=0.5),
transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
transforms.RandomRotation(degrees=15),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
val_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])व्यावहारिक फ़ाइन-ट्यूनिंग परिणाम
फीचर एक्सट्रैक्शन की तुलना में फाइन-ट्यूनिंग से कितना सुधार मिलता है? लगभग 1000 छवियों वाले किसी सामान्य कस्टम डेटासेट में फीचर एक्सट्रैक्शन से 88% सटीकता मिल सकती है, जबकि फाइन-ट्यूनिंग से यह 92–95% तक पहुँच सकती है। सुधार इस बात पर बहुत निर्भर करता है कि आपका डेटा ImageNet से कितना अलग है।
क्या हो रहा है, यह समझने के लिए इन चार संख्याओं पर नज़र रखें: चरण 1 की सत्यापन सटीकता (फीचर एक्सट्रैक्शन का आधार स्तर), चरण 2 की प्रारंभिक सत्यापन सटीकता (यदि LR सही है, तो यह चरण 1 से कम नहीं होनी चाहिए), चरण 2 की सर्वोत्तम सत्यापन सटीकता (फाइन-ट्यूनिंग का लाभ), और परीक्षण सटीकता (अंतिम परिणाम, जिसे परीक्षण सेट के अनधिकृत प्रभाव से बचने के लिए सबसे अंत में केवल एक बार रिपोर्ट किया जाता है)।
# Example fine-tuning progression
results = {
'Phase 1 (frozen backbone, 10 epochs)': '88.2%',
'Phase 2 initial (unfroze layer4, epoch 1)': '88.5%',
'Phase 2 best (epoch 15)': '92.7%',
'Phase 2 (unfroze layer3 too, epoch 20)': '93.1%',
'Final test accuracy': '92.8%', # Reported only at the end
}
for stage, acc in results.items():
print(f'{stage}: {acc}')
# Key takeaway: fine-tuning added ~4.5% over feature extractionCNN बैकबोन बनाम ViT की फाइन-ट्यूनिंग
ViT (Vision Transformer) मॉडलों की फाइन-ट्यूनिंग के लिए CNN की तुलना में थोड़ी अतिरिक्त सावधानी की आवश्यकता होती है। ViT मॉडलों में Batch Normalisation के बजाय Layer Normalisation होता है, इसलिए model.eval() / model.train() मोड मुख्य रूप से ड्रॉपआउट को प्रभावित करते हैं, न कि सामान्यीकरण के आँकड़ों को — इससे फाइन-ट्यूनिंग थोड़ी सरल हो जाती है।
फाइन-ट्यूनिंग के दौरान ViT मॉडलों को कम अधिकतम लर्निंग रेट से भी लाभ मिलता है (CNN के लिए 1e-4 की तुलना में 1e-5 से 5e-5), क्योंकि अटेंशन वेट बड़े अपडेट के प्रति संवेदनशील होते हैं। ViT की फाइन-ट्यूनिंग के लिए AdamW ऑप्टिमाइज़र को विशेष रूप से प्राथमिकता दी जाती है। सावधानीपूर्वक फाइन-ट्यूनिंग करने पर ViT-B/16 कई कार्यों में CNN के आधार मॉडलों से बेहतर प्रदर्शन कर सकता है।
import torchvision.models as models
import torch.nn as nn
import torch.optim as optim
# Fine-tuning ViT-B/16
vit = models.vit_b_16(weights=models.ViT_B_16_Weights.IMAGENET1K_V1)
vit.heads = nn.Linear(768, num_classes)
# Very low LR for ViT fine-tuning
optimizer = optim.AdamW(
vit.parameters(),
lr=2e-5,
weight_decay=0.01
)
# Warm-up scheduler (common for transformers)
from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR
warmup = LinearLR(optimizer, start_factor=0.01, total_iters=5)
cosine = CosineAnnealingLR(optimizer, T_max=25)
scheduler = SequentialLR(optimizer, schedulers=[warmup, cosine], milestones=[5])त्वरित जाँच
इस पाठ में बताई गई फाइन-ट्यूनिंग रणनीतियों की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: दो-चरणीय फाइन-ट्यूनिंग में पहले हेड को प्रशिक्षित किया जाता है (बैकबोन को स्थिर रखकर), फिर विनाशकारी विस्मरण से बचने के लिए बहुत कम लर्निंग रेट के साथ बैकबोन को भी अनफ्रीज़ किया जाता है; अलग-अलग लर्निंग रेट हेड के लिए अधिक और बैकबोन की गहरी परतों के लिए कम रेट निर्धारित करते हैं; और चयनात्मक अनफ्रीज़िंग में ऊपर की परतों से नीचे की ओर बढ़ने पर सटीकता और दक्षता का सबसे अच्छा संतुलन मिलता है। अगले पाठ में हम इन तकनीकों को कम लेबल वाले वास्तविक मेडिकल इमेजिंग कार्य पर लागू करेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “फ़ाइन-ट्यूनिंग: परतों को खोलना और कम लर्निंग रेट” पाठ निःशुल्क है?
हाँ—“फ़ाइन-ट्यूनिंग: परतों को खोलना और कम लर्निंग रेट” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“फ़ाइन-ट्यूनिंग: परतों को खोलना और कम लर्निंग रेट” में मैं क्या सीखूँगा?
शिक्षार्थी प्रारंभिक हेड प्रशिक्षण के बाद पहले की परतों को खोलेंगे, पूर्व-प्रशिक्षित विशेषताओं को नष्ट होने से बचाने के लिए कम लर्निंग रेट लागू करेंगे और सटीकता में वृद्धि देखेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“फ़ाइन-ट्यूनिंग: परतों को खोलना और कम लर्निंग रेट” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- torchvision में पूर्व-प्रशिक्षित मॉडल: ResNet, EfficientNet और ViT
- विशेषता निष्कर्षण: बैकबोन को स्थिर करना
- फ़ाइन-ट्यूनिंग: परतों को खोलना और कम लर्निंग रेट
- डोमेन अनुकूलन: कम लेबल वाली मेडिकल इमेजिंग