TD CNN

1 Applications directes

1.1 Exercice 1

On considère la couche convolutionnelle suivante:

self.conv1 = nn.Conv2d(1, 6, 3, padding=1)

1. Quel est le nombre de canaux d’entrée ? Combien de filtres (convolutions) sont appliquées ?
2. Quelle est la taille de la matrice de convolution ? Quel est le nombre de paramètres en incluant les biais ?
3. Quelle est la taille de sortie d’une image \(50\times 50\) ?

Pour le pooling layer suivant:

nn.MaxPool2d(kernel_size = 2, stride = 2)

4. Quelle est la taille de sortie d’une image \(50\times 50\) ?
5. Combien faut-il de couches pour arriver à une taille d’image inférieure ou égale à \(2\times2\) ?

1.2 Exercice 2

On considère ici le dataset d’exemple MNIST, que l’on peut charger avec les commandes suivantes:

import torchvision.transforms as transforms
import torchvision

transform = transforms.Compose([
    transforms.ToTensor(),  # Convertir en tenseur
    transforms.Normalize((0.5,), (0.5,))  # Normalisation des images
])

train_data = torchvision.datasets.MNIST('.', train=True, download=True, transform=transform)
test_data = torchvision.datasets.MNIST('.', train=False, download=True, transform=transform)

1. Quelle est la taille des images du dataset ?
2. Créer un modèle comprenant:
   • une première couche de convolution, comprenant un unique filtre, avec un padding de 1
   • une deuxième couche de pooling divisant la taille par 2
   • une troisième couche de convolution, comprenant un unique filtre, avec un padding de 1
   • une quatrième couche de pooling divisant la taille par 2
   • une 5ème couche complètement connectée de taille 10
   • une couche de sortie de taille 10
3. Entraîner le modèle sur le dataset d’entraînement pendant 3 epochs.
4. Calculer la précision sur l’ensemble de test à la fin de chaque epoch.
5. Pour la couche 1 et 3, utiliser 6 filtres plutôt que 1. Cela améliore-t-il la précision ?

2 Approfondir

2.1 Exercice 3: CIFAR-10

Charger le dataset CIFAR-10 grâce à la commande:

import torch
import torchvision.transforms as transforms
from datasets import load_dataset

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

# Téléchargement depuis Hugging Face (le serveur utilisé par
# torchvision.datasets.CIFAR10 est très lent)
cifar = load_dataset("uoft-cs/cifar10")

# Petit wrapper pour obtenir des paires (image, label) comme avec torchvision
class CIFAR10(torch.utils.data.Dataset):
    def __init__(self, hf_dataset, transform=None):
        self.data = hf_dataset
        self.transform = transform
        self.classes = hf_dataset.features["label"].names

    def __len__(self):
        return len(self.data)

    def __getitem__(self, i):
        exemple = self.data[i]
        image, label = exemple["img"], exemple["label"]
        if self.transform:
            image = self.transform(image)
        return image, label

trainset = CIFAR10(cifar["train"], transform=transform)
testset = CIFAR10(cifar["test"], transform=transform)

1. Quelle est la taille des images dans le dataset CIFAR-10 ?
2. Divisez la taille du dataset d’entraînement par 10.
3. Créez des modèles avec 2, 5 et 10 couches de convolutions. On ajustera le stride / pooling pour obtenir une image 1x1 à la fin de la convolution.
4. Comparer les performances après 3 epochs sur le dataset de test.

3 Pour aller plus loin

3.1 Exercice 4

Reprendre le modèle de l’exercice 2.

1. Afficher les filtres appris.
2. Pour une image d’exemple, afficher les feature map (i.e. l’image transformée après chaque filtre).

3.2 Exercice 5

Lire et faire les exercices ici: https://d2l.ai/chapter_convolutional-modern/index.html