Qu’est-ce qu’un réseau de neurones ?
Un réseau de neurones artificiel est un modèle mathématique inspiré du fonctionnement du cerveau humain. Il est composé de « neurones » artificiels organisés en couches, qui apprennent à reconnaître des patterns dans les données. C’est la technologie qui permet à ChatGPT de comprendre le langage, à Google Photos de reconnaître des visages, et à Tesla de conduire de manière autonome. Comprendre son fonctionnement est essentiel pour quiconque travaille dans le domaine de l’IA.
Le neurone artificiel : l’unité de base
Un neurone artificiel fonctionne en trois étapes simples : il reçoit des entrées, les combine et produit une sortie.
Visualisation d'un neurone artificiel :
Entrée 1 (x₁) ──── poids w₁ ────┐
│
Entrée 2 (x₂) ──── poids w₂ ────┼──→ [ Σ + biais ] ──→ [ Activation f() ] ──→ Sortie
│
Entrée 3 (x₃) ──── poids w₃ ────┘
Formule : sortie = f(w₁·x₁ + w₂·x₂ + w₃·x₃ + biais)
Analogie concrète :
Imaginez que vous décidez d'acheter un téléphone à Sandaga (Dakar).
- Entrée 1 : prix (x₁ = 85 000 FCFA, poids w₁ = 0.4 → très important)
- Entrée 2 : marque (x₂ = Samsung, poids w₂ = 0.3 → important)
- Entrée 3 : état batterie (x₃ = 90%, poids w₃ = 0.3 → important)
- Biais : votre tendance générale à acheter = -0.2 (plutôt prudent)
Score = 0.4 × 0.85 + 0.3 × 0.9 + 0.3 × 0.9 + (-0.2) = 0.68
Activation (seuil > 0.5) → Décision : ACHETER ✓Les fonctions d’activation
La fonction d’activation déterminé si un neurone « s’activé » ou non. Sans elle, le réseau ne pourrait résoudre que des problèmes linéaires (tracer une ligne droite). Les fonctions d’activation introduisent la non-linéarité qui permet au réseau d’apprendre des relations complexes.
Les principales fonctions d'activation :
1. SIGMOID : écrase la valeur entre 0 et 1
σ(x) = 1 / (1 + e^(-x))
Entrée : -5 -2 0 2 5
Sortie : 0.01 0.12 0.50 0.88 0.99
Forme : ___________
/
/
___________/
Usage : couche de sortie pour classification binaire (oui/non)
2. ReLU (Rectified Linear Unit) : le plus utilisé
f(x) = max(0, x)
Entrée : -5 -2 0 2 5
Sortie : 0 0 0 2 5
Forme : /
/
/
____________/
Usage : couches cachées — simple et efficace
3. SOFTMAX : transforme en probabilités (somme = 1)
Entrée : [2.0, 1.0, 0.1]
Sortie : [0.66, 0.24, 0.10] → total = 1.00
Usage : couche de sortie pour classification multi-classes
Exemple : "Cette image est un chat (66%), un chien (24%), un oiseau (10%)"Architecture d’un réseau de neurones
Un réseau de neurones est composé de couches empilées. Chaque couche contient plusieurs neurones qui traitent les données en parallèle.
Architecture d'un réseau à 3 couches :
COUCHE D'ENTRÉE COUCHE CACHÉE 1 COUCHE CACHÉE 2 COUCHE DE SORTIE
(vos données) (extraction) (combinaison) (résultat)
○ x₁ ─────────────── ○ ─────────────── ○ ─────────────── ○ Chat (0.85)
│ ╲ ╱ │ ╲ ╱ │ ╲ ╱
│ ╲ ╱ │ ╲ ╱ │ ╲ ╱
○ x₂ ──╳──────╳──── ○ ───╳──────╳── ○ ───╳──────╳── ○ Chien (0.12)
│ ╱ ╲ │ ╱ ╲ │ ╱ ╲
│ ╱ ╲ │ ╱ ╲ │ ╱ ╲
○ x₃ ─────────────── ○ ─────────────── ○ ─────────────── ○ Oiseau (0.03)
3 neurones 4 neurones 4 neurones 3 neurones
(pixels, valeurs) (détails simples) (formes complexes) (probabilités)
Chaque trait (─) représente un poids (nombre) que le réseau apprend.
Total de poids dans cet exemple : 3×4 + 4×4 + 4×3 = 40 paramètrès
GPT-4 en a environ 1 800 000 000 000 (1.8 trillion) !Comment un réseau apprend : la rétropropagation
L’apprentissage d’un réseau de neurones se fait en quatre étapes qui se répètent des milliers de fois sur les données d’entraînement.
LE PROCESSUS D'APPRENTISSAGE (4 étapes) :
ÉTAPE 1 : PROPAGATION AVANT (Forward Pass)
Les données traversent le réseau de gauche à droite.
Image de chat → [réseau avec poids aléatoires] → Prédiction : "Chien" (0.7)
→ Erreur !
ÉTAPE 2 : CALCUL DE L'ERREUR (Loss)
On compare la prédiction avec la bonne réponse.
Prédiction : Chien (0.7), Chat (0.2), Oiseau (0.1)
Réalité : Chien (0.0), Chat (1.0), Oiseau (0.0)
Erreur = Σ(prédiction - réalité)² = 0.49 + 0.64 + 0.01 = 1.14
→ L'erreur est élevée, le réseau se trompe beaucoup.
ÉTAPE 3 : RÉTROPROPAGATION (Backpropagation)
L'erreur est propagée en arrière pour identifier quels poids ont causé l'erreur.
Couche sortie ← "Le neurone Chat doit augmenter, Chien doit diminuer"
Couche cachée 2 ← "Ces neurones doivent ajuster leurs poids de X%"
Couche cachée 1 ← "Ces neurones doivent ajuster leurs poids de Y%"
(C'est du calcul différentiel : dérivées partielles / gradient)
ÉTAPE 4 : MISE À JOUR DES POIDS (Gradient Descent)
Chaque poids est ajusté proportionnellement à sa contribution à l'erreur.
w_nouveau = w_ancien - taux_apprentissage × gradient
Exemple : w = 0.5 - 0.01 × (-0.34) = 0.5034
Après 1000 répétitions sur des milliers d'images :
Image de chat → [réseau entraîné] → Prédiction : "Chat" (0.97) ✓Implémentation en Python avec NumPy
Voici un réseau de neurones minimal construit à partir de zéro, sans bibliothèque de deep learning. Ce code illustre concrètement tout ce que nous avons expliqué :
import numpy as np
# Fonction d'activation sigmoid et sa dérivée
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return x * (1 - x)
# Données d'entraînement : porte logique XOR
# Le XOR est le test classique — impossible à résoudre sans couche cachée
X = np.array([
[0, 0],
[0, 1],
[1, 0],
[1, 1]
])
y = np.array([[0], [1], [1], [0]]) # XOR : vrai si les entrées diffèrent
# Initialisation aléatoire des poids
np.random.seed(42)
poids_couche1 = np.random.randn(2, 4) * 0.5 # 2 entrées → 4 neurones cachés
biais_couche1 = np.zeros((1, 4))
poids_couche2 = np.random.randn(4, 1) * 0.5 # 4 neurones cachés → 1 sortie
biais_couche2 = np.zeros((1, 1))
taux_apprentissage = 1.0
erreurs = []
# Entraînement : 10 000 itérations
for epoch in range(10000):
# --- ÉTAPE 1 : Propagation avant ---
couche_cachee = sigmoid(np.dot(X, poids_couche1) + biais_couche1)
sortie = sigmoid(np.dot(couche_cachee, poids_couche2) + biais_couche2)
# --- ÉTAPE 2 : Calcul de l'erreur ---
erreur = y - sortie
mse = np.mean(erreur ** 2)
erreurs.append(mse)
# --- ÉTAPE 3 : Rétropropagation ---
d_sortie = erreur * sigmoid_derivative(sortie)
erreur_cachee = d_sortie.dot(poids_couche2.T)
d_cachee = erreur_cachee * sigmoid_derivative(couche_cachee)
# --- ÉTAPE 4 : Mise à jour des poids ---
poids_couche2 += couche_cachee.T.dot(d_sortie) * taux_apprentissage
biais_couche2 += np.sum(d_sortie, axis=0, keepdims=True) * taux_apprentissage
poids_couche1 += X.T.dot(d_cachee) * taux_apprentissage
biais_couche1 += np.sum(d_cachee, axis=0, keepdims=True) * taux_apprentissage
if epoch % 2000 == 0:
print(f"Epoch {epoch:5d} | Erreur MSE : {mse:.6f}")
# Résultat final
print(f"
Résultats après entraînement :")
print(f"[0,0] → {sortie[0][0]:.4f} (attendu : 0)")
print(f"[0,1] → {sortie[1][0]:.4f} (attendu : 1)")
print(f"[1,0] → {sortie[2][0]:.4f} (attendu : 1)")
print(f"[1,1] → {sortie[3][0]:.4f} (attendu : 0)")
# Sortie :
# Epoch 0 | Erreur MSE : 0.274190
# Epoch 2000 | Erreur MSE : 0.125384
# Epoch 4000 | Erreur MSE : 0.007283
# Epoch 6000 | Erreur MSE : 0.002841
# Epoch 8000 | Erreur MSE : 0.001672
# [0,0] → 0.0234 (attendu : 0) ✓
# [0,1] → 0.9753 (attendu : 1) ✓
# [1,0] → 0.9749 (attendu : 1) ✓
# [1,1] → 0.0312 (attendu : 0) ✓Les types de réseaux de neurones
CNN — Réseaux convolutifs (vision)
Architecture d'un CNN pour la reconnaissance d'images :
Image (224×224×3)
│
▼
┌─────────────────┐
│ CONVOLUTION 1 │ 32 filtres 3×3 — détecte les bords, lignes, textures
│ + ReLU + Pool │ Sortie : 112×112×32
└────────┬────────┘
│
┌────────▼────────┐
│ CONVOLUTION 2 │ 64 filtres 3×3 — détecte les formes (yeux, roues, lettres)
│ + ReLU + Pool │ Sortie : 56×56×64
└────────┬────────┘
│
┌────────▼────────┐
│ CONVOLUTION 3 │ 128 filtres 3×3 — détecte les objets partiels
│ + ReLU + Pool │ Sortie : 28×28×128
└────────┬────────┘
│
┌────────▼────────┐
│ APLATIR │ 28×28×128 = 100 352 neurones
│ (Flatten) │
└────────┬────────┘
│
┌────────▼────────┐
│ COUCHE DENSE │ 512 neurones — combine les features
│ + ReLU │
└────────┬────────┘
│
┌────────▼────────┐
│ SORTIE │ Chat: 0.92, Chien: 0.05, Oiseau: 0.03
│ (Softmax) │
└─────────────────┘
Usage : reconnaissance d'images, détection d'objets, OCR, imagerie médicaleRNN/LSTM — Réseaux récurrents (séquences)
Architecture d'un RNN pour le traitement de texte :
Phrase : "Le Sénégal est un beau pays"
"Le" "Sénégal" "est" "un" "beau" "pays"
│ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼
┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐
│RNN│─h₁──→│RNN│─h₂──→│RNN│─h₃─→│RNN│─h₄─→│RNN│─h₅─→│RNN│──→ Sortie
└───┘ └───┘ └───┘ └───┘ └───┘ └───┘
h₁, h₂... = "mémoire" : chaque cellule transmet un résumé de ce qu'elle
a lu jusqu'ici. Quand le réseau lit "pays", il se souvient de "Sénégal".
Problème : la mémoire s'estompe sur les longues séquences.
Solution : LSTM (Long Short-Term Memory) avec une "cellule mémoire"
qui peut retenir l'information sur de longues distances.
Usage : traduction, analyse de sentiment, génération de texte,
prédiction de séries temporelles (cours de bourse, météo)Transformer — L’architecture derrière ChatGPT
Architecture simplifiée d'un Transformer :
Phrase : "Comment créer un site web au Sénégal ?"
┌──────────────────────────────────────┐
│ TOKENISATION │
│ "Comment" "créer" "un" "site" "web" │
│ "au" "Sénégal" "?" │
└──────────────┬───────────────────────┘
│
┌──────────────▼───────────────────────┐
│ EMBEDDING + POSITION │
│ Chaque mot → vecteur de 768 nombres │
│ + position dans la phrase │
└──────────────┬───────────────────────┘
│
┌──────────────▼───────────────────────┐
│ SELF-ATTENTION (la clé !) │
│ │
│ Chaque mot "regarde" tous les autres │
│ pour comprendre le contexte : │
│ │
│ "site" ← forte attention → "web" │
│ "site" ← forte attention → "Sénégal"│
│ "créer" ← forte attention → "site" │
│ │
│ Le mot "Sénégal" change le sens de │
│ toute la phrase (hébergement local, │
│ domaine .sn, contexte africain) │
└──────────────┬───────────────────────┘
│
┌──────────────▼───────────────────────┐
│ FEED-FORWARD + NORMALISATION │
│ × 12 à 96 couches empilées │
└──────────────┬───────────────────────┘
│
┌──────────────▼───────────────────────┐
│ SORTIE │
│ Génère le prochain mot le plus │
│ probable, un par un : │
│ "Pour" "créer" "un" "site"... │
└──────────────────────────────────────┘
Tailles typiques :
- GPT-3 : 96 couches, 175 milliards de paramètrès
- GPT-4 : ~120 couches, ~1.8 trillion de paramètrès (estimé)
- Mistral 7B : 32 couches, 7 milliards de paramètrès
- LLaMA 3 70B : 80 couches, 70 milliards de paramètrèsConstruire un réseau avec PyTorch
Voici un exemple concret de classification d’images avec PyTorch, le framework le plus utilisé en recherche et en production :
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# 1. Préparer les données (MNIST : chiffres manuscrits)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_data = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_data = datasets.MNIST('./data', train=False, transform=transform)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=64)
# 2. Définir le réseau de neurones
class ReseauClassification(nn.Module):
def __init__(self):
super().__init__()
self.couches = nn.Sequential(
nn.Flatten(), # 28×28 → 784
nn.Linear(784, 256), # Couche cachée 1
nn.ReLU(),
nn.Dropout(0.2), # Régularisation
nn.Linear(256, 128), # Couche cachée 2
nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(128, 10) # 10 classes (chiffres 0-9)
)
def forward(self, x):
return self.couches(x)
# 3. Configurer l'entraînement
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ReseauClassification().to(device)
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
# 4. Entraîner
for epoch in range(5):
model.train()
total_loss = 0
for images, labels in train_loader:
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
output = model(images)
loss = criterion(output, labels)
loss.backward() # Rétropropagation
optimizer.step() # Mise à jour des poids
total_loss += loss.item()
print(f"Epoch {epoch+1}/5 | Loss : {total_loss/len(train_loader):.4f}")
# 5. Évaluer
model.eval()
correct = 0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to(device), labels.to(device)
output = model(images)
correct += (output.argmax(1) == labels).sum().item()
accuracy = correct / len(test_data) * 100
print(f"Précision sur le test : {accuracy:.1f}%")
# Résultat typique : 97.5% de précisionHyperparamètrès clés à comprendre
Taux d’apprentissage (learning rate) : contrôle la taille des ajustements de poids à chaque itération. Trop élevé (0.1) : le réseau oscille et ne converge pas. Trop faible (0.00001) : l’entraînement est très lent. Valeur typique : 0.001. C’est l’hyperparamètre le plus important à ajuster.
Nombre d’époques : combien de fois le réseau voit l’intégralité des données d’entraînement. Trop peu : le modèle n’a pas assez appris (sous-apprentissage). Trop : le modèle mémorise les données d’entraînement sans généraliser (surapprentissage). Surveillez l’erreur sur les données de validation pour trouver le bon nombre.
Taille du batch : combien d’exemples le réseau traite avant de mettre à jour ses poids. Batch de 32 : mises à jour fréquentes, apprentissage bruité mais rapide. Batch de 256 : mises à jour plus stables mais nécessite plus de mémoire GPU. Valeurs courantes : 16, 32, 64, 128.
Dropout : pendant l’entraînement, désactive aléatoirement un pourcentage de neurones (typiquement 20-50%). Force le réseau à ne pas dépendre d’un seul chemin, améliorant la généralisation. C’est comme si un étudiant apprenait à résoudre un problème sans avoir toujours accès à sa calculatrice — il développe une compréhension plus profonde.
L histoire courte : du perceptron a GPT
Le perceptron, premier modele de neurone artificiel, est decrit par Frank Rosenblatt en 1957. Il s agit alors d un seul neurone qui apprend a classifier des points dans un plan. Pendant trois decennies, l idee stagne — un perceptron ne peut pas resoudre XOR, et l on doute de l interet pratique. Le declic vient en 1986 avec la generalisation de la retropropagation du gradient par Rumelhart, Hinton et Williams, qui permet d entrainer des reseaux multi-couches.
Les annees 2010 marquent l explosion : la disponibilite des GPU, l accumulation de donnees etiquetees (ImageNet en 2009), et les architectures profondes (AlexNet en 2012, ResNet en 2015) transforment le machine learning. Le moment Transformer arrive en 2017 avec l article Attention Is All You Need de Vaswani et al. — c est cette architecture qui sous-tend tous les grands modeles de langage actuels (GPT, Claude, Gemini, Llama).
Anatomie d un neurone artificiel
Un neurone artificiel fait une operation simple : il combine ses entrees ponderees, ajoute un biais, applique une fonction non lineaire (l activation), et produit une sortie. Mathematiquement : sortie = f(somme(wi * xi) + b) ou les wi sont les poids, xi les entrees, b le biais, et f l activation.
Les activations courantes en 2026 : ReLU (rectifier les valeurs negatives a zero, simple et tres efficace pour les couches intermediaires), GELU (variante lissee privilegiee dans les Transformers), sigmoid (transforme en probabilite 0-1, utile en sortie de classifieur binaire), softmax (en sortie de classifieur multi-classes, transforme les scores en distribution de probabilites). Le choix de l activation n est pas anodin : ReLU a ouvert l ere du deep learning en 2010 en resolvant le probleme du gradient qui disparait dans les couches profondes.
Les architectures dominantes
Reseaux denses (MLP). Empilement de couches ou chaque neurone d une couche se connecte a tous les neurones de la suivante. Bon pour des donnees tabulaires structurees (lignes-colonnes). Limite par le nombre de parametres qui explose avec la taille de l entree.
Reseaux convolutionnels (CNN). Specialises pour les images. Chaque filtre detecte un motif local (bordure, texture, forme), et les couches successives combinent ces motifs pour reconnaitre des objets complets. Architectures de reference : ResNet (2015), EfficientNet (2019), ConvNeXt (2022). En 2026, les Vision Transformers (ViT) concurrencent fortement les CNN sur les benchmarks d images.
Reseaux recurrents (RNN, LSTM, GRU). Traitent des sequences (texte, audio, series temporelles). Chaque element de la sequence est traite en gardant un etat memoire des elements precedents. Largement supplantes par les Transformers depuis 2018-2019 sur le langage et l audio.
Transformers. Architecture qui domine 2020-2026. Utilise un mecanisme d attention qui permet a chaque position de la sequence de se referer directement a toutes les autres, sans passer par un etat memoire sequentiel. Permet la parallelisation a grande echelle (donc l entrainement de modeles a milliards de parametres) et capture des dependances longue distance. C est l architecture des LLM modernes : GPT, Claude, Gemini, Llama, Mistral.
Modeles de diffusion. Generent des images de haute qualite a partir de bruit aleatoire en l affinant par etapes. Architectures : Stable Diffusion, DALL-E 3, Midjourney, Flux. Utilisent en interne des U-Net (variante de CNN) et de l attention. Etat de l art pour la generation d images en 2026.
Comment un reseau apprend : la retropropagation
L apprentissage est un processus d ajustement iteratif des poids. La procedure complete sur un batch de donnees :
(1) Le reseau fait une prediction sur l entree. (2) On compare la prediction a la verite-terrain via une fonction de perte (loss) — typiquement cross-entropy pour la classification, MSE pour la regression. (3) On calcule le gradient de la perte par rapport a chaque poids du reseau, ce qui donne la direction dans laquelle ajuster chaque poids pour reduire la perte (c est la retropropagation, ou backprop). (4) On met a jour les poids dans la direction opposee au gradient, avec un pas (learning rate) typiquement entre 0,0001 et 0,01.
Repete sur des milliers ou des millions de batches, ce processus converge vers une configuration des poids qui minimise la perte sur les donnees d entrainement. Tout l art consiste a ajuster les hyperparametres (taille du batch, learning rate, architecture, regularisation) pour eviter le sur-apprentissage : un modele qui memorise le training set sans generaliser aux donnees nouvelles.
Le scaling : pourquoi les modeles grossissent
L empirisme du deep learning depuis 2018 montre que la performance s ameliore continument avec la taille du modele, la quantite de donnees, et le compute d entrainement — les fameuses scaling laws formalisees par Kaplan et al. (2020) et Hoffmann et al. (2022 — DeepMind Chinchilla). Cette observation explique l explosion des tailles : GPT-2 (2019) avait 1,5 milliard de parametres, GPT-3 (2020) 175 milliards, GPT-4 plusieurs centaines de milliards. En 2026, les meilleurs modeles depassent le trillion de parametres dans leurs variantes Mixture of Experts.
Cette tendance a des limites : le coup d entrainement de GPT-4 a couté plus de 100 millions de dollars, et les data centers consomment des dizaines de megawatts. Le mouvement de fond depuis 2024 est de chercher l efficience : plus de capacite par parametre via de meilleures architectures et de meilleures donnees, plutot que plus de parametres bruts.
FAQ
Combien de donnees faut-il pour entrainer un reseau de neurones ?
Tres variable selon la tache. Pour une classification d image binaire simple, 1 000 images par classe peuvent suffire avec un modele pre-entraine fine-tune. Pour entrainer un LLM depuis zero, des trillions de tokens sont necessaires. La regle empirique : commencer par un modele pre-entraine, le fine-tuner sur les donnees disponibles, et ne re-entrainer depuis zero que si rien ne convient.
Quelle difference entre IA, machine learning et deep learning ?
L IA est le domaine general (toute machine qui imite des taches humaines). Le machine learning est un sous-ensemble : la machine apprend par les donnees plutot que par des regles ecrites. Le deep learning est un sous-ensemble du ML : utilise des reseaux de neurones profonds. La quasi-totalite des IA performantes en 2026 sont du deep learning.
Peut-on comprendre ce qu un reseau a appris ?
Partiellement. Les techniques d interpretabilite (attention maps, saliency maps, mechanistic interpretability) revelent quels patterns un reseau a appris. Mais les grands modeles restent largement opaques — c est l un des grands defis de recherche actuels (interpretabilite d Anthropic, Apollo Research, etc.).
Quel langage et framework pour commencer ?
Python avec PyTorch en 2026. C est le standard absolu de la recherche et de plus en plus de la production. TensorFlow garde des parts dans certains secteurs industriels mais perd en momentum. Pour debuter, la combinaison Python + PyTorch + Hugging Face Transformers couvre 90 pour cent des besoins.
References
- Attention Is All You Need (Vaswani et al., 2017) — arxiv.org/abs/1706.03762
- Deep Learning (Goodfellow, Bengio, Courville) — deeplearningbook.org
- Neural Networks and Deep Learning (Michael Nielsen) — neuralnetworksanddeeplearning.com
- PyTorch tutorials — pytorch.org/tutorials
- Distill.pub (visualisations) — distill.pub
- 3Blue1Brown (videos) — 3blue1brown.com