मल्टी-आउटपुट मॉडल

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

Michal Oleszak

Machine Learning Engineer

मल्टी-आउटपुट क्यों?

मल्टी-टास्क लर्निंग मॉडल स्कीमा: इनपुट में कार की इमेज, आउटपुट में मेक और मॉडल।

मल्टी-लेबल क्लासिफिकेशन मॉडल स्कीमा: एक इमेज इनपुट, आउटपुट में कई प्रेडिक्शन।

रेग्युलराइज़ेशन मॉडल स्कीमा: लेयर्स के कई ब्लॉक; हर ब्लॉक के बाद एक आउटपुट प्रेडिक्ट होता है।

कैरेक्टर और अल्फाबेट क्लासिफिकेशन

मॉडल स्कीमा: कैरेक्टर इमेज को एक न्यूरल नेटवर्क में भेजा गया है.

कैरेक्टर और अल्फाबेट क्लासिफिकेशन

मॉडल स्कीमा: दो क्लासिफायर, इमेज एम्बेडिंग से कैरेक्टर और अल्फाबेट क्लासिफाई करते हैं.

टू-आउटपुट Dataset

class OmniglotDataset(Dataset):
    def __init__(self, transform, samples):
        self.transform = transform
        self.samples = samples

    def __len__(self):
        return len(self.samples)

    def __getitem__(self, idx):
        img_path, alphabet, label = \
            self.samples[idx]
        img = Image.open(img_path).convert('L')
        img = self.transform(img)
        return img, alphabet, label

हम वही Dataset उपयोग कर सकते हैं...
...सिर्फ samples अपडेट करके:

  print(samples[0])

  [(
    'omniglot_train/.../0459_14.png',
     0,
     0,
   )]

टू-आउटपुट आर्किटेक्चर

class Net(nn.Module):
    def __init__(self, num_alpha, num_char):
        super().__init__()
        self.image_layer = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3, padding=1),
            nn.MaxPool2d(kernel_size=2),
            nn.ELU(),
            nn.Flatten(),
            nn.Linear(16*32*32, 128)
        )

        self.classifier_alpha = nn.Linear(128, 30)
        self.classifier_char = nn.Linear(128, 964)


    def forward(self, x):
        x_image = self.image_layer(x)

        output_alpha = self.classifier_alpha(x_image)
        output_char = self.classifier_char(x_image)

        return output_alpha, output_char

इमेज-प्रोसेसिंग सब-नेटवर्क परिभाषित करें
आउटपुट-विशिष्ट क्लासिफायर परिभाषित करें
इमेज को समर्पित सब-नेटवर्क से पास करें
परिणाम को हर आउटपुट लेयर से गुजारें
दोनों आउटपुट रिटर्न करें

ट्रेनिंग लूप

for epoch in range(10):
    for images, labels_alpha, labels_char \
    in dataloader_train:
        optimizer.zero_grad()
        outputs_alpha, outputs_char = net(images)

        loss_alpha = criterion(
          outputs_alpha, labels_alpha
        )
        loss_char = criterion(
          outputs_char, labels_char
        )

        loss = loss_alpha + loss_char

        loss.backward()
        optimizer.step()

मॉडल दो आउटपुट बनाता है
हर आउटपुट का loss निकालें
losses जोड़कर कुल loss बनाएँ
कुल loss से बैकप्रोप करें और ऑप्टिमाइज़ करें

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

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