संवादात्मक तंत्रिका नेटवर्क - CIFAR-10 डेटासेट पर PyTorch कार्यान्वयन

प्लेटो द्वारा पुनर्प्रकाशित

अनुयायियों: 0

इस लेख के एक भाग के रूप में प्रकाशित किया गया था डेटा साइंस ब्लॉगथॉन

परिचय

सिफर 10 | कन्वेन्शनल न्यूरल नेटवर्क पाइटोरच — छवि 1

कन्वेक्शनल न्यूरल नेटवर्क, जिसे कन्वनेट्स भी कहा जाता है, को पहली बार 1980 के दशक में एक कंप्यूटर विज्ञान शोधकर्ता यान लेकन द्वारा पेश किया गया था, जिन्होंने पृष्ठभूमि में काम किया था। LeCun एक जापानी वैज्ञानिक कुनिहिको फुकुशिमा के काम पर बनाया गया है, जो छवि पहचान के लिए एक बुनियादी नेटवर्क है।

CNN का पुराना संस्करण, जिसे LeNet (LeCun के बाद) कहा जाता है, हस्तलिखित अंक देख सकता है। सीएनएन डाक से पिन कोड खोजने में मदद करता है। लेकिन उनकी विशेषज्ञता के बावजूद, ConvNets कंप्यूटर विज़न और आर्टिफिशियल इंटेलिजेंस के करीब रहे क्योंकि उन्हें एक बड़ी समस्या का सामना करना पड़ा: वे ज्यादा पैमाना नहीं बना सके। सीएनएन को बड़ी छवियों के लिए अच्छी तरह से काम करने के लिए बहुत सारे डेटा और एकीकृत संसाधनों की आवश्यकता होती है।

उस समय, यह विधि केवल कम-रिज़ॉल्यूशन वाली छवियों पर लागू होती थी। पाइटोरच एक पुस्तकालय है जो गहन शिक्षण कार्य कर सकता है। हम इसका उपयोग कन्वेन्शनल न्यूरल नेटवर्क करने के लिए कर सकते हैं। संवेदी तंत्रिका नेटवर्क में कृत्रिम न्यूरॉन्स की कई परतें होती हैं। सिंथेटिक न्यूरॉन्स, जैविक समकक्षों के जटिल सिमुलेशन, गणितीय कार्य हैं जो कई इनपुट और उत्पाद मूल्य सक्रियण के भारित द्रव्यमान की गणना करते हैं।

कन्वेन्शनल न्यूरल नेटवर्क पाइटोरच — छवि 2

उपरोक्त छवि हमें एक सीएनएन मॉडल दिखाती है जो 2 की अंक जैसी छवि लेती है और हमें यह परिणाम देती है कि छवि में किस अंक को एक संख्या के रूप में दिखाया गया है। हम इस लेख में इसे कैसे प्राप्त करते हैं, इसके बारे में हम विस्तार से चर्चा करेंगे।

CIFAR-10 एक डेटासेट है जिसमें 10 अलग-अलग वर्गों की छवियों का संग्रह होता है। विभिन्न मशीन लर्निंग मॉडल और विशेष रूप से कंप्यूटर दृष्टि समस्याओं के परीक्षण के लिए अनुसंधान उद्देश्यों के लिए इस डेटासेट का व्यापक रूप से उपयोग किया जाता है। इस लेख में, हम Pytorch का उपयोग करके एक न्यूरल नेटवर्क मॉडल बनाने की कोशिश करेंगे और CIFAR-10 डेटासेट पर इसका परीक्षण करेंगे कि भविष्यवाणी की सटीकता क्या प्राप्त की जा सकती है।

PyTorch लाइब्रेरी का आयात

एनपी के रूप में numpy आयात करें पीडी के रूप में पांडा आयात करें

टार्चविजन आयात डेटासेट से F के रूप में मशाल आयात करें।

इस चरण में, हम आवश्यक पुस्तकालयों को आयात करते हैं। हम देख सकते हैं कि हम संख्यात्मक संचालन के लिए NumPy और डेटा फ्रेम संचालन के लिए पांडा का उपयोग करते हैं। मशाल पुस्तकालय का उपयोग पाइटोरच को आयात करने के लिए किया जाता है।

Pytorch में एक nn घटक होता है जिसका उपयोग मशीन सीखने के संचालन और कार्यों को अमूर्त करने के लिए किया जाता है। इसे F के रूप में आयात किया जाता है। टॉर्चविजन लाइब्रेरी का उपयोग किया जाता है ताकि हम CIFAR-10 डेटासेट आयात कर सकें। इस पुस्तकालय में कई छवि डेटासेट हैं और व्यापक रूप से अनुसंधान के लिए उपयोग किया जाता है। रूपांतरणों को आयात किया जा सकता है ताकि हम सभी छवियों के लिए छवि को समान आकार में बदल सकें। Tqdm का उपयोग इसलिए किया जाता है ताकि हम प्रशिक्षण के दौरान प्रगति का ट्रैक रख सकें और इसका उपयोग विज़ुअलाइज़ेशन के लिए किया जाता है।

आवश्यक डेटासेट पढ़ें

trainData = pd.read_csv('cifar-10/trainLabels.csv') trainData.head()

एक बार जब हम डेटासेट पढ़ लेते हैं तो हम मेंढक, ट्रक, हिरण, ऑटोमोबाइल आदि जैसे विभिन्न लेबल देख सकते हैं।

PyTorch के साथ डेटा का विश्लेषण

प्रिंट ("अंकों की संख्या:", ट्रेनडाटा। अद्वितीय मान") ट्रेनडेटा में कॉल के लिए: प्रिंट (कॉल,": "लेन (ट्रेनडाटा [कॉल]। अद्वितीय ())) plt.figure (अंजीर = (0))

आउटपुट:

अंकों की संख्या: ५०००० सुविधाओं की संख्या: २ विशेषताएं: ['आईडी' 'लेबल'] अद्वितीय मूल्यों की संख्या आईडी: ५०००० लेबल: १०

इस चरण में, हम डेटासेट का विश्लेषण करते हैं और देखते हैं कि हमारे ट्रेन डेटा में उनकी आईडी और संबद्ध लेबल के साथ लगभग ५०००० पंक्तियाँ हैं। CIFAR-50000 नाम के अनुसार कुल १० वर्ग हैं।

PyTorch का उपयोग करके सत्यापन सेट प्राप्त करना

से टॉर्च.utils.data आयात random_split val_size = 5000 ट्रेन_साइज = लेन (डेटासेट) - val_size train_ds, val_ds = random_split (डेटासेट, [train_size, val_size]) लेन (train_ds), लेन (val_ds)

यह चरण प्रशिक्षण चरण के समान है, लेकिन हम डेटा को ट्रेन और सत्यापन सेट में विभाजित करना चाहते हैं।

(45000, 5000)

से टॉर्च.utils.data.dataloader आयात डेटा लोडर बैच_साइज = 64 ट्रेन_डीएल = डेटा लोडर (ट्रेन_डीएस, बैच_साइज, शफल = ट्रू, num_workers = 4, पिन_मेमोरी = ट्रू) वैल_डीएल = डेटा लोडर (वैल_डीएस, बैच_साइज, num_workers = 4, पिन_मेमोरी)

Torch.utils में एक डेटा लोडर होता है जो वर्कर नंबर या बैच आकार जैसे विभिन्न पैरामीटरों को छोड़कर आवश्यक डेटा लोड करने में हमारी सहायता कर सकता है।

आवश्यक कार्यों को परिभाषित करना

@torch.no_grad() डीईएफ़ सटीकता (आउटपुट, लेबल): _, preds = मशाल। अधिकतम (आउटपुट, मंद = 1) वापसी मशाल। टेंसर (टॉर्च.सम (preds == लेबल)। आइटम () / लेन (preds) )) क्लास इमेजक्लासीफिकेशनबेस (एनएन। मॉड्यूल): डीईएफ़ ट्रेनिंग_स्टेप (सेल्फ, बैच): इमेज, लेबल = बैच आउट = सेल्फ (इमेज) # प्रेडिक्शन लॉस उत्पन्न करें = एफ। क्रॉस_एंट्रॉपी (आउट, लेबल) # नुकसान की गणना करें = सटीकता (आउट) ,लेबल) वापसी हानि, accu def सत्यापन_स्टेप (स्वयं, बैच): छवियां, लेबल = बैच आउट = स्वयं (छवियां) # पूर्वानुमान हानि उत्पन्न करें = F.cross_entropy (बाहर, लेबल) # हानि की गणना करें acc = सटीकता (बाहर, लेबल) # सटीकता वापसी की गणना करें {'नुकसान': हानि। अलग (), 'सटीकता': एसीसी} def सत्यापन_एपोच_एंड (स्वयं, आउटपुट): बैच_लॉस = [एक्स ['नुकसान'] आउटपुट में एक्स के लिए] epoch_loss = मशाल। स्टैक (बैच_लॉस) .mean() # नुकसान को मिलाएं बैच_एसीसी = [एक्स ['सटीकता'] आउटपुट में एक्स के लिए] epoch_acc = टॉर्च.स्टैक (बैच_एसीसी)। माध्य () # संयोजन सटीकता वापसी {'नुकसान': epoch_loss.item (), ' शुद्धता': epoch_acc.item()} def epoch_end(self, epoch, result): pr int ("युग:", युग + 1) प्रिंट (f'ट्रेन सटीकता: {परिणाम ["train_accuracy"] * 100: .2f}% सत्यापन सटीकता: {परिणाम ["सटीकता"] * 100: .2f}%' ) प्रिंट (f'ट्रेन हानि:{result["train_loss"]:.4f} सत्यापन हानि:{result["हानि"]:.4f}')

जैसा कि हम यहां देख सकते हैं कि हमने ImageClassification के वर्ग कार्यान्वयन का उपयोग किया है और यह एक पैरामीटर लेता है जो nn.Module है। इस वर्ग के भीतर, हम विभिन्न कार्यों या प्रशिक्षण, सत्यापन आदि जैसे विभिन्न चरणों को लागू कर सकते हैं। यहां कार्य सरल पायथन कार्यान्वयन हैं।

प्रशिक्षण चरण बैचों में चित्र और लेबल लेता है। हम नुकसान फ़ंक्शन के लिए क्रॉस-एन्ट्रॉपी का उपयोग करते हैं और नुकसान की गणना करते हैं और नुकसान को वापस करते हैं। यह सत्यापन चरण के समान है जैसा कि हम फ़ंक्शन में देख सकते हैं। युग का अंत नुकसान और सटीकता को मिलाता है और अंत में, हम सटीकता और नुकसान को प्रिंट करते हैं।

दृढ़ तंत्रिका नेटवर्क मॉड्यूल का कार्यान्वयन

क्लास Cifar10CnnModel(ImageClassificationBase): def __init__(self): सुपर().__init__() self.network = nn.Sequential(nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2), # आउटपुट: 64 x 16 x 16 nn.BatchNorm2d(64) , nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1), nn .ReLU(), nn.MaxPool2d(2, 2), # आउटपुट: 128 x 8 x 8 nn.BatchNorm2d(128), nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2), # आउटपुट: 256 x 4 x 4 nn.BatchNorm2d(256), nn.Flatten(), nn.Linear(256*4*4, 1024), nn.ReLU(), nn.Linear(1024, 512), nn.ReLU(), nn.Linear (५१२, १०)) डीईएफ़ फॉरवर्ड (सेल्फ, एक्सबी): रिटर्न सेल्फ.नेटवर्क (एक्सबी)

यह तंत्रिका नेटवर्क कार्यान्वयन का सबसे महत्वपूर्ण हिस्सा है। पूरे समय में, हम टॉर्च से आयात किए गए nn मॉड्यूल का उपयोग करते हैं। जैसा कि हम पहली पंक्ति में देख सकते हैं, Conv2d एक मॉड्यूल है जो एक दृढ़ तंत्रिका नेटवर्क को लागू करने में मदद करता है। यहां पहला पैरामीटर 3 दर्शाता है कि छवि रंगीन है और आरजीबी प्रारूप में है। यदि यह एक ग्रेस्केल छवि होती तो हम 1 के लिए जाते।

32 प्रारंभिक आउटपुट चैनल का आकार है और जब हम अगली conv2d परत के लिए जाते हैं तो हमारे पास यह 32 इनपुट चैनल के रूप में और 64 आउटपुट चैनल के रूप में होगा।

पहली पंक्ति में तीसरे पैरामीटर को कर्नेल आकार कहा जाता है और यह हमें उपयोग किए गए फ़िल्टर की देखभाल करने में मदद करता है। पैडिंग ऑपरेशन अंतिम पैरामीटर है।

कनवल्शन ऑपरेशन एक एक्टिवेशन लेयर से जुड़ा है और यहाँ Relu। दो Conv2d परतों के बाद, हमारे पास आकार 2 * 2 का अधिकतम-पूलिंग ऑपरेशन है। इससे निकलने वाला मान स्थिरता के लिए और आंतरिक कोवरिएट शिफ्ट से बचने के लिए बैच सामान्यीकृत है। नेटवर्क को गहरा करने और आकार को कम करने के लिए इन कार्यों को अधिक परतों के साथ दोहराया जाता है। अंत में, हम परत को समतल करते हैं ताकि हम मानों को 10 मानों पर मैप करने के लिए एक रैखिक परत बना सकें। इन 10 न्यूरॉन्स के प्रत्येक न्यूरॉन की संभावना यह निर्धारित करेगी कि अधिकतम संभावना के आधार पर एक विशेष छवि किस वर्ग की है।

मॉडल को प्रशिक्षित करें

@torch.no_grad() def मूल्यांकन (मॉडल, डेटा_लोडर): मॉडल। eval () आउटपुट = [डेटा_लोडर में बैच के लिए मॉडल। सत्यापन_स्टेप (बैच)] रिटर्न मॉडल। सत्यापन_एपोच_एंड (आउटपुट) डीफ़ फिट (मॉडल, ट्रेन_लोडर, वैल_लोडर, युग) = १०, लर्निंग_रेट = ०.००१): best_valid = कोई नहीं इतिहास = [] अनुकूलक = टॉर्च। ऑप्टिम। एडम (मॉडल। पैरामीटर (), लर्निंग_रेट, वेट_डेके = ०.०००५) रेंज में युग के लिए (युग): # प्रशिक्षण चरण मॉडल। ट्रेन ( ) train_losses = [] train_accuracy = [] tqdm (train_loader) में बैच के लिए: हानि, accu = model.training_step (बैच) train_losses.append (हानि) train_accuracy.append (accu) loss.backward() ऑप्टिमाइज़र.स्टेप () ऑप्टिमाइज़र .zero_grad() # सत्यापन चरण परिणाम = मूल्यांकन (मॉडल, वैल_लोडर) परिणाम ['ट्रेन_लॉस'] = मशाल। स्टैक (ट्रेन_लॉस)। माध्य ()। आइटम () परिणाम ['train_accuracy'] = मशाल। स्टैक (ट्रेन_सटीकता)। माध्य ()। आइटम () model.epoch_end (युग, परिणाम) अगर (best_valid == कोई नहीं या best_valid

इतिहास = फिट (मॉडल, ट्रेन_डीएल, वैल_डीएल)

आवश्यक परिणाम प्राप्त करने के लिए हमारे मॉडल को प्रशिक्षित करने के लिए यह एक बुनियादी कदम है। यहां फिट फ़ंक्शन हमारे द्वारा बनाए गए मॉडल के साथ ट्रेन और वैल डेटा को फिट करेगा। फिट फ़ंक्शन प्रारंभ में इतिहास नामक एक सूची लेता है जो प्रत्येक युग के पुनरावृत्ति डेटा का ख्याल रखता है। हम लूप के लिए चलाते हैं ताकि हम प्रत्येक युग में पुनरावृति कर सकें। प्रत्येक बैच के लिए, हम सुनिश्चित करते हैं कि हम tqdm का उपयोग करके प्रगति दिखाएं। हम पहले लागू किए गए प्रशिक्षण चरण को कहते हैं और सटीकता और हानि की गणना करते हैं। पिछड़े प्रसार और रन ऑप्टिमाइज़र के लिए जाना जिसे हमने पहले परिभाषित किया था। एक बार जब हम ऐसा कर लेते हैं तो हम अपनी सूची पर नज़र रखते हैं और फ़ंक्शंस हमें विवरण और प्रगति को प्रिंट करने में मदद करते हैं।

दूसरी ओर, मूल्यांकन फ़ंक्शन, eval फ़ंक्शन का उपयोग करता है, और प्रत्येक चरण के लिए, हम डेटा लोडर से लोड किए गए बैच को लेते हैं, और आउटपुट की गणना की जाती है। मान तब सत्यापन युग के अंत में पारित किया जाता है जिसे हमने पहले परिभाषित किया था और संबंधित मूल्य वापस कर दिया गया है।

परिणामों की साजिश रचना

इस चरण में, हम प्रत्येक युग की तुलना में सटीकता की कल्पना करेंगे। हम देख सकते हैं कि जैसे-जैसे युग बढ़ता है सिस्टम की सटीकता बढ़ती जाती है और इसी तरह नुकसान कम होता रहता है। यहां लाल रेखा प्रशिक्षण डेटा प्रगति और सत्यापन के लिए नीले रंग को इंगित करती है। हम देख सकते हैं कि हमारे परिणामों में अच्छी मात्रा में ओवरफिटिंग हुई है क्योंकि प्रशिक्षण डेटा सत्यापन परिणाम से काफी बेहतर प्रदर्शन कर रहा है और इसी तरह नुकसान के मामले में। 10 युगों के बाद, ट्रेन डेटा 90% सटीकता को बायपास करता है, लेकिन इसमें लगभग 0.5 का नुकसान होता है। परीक्षण डेटा लगभग 81% आता है और नुकसान 0.2 के करीब है।

def plot_accuracies(इतिहास): Validation_accuracies = [x ['सटीकता'] इतिहास में x के लिए] प्रशिक्षण_सटीकता = [x ['train_accuracy'] इतिहास में x के लिए] plt.plot (प्रशिक्षण_सटीकता, '-rx') plt.plot (Validation_accuracies) , '-bx') plt.xlabel('epoch') plt.ylabel('accuracy') plt.legend(['Training', 'Validation']) plt.title('सटीकता बनाम युगों की संख्या') ; प्लॉट_सटीकता (इतिहास)

def प्लॉट_लॉस (इतिहास): ट्रेन_लॉस = [x.get('train_loss') इतिहास में x के लिए] val_losses = [x['हानि'] इतिहास में x के लिए] plt.plot(train_losses, '-bx') plt.plot (val_losses, '-rx') plt.xlabel('epoch') plt.ylabel('loss') plt.legend(['training', 'Validation']) plt.title('नुकसान बनाम युगों की संख्या '); प्लॉट_लॉस (इतिहास)

test_dataset = ImageFolder (data_dir + '/ test', ट्रांसफ़ॉर्म = ToTensor ()) test_loader = DeviceDataLoader (DataLoader (test_dataset, बैच_साइज़), डिवाइस) परिणाम = मूल्यांकन (final_model, test_loader) प्रिंट (f'Test Accuracy: {result ["सटीकता" ]*100:.2f}%')

परीक्षण सटीकता: ८१.०७%

हम देख सकते हैं कि हम 81.07% की सटीकता के साथ समाप्त हुए।

निष्कर्ष:

छवि:https://unsplash.com/photos/5L0R8ZqPZHk

मेरे बारे में: मैं डीप लर्निंग और नेचुरल लैंग्वेज प्रोसेसिंग के क्षेत्र में दिलचस्पी रखने वाला एक शोध छात्र हूं और वर्तमान में आर्टिफिशियल इंटेलिजेंस में पोस्ट-ग्रेजुएशन कर रहा हूं।

छवि स्रोत

Image 1: https://becominghuman.ai/cifar-10-image-classification-fd2ace47c5e8
चित्र 2: https://www.analyticsvidhya.com/blog/2021/05/convolutional-neural-networks-cnn/

मेरे साथ जुड़ने के लिए स्वतंत्र महसूस करें: