torchvision में पूर्व-प्रशिक्षित मॉडल: ResNet, EfficientNet और ViT
शिक्षार्थी ImageNet पर पूर्व-प्रशिक्षित ResNet-50 लोड करेंगे, उसकी संरचना का निरीक्षण करेंगे और पहले से सीखी गई अभिव्यक्तियों की पुष्टि के लिए नई छवि पर अनुमान करेंगे।
torchvision में पूर्व-प्रशिक्षित मॉडल: ResNet, EfficientNet और ViT, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
पहले से प्रशिक्षित मॉडल का उपयोग क्यों करें?
ImageNet पर शुरू से एक डीप न्यूरल नेटवर्क को प्रशिक्षित करने के लिए लाखों लेबल की गई छवियों और कई सप्ताह की GPU गणना की आवश्यकता होती है। पहले से प्रशिक्षित मॉडल इस विशाल डेटासेट से सामान्य दृश्य विशेषताएँ—किनारे, बनावट, आकार और वस्तुओं के उच्च-स्तरीय भाग—पहले ही सीख चुके होते हैं।
इन भारों का पुनः उपयोग करके, आपको 12 लाख छवियों पर किए गए प्रशिक्षण से लाभ मिलता है और प्रशिक्षण की लागत नहीं उठानी पड़ती। यही ट्रांसफर लर्निंग का मूल विचार है: एक बड़े कार्य पर सीखी गई विशेषताएँ संबंधित छोटे कार्यों में भी अच्छी तरह स्थानांतरित हो जाती हैं। torchvision.models डाउनलोड करके उपयोग करने के लिए तैयार दर्जनों पहले से प्रशिक्षित आर्किटेक्चर उपलब्ध कराता है।
import torchvision.models as models
# List some available pre-trained models
print(dir(models)) # Shows resnet50, efficientnet_b0, vit_b_16, etc.
# Loading weights pre-trained on ImageNet-1k
resnet = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
print('ResNet-50 loaded, parameters:', sum(p.numel() for p in resnet.parameters()))ResNet-50: आर्किटेक्चर का अवलोकन
ResNet-50 (50 परतों वाला रेज़िडुअल नेटवर्क) ने स्किप कनेक्शन प्रस्तुत किए, जो किसी ब्लॉक के इनपुट को सीधे उसके आउटपुट में जोड़ते हैं: output = F(x) + x। इससे ग्रेडिएंट जोड़ के माध्यम से सीधे प्रवाहित हो सकते हैं और ग्रेडिएंट के लुप्त होने की समस्या के बिना बहुत गहरे नेटवर्क को प्रशिक्षित करना संभव होता है।
ResNet-50 में लगभग 2.5 करोड़ पैरामीटर होते हैं और इसमें ये घटक शामिल हैं: एक प्रारंभिक 7×7 कन्वोल्यूशनल परत, अधिकतम पूलिंग, चार रेज़िडुअल ब्लॉक (layer1–layer4), तथा एक ग्लोबल एवरेज पूलिंग परत, जिसके बाद ImageNet वर्गीकरण के लिए 1000-वर्गों वाला पूर्णतः कनेक्टेड हेड होता है। अंतिम fc परत को ही हम अपने कस्टम कार्यों के लिए बदलते हैं।
import torchvision.models as models
import torch
resnet = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
print(resnet) # Prints the full architecture
# Key layers
print('Final FC layer:', resnet.fc) # Linear(2048, 1000)
print('Layer4 output channels:', 2048) # Feature dimension before FCResNet-50 के साथ अनुमान चलाना
अनुमान चलाने से पहले, इनपुट का प्रारूप ImageNet प्रशिक्षण में उपयोग किए गए पूर्व-प्रसंस्करण से मेल खाना चाहिए: आकार कम से कम 224×224 करें और ImageNet के माध्य तथा मानक विचलन से सामान्यीकृत करें। torchvision.transforms API यह कार्य संभालती है। ड्रॉपआउट और बैच सामान्यीकरण के प्रशिक्षण मोड को अक्षम करने के लिए अनुमान से पहले हमेशा model.eval() कॉल करें।
मॉडल 1000 लॉजिट आउटपुट करता है, ImageNet के प्रत्येक वर्ग के लिए एक। प्रायिकताएँ प्राप्त करने के लिए हम softmax लगाते हैं और शीर्ष-k वर्ग चुनते हैं। torchvision.models में अब भारों के मेटाडेटा में वर्गों के नाम भी शामिल होते हैं, इसलिए अलग लेबल फ़ाइल की आवश्यकता नहीं रहती।
import torch
from torchvision import transforms
from PIL import Image
import torchvision.models as models
weights = models.ResNet50_Weights.IMAGENET1K_V1
resnet = models.resnet50(weights=weights)
resnet.eval()
# Preprocessing transforms from the weights metadata
preprocess = weights.transforms()
# Load and preprocess an image
img = Image.open('cat.jpg')
tensor = preprocess(img).unsqueeze(0) # Add batch dimension
with torch.no_grad():
logits = resnet(tensor)
probs = torch.softmax(logits, dim=1)
top5 = torch.topk(probs, 5)
print('Top-5 probabilities:', top5.values)EfficientNet: समग्र स्केलिंग
EfficientNet (2019) ने समग्र स्केलिंग प्रस्तुत की: एकल समग्र गुणांक का उपयोग करके नेटवर्क की चौड़ाई, गहराई और इनपुट रिज़ॉल्यूशन को व्यवस्थित रूप से एक साथ बढ़ाना। नेटवर्क को मनमाने ढंग से अधिक चौड़ा या गहरा बनाने के बजाय, EfficientNet सर्वोत्तम सटीकता-दक्षता संतुलन के लिए इन तीनों आयामों को संतुलित करता है।
EfficientNet परिवार efficientnet_b0 (50 लाख पैरामीटर) से लेकर efficientnet_b7 (6.6 करोड़ पैरामीटर) तक है। EfficientNet-B0, ResNet-50 के समान सटीकता प्राप्त करता है, जबकि इसमें 8 गुना कम पैरामीटर और 6 गुना कम FLOPs होते हैं, जिससे यह मोबाइल और एज परिनियोजन के लिए आदर्श बनता है। PyTorch सभी आठ वैरिएंट उपलब्ध कराता है।
import torchvision.models as models
import torch
# EfficientNet-B0: lightweight but accurate
eff_b0 = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.IMAGENET1K_V1)
print('EfficientNet-B0 params:', sum(p.numel() for p in eff_b0.parameters()))
print('EfficientNet-B0 classifier:', eff_b0.classifier)
# Compare with ResNet-50
resnet50 = models.resnet50(weights=None) # No weights to count params only
print('ResNet-50 params:', sum(p.numel() for p in resnet50.parameters()))Vision Transformer (ViT): कन्वोल्यूशन के बिना ध्यान
Vision Transformers (ViT) (2020) किसी भी कन्वोल्यूशन के बिना transformer आर्किटेक्चर को सीधे छवियों पर लागू करते हैं। छवि को निश्चित आकार वाले पैचों (जैसे, 16×16 पिक्सेल) के ग्रिड में बाँटा जाता है; प्रत्येक पैच को एक पंक्ति में बदलकर एंबेडिंग वेक्टर में प्रक्षेपित किया जाता है। इन पैच एंबेडिंग को NLP में शब्द टोकन की तरह माना जाता है।
पैच अनुक्रम की शुरुआत में एक CLS (वर्गीकरण) टोकन जोड़ा जाता है। सेल्फ-अटेंशन वाले कई transformer एनकोडर ब्लॉकों से गुज़रने के बाद, CLS टोकन के आउटपुट का उपयोग वर्गीकरण के लिए किया जाता है। CNN से बेहतर प्रदर्शन के लिए ViT को बड़े प्रशिक्षण डेटासेट की आवश्यकता होती है, लेकिन torchvision के पहले से प्रशिक्षित ViT मॉडल यह क्षमता आपके कार्यों के लिए तुरंत उपलब्ध करा देते हैं।
import torchvision.models as models
import torch
# ViT-B/16: Base model with 16x16 patches
vit = models.vit_b_16(weights=models.ViT_B_16_Weights.IMAGENET1K_V1)
print('ViT-B/16 params:', sum(p.numel() for p in vit.parameters()))
print('ViT patch size: 16x16 pixels')
print('ViT sequence length for 224x224 image:', (224 // 16) ** 2 + 1, '(196 patches + 1 CLS token)')
print('ViT head:', vit.heads) # Linear(768, 1000)ResNet, EfficientNet और ViT की तुलना
इन आर्किटेक्चर में से चुनाव आपकी सीमाओं और कार्य पर निर्भर करता है। ResNet-50 विश्वसनीय डिफ़ॉल्ट विकल्प है: इसे अच्छी तरह समझा गया है, इसका आधारभूत प्रदर्शन मजबूत है और इसके लिए अनेक ट्यूटोरियल तथा कार्यान्वयन उपलब्ध हैं। जब अनुमान की गति और मॉडल का आकार महत्वपूर्ण हों—जैसे मोबाइल ऐप, रीयल-टाइम सिस्टम या एज हार्डवेयर में—तो EfficientNet-B0/B2 बेहतर विकल्प है।
ViT बड़े पैमाने के कार्यों में उत्कृष्ट प्रदर्शन करता है और सेल्फ-सुपरवाइज़्ड प्री-ट्रेनिंग (DINO, CLIP) से लाभ पाता है। समान सटीकता वाले CNN की तुलना में इसे अधिक गणना और मेमोरी की आवश्यकता होती है। मध्यम आकार के डेटासेट वाले अधिकांश कस्टम छवि वर्गीकरण कार्यों के लिए EfficientNet-B2 या ResNet-50 से शुरुआत करें, फिर यदि आपके पास इसे फाइन-ट्यून करने के पर्याप्त संसाधन हों तो ViT आज़माएँ।
# Rough comparison on ImageNet top-1 accuracy
comparison = {
'ResNet-50': {'params': '25M', 'top1': '76.1%', 'year': 2015},
'EfficientNet-B0': {'params': '5M', 'top1': '77.7%', 'year': 2019},
'EfficientNet-B4': {'params': '19M', 'top1': '83.4%', 'year': 2019},
'ViT-B/16': {'params': '86M', 'top1': '81.1%', 'year': 2020},
'ViT-L/16': {'params': '307M','top1': '85.1%', 'year': 2020},
}
for name, info in comparison.items():
print(f'{name}: {info["params"]} params, {info["top1"]} top-1')मॉडल के आंतरिक भागों का निरीक्षण
अपने कार्य के लिए पहले से प्रशिक्षित मॉडल को संशोधित करने से पहले, उसके आर्किटेक्चर का निरीक्षण करें ताकि समझ सकें कि किन परतों को बदलना है। परतों का वृक्ष देखने के लिए print(model) का उपयोग करें और प्रोग्राम के माध्यम से क्रमशः देखने के लिए named_modules() या named_children() का उपयोग करें।
मुख्य बात यह है कि प्रत्येक torchvision मॉडल का अंत 1000 ImageNet वर्गों के लिए बनाए गए वर्गीकरण हेड से होता है। अपने कार्य के अनुसार मॉडल को ढालने के लिए, जब num_classes का मान 1000 से अलग हो, तो इस अंतिम परत को बदल दें। फीचर एक्सट्रैक्टर (हेड से पहले का सब कुछ) ImageNet से सीखी गई विशेषताओं को बनाए रखता है।
import torchvision.models as models
resnet = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
# Find the names of top-level children
for name, module in resnet.named_children():
print(name, '->', type(module).__name__)
# Output:
# conv1 -> Conv2d
# bn1 -> BatchNorm2d
# relu -> ReLU
# maxpool -> MaxPool2d
# layer1 -> Sequential (Residual blocks)
# layer2 -> Sequential
# layer3 -> Sequential
# layer4 -> Sequential
# avgpool -> AdaptiveAvgPool2d
# fc -> Linear <-- This is what we replaceप्रत्येक आर्किटेक्चर के लिए फीचर वेक्टर का आकार
वर्गीकरण हेड को बदलते समय, आपको बैकबोन (अंतिम परत को छोड़कर बाकी सब) से आउटपुट होने वाला फीचर आयाम पता होना चाहिए। यही आपके नए वर्गीकरण हेड का इनपुट आकार होता है।
बैकबोन के सामान्य आउटपुट आयाम ये हैं: ResNet-50 से 2048, EfficientNet-B0 से 1280, और ViT-B/16 से 768। ये फीचर वेक्टर स्थानिक फीचर मैप पर ग्लोबल एवरेज पूलिंग द्वारा बनाए जाते हैं, जिससे प्रत्येक छवि के लिए एकल वेक्टर मिलता है। आपका प्रतिस्थापन हेड इसी वेक्टर को इनपुट के रूप में लेता है।
import torch
import torchvision.models as models
# Feature dimensions before the classification head
feature_dims = {
'resnet50': 2048,
'efficientnet_b0': 1280,
'efficientnet_b2': 1408,
'efficientnet_b4': 1792,
'vit_b_16': 768,
'vit_l_16': 1024,
}
# Verify for ResNet-50 by running a dummy forward pass without the head
resnet = models.resnet50(weights=None)
resnet.fc = torch.nn.Identity() # Remove FC layer
x = torch.randn(1, 3, 224, 224)
features = resnet(x)
print('ResNet-50 feature size:', features.shape) # (1, 2048)पहले से प्रशिक्षित भारों की गुणवत्ता जाँचना
आप किसी पहले से प्रशिक्षित मॉडल को प्रसिद्ध परीक्षण छवि पर चलाकर और यह जाँचकर जल्दी सत्यापित कर सकते हैं कि शीर्ष पूर्वानुमान अपेक्षित लेबल से मेल खाता है या नहीं। यह सामान्यता जाँच सुनिश्चित करती है कि भार सही ढंग से लोड हुए हैं और पूर्व-प्रसंस्करण प्रक्रिया सही है।
इस परीक्षण के अलावा, भारों के मेटाडेटा से अपेक्षित इनपुट प्रारूप की जाँच करना भी अच्छा अभ्यास है: इनपुट आकार (अधिकांश मॉडलों के लिए 224×224), चैनल क्रम (BGR नहीं, RGB) और सामान्यीकरण स्थिरांक (ImageNet का माध्य और मानक विचलन)। गलत सामान्यीकरण का उपयोग एक सामान्य बग है, जो ट्रांसफर लर्निंग के खराब परिणामों का कारण बनता है।
import torchvision.models as models
weights = models.ResNet50_Weights.IMAGENET1K_V1
print('Expected input size:', weights.meta['min_size']) # (1, 1)
print('Transforms:', weights.transforms())
# Includes Resize(232), CenterCrop(224), Normalize(mean, std)
# ImageNet normalisation constants
IMAGENET_MEAN = [0.485, 0.456, 0.406]
IMAGENET_STD = [0.229, 0.224, 0.225]
# Always use these EXACT values with ImageNet pre-trained modelsअपने कार्य के लिए फाइन-ट्यूनिंग की तैयारी
कस्टम कार्यों पर पहले से प्रशिक्षित मॉडलों का उपयोग करने की सामान्य प्रक्रिया यह है: (1) weights=...IMAGENET1K... के साथ पहले से प्रशिक्षित मॉडल लोड करें, (2) अंतिम वर्गीकरण हेड को आपकी वर्गों की संख्या के अनुसार बनाए गए नए nn.Linear से बदलें, (3) प्रारंभ में वैकल्पिक रूप से बैकबोन के भारों को स्थिर रखें, और (4) शुरू से प्रशिक्षण लेने की तुलना में कम सीखने की दर का उपयोग करके प्रशिक्षण करें।
नया वर्गीकरण हेड यादृच्छिक भारों के साथ शुरू होता है और उसे आपके डेटा से सीखना पड़ता है। बैकबोन उत्कृष्ट विशेषताओं के साथ शुरू होता है और उसमें केवल मामूली समायोजन की आवश्यकता होती है। इसी कारण अंतरात्मक सीखने की दरें—बैकबोन के लिए बहुत कम दर और हेड के लिए अधिक दर—अक्सर अभिसरण की गति और अंतिम सटीकता में सुधार करती हैं।
import torchvision.models as models
import torch.nn as nn
# Example: Adapt ResNet-50 for 5-class flower classification
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
# Replace the final FC layer
num_classes = 5
model.fc = nn.Linear(model.fc.in_features, num_classes)
# Differential learning rates
optimizer = torch.optim.Adam([
{'params': model.fc.parameters(), 'lr': 1e-3}, # High LR for new head
{'params': [p for n, p in model.named_parameters() if 'fc' not in n], 'lr': 1e-5} # Low LR for backbone
])त्वरित जाँच
इस पाठ से पहले से प्रशिक्षित torchvision मॉडलों की अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: ResNet-50 बहुत गहरे नेटवर्क को प्रशिक्षित करने के लिए स्किप कनेक्शन का उपयोग करता है और 2048-आयामी विशेषताएँ आउटपुट करता है, EfficientNet चौड़ाई, गहराई और रिज़ॉल्यूशन की समग्र स्केलिंग द्वारा बेहतर सटीकता-दक्षता संतुलन प्राप्त करता है, तथा ViT कन्वोल्यूशन के बिना छवि पैचों पर transformer सेल्फ-अटेंशन लागू करता है। आगे हम फीचर एक्सट्रैक्शन सीखेंगे—पहले से प्रशिक्षित बैकबोन को स्थिर रखना और अपने कस्टम डेटासेट पर केवल नए वर्गीकरण हेड को प्रशिक्षित करना।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “torchvision में पूर्व-प्रशिक्षित मॉडल: ResNet, EfficientNet और ViT” पाठ निःशुल्क है?
हाँ—“torchvision में पूर्व-प्रशिक्षित मॉडल: ResNet, EfficientNet और ViT” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“torchvision में पूर्व-प्रशिक्षित मॉडल: ResNet, EfficientNet और ViT” में मैं क्या सीखूँगा?
शिक्षार्थी ImageNet पर पूर्व-प्रशिक्षित ResNet-50 लोड करेंगे, उसकी संरचना का निरीक्षण करेंगे और पहले से सीखी गई अभिव्यक्तियों की पुष्टि के लिए नई छवि पर अनुमान करेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“torchvision में पूर्व-प्रशिक्षित मॉडल: ResNet, EfficientNet और ViT” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- torchvision में पूर्व-प्रशिक्षित मॉडल: ResNet, EfficientNet और ViT
- विशेषता निष्कर्षण: बैकबोन को स्थिर करना
- फ़ाइन-ट्यूनिंग: परतों को खोलना और कम लर्निंग रेट
- डोमेन अनुकूलन: कम लेबल वाली मेडिकल इमेजिंग