Module 7 — Inception, MobileNet et l'efficacité de calcul

Jusqu'ici, chaque architecture explorée gagne en performance en payant en calcul et en mémoire. VGG et ResNet50 atteignent d'excellents scores sur ImageNet, mais un ResNet50 ne tient pas dans une caméra embarquée à 30 images par seconde, et VGG16 sature un GPU dès quelques images en 224x224. Ce module présente deux familles qui ont pris le problème à l'envers : Inception, qui cherche à extraire plus de représentations pour un même budget, et MobileNet, qui compresse le calcul convolutif jusqu'à tenir sur un téléphone. EfficientNet, à la fin, réconcilie les deux approches.

Le module Inception, plusieurs échelles en parallèle

L'idée d'Inception (Szegedy et al., 2014, GoogLeNet) : à une position donnée, on ne sait pas quelle taille de filtre convient le mieux — un motif fin veut du 1x1, un motif moyen veut du 3x3, un motif large veut du 5x5. Plutôt que de choisir, on applique les trois en parallèle sur la même entrée, on concatène les sorties en canaux, et on laisse le réseau doser.

from tensorflow import keras
from tensorflow.keras import layers

def module_inception(x, c1, c3_reduc, c3, c5_reduc, c5, cpool):
    branche1 = layers.Conv2D(c1, 1, activation="relu", padding="same")(x)

    branche3 = layers.Conv2D(c3_reduc, 1, activation="relu", padding="same")(x)
    branche3 = layers.Conv2D(c3, 3, activation="relu", padding="same")(branche3)

    branche5 = layers.Conv2D(c5_reduc, 1, activation="relu", padding="same")(x)
    branche5 = layers.Conv2D(c5, 5, activation="relu", padding="same")(branche5)

    branche_pool = layers.MaxPooling2D(3, strides=1, padding="same")(x)
    branche_pool = layers.Conv2D(cpool, 1, activation="relu", padding="same")(branche_pool)

    return layers.Concatenate()([branche1, branche3, branche5, branche_pool])

Les convolutions 1x1 dites de réduction placées avant les 3x3 et 5x5 sont l'astuce qui rend le tout viable. Une convolution 5x5 sur 256 canaux d'entrée coûte $5 \times 5 \times 256 \times C_{\text{out}}$ opérations par pixel — sur ImageNet, c'est prohibitif. En intercalant une 1x1 qui ramène 256 canaux à 32, puis en appliquant la 5x5, on divise le coût par un ordre de grandeur.

La convolution 1x1, l'outil oublié

Une convolution 1x1 ne mélange pas les pixels voisins — puisqu'elle n'a qu'un pixel de champ récepteur — mais mélange les canaux. Chaque pixel de sortie est une combinaison linéaire apprise des canaux d'entrée à la même position.

C'est un outil à trois usages :

• Réduction de canaux : passer de 256 à 32 avant une 3x3 coûteuse.
• Expansion de canaux : passer de 64 à 256 en fin d'un bloc bottleneck (module 6).
• Non-linéarité entre couches : deux 1x1 avec ReLU au milieu forment une petite couche dense position par position.

Les architectures modernes en abusent : c'est cheap, expressif, et cela ne change pas la géométrie spatiale.

La convolution séparable en profondeur

MobileNet (Howard et al., 2017) pousse plus loin l'idée que la 1x1 mélange les canaux et que les 3x3 mélangent le voisinage : on sépare les deux gestes.

Une convolution 3x3 ordinaire à $C_{\text{in}}$ canaux d'entrée et $C_{\text{out}}$ canaux de sortie coûte, par pixel :

$$3 \times 3 \times C_{\text{in}} \times C_{\text{out}}.$$

Une convolution séparable en profondeur la remplace par deux gestes successifs :

1. Depthwise 3x3 : chaque canal d'entrée est convolué par un filtre 3x3 qui lui est propre. Aucun mélange de canaux. Coût : $3 \times 3 \times C_{\text{in}}$ par pixel.
2. Pointwise 1x1 : la sortie précédente passe par une 1x1 qui recombine les canaux. Coût : $C_{\text{in}} \times C_{\text{out}}$ par pixel.

Total : $9 C_{\text{in}} + C_{\text{in}} C_{\text{out}}$ contre $9 C_{\text{in}} C_{\text{out}}$ pour la version dense. Le rapport est

$$\dfrac{9 C_{\text{in}} + C_{\text{in}} C_{\text{out}}}{9 C_{\text{in}} C_{\text{out}}} = \dfrac{1}{C_{\text{out}}} + \dfrac{1}{9}.$$

Pour $C_{\text{out}} = 256$, le rapport tombe à environ $\tfrac{1}{9} + \tfrac{1}{256} \approx 0{,}115$. La convolution séparable utilise à peu près huit fois moins de FLOPs qu'une convolution dense équivalente. C'est ce qui rend MobileNet et ses successeurs viables sur des accélérateurs de téléphone.

from tensorflow.keras import layers

# convolution 3x3 classique
layers.Conv2D(256, 3, padding="same")

# equivalent separable en profondeur
layers.SeparableConv2D(256, 3, padding="same")
# = DepthwiseConv2D(3, padding="same") suivie de Conv2D(256, 1)

En précision, la version séparable perd typiquement 1 à 2 points sur ImageNet par rapport à sa version dense, ce qui reste largement rentable dès que la latence compte.

FLOPs, paramètres, latence : trois métriques distinctes

Un piège fréquent est d'assimiler FLOPs et latence réelle. Ce n'est pas la même chose, et l'écart se paie.

• Les FLOPs (opérations à virgule flottante par passe avant) mesurent le travail arithmétique théorique.
• Les paramètres mesurent la mémoire des poids, qui pèse au chargement et à la sauvegarde.
• La latence réelle dépend du matériel : accès mémoire, parallélisme utilisable, taille de lot minimale efficace, opérations fusibles.

MobileNet a peu de FLOPs mais un grand nombre d'accès mémoire non contigus, et sa latence réelle sur un GPU serveur peut être pire qu'un ResNet50 malgré la moitié des FLOPs. À l'inverse, sur un accélérateur mobile optimisé pour la depthwise, MobileNet écrase ResNet50 d'un ordre de grandeur.

Modèle	Paramètres	FLOPs	Latence GPU (typique)	Latence CPU mobile
VGG16	138 M	15,5 G	moyenne	inutilisable
ResNet50	25,6 M	4,1 G	rapide	lente
MobileNetV2	3,5 M	0,3 G	modérée	très rapide
EfficientNet-B0	5,3 M	0,4 G	modérée	rapide

FLOPs ≠ latence

Si votre cible est une puce donnée, mesurez la latence sur cette puce. Un modèle avec moins de FLOPs peut être plus lent parce que ses opérations ne se fusionnent pas bien, ou parce que sa dimension de canaux ne remplit pas les registres. C'est la principale raison pour laquelle EfficientNet a été conçu conjointement avec sa contrainte matérielle.

EfficientNet, l'ajustement conjoint

EfficientNet (Tan et Le, 2019) prend un modèle de base — MobileNetV2 amélioré — et fait varier trois axes ensemble :

• Profondeur (nombre de blocs),
• Largeur (nombre de canaux),
• Résolution d'entrée.

Un coefficient $\phi$ règle les trois selon une règle empirique. B0 est le point de départ (5 M paramètres, 224x224), B7 est la version scalée ($\phi = 6$, 66 M paramètres, 600x600). Pour un même niveau de précision, EfficientNet-B0 dépasse ResNet50 avec 5 fois moins de paramètres et 10 fois moins de FLOPs — une des rares familles à l'avoir clairement fait à sa sortie.

En 2026, la vision moderne mélange trois lignées : ResNet et ses descendants convolutifs (ConvNeXt), les architectures inspirées de MobileNet pour l'embarqué (EfficientNet, MobileNetV3), et les transformeurs de vision (ViT, Swin). Le choix se fait davantage sur la contrainte matérielle et le jeu de données que sur les scores ImageNet, qui sont maintenant serrés au dixième de point.

Sur le fil rouge

Pour le jeu de déchets à trier (module 8 et suivants), on choisira ResNet50 en base préentraînée. Les raisons sont pragmatiques : les poids ImageNet sont largement testés, la profondeur suffit pour six classes, et la latence n'est pas critique — un système de tri à bande transporteuse tolère 100 ms par image. Si la cible était une caméra embarquée temps réel, MobileNetV3 ou EfficientNet-B0 seraient préférables. Le module 9 démontre le geste de transfert, transposable à n'importe laquelle de ces architectures.

En résumé

• Inception applique plusieurs tailles de filtres en parallèle et laisse le réseau doser ; la convolution 1x1 de réduction placée avant les gros filtres est ce qui rend le coût acceptable.
• La convolution séparable en profondeur (depthwise + pointwise) divise le coût par 8 à 10 sur les configurations courantes, avec 1 à 2 points de précision en moins.
• FLOPs, paramètres et latence sont trois métriques distinctes ; ne jamais choisir un modèle d'embarqué sans mesurer la latence sur la cible.
• EfficientNet ajuste conjointement profondeur, largeur et résolution ; c'est le point d'entrée moderne pour un compromis précision/coût sur nouvelle tâche.

Module suivant : l'augmentation de données pour l'image, condition sine qua non pour tirer profit d'un ResNet50 sur un jeu de quelques milliers de photos.