Couches de convolution (SeparableConv2D)

Les couches SeparableConv2D sont une variante des couches Conv2D conçue pour réduire le nombre de paramètres et la complexité computationnelle tout en conservant la capacité d’extraction de motifs spatiaux dans les images. L’objectif est de rendre les réseaux plus efficaces, particulièrement pour les applications mobiles ou les modèles profonds.

Le principe consiste à décomposer la convolution classique en deux étapes : une convolution en profondeur (depthwise) qui applique un filtre par canal d’entrée pour capturer les motifs spatiaux, suivie d’une convolution pointwise (1×1) qui combine les canaux pour créer de nouvelles cartes de caractéristiques. Cette séparation réduit considérablement le nombre de calculs nécessaires tout en préservant la qualité des représentations.

Les couches SeparableConv2D sont utilisées dans les réseaux convolutionnels pour la classification d’images, la détection d’objets et la segmentation, notamment dans les architectures optimisées comme MobileNet.

En résumé, les couches SeparableConv2D permettent d’extraire des motifs spatiaux dans les images de manière efficace et légère, réduisant la complexité du réseau tout en conservant de bonnes performances.

Fonctions :

SeparableConv2D()

SeparableConv2D est une couche de convolution 2D factorisée en deux étapes : une convolution en profondeur (depthwise) suivie d’une convolution pointwise (1x1). Elle permet de réduire le nombre de paramètres tout en conservant une bonne performance, notamment dans les réseaux légers (comme MobileNet).

Importation :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SeparableConv2D, Flatten, Dense
import numpy as np

Attributs :

Paramètre	Type	Description	Valeur par défaut
`filters`	int	Nombre de filtres de sortie (dimensionnalité de la sortie).	Obligatoire
`kernel_size`	int ou tuple	Taille du noyau de convolution (hauteur, largeur).	Obligatoire
`strides`	int ou tuple	Pas de déplacement de la convolution.	`(1, 1)`
`padding`	str	`'valid'` (sans remplissage) ou `'same'` (conservation de taille).	`'valid'`
`depth_multiplier`	int	Nombre de filtres par canal d’entrée lors de la convolution en profondeur.	`1`
`activation`	str ou fonction	Fonction d’activation à appliquer.	`None`
`input_shape`	tuple	Forme des données d’entrée (hauteur, largeur, canaux).	À spécifier dans la première couche

Exemple de code :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SeparableConv2D, Flatten, Dense
import numpy as np

# Données simulées : 100 images 28x28 en niveaux de gris (1 canal)
X = np.random.rand(100, 28, 28, 1)
y = np.random.randint(0, 10, size=(100,))

# Création du modèle
model = Sequential()
model.add(SeparableConv2D(filters=16, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(Flatten())
model.add(Dense(10, activation='softmax'))

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.summary()

Explication du code :

Importation des bibliothèques

On importe les modules nécessaires depuis Keras et génère des données aléatoires avec NumPy.

Création des données

Les images d’entrée sont des matrices 28×28 avec un seul canal. Les étiquettes vont de 0 à 9 pour un problème de classification à 10 classes.

Définition du modèle

`SeparableConv2D` applique une convolution factorisée (depthwise + pointwise) avec 16 filtres. Cette couche est suivie d’un aplatissement et d’une couche `Dense` pour la classification.

Compilation

Le modèle est compilé pour un problème de classification multi-classes avec l’optimiseur Adam.