4.4 Réseaux de Neurones et CNN

Ouvrez la porte au deep learning

Dans les chapitres précédents, nous avons vu que les méthodes traditionnelles de vision par ordinateur échouent souvent dans le monde réel. Leur succès dépend généralement du fait que la scène corresponde à un motif spécifique ou à un ensemble d'hypothèses, comme un éclairage stable, des arrière-plans propres, des points de vue fixes ou des formes d'objets prévisibles. Dès que ces conditions changent, leurs performances peuvent se dégrader rapidement. Le deep learning, en revanche, adopte une approche très différente. Au lieu de s'appuyer principalement sur des règles faites à la main, il apprend des motifs visuels utiles directement à partir de grandes quantités de données. Cela lui permet de gérer beaucoup plus de variations d'apparence, d'arrière-plan, d'échelle, d'éclairage et de pose. Par conséquent, le deep learning a rendu la vision par ordinateur beaucoup plus robuste et pratique pour les applications du monde réel.

Des Règles aux Représentations Apprises

En vision classique, nous écrivons les règles explicitement :

• flouter l'image
• trouver les contours
• extraire le contour

Dans un réseau de neurones, nous laissons le modèle apprendre des motifs utiles à partir d'exemples.

C'est le changement conceptuel clé : le système apprend des représentations au lieu de s'appuyer uniquement sur des caractéristiques conçues manuellement.

Qu'est-ce qu'un Réseau de Neurones

Un réseau de neurones est une fonction composée de couches qui transforment les données d'entrée étape par étape.

Chaque couche apprend des paramètres. Pendant l'entraînement, ces paramètres sont ajustés pour que les sorties du réseau deviennent plus utiles pour la tâche.

À quoi ressemble un NN dans le code ?

import torch
import torch.nn as nn
import torch.nn.functional as F

# 1. Define the Network Structure
class SimpleMLP(nn.Module):
    def __init__(self, input_size=784, hidden_size=128, num_classes=10):
        super(SimpleMLP, self).__init__()
        
        # --- Fully Connected Layers (Dense Layers) ---
        
        # First layer: Maps input features to the first hidden layer
        self.fc1 = nn.Linear(input_size, hidden_size)
        
        # Second layer: Maps first hidden layer to the second hidden layer
        self.fc2 = nn.Linear(hidden_size, 64)
        
        # Output layer: Maps second hidden layer to the number of classes
        self.fc3 = nn.Linear(64, num_classes)
        
        # Optional: Dropout layer to prevent overfitting (drops 20% of neurons)
        self.dropout = nn.Dropout(p=0.2)

    # 2. Define the Data Flow (Forward Pass)
    def forward(self, x):
        # Flatten the input tensor
        # Converts (batch_size, channels, height, width) to (batch_size, -1)
        # Example: 28x28 image becomes a 784-dimensional vector
        x = x.view(x.size(0), -1)  
        
        # First hidden layer: Linear transformation -> ReLU Activation -> Dropout
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        
        # Second hidden layer: Linear transformation -> ReLU Activation
        x = F.relu(self.fc2(x))
        
        # Output layer: Linear transformation (no activation here, usually handled by loss function)
        x = self.fc3(x)
        
        return x

# 3. Instantiate the Model
model = SimpleMLP()
print(model)

Essayez

cd 4.4-Neural-Networks-and-CNNs/code
python powerful_neural_network.py

🚀 Entraînez votre propre réseau de neurones pour voir comment il se comporte !

Pourquoi les CNN Sont Adaptés aux Images

Les CNN (réseau de neurones convolutif) fonctionnent bien pour les images car les images ne sont pas que des nombres aléatoires. Dans une image, les pixels voisins appartiennent généralement au même contour, à la même forme ou à la même texture, donc les motifs locaux ont beaucoup d'importance. Les CNN tirent parti de cela en utilisant de petits filtres qui balaient l'image et recherchent des caractéristiques utiles telles que des contours, des coins et des formes simples. À mesure que le réseau s'enfonce, il combine ces petites caractéristiques en de plus grandes, comme des parties d'un objet et, finalement, l'objet complet lui-même. C'est pourquoi les CNN sont particulièrement bons pour comprendre les images de manière efficace et précise.

Un CNN possède généralement une structure en couches pour transformer une image en une compréhension visuelle de plus haut niveau. Il commence par une image d'entrée, puis la fait passer à travers plusieurs couches de convolution qui apprennent des motifs locaux tels que des contours, des textures et des formes. Celles-ci sont souvent suivies par des fonctions d'activation comme ReLU et des couches de pooling qui réduisent la taille spatiale tout en conservant les informations importantes. Après plusieurs blocs de ce type, les cartes de caractéristiques sont aplaties ou poolées en une représentation compacte, puis passées à une ou plusieurs couches entièrement connectées pour produire la prédiction finale, comme une étiquette de classe. En bref, un CNN courant ressemble à :

entrée → convolution + activation → pooling → blocs d'extraction de caractéristiques répétés → couche entièrement connectée → sortie

Avantages de la convolution :

• extraction de motifs locaux

La convolution aide le modèle à trouver de petits motifs utiles dans une image, tels que des contours, des coins, des textures ou des formes simples. Ces petits motifs sont les blocs de base pour comprendre des objets plus grands.

• partage de paramètres

Le même filtre est utilisé à différents endroits de l'image. Cela signifie que le modèle n'a pas besoin d'apprendre un nouvel ensemble de poids pour chaque position, ce qui le rend plus efficace et réduit le nombre de paramètres.

• robustesse à la translation

Si un objet se déplace à un autre endroit de l'image, le filtre de convolution peut toujours le détecter. Autrement dit, le modèle peut reconnaître le même motif même si sa position change.

Cartes de Caractéristiques

Lorsqu'une couche convolutive traite une image, elle produit des cartes de caractéristiques. Ces cartes répondent à des motifs tels que :

• des contours
• des coins
• des textures
• des structures sémantiques plus grandes dans les couches plus profondes

Pooling et Sous-échantillonnage

Le pooling réduit la taille spatiale tout en conservant les informations importantes.

Cela aide à :

• réduire le calcul
• améliorer la robustesse
• construire des représentations plus compactes

Essayez

cd 4.4-Neural-Networks-and-CNNs/code
python cnn_process_visualization.py

🚀 Lancez le script pour vivre le processus de traitement de l'image par un réseau convolutif.

Entraînement vs Inférence

• Training : le modèle apprend en mettant à jour les poids
• Inference : le modèle entraîné fait des prédictions sans mettre à jour les poids

Cette distinction est cruciale car les chapitres ultérieurs sur le déploiement se concentrent principalement sur l'inférence.

À quoi ressemble un CNN dans le code ?

mport torch
import torch.nn as nn

class TinyCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(16, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(32 * 56 * 56, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

model = TinyCNN()
dummy = torch.randn(1, 3, 224, 224)
output = model(dummy)
print(output.shape)

Malentendus Courants

• « Un CNN voit littéralement comme un œil humain. »
  • Les CNN traitent des motifs numériques. L'analogie est utile, mais pas littérale.
• « Plus de couches signifie toujours de meilleures performances. »
  • Des modèles plus profonds peuvent être plus puissants, mais aussi plus difficiles à entraîner et à déployer.
• « Si je comprends le code, je comprends automatiquement l'entraînement. »
  • L'entraînement dépend aussi des données, de la fonction de perte, de l'optimisation et de l'évaluation.

Exercices / Réflexion

1. Avec vos propres mots, expliquez pourquoi la convolution est plus adaptée aux images qu'une simple couche entièrement connectée.
2. Lancez l'exemple tiny CNN et affichez la forme de la sortie.
3. Modifiez le nombre de canaux de sortie dans la première convolution et observez comment la structure du modèle change.
4. Réfléchissez à la manière dont les CNN diffèrent des filtres classiques tels que le flou ou la détection de contours.

Résumé

Les réseaux de neurones apprennent des représentations à partir des données, et les CNN sont particulièrement efficaces pour les images parce qu'ils exploitent la structure locale. Comprendre la convolution, les cartes de caractéristiques, le pooling et la différence entre entraînement et inférence prépare l'apprenant aux tâches de vision modernes.

Étape Suivante Suggérée

Continuez vers 4.5 Tâches de Vision par Ordinateur en Deep Learning.

Références

• PyTorch Tutorials