Réseaux de neurones convolutionnels

Deep learning intermédiaire avec PyTorch

Michal Oleszak

Machine Learning Engineer

Pourquoi pas des couches linéaires ?

Un carré noir représentant une image en niveaux de gris 256×256.

Deep learning intermédiaire avec PyTorch

Pourquoi pas des couches linéaires ?

Une image 256×256 en niveaux de gris contient environ 65 k valeurs de pixels.

Deep learning intermédiaire avec PyTorch

Pourquoi pas des couches linéaires ?

Une couche linéaire de 1000 neurones traite les 65 k valeurs de pixels.

Deep learning intermédiaire avec PyTorch

Pourquoi pas des couches linéaires ?

Il y a 65 M de connexions entre l'image et la couche.

Deep learning intermédiaire avec PyTorch

Pourquoi pas des couches linéaires ?

Avec une image couleur RVB, il y a 200 M de connexions.

Deep learning intermédiaire avec PyTorch

Pourquoi pas des couches linéaires ?

  • Couches linéaires :
    • Apprentissage lent
    • Surapprentissage
    • Ne détectent pas les motifs spatiaux
  • Meilleure option : couches convolutionnelles !

Image avec un chat dans un coin et des neurones lisant cette zone de l'image

Deep learning intermédiaire avec PyTorch

Couche convolutionnelle

Un filtre 3×3 glisse sur une entrée 5×5 pour produire une carte de caractéristiques 3×3.

  • Faire glisser le(s) filtre(s) de paramètres sur l'entrée
  • À chaque position, effectuer la convolution
  • Carte de caractéristiques obtenue :
    • Préserve les motifs spatiaux de l'entrée
    • Moins de paramètres qu'une couche linéaire
  • Un filtre = une carte de caractéristiques
  • Appliquer des activations aux cartes
  • Toutes les cartes combinées forment la sortie
  • nn.Conv2d(3, 32, kernel_size=3)
Deep learning intermédiaire avec PyTorch

Convolution

Deux matrices 3×3 sont multipliées élément par élément puis la somme de tous les éléments est calculée.

  1. Calculer le produit scalaire entre le patch d'entrée et le filtre
    • Case en haut à gauche : 2 × 1 = 2
  2. Additionner le résultat
Deep learning intermédiaire avec PyTorch

Zero-padding

Une image 4×4 entourée d'un cadre de pixels de valeur zéro.

  • Ajouter un cadre de zéros à l'entrée de la couche convolutionnelle
nn.Conv2d(
  3, 32, kernel_size=3, padding=1
)
  • Conserve les dimensions spatiales des tenseurs d'entrée et de sortie
  • Assure un traitement équitable des pixels en bordure
Deep learning intermédiaire avec PyTorch

Max pooling

Une matrice 4×4 dont chaque quadrant 2×2 a une couleur différente devient 2×2 après max pooling.

  • Faire glisser une fenêtre sans chevauchement sur l'entrée
  • À chaque position, ne garder que la valeur maximale
  • Utilisé après les convolutions pour réduire les dimensions spatiales
  • nn.MaxPool2d(kernel_size=2)
Deep learning intermédiaire avec PyTorch

Réseau de neurones convolutionnel

class Net(nn.Module):
    def __init__(self, num_classes):
        super().__init__()

        self.feature_extractor = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
        )

        self.classifier = nn.Linear(64*16*16, num_classes)


    def forward(self, x):  
        x = self.feature_extractor(x)
        x = self.classifier(x)
        return x
  • feature_extractor : (convolution, activation, pooling), deux fois puis aplati
  • classifier : une couche linéaire
  • forward() : passer l'image d'entrée par l'extracteur puis le classifieur
Deep learning intermédiaire avec PyTorch

Taille de sortie de l'extracteur de caractéristiques

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schéma montrant comment une image d'entrée de forme 3×64×64 passe par une couche conv, une couche de pooling, une autre conv, puis un autre pooling.

Deep learning intermédiaire avec PyTorch

Taille de sortie de l'extracteur de caractéristiques

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schéma montrant comment une image d'entrée de forme 3×64×64 passe par une couche conv, une couche de pooling, une autre conv, puis un autre pooling.

Deep learning intermédiaire avec PyTorch

Taille de sortie de l'extracteur de caractéristiques

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schéma montrant comment une image d'entrée de forme 3×64×64 passe par une couche conv, une couche de pooling, une autre conv, puis un autre pooling.

Deep learning intermédiaire avec PyTorch

Taille de sortie de l'extracteur de caractéristiques

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schéma montrant comment une image d'entrée de forme 3×64×64 passe par une couche conv, une couche de pooling, une autre conv, puis un autre pooling.

Deep learning intermédiaire avec PyTorch

Taille de sortie de l'extracteur de caractéristiques

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schéma montrant comment une image d'entrée de forme 3×64×64 passe par une couche conv, une couche de pooling, une autre conv, puis un autre pooling.

Deep learning intermédiaire avec PyTorch

Passons à la pratique !

Deep learning intermédiaire avec PyTorch

Preparing Video For Download...