इमेज के लिए Convolutional लेयर्स

PyTorch के साथ इमेज के लिए डीप लर्निंग

Michal Oleszak

Machine Learning Engineer

इमेज के लिए Convolutional लेयर्स

इमेज डेटा पर convolutional लेयर्स लागू करें
Convolutional लेयर्स एक्सेस करें और जोड़ें
Convolutional ब्लॉक्स बनाएँ

मॉडल को किसी खास टास्क के अनुसार ढालने के लिए उपयोग होते हैं

बिल्ली के चारों ओर बॉक्स

Conv2d: इनपुट चैनल

RGB चैनल

ग्रेस्केल इमेज: in_channels=1
RGB इमेज (red, green, blue): in_channels=3
ट्रांसपेरेंसी में alpha चैनल शामिल: in_channels=4

from torchvision.transforms import functional
image = PIL.Image.open("dog.png")
num_channels = functional.get_image_num_channels(image)
print("Number of channels: ", num_channels)

Number of channels: 3

Conv2d: kernel

फिल्टर्स

Input tensor Kernel Output tensor (feature map)

Kernel (हरा रंग) इमेज पर बाएँ से दाएँ, ऊपर से नीचे चलता है$^1$

¹ Thevenot, Axel. 2020. A visual and mathematical explanation of the 2D convolution layer.

Kernel साइज़

मैट्रिक्स कैलकुलेशन

सबसे आम kernel साइज़: 3x3 (Conv2d) और 2x2 (MaxPool2d)
Convolution, kernel (हरा) और इमेज रीजन (गुलाबी) का डॉट प्रोडक्ट है
डॉट प्रोडक्ट का सम फीचर मैप (नीला) बनाता है

Kernel एक फ़िल्टर है

इमेज पैटर्न पकड़ें

एरिया फ़िल्टर

लाइन फ़िल्टर

Conv2d: आउटपुट चैनल

आउटपुट चैनल Input channel Kernel filters Output channels

आउटपुट चैनलों की संख्या तय करती है कि कितने फ़िल्टर लगेंगे
हर आउटपुट चैनल एक अलग फ़िल्टर से मेल खाता है
ज्यादा आउटपुट चैनल लेयर को अधिक जटिल फीचर्स सीखने देते हैं
आउटपुट चैनल अक्सर 2 की घातें चुने जाते हैं (16, 32, 64, 128)
- इससे अगली लेयर्स में चैनल्स को जोड़ना/बाँटना आसान होता है

Convolutional लेयर्स जोड़ना

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1)

conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1)

model = Net()

model.add_module('conv2', conv2)

Convolutional लेयर्स एक्सेस करना

print(model)

Net(
  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)

model.conv2

Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))

Convolutional ब्लॉक्स बनाना

nn.Sequential() से एक ब्लॉक में convolutional लेयर्स स्टैक करें

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

        self.conv_block = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

     def forward(self, x):
         x = self.conv_block(x)

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

PyTorch के साथ इमेज के लिए डीप लर्निंग