Couches convolutionnelles pour les images

Deep Learning pour les images avec PyTorch

Michal Oleszak

Machine Learning Engineer

Couches convolutionnelles pour les images

Appliquer des couches convolutionnelles aux images
Accéder aux couches convolutionnelles et en ajouter
Créer des blocs convolutionnels

Servent à adapter les modèles à une tâche précise

Boîte autour d'un chat

Conv2d : canaux d'entrée

Canaux RVB

Image en niveaux de gris : in_channels=1
Image RVB (rouge, vert, bleu) : in_channels=3
Transparence avec canal alpha : in_channels=4

from torchvision.transforms import functional
image = PIL.Image.open("dog.png")
num_channels = functional.get_image_num_channels(image)
print("Number of channels: ", num_channels)

Number of channels: 3

Conv2d : noyau

filtres

Tenseur d'entrée Noyau Tenseur de sortie (carte de caractéristiques)

Le noyau (en vert) se déplace de gauche à droite et de haut en bas sur l'image$^1$

¹ Thevenot, Axel. 2020. A visual and mathematical explanation of the 2D convolution layer.

Tailles de noyau

calcul matriciel

Tailles de noyau les plus courantes : 3x3 (Conv2d) et 2x2 (MaxPool2d)
La convolution est un produit scalaire entre le noyau (vert) et la région de l'image (rose)
La somme du produit scalaire produit une carte de caractéristiques (bleu)

Un noyau est un filtre

Repérer des motifs dans l'image

filtre de zone

filtre de ligne

Conv2d : canaux de sortie

Canal d'entrée Filtres du noyau Canaux de sortie

Le nombre de canaux de sortie détermine combien de filtres sont appliqués
Chaque canal de sortie correspond à un filtre distinct
Plus de canaux de sortie permettent d'apprendre des caractéristiques plus complexes
On choisit souvent des puissances de 2 (16, 32, 64, 128)
- Cela facilite la combinaison et la division des canaux dans les couches suivantes

Ajouter des couches convolutionnelles

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1)

conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1)

model = Net()

model.add_module('conv2', conv2)

Accéder aux couches convolutionnelles

print(model)

Net(
  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)

model.conv2

Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))

Créer des blocs convolutionnels

Empiler des couches convolutionnelles dans un bloc avec nn.Sequential()

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

        self.conv_block = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

     def forward(self, x):
         x = self.conv_block(x)

Passons à la pratique !

Deep Learning pour les images avec PyTorch