मल्टी-इनपुट मॉडल्स

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

Michal Oleszak

Machine Learning Engineer

मल्टी-इनपुट क्यों?

और अधिक जानकारी का उपयोग

एक मॉडल की रूपरेखा जो इनपुट में दो कार इमेज लेता है और एक आउटपुट देता है.

मल्टी-मोडल मॉडल्स

एक मॉडल की रूपरेखा जो इनपुट में एक इमेज और एक टेक्स्ट लेता है और टेक्स्ट आउटपुट देता है.

मेट्रिक लर्निंग

एक मॉडल की रूपरेखा जो इनपुट में दो चेहरे की इमेज लेता है और अनुमान लगाता है कि क्या वे एक ही हैं.

सेल्फ-सुपरवाइज्ड लर्निंग

एक मॉडल की रूपरेखा जो एक ही इमेज के दो ऑगमेंटेड वर्शन इनपुट के रूप में लेता है और सीखता है कि वे समान हैं.

Omniglot डेटासेट

Omniglot डेटासेट से इमेज का एक सैंपल.

¹ Lake, B. M., Salakhutdinov, R., and Tenenbaum, J. B. (2015). Human-level concept learning through probabilistic program induction. Science, 350(6266), 1332-1338.

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

मॉडल रूपरेखा: कैरेक्टर इमेज को एक न्यूरल नेटवर्क में पास किया जाता है.

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

मॉडल रूपरेखा: वन-हॉट अल्फाबेट वेक्टर को एक न्यूरल नेटवर्क में पास किया जाता है.

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

मॉडल रूपरेखा: कैरेक्टर और अल्फाबेट एम्बेडिंग्स को जोड़ा जाता है.

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

मॉडल रूपरेखा: संयुक्त एम्बेडिंग्स से क्लासिफायर कैरेक्टर की भविष्यवाणी करता है.

दो-इनपुट Dataset

from PIL import Image

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

सैंपल्स और ट्रांसफॉर्म्स असाइन करें

print(samples[0])

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

__len__() इम्प्लीमेंट करें
इमेज लोड करें और ट्रांसफॉर्म करें
दोनों इनपुट और लेबल रिटर्न करें

टेंसर कन्सैटिनेशन

x = torch.tensor([
  [1, 2, 3],
])

y = torch.tensor([
  [4, 5, 6],
])

एक्सिस 0 के साथ कन्सैटिनेशन

torch.cat((x, y), dim=0)

[[1, 2, 3],
 [4, 5, 6]]

एक्सिस 1 के साथ कन्सैटिनेशन

torch.cat((x, y), dim=1)

[[1, 2, 3, 4, 5, 6]]

दो-इनपुट आर्किटेक्चर

class Net(nn.Module):
    def __init__(self):
        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.alphabet_layer = nn.Sequential(
            nn.Linear(30, 8),
            nn.ELU(),
        )

        self.classifier = nn.Sequential(
            nn.Linear(128 + 8, 964), 
        )

इमेज प्रोसेसिंग लेयर परिभाषित करें
अल्फाबेट प्रोसेसिंग लेयर परिभाषित करें
क्लासिफायर लेयर परिभाषित करें

दो-इनपुट आर्किटेक्चर

def forward(self, x_image, x_alphabet):

    x_image = self.image_layer(x_image)

    x_alphabet = self.alphabet_layer(x_alphabet)

    x = torch.cat((x_image, x_alphabet), dim=1)

    return self.classifier(x)

इमेज को इमेज लेयर से पास करें
अल्फाबेट को अल्फाबेट लेयर से पास करें
इमेज और अल्फाबेट आउटपुट को कन्सैटिनेट करें
परिणाम को क्लासिफायर से पास करें

ट्रेनिंग लूप

net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

for epoch in range(10):
    for img, alpha, labels in dataloader_train:
        optimizer.zero_grad()
        outputs = net(img, alpha)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

ट्रेनिंग डेटा में तीन आइटम होते हैं:
- इमेज
- अल्फाबेट वेक्टर
- लेबल्स
हम मॉडल को इमेज और अल्फाबेट पास करते हैं

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

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