U-Net के साथ सेमान्टिक सेगमेंटेशन

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

Michal Oleszak

Machine Learning Engineer

सेमान्टिक सेगमेंटेशन

एक ही क्लास के अलग-अलग इंस्टेंस में फर्क नहीं
मेडिकल इमेजिंग या सैटेलाइट इमेज विश्लेषण में उपयोगी
लोकप्रिय आर्किटेक्चर: U-Net

U-Net आर्किटेक्चर

U-Net आर्किटेक्चर डायग्राम

Encoder:

Convolutional और pooling लेयर्स
Downsampling: स्पैटियल डायमेंशंस घटती हैं, depth बढ़ती है

U-Net आर्किटेक्चर

U-Net आर्किटेक्चर डायग्राम

Decoder:

Encoder के समानान्तर (सिमेट्रिक)
Transposed convolutions से फीचर मैप्स को अपसैंपल करता है

U-Net आर्किटेक्चर

U-Net आर्किटेक्चर डायग्राम

Skip connections:

Encoder से decoder तक लिंक
Downsampling में खोई डिटेल्स बचाती हैं

Transposed convolution

Transposed convolution डायग्राम

Decoder में फीचर मैप्स को अपसैंपल करता है: height और width बढ़ती हैं, depth घटती है
Transposed convolution प्रोसेस:
1. इनपुट फीचर मैप के बीच/आसपास zeros डालें
2. Zero-padded इनपुट पर रेगुलर convolution चलाएँ

PyTorch में Transposed convolution

import torch.nn as nn

upsample = nn.ConvTranspose2d(
    in_channels=in_channels,
    out_channels=out_channels,
    kernel_size=2,
    stride=2,
)

U-Net: लेयर डिफिनिशन

class UNet(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(UNet, self).__init__()


        self.enc1 = self.conv_block(in_channels, 64)
        self.enc2 = self.conv_block(64, 128)
        self.enc3 = self.conv_block(128, 256)
        self.enc4 = self.conv_block(256, 512)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)


        self.upconv3 = nn.ConvTranspose2d(512, 256,
                                          kernel_size=2, stride=2)
        self.upconv2 = nn.ConvTranspose2d(256, 128,
                                          kernel_size=2, stride=2)
        self.upconv1 = nn.ConvTranspose2d(128, 64,
                                          kernel_size=2, stride=2)


        self.dec1 = self.conv_block(512, 256)
        self.dec2 = self.conv_block(256, 128)
        self.dec3 = self.conv_block(128, 64)
        self.out = nn.Conv2d(64, out_channels, kernel_size=1)

Encoder:

Convolutional ब्लॉक्स

def conv_block(self, in_channels, out_channels):
return nn.Sequential(
  nn.Conv2d(in_channels, out_channels),
  nn.ReLU(inplace=True),
  nn.Conv2d(out_channels, out_channels),
  nn.ReLU(inplace=True)
)

Pooling लेयर

Decoder:
- Transposed convolutions
- Convolutional ब्लॉक्स

U-Net: forward मेथड

def forward(self, x):

    x1 = self.enc1(x)
    x2 = self.enc2(self.pool(x1))
    x3 = self.enc3(self.pool(x2))
    x4 = self.enc4(self.pool(x3))


    x = self.upconv3(x4)

    x = torch.cat([x, x3], dim=1)

    x = self.dec1(x)


    x = self.upconv2(x)
    x = torch.cat([x, x2], dim=1)
    x = self.dec2(x)

    x = self.upconv1(x)
    x = torch.cat([x, x1], dim=1)
    x = self.dec3(x)


    return self.out(x)

इनपुट को encoder के convolutional ब्लॉक्स और pooling लेयर्स से पास करें
Decoder और skip connections:
- Encoded इनपुट पर transpose convolution चलाएँ
- संबंधित encoder आउटपुट से concatenate करें
- Convolution ब्लॉक से पास करें
- सभी decoder स्टेप्स के लिए दोहराएँ
आखिरी decoder स्टेप का आउटपुट रिटर्न करें

इन्फरेंस चलाना

model = UNet()
model.eval()


image = Image.open("car.jpg")
transform = transforms.Compose([transforms.ToTensor()])
image_tensor = transform(image).unsqueeze(0)


with torch.no_grad():
    prediction = model(image_tensor).squeeze(0)


plt.imshow(prediction[1, :, :])
plt.show()

मूल कार इमेज

कार इमेज पर ओवरले की गई सेमान्टिक मास्क

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

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