Modele cu intrări multiple

Deep Learning intermediar cu PyTorch

Michal Oleszak

Machine Learning Engineer

De ce intrări multiple?

Utilizarea mai multor informații

Schema unui model care primește două imagini ale unui automobil ca intrări și produce o ieșire.

Modele multimodale

Schema unui model care primește o imagine și un text ca intrări și produce o ieșire text.

Învățare metrică

Schema unui model care primește două imagini cu fețe ca intrări și prezice dacă sunt aceeași persoană.

Învățare auto-supervizată

Schema unui model care primește două versiuni augmentate ale aceleiași imagini și învață că sunt identice.

Setul de date Omniglot

Un eșantion de imagini din setul de date Omniglot.

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

Clasificarea caracterelor

Schema modelului: imaginea unui caracter este transmisă unei rețele neuronale.

Clasificarea caracterelor

Schema modelului: vectorul alfabetului one-hot este transmis unei rețele neuronale.

Clasificarea caracterelor

Schema modelului: reprezentările caracterului și ale alfabetului sunt combinate.

Clasificarea caracterelor

Schema modelului: din reprezentările combinate, un clasificator prezice caracterul.

Dataset cu două intrări

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

Atribuirea eșantioanelor și transformărilor

print(samples[0])

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

Implementarea __len__()
Încărcarea și transformarea imaginii
Returnarea ambelor intrări și a etichetei

Concatenarea tensorilor

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

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

Concatenare după axa 0

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

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

Concatenare după axa 1

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

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

Arhitectură cu două intrări

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

Definirea stratului de procesare a imaginii
Definirea stratului de procesare a alfabetului
Definirea stratului clasificator

Arhitectură cu două intrări

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)

Procesarea imaginii prin stratul de imagine
Procesarea alfabetului prin stratul de alfabet
Concatenarea ieșirilor imaginii și alfabetului
Transmiterea rezultatului prin clasificator

Bucla de antrenare

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

Datele de antrenare conțin trei elemente:
- Imaginea
- Vectorul de alfabet
- Etichetele
Modelului îi sunt transmise imaginile și alfabetele

Să exersăm!

Deep Learning intermediar cu PyTorch