🤖 AlexNet – Le Guide Ultime

AlexNet est le nom d'un Réseau de Neurones Convolutif (CNN) qui a marqué un tournant décisif dans l'histoire de l'Intelligence Artificielle.

L'Événement : Le concours ILSVRC (ImageNet Large Scale Visual Recognition Challenge) de 2012. Le but était de classifier des images (parmi 1000 classes, ex: "chat", "chien", "avion").

L'Impact (Le "Big Bang")

Avant 2012, la "Computer Vision" (CV) était dominée par des techniques "classiques" (ex: SIFT, HOG) qui plafonnaient à un taux d'erreur de 26.2% (Top-5).

En 2012, AlexNet (créé par Alex Krizhevsky, Ilya Sutskever, et Geoffrey Hinton de l'Université de Toronto) est arrivé. C'était un "Deep Learning" CNN "très profond" (8 couches, ce qui était énorme à l'époque) entraîné sur des GPUs.

Résultat : AlexNet a obtenu un taux d'erreur de 15.3%. Il a pulvérisé le 2ème (qui était à 26.2%) d'une marge de plus de 10 points. Le monde académique et industriel a compris ce jour-là que le Deep Learning (CNNs + GPUs) était l'avenir. C'est le début de l'IA moderne.

Pour comprendre l'impact d'AlexNet, il faut comprendre l'état de l'art en 2011.

La CV "Classique" (Avant AlexNet)

L'approche "classique" (ex: SIFT, HOG) était basée sur le "Handcrafted Feature Engineering" (Ingénierie de caractéristiques à la main) :

1. Des experts (humains) passaient des mois à *coder* un algorithme pour *extraire* des "features" (ex: "détecter les coins", "mesurer les gradients de texture").
2. On donnait ensuite ces "features" (simplifiées) à un classifieur (ex: un SVM).

L'Approche AlexNet (Deep Learning)

AlexNet a prouvé que cette approche était obsolète.
1. On donne l'image brute (pixels) au réseau (le CNN).
2. On lui donne le label ("chat").
3. On le "force" (via la "backpropagation") à *apprendre* lui-même les "features" pertinentes.

AlexNet a prouvé que le réseau "apprenait" de meilleures features (des filtres) que les humains ne pouvaient en "designer".

Les Chiffres (ILSVRC Top-5 Error Rate)

Pour 2012, AlexNet était *massif*. Il a 60 millions de paramètres (poids) et 8 couches apprenables.

Diagramme (Simplifié)

(Input: Image 227x227x3)
     |
     ▼
[ CONV 1 (11x11, Stride 4) + ReLU + MaxPool(3x3, S2) ]  (-> 27x27)
     |
     ▼
[ CONV 2 (5x5, Stride 1) + ReLU + MaxPool(3x3, S2) ]   (-> 13x13)
     |
     ▼
[ CONV 3 (3x3, Stride 1) + ReLU ]
     |
     ▼
[ CONV 4 (3x3, Stride 1) + ReLU ]
     |
     ▼
[ CONV 5 (3x3, Stride 1) + ReLU + MaxPool(3x3, S2) ]   (-> 6x6)
     |
     | (Flatten -> 6*6*256 = 9216)
     ▼
[ FC 6 (Fully Connected) (4096 neurones) + ReLU + Dropout ]
     |
     ▼
[ FC 7 (Fully Connected) (4096 neurones) + ReLU + Dropout ]
     |
     ▼
[ FC 8 (Output) (1000 neurones) + Softmax ]
     |
     ▼
(Sortie: Probabilités pour 1000 classes)

Split sur 2 GPUs

Le "plugin" secret était l'entraînement sur 2 GPUs NVIDIA GTX 580 (avec 3GB de VRAM !). 60M de paramètres ne rentraient pas sur 1 seul GPU.
L'architecture était *littéralement* coupée en deux : 4 couches sur le GPU 1, 4 couches sur le GPU 2, avec des "communications" (cross-over) à certaines couches.

Avant AlexNet, les réseaux de neurones utilisaient des fonctions d'activation "saturantes" (tanh ou sigmoïde).

Le Problème : "Vanishing Gradient" (Gradient Evanescent)

Les fonctions tanh/sigmoïde ont un problème : si l'entrée (x) est très grande ou très petite, la courbe devient "plate". La dérivée (le "gradient") devient zéro.
Lors de la "backpropagation" (l'apprentissage), on multiplie ces gradients. Si on multiplie 0.1 * 0.1 * 0.1... le signal "disparaît" (vanish). Les premières couches du réseau n'apprennent *rien*.

La Solution : ReLU f(x) = max(0, x)

AlexNet a popularisé l'utilisation de ReLU (Rectified Linear Unit).

• Si x < 0 (négatif) : La sortie est 0.
• Si x > 0 (positif) : La sortie est x.

Avantages du "Plugin" ReLU

Selon le papier d'AlexNet, l'utilisation de ReLU a permis à l'entraînement de converger 6 fois plus vite que tanh.

L'entraînement d'un réseau de 60M de paramètres sur 1.1M d'images (ImageNet) était *impossible* sur CPU (aurait pris des mois/années).

L'innovation d'Alex Krizhevsky a été d'utiliser des GPUs (processeurs graphiques) de "gaming" (NVIDIA) pour paralléliser les calculs (les convolutions sont des multiplications de matrices, ce pour quoi les GPUs sont faits).

Le "Setup" (L'Addon Matériel)

• GPU : 2x NVIDIA GTX 580
• VRAM (Mémoire) : 3 GB par carte. (Aujourd'hui, une RTX 4090 a 24 GB).

Le Défi : 3 GB de VRAM

Les 60M de paramètres ne rentraient pas dans 3 GB de RAM. La solution fut de "splitter" (diviser) le modèle en deux.

+----------------------+ +----------------------+
| GPU 1                | | GPU 2                |
| (3M de paramètres)   | | (3M de paramètres)   |
+----------------------+ +----------------------+
            |                      |
            ▼                      ▼
      [ CONV 1a ]            [ CONV 1b ]
      [ POOL 1a ]            [ POOL 1b ]
            |                      |
            ▼                      ▼
      [ CONV 2a ]            [ CONV 2b ]
            | \                  / |
            |  \ (Communication) /  |
            |  / (Cross-over)  \  |
            ▼ /                  \ ▼
      [ CONV 3a ]            [ CONV 3b ]
            |                      |
            ...                    ...
            |                      |
            +----------+-----------+
                       |
                       ▼
                 [ FC 8 (Softmax) ]

Cette utilisation (très complexe) de 2 GPUs a permis d'entraîner un modèle 2x plus gros que ce qu'un seul GPU pouvait supporter. L'entraînement a quand même pris 5 à 6 jours.

Le Problème : L'Overfitting (Sur-apprentissage).
Avec 60 millions de paramètres, le réseau a une tendance *massive* à "apprendre par cœur" les 1.1M d'images d'entraînement. Il devient "nul" sur les nouvelles images (validation).

La Solution (Plugin) : Le Dropout.
C'est une technique de régularisation (introduite par Hinton/Sutskever). C'est un "plugin" (une couche) ajouté *après* les couches "Fully Connected" (FC).

Comment ça marche ?

Pendant l'entraînement (model.train()) :

1. Le "Dropout Layer" (avec p=0.5) "désactive" (met à zéro) 50% des neurones de la couche précédente, de façon *aléatoire* à chaque "batch".
2. Le réseau est forcé d'apprendre avec un "sous-réseau" différent à chaque fois.

Analogie : C'est comme entraîner une équipe où, chaque jour, 50% des joueurs sont (aléatoirement) absents. Les joueurs restants sont *forcés* de devenir plus robustes et de ne pas dépendre d'un seul "superstar" (neurone).

Pendant l'inférence (model.eval()) :
Le Dropout est *désactivé*. Tous les neurones (100%) sont utilisés.

# En PyTorch, c'est juste une couche "plugin"
model = nn.Sequential(
    nn.Linear(9216, 4096),
    nn.ReLU(inplace=True),
    nn.Dropout(p=0.5), # <-- Le voici
    
    nn.Linear(4096, 4096),
    nn.ReLU(inplace=True),
    nn.Dropout(p=0.5),
    
    nn.Linear(4096, 1000)
)

1. Overlapping Pooling (Pooling "chevauchant")

Le "Pooling" (Max Pooling) est une opération qui réduit la taille d'une image (downsampling) en gardant la "feature" la plus forte.

Avant AlexNet (Pooling "non-overlapping") :
Taille de fenêtre (Kernel Size) = 2x2. Stride (Pas) = 2. Les fenêtres ne se chevauchaient pas.

AlexNet (Overlapping Pooling) :
Taille de fenêtre = 3x3. Stride (Pas) = 2.
Les fenêtres se chevauchent.

Résultat : Cela a réduit le taux d'erreur de ~0.4%. L'idée est que ce chevauchement ("plugin" de design) permet de capturer plus de "features" adjacentes et d'éviter un "overfitting" trop agressif.

2. LRN (Local Response Normalization)

C'est l'innovation d'AlexNet qui est aujourd'hui obsolète.

L'idée (inspirée du cerveau) : Créer une "inhibition latérale". Si un neurone (pixel) s'active *très* fort, LRN "diminue" l'activation des neurones voisins.

Pourquoi c'est obsolète ? C'était très lourd à calculer (coûteux en GPU) et s'est avéré (plus tard) peu efficace.
Le "plugin" Batch Normalization (BatchNorm) (introduit en 2015 avec ResNet) a rendu LRN totalement inutile. BatchNorm est 1000x plus efficace pour stabiliser l'entraînement.

Le dataset ImageNet (1.1M images) était "petit" pour un modèle de 60M de paramètres. L'overfitting était le principal ennemi. En plus de Dropout (1.6), AlexNet a utilisé massivement des "plugins" de Data Augmentation (Augmentation de Données).

L'idée est de "créer" des nouvelles données (synthétiques) à partir des données existantes, en appliquant des transformations aléatoires.

Techniques d'Augmentation d'AlexNet

Voici à quoi ressemble l'architecture AlexNet (Modale 1.3) implémentée avec PyTorch (le framework d'IA de Meta).

import torch
import torch.nn as nn

class AlexNet(nn.Module):
    def __init__(self, num_classes: int = 1000):
        super(AlexNet, self).__init__()
        
        # 1. Le "Backbone" (Conv + Pool)
        # Note: PyTorch utilise 224x224 (pas 227x227)
        self.features = nn.Sequential(
            # Conv1
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            
            # Conv2
            nn.Conv2d(64, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            
            # Conv3
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            
            # Conv4
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            
            # Conv5
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        
        # 2. Le "Classifieur" (FC + Dropout)
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        
        self.classifier = nn.Sequential(
            # FC1
            nn.Dropout(p=0.5),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            
            # FC2
            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            
            # FC3 (Output)
            nn.Linear(4096, num_classes),
        )

    # 3. Le "forward pass"
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1) # Aplatir (Flatten)
        x = self.classifier(x)
        return x

Aujourd'hui, personne n'entraîne AlexNet (sauf pour l'histoire). On utilise des modèles pré-entraînés (ex: sur ImageNet) via des "addons" (frameworks) comme torchvision.

Inférence (PyTorch)

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

# 1. Charger le modèle AlexNet pré-entraîné (plugin torchvision)
model = models.alexnet(pretrained=True)
model.eval() # IMPORTANT: Mettre en mode 'eval' (désactive Dropout)

# 2. Définir les "Transforms" (pré-processing)
#    (AlexNet a été entraîné sur 224x224, avec cette normalisation)
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 l'image
img = Image.open("mon_chien.jpg")
img_t = preprocess(img)
batch_t = torch.unsqueeze(img_t, 0) # (Ajoute une dimension "batch")

# 4. Inférence (avec 'no_grad' pour économiser la mémoire)
with torch.no_grad():
    output = model(batch_t)

# 5. Obtenir la prédiction
# (output est un tenseur de 1000 scores (logits))
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}")

AlexNet (2012) a prouvé que "plus profond" (deep) était mieux. Cela a lancé une "course à la profondeur" (frameworks dérivés) dans les concours ImageNet suivants.

Le "Plugin" ResNet (Skip Connection)

L'idée de ResNet (Microsoft) est de permettre au gradient de "sauter" (skip) des couches, évitant sa disparition.

(Input: x)
   |
   +-----> (Identité) ----+
   |                      |
   ▼                      ▼
[ Couche 1 (Conv) ]       |
[ Couche 2 (Conv) ]       |
   |                      |
   ▼                      ▼
( F(x) )                ( x )
   |                      |
   +-----> (Addition) <---+
              |
              ▼
           (Sortie: F(x) + x)

Aujourd'hui, on n'utilise *jamais* AlexNet pour sa précision (ResNet est bien meilleur). On l'utilise pour deux raisons :
1. Apprendre : C'est le modèle "Hello World" des CNNs profonds.
2. Transfer Learning (rare) : Le "Transfer Learning" est la technique "addon" n°1 en Computer Vision.

Projet : "Transfer Learning" (ex: "Hot Dog / Not Hot Dog")

Objectif : Classer si une image est un "Hot Dog" ou "Pas Hot Dog".

Vous n'avez pas 1M d'images. Vous n'avez que 1000 images (500 "hotdog", 500 "autre").

Le Workflow (Le "Plugin" Transfer Learning) :

1. Charger AlexNet (ou ResNet) pré-entraîné sur ImageNet (1.1M images). Ce modèle sait déjà "voir" (les bords, les textures, les formes...).
2. Geler (Freeze) les couches de "features" (model.features). On ne les ré-entraîne pas.
3. Remplacer la "Tête" (Head) : On jette la dernière couche (nn.Linear(4096, 1000)).
4. Ajouter une nouvelle Tête : On ajoute notre propre classifieur (nn.Linear(4096, 2)) (pour 2 classes : "hotdog", "not_hotdog").
5. Entraîner (fine-tune) : On n'entraîne *que* la nouvelle tête sur nos 1000 images.