Modeller med flera ingångar

Fördjupad djupinlärning med PyTorch

Michal Oleszak

Machine Learning Engineer

Varför flera ingångar?

Mer information

Schema över en modell som tar två bildindata av bilar och producerar ett utdata.

Multimodala modeller

Schema över en modell som tar en bild och en text som indata och producerar ett textutdata.

Metrisk inlärning

Schema över en modell som tar två ansiktsbilder som indata och förutsäger om de föreställer samma person.

Självövervakad inlärning

Schema över en modell som tar två augmenterade versioner av samma bild som indata och lär sig att de är identiska.

Omniglot-datamängden

Ett urval av bilder från Omniglot-datamängden.

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

Teckenigenkänning

Modellschema: teckenbilder skickas till ett neuralt nätverk.

Teckenigenkänning

Modellschema: en one-hot-vektor för alfabet skickas till ett neuralt nätverk.

Teckenigenkänning

Modellschema: inbäddningar för tecken och alfabet kombineras.

Teckenigenkänning

Modellschema: från kombinerade inbäddningar förutsäger en klassificerare tecknet.

Dataset med två ingångar

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

Tilldela samples och transformationer

print(samples[0])

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

Implementera __len__()
Ladda och transformera bild
Returnera båda ingångarna och etiketten

Tensorkoncatenering

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

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

Konkatenering längs axel 0

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

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

Konkatenering längs axel 1

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

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

Arkitektur med två ingångar

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

Definiera bildbehandlingslager
Definiera alfabetbehandlingslager
Definiera klassificeringslager

Arkitektur med två ingångar

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)

Skicka bilden genom bildlagret
Skicka alfabetet genom alfabetlagret
Konkatenera bildutdata och alfabetutdata
Skicka resultatet genom klassificeraren

Träningsloop

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

Träningsdata består av tre delar:
- Bild
- Alfabetsvektor
- Etiketter
Vi skickar bilder och alfabet till modellen

Nu kör vi en övning!

Fördjupad djupinlärning med PyTorch