Multi-inputmodellen

Gevorderde Deep Learning met PyTorch

Michal Oleszak

Machine Learning Engineer

Waarom multi-input?

Meer informatie gebruiken

Schema van een model dat twee auto-afbeeldingen als input neemt en één output geeft.

Multimodale modellen

Schema van een model dat een afbeelding en een stuk tekst als input neemt en tekst als output geeft.

Metric learning

Schema van een model dat twee gezichtsafbeeldingen als input neemt en voorspelt of ze gelijk zijn.

Zelfgestuurd leren

Schema van een model dat twee geaugmenteerde versies van dezelfde afbeelding als input neemt en leert dat ze gelijk zijn.

Omniglot-dataset

Een selectie afbeeldingen uit de Omniglot-dataset.

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

Tekenclassificatie

Modelschema: tekenafbeelding gaat naar een neuraal netwerk.

Tekenclassificatie

Modelschema: one-hot alfabetvector gaat naar een neuraal netwerk.

Tekenclassificatie

Modelschema: teken- en alfabet-embeddings worden gecombineerd.

Tekenclassificatie

Modelschema: uit gecombineerde embeddings voorspelt een classifier het teken.

Dataset met twee inputs

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

Ken samples en transforms toe

print(samples[0])

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

Implementeer __len__()
Laad en transformeer afbeelding
Retourneer beide inputs en label

Tensor-concatenatie

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

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

Concatenatie langs as 0

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

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

Concatenatie langs as 1

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

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

Architectuur met twee inputs

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), 
        )

Definieer afbeeldingslaag
Definieer alfabetlaag
Definieer classifier

Architectuur met twee inputs

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)

Stuur afbeelding door afbeeldingslaag
Stuur alfabet door alfabetlaag
Concateneer outputs van afbeelding en alfabet
Stuur resultaat door classifier

Trainingslus

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()

Trainset bevat drie items:
- Afbeelding
- Alfabetvector
- Labels
We geven het model afbeeldingen en alfabetten door

Laten we oefenen!

Gevorderde Deep Learning met PyTorch