Convolutional Neural Networks

इंटरमीडिएट Deep Learning with PyTorch

Michal Oleszak

Machine Learning Engineer

लिनीयर लेयर्स क्यों नहीं?

256x256 ग्रेस्केल इमेज दर्शाता एक काला वर्ग.

लिनीयर लेयर्स क्यों नहीं?

256x256 ग्रेस्केल इमेज में लगभग 65k पिक्सेल वैल्यू होते हैं.

लिनीयर लेयर्स क्यों नहीं?

1000 न्यूरॉन्स का एक लिनीयर लेयर 65k पिक्सेल वैल्यू प्रोसेस करता है.

लिनीयर लेयर्स क्यों नहीं?

इमेज और लेयर के बीच 65m कनेक्शन हैं.

लिनीयर लेयर्स क्यों नहीं?

RGB कलर इमेज के साथ, 200m कनेक्शन होते हैं.

लिनीयर लेयर्स क्यों नहीं?

लिनीयर लेयर्स:
- ट्रेनिंग धीमी
- ओवरफिटिंग
- स्पेशियल पैटर्न नहीं पहचानते
बेहतर विकल्प: कॉन्वोल्यूशनल लेयर्स!

इमेज के कोने में बिल्ली और उसी हिस्से को पढ़ते न्यूरॉन्स

Convolutional layer

साइज 3x3 का फ़िल्टर, 5x5 इनपुट पर स्लाइड होकर 3x3 फीचर मैप बनाता है.

पैरामीटर वाले फ़िल्टर इनपुट पर स्लाइड करें
हर पोजीशन पर कॉन्वोल्यूशन करें
बनने वाला फीचर मैप:
- इनपुट के स्पेशियल पैटर्न बनाए रखता है
- लिनीयर लेयर से कम पैरामीटर इस्तेमाल करता है
एक फ़िल्टर = एक फीचर मैप
फीचर मैप्स पर एक्टिवेशंस लगाएँ
सभी फीचर मैप्स मिलकर आउटपुट बनाते हैं
nn.Conv2d(3, 32, kernel_size=3)

Convolution

दो 3x3 मैट्रिसेस का एलीमेंट-वाइज़ गुणन करके बनी मैट्रिक्स के सभी नंबर जोड़े जाते हैं.

इनपुट पैच और फ़िल्टर का डॉट प्रोडक्ट निकालें
- टॉप-लेफ्ट फ़ील्ड: 2 × 1 = 2
परिणाम को जोड़ें

Zero-padding

एक 4x4 इमेज, जिसे ज़ीरो वैल्यू वाले पिक्सेल की फ्रेम से घेरा गया है.

कॉन्वोल्यूशनल लेयर के इनपुट में ज़ीरो की फ्रेम जोड़ें

nn.Conv2d(
  3, 32, kernel_size=3, padding=1
)

इनपुट और आउटपुट टेन्सर्स के स्पेशियल डायमेंशन्स समान रखता है
बॉर्डर पिक्सेल को बाकी की तरह ही ट्रीट करता है

Max Pooling

4x4 मैट्रिक्स, जिसके हर 2x2 क्वार्टर अलग रंग में चिन्हित हैं, मैक्स पूलिंग के बाद 2x2 बन जाता है.

नॉन-ओवरलैपिंग विंडो को इनपुट पर स्लाइड करें
हर पोजीशन पर केवल अधिकतम वैल्यू रखें
स्पेशियल डायमेंशन्स घटाने के लिए कॉन्वोल्यूशनल लेयर्स के बाद उपयोग करें
nn.MaxPool2d(kernel_size=2)

Convolutional Neural Network

class Net(nn.Module):
    def __init__(self, num_classes):
        super().__init__()

        self.feature_extractor = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
        )

        self.classifier = nn.Linear(64*16*16, num_classes)


    def forward(self, x):  
        x = self.feature_extractor(x)
        x = self.classifier(x)
        return x

feature_extractor: (convolution, activation, pooling), दोहराया गया और फ्लैटन किया
classifier: एक सिंगल लिनीयर लेयर
forward(): इनपुट इमेज को फीचर एक्सट्रैक्टर और क्लासिफायर से पास करें

Feature extractor आउटपुट साइज

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

स्कीमैटिक: 3x64x64 शेप की इनपुट इमेज एक conv लेयर, एक pooling लेयर, फिर एक और conv और pooling से गुजरती है.

Feature extractor आउटपुट साइज

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Feature extractor आउटपुट साइज

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Feature extractor आउटपुट साइज

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Feature extractor आउटपुट साइज

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

अभ्यास करते हैं!

इंटरमीडिएट Deep Learning with PyTorch