🏛️ GoogleNet (Inception v1) – Le Guide Ultime

GoogleNet (aussi appelé Inception v1) est l'architecture de Réseau de Neurones Convolutif (CNN) qui a gagné le concours ILSVRC 2014 (ImageNet).

Il a été créé par une équipe de Google (Szegedy, Ioffe, Vanhoucke...). Son nom est un hommage à "LeNet" (de Yann LeCun) et au film "Inception" (à cause de ses modules imbriqués).

L'Impact (Les Chiffres ILSVRC 2014)

2014 a été la "bataille" entre la profondeur "brute" (VGG) et la profondeur "efficace" (GoogleNet).

Conclusion : GoogleNet a prouvé qu'un réseau pouvait être profond (22 couches) tout en étant extrêmement efficace (20x moins de paramètres que VGG !). Il a introduit des "plugins" (concepts) que *tous* les réseaux modernes (ResNet, MobileNet, YOLO) utilisent aujourd'hui.

Le Problème (Post-AlexNet) : "Plus profond = mieux" (VGG). Mais la profondeur a un coût :
1. Coût de Calcul : Des convolutions 5x5 ou 7x7 sont *très* chères (beaucoup de multiplications).
2. Coût Mémoire : VGG-16 (138M params) pèse > 500 MB. Inutilisable sur mobile.
3. Overfitting : Plus de paramètres = plus de risque de sur-apprentissage.

La Solution (GoogleNet) : Approximer un réseau "clairsemé" (sparse) par des blocs "denses".

L'idée (inspirée du cerveau) est qu'un neurone ne devrait se connecter qu'à *quelques* neurones précédents (sparse), pas à *tous* (dense). Mais le "sparse" est inefficace pour les GPUs.

Le "plugin" Inception (voir 1.4) est la solution : il utilise des filtres parallèles (1x1, 3x3, 5x5) et des "bottlenecks" (goulots) 1x1 (voir 1.3) pour simuler un réseau "sparse" tout en restant "dense" (efficace) pour le GPU.

C'est le "plugin" le plus important de GoogleNet, utilisé *partout* aujourd'hui (y compris dans ResNet et YOLO).

Une Convolution 1x1 (appelée "Pointwise Convolution") est un filtre qui "regarde" 1 seul pixel, mais à travers *toute la profondeur* (tous les canaux). Son seul but est de réduire (ou augmenter) le nombre de filtres (canaux).

Le Problème : Le coût d'un Conv 5x5

Imaginez une entrée (Input) de 28x28x192 (192 filtres).

Si je fais une Convolution 5x5 (pour 32 filtres) :
Nb. de Calculs (Poids) = (5*5 * 192) * 32 = 153 600. (Très cher).

La Solution : Le "Bottleneck" (Goulot)

Au lieu de faire 5x5 directement, on "triche" :

1. Étape 1 (Réduction 1x1) : On réduit 192 filtres à 16.
   Calcul : (1*1 * 192) * 16 = 3 072. (Entrée: 28x28x192 -> Sortie: 28x28x16)
2. Étape 2 (Conv 5x5) : On fait le 5x5 sur la *petite* version.
   Calcul : (5*5 * 16) * 32 = 12 800. (Entrée: 28x28x16 -> Sortie: 28x28x32)

Total : 3 072 + 12 800 = 15 872 poids.
Résultat : On a *divisé* le coût de calcul par 10 (153k vs 15k) pour (presque) le même résultat sémantique.

Le Module Inception (le "plugin" de base) est le bloc qui utilise le "Bottleneck 1x1".

L'idée : "Pourquoi choisir (1x1, 3x3, ou 5x5) ? Faisons *tout* en parallèle, et laissons le réseau apprendre."

Diagramme (Inception v1, avec Bottlenecks)

                     (Input)
                        |
   +--------------------+--------------------+--------------------+
   |                    |                    |                    |
   ▼                    ▼                    ▼                    ▼
[ Conv 1x1 ]      [ Conv 1x1 (Bottleneck) ]  [ Conv 1x1 (Bottleneck) ]  [ MaxPool 3x3 ]
   |                    |                    |                    |
   |                    ▼                    ▼                    ▼
   |              [ Conv 3x3 ]         [ Conv 5x5 ]         [ Conv 1x1 (Bottleneck) ]
   |                    |                    |                    |
   +--------------------+--------------------+--------------------+
                        |
                        ▼
            [ CONCATENATE (par Filtre/Canal) ]
                        |
                     (Output)

Le "Bottleneck" 1x1 est utilisé *avant* les Conv 3x3 et 5x5 (pour réduire le coût) et *après* le MaxPool (pour aligner les filtres).

L'architecture complète de GoogleNet (Inception v1) est un "Stem" (tige) de convolutions classiques, suivi d'une pile de 9 modules Inception.

Diagramme (Architecture GoogleNet)

(Input: Image 224x224x3)
     |
     ▼
[ STEM (Conv 7x7 + MaxPool 3x3) ]
     |
     ▼
[ Conv 1x1 + Conv 3x3 + MaxPool 3x3 ]
     |
     ▼
[ Inception(3a) x 1 ]
[ Inception(3b) x 1 ]
     |
     ▼
[ MaxPool 3x3 ]
     |
     ▼
[ Inception(4a) x 1 ]
[ Inception(4b) x 1 ]
[ Inception(4c) x 1 ]
[ Inception(4d) x 1 ]
[ Inception(4e) x 1 ]
     |
     ▼
[ MaxPool 3x3 ]
     |
     ▼
[ Inception(5a) x 1 ]
[ Inception(5b) x 1 ]
     |
     ▼
[ Global Average Pooling (GAP) ] (voir 1.6)
     |
     ▼
[ Dropout (40%) ]
     |
     ▼
[ FC (Fully Connected) (1000 neurones) ]
     |
     ▼
[ Softmax ]
     |
     ▼
(Sortie: 1000 classes ImageNet)

C'est la deuxième innovation majeure (après le "1x1 bottleneck"). ResNet l'a ensuite copiée et popularisée.

Le Problème : Les couches "Fully Connected" (FC) de VGG

VGG (voir VGG 1.6) "aplatit" (Flatten) sa dernière sortie (7x7x512) en un vecteur géant (25088). Il le connecte ensuite à deux couches FC (4096 neurones).
Ces couches FC représentent > 80% des 138M de paramètres de VGG. Elles sont *très* lourdes et causent de l'overfitting.

La Solution : Global Average Pooling (GAP)

GoogleNet *supprime* ces couches FC.

À la fin du réseau (après Inception(5b)), la sortie est 7x7x1024 (1024 filtres/canaux).

Le GAP (un "plugin" de pooling) prend *chaque* canal (7x7) et le réduit à 1 seul pixel (sa moyenne).

Résultat : 7x7x1024 -> 1x1x1024.
Ce vecteur (1024) est *directement* connecté à la couche de sortie Dense(1000).

Bénéfices :
1. Zéro (ou presque) paramètre (comparé aux 100M+ de VGG).
2. Réduit massivement l'overfitting.
3. Le modèle est beaucoup plus "léger" (7M de params au total).

Le Problème : GoogleNet (22 couches) est *très* profond. Les créateurs avaient peur que le "Vanishing Gradient" (voir 1.2) soit un problème (ResNet n'existait pas encore).

La Solution (Plugin) : Ajouter des "sorties" (têtes de classification) au *milieu* du réseau.
Ces "classifieurs auxiliaires" sont des petites têtes FC (branchées après Inception(4a) et Inception(4d)) qui tentent de prédire la classe (avec un "poids" de 0.3 sur la loss totale).

Diagramme (Flux du Gradient)

(Input) -> [STEM] -> [INCEPTION 3] -> [INCEPTION 4a] ----> (Tête Auxiliaire 1) -> (Loss 1)
                                            |
                                            ▼
                                     [INCEPTION 4d] ----> (Tête Auxiliaire 2) -> (Loss 2)
                                            |
                                            ▼
                                     [INCEPTION 5] -> [GAP] -> (Tête Principale) -> (Loss 3)

(Loss Totale = 1.0 * Loss_3 + 0.3 * Loss_2 + 0.3 * Loss_1)

But : "Injecter" du gradient (signal d'erreur) directement dans les couches du milieu, pour les forcer à apprendre (combattre le vanishing gradient).

Important : Ces têtes auxiliaires ne sont utilisées que pendant l'ENTRAÎNEMENT (training). Elles sont *retirées* pendant l'INFÉRENCE (production).

Le concours ILSVRC 2014 a opposé deux philosophies :

Conclusion : GoogleNet a gagné, mais VGG (plus simple) est devenu le "Backbone" (plugin) préféré pour le *Transfer Learning* (voir 2.3) pendant plusieurs années, car son architecture "linéaire" était plus facile à découper et à réutiliser.

Le "plugin" torchvision (l'addon officiel de PyTorch pour la vision) fournit le modèle GoogleNet (Inception v1) pré-entraîné sur ImageNet.

Exemple (Inférence simple)

import torch
from torchvision import models, transforms
from PIL import Image

# 1. Charger GoogleNet pré-entraîné
# (Note: torchvision.models.googlenet)
model = models.googlenet(pretrained=True)
model.eval() # IMPORTANT: Mode évaluation (désactive les têtes auxiliaires)

# 2. Définir les transforms (standard ImageNet)
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                         std=[0.229, 0.224, 0.225]),
])

# 3. Charger & Pré-processer l'image
img = Image.open("mon_chat.jpg")
img_t = preprocess(img)
batch_t = torch.unsqueeze(img_t, 0) # (Ajoute la dimension batch)

# 4. Inférence
with torch.no_grad():
    output = model(batch_t) # (Output: [1, 1000])

# 5. Interpréter
probabilities = torch.nn.functional.softmax(output[0], dim=0)
top_class_index = torch.argmax(probabilities).item()

# (Charger les 1000 labels d'ImageNet...)
print(f"Prédiction: Classe {top_class_index}") # (ex: 281, 'tabby cat')

L'écosystème Keras (intégré à TensorFlow) fournit également GoogleNet, mais sous son nom "dérivé" le plus populaire : InceptionV3 (voir 3.2).

InceptionV3 est la version "moderne" de GoogleNet (elle inclut Batch Normalization et autres améliorations).

include_top=False (Le "Plugin" Transfer Learning)

Keras rend le Transfer Learning (l'usage n°1) très facile avec l'argument include_top.

import tensorflow as tf
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input, decode_predictions
from tensorflow.keras.preprocessing import image
import numpy as np

# --- 1. Inférence Simple (Avec la "Tête") ---
# (Note: InceptionV3 attend du 299x299)
model_full = InceptionV3(weights='imagenet', include_top=True)

img = image.load_img('mon_chat.jpg', target_size=(299, 299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x) # (Normalisation Keras)

preds = model_full.predict(x)
print(decode_predictions(preds, top=3)[0])
# (Affiche les 3 top prédictions ImageNet)


# --- 2. Mode "Feature Extractor" (Sans la "Tête") ---
# (C'est la base du Transfer Learning)
model_features = InceptionV3(weights='imagenet', include_top=False)

# 'preds_features' n'est PAS (1, 1000), 
# c'est la sortie du "Backbone"
preds_features = model_features.predict(x)

GoogleNet (v1) n'était que le début. Les auteurs ont continué d'améliorer le "plugin" Inception.

Héritage

GoogleNet n'est (presque) plus utilisé "tel quel" (InceptionV1). Il a été remplacé par InceptionV3 (mieux) ou ResNet-50 (plus simple et performant).

Mais son héritage ("plugin") est *fondamental* :

1. Le "1x1 Bottleneck" : C'est la brique de base de ResNet (voir 1.5), MobileNet, et de tous les "necks" (YOLO, ...).
2. Global Average Pooling (GAP) : A tué les couches FC, permettant des réseaux beaucoup plus profonds et légers.
3. Idée "Parallèle" : L'idée d'avoir plusieurs "branches" (paths) dans un bloc est revenue en force (ex: C2f de YOLOv8).