Modèles à entrées multiples

Deep learning intermédiaire avec PyTorch

Michal Oleszak

Machine Learning Engineer

Pourquoi des entrées multiples ?

Exploiter plus d’informations

Schéma d’un modèle qui prend deux images de voiture en entrée et produit une sortie.

Modèles multimodaux

Schéma d’un modèle qui prend une image et un texte en entrée et produit un texte en sortie.

Apprentissage métrique

Schéma d’un modèle qui prend deux visages en entrée et prédit s’ils sont identiques.

Apprentissage auto-supervisé

Schéma d’un modèle qui prend deux versions augmentées de la même image en entrée et apprend qu’elles sont identiques.

Jeu de données Omniglot

Un échantillon d’images du jeu de données Omniglot.

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

Classification de caractères

Schéma du modèle : l’image du caractère est envoyée à un réseau de neurones.

Classification de caractères

Schéma du modèle : un vecteur one-hot de l’alphabet est envoyé à un réseau de neurones.

Classification de caractères

Schéma du modèle : les embeddings du caractère et de l’alphabet sont combinés.

Classification de caractères

Schéma du modèle : à partir des embeddings combinés, un classifieur prédit le caractère.

Dataset à deux entrées

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

Assigner les échantillons et les transforms

print(samples[0])

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

Implémenter __len__()
Charger et transformer l’image
Retourner les deux entrées et le label

Concaténation de tenseurs

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

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

Concaténation selon l’axe 0

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

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

Concaténation selon l’axe 1

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

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

Architecture à deux entrées

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

Définir la couche image
Définir la couche alphabet
Définir la couche classifieur

Architecture à deux entrées

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)

Envoyer l’image dans la couche image
Envoyer l’alphabet dans la couche alphabet
Concaténer les sorties image et alphabet
Envoyer le résultat au classifieur

Boucle d’entraînement

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

Les données d’entraînement contiennent trois éléments :
- Image
- Vecteur alphabet
- Labels
On passe au modèle les images et alphabets

Passons à la pratique !

Deep learning intermédiaire avec PyTorch