Machine Learning

Cours complet — Perceptron Multi-Couches

Contenu du cours :
1. Intelligence Artificielle et Apprentissage Automatique
2. Le Neurone Biologique et Artificiel
3. Le Perceptron Simple
4. Le Perceptron Multi-Couches (PMC)
5. La Rétropropagation de l’Erreur
6. Exemple Numérique Complet
7. Implémentation en Python

Mohammed Madiafi
ENSA Safi — Université Cadi Ayyad

13 mars 2026
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

Table des matières

1 Intelligence Artificielle et Apprentissage Automatique 2
1.1 Définition de l’Intelligence Artificielle . . . . . . . . . . . . . . . . . . . . . 2
1.2 Apprentissage Automatique (Machine Learning) . . . . . . . . . . . . . . . 2
1.3 Types d’apprentissage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Le Neurone Biologique 3

3 Le Perceptron Simple 3
3.1 Modèle mathématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.2 La fonction d’activation sigmoïde . . . . . . . . . . . . . . . . . . . . . . . 3
3.3 Représentation graphique du perceptron . . . . . . . . . . . . . . . . . . . 4

4 Le Perceptron Multi-Couches (PMC) 4

4.1 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4.2 Propagation des signaux d’entrée . . . . . . . . . . . . . . . . . . . . . . . 4
4.3 Applications du PMC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

5 La Rétropropagation de l’Erreur 5
5.1 Pourquoi la rétropropagation ? . . . . . . . . . . . . . . . . . . . . . . . . . 5
5.2 Calcul de l’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5.2.1 Erreur locale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5.2.2 Erreur globale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5.3 Dérivée de la fonction sigmoïde . . . . . . . . . . . . . . . . . . . . . . . . 6
5.4 Mise à jour des poids — Couche de sortie . . . . . . . . . . . . . . . . . . . 6
5.5 Mise à jour des poids — Couches cachées . . . . . . . . . . . . . . . . . . . 7
5.6 Algorithme complet de rétropropagation . . . . . . . . . . . . . . . . . . . 7

6 Exemple Numérique Complet 8

6.1 Étape 1 : Propagation avant . . . . . . . . . . . . . . . . . . . . . . . . . . 8
6.2 Étape 2 : Calcul de l’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . 8
6.3 Étape 3 : Rétropropagation . . . . . . . . . . . . . . . . . . . . . . . . . . 8
6.4 Résumé des corrections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

7 Implémentation en Python 9
7.1 Classe Neurone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
7.2 Classe Couche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
7.3 Classe PMC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Conclusion 11

1
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

1 Intelligence Artificielle et Apprentissage Automatique

1.1 Définition de l’Intelligence Artificielle
Définition
Intelligence Artificielle (IA) : simulation des aptitudes des êtres vivants par un
système informatique. Elle regroupe la capacité d’un système à :
— Interagir avec son environnement,
— S’adapter à ses changements.
Un système intelligent prend des décisions de manière logique en se basant sur
des données, contrairement à l’homme qui se base sur les émotions.

1.2 Apprentissage Automatique (Machine Learning)

Définition
L’apprentissage automatique est l’aptitude d’un système à améliorer ses perfor-
mances concernant la réalisation d’une tâche bien déterminée, par interaction avec
son environnement.
Il nécessite :
— Un algorithme d’apprentissage,
— Des données (base d’apprentissage).

1.3 Types d’apprentissage

Il existe trois grandes familles d’apprentissage :

Type Description Exemple

Supervisé Données étiquetées (on Reconnaissance d’images
connaît les réponses) annotées
Non supervisé Données non étiquetées Regroupement de clients
— le système cherche des
structures cachées
Par renforcement Apprentissage par essai/er- Jeux vidéo, robots
reur avec récompenses

Analogie
Apprentissage supervisé : c’est comme apprendre à lancer une balle dans un
panier de basket. À chaque lancer raté, tu identifies ce qui n’allait pas (l’angle, la
force) et tu corriges. Quelqu’un te dit si tu as réussi ou non.
Apprentissage non supervisé : c’est comme trier des objets inconnus en groupes
sans savoir à l’avance ce que sont ces groupes.

2
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

2 Le Neurone Biologique
Le neurone artificiel s’inspire du neurone biologique. Voici ses composants principaux :
— Corps cellulaire (soma) : contient le noyau avec le génome (ADN) et le plasma.
— Dendrites : jouent le rôle de récepteurs. Ils permettent au neurone de recevoir les
signaux émis par d’autres neurones.
— Axone : prolongement centrifuge qui transmet le signal vers d’autres neurones via
les synapses. La juxtaposition d’axones longs forme un nerf.

Définition
Principe de fonctionnement : lorsque l’excitation issue des dendrites dépasse
un certain seuil, le neurone s’active et génère un signal qu’il transmet à d’autres
neurones par le biais de son axone.

3 Le Perceptron Simple
3.1 Modèle mathématique
Le perceptron est le modèle mathématique du neurone biologique. Il effectue deux
opérations successives :

Formule clé
Étape 1 — Somme pondérée :
p
X
v= ωi ei + θ
i=1

Étape 2 — Fonction d’activation :

s = φ(v)

Où :
— ei : i-ème entrée (caractéristique de l’objet),
— ωi : poids synaptique associé à ei ,
— θ : biais (seuil),
— φ : fonction d’activation (ex : sigmoïde).

3.2 La fonction d’activation sigmoïde

La fonction d’activation la plus courante est la sigmoïde :

Formule clé
1
φ(v) =
1 + e−v
Elle écrase toute valeur v dans l’intervalle ]0, 1[.

3
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

Exemple
Avec une entrée v = 0.97 :
1 1
φ(0.97) = ≈ ≈ 0.725
1 + e−0.97 1 + 0.379

3.3 Représentation graphique du perceptron

e1
ω1
ω2 v s = φ(v)
e2 Σ φ s

ω3
e3

4 Le Perceptron Multi-Couches (PMC)

4.1 Architecture
Définition
Un Perceptron Multi-Couches (PMC) est un réseau de neurones organisé en
couches successives :
1. Couche d’entrée : reçoit les données brutes,
2. Couche(s) cachée(s) : transforment les données,
3. Couche de sortie : produit la prédiction finale.
Chaque neurone d’une couche est connecté à tous les neurones de la couche suivante
(connexions complètes).

4.2 Propagation des signaux d’entrée

La sortie du neurone k de la couche de sortie après propagation du signal relatif à
l’objet n est calculée comme suit :

Formule clé
cj
X
vk (n) = wkj yj (n)
j=1

1
yk (n) = φ vk (n) =
1 + e−vk (n)
Où yj (n) est la sortie du neurone j de la couche précédente.

4
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

4.3 Applications du PMC

Le PMC peut être utilisé pour :
— Classification : distinguer des catégories (ex : chat vs chien),
— Approximation de fonctions : apprendre à reproduire une courbe,
— Compression : réduire la dimensionnalité des données.

5 La Rétropropagation de l’Erreur
5.1 Pourquoi la rétropropagation ?
Analogie
Imagine que tu apprends à lancer une balle dans un panier de basket :
1. Tu lances la balle → le réseau fait une prédiction,
2. Tu rates → il y a une erreur,
3. Tu identifies que ton angle était mauvais → tu trouves le responsable,
4. Tu corriges ton angle → tu ajustes les poids.
La rétropropagation remonte de la sortie vers l’entrée, exactement comme tu
cherches la cause de l’erreur depuis le résultat final.

5.2 Calcul de l’erreur

5.2.1 Erreur locale
Formule clé
L’erreur locale au neurone k de la couche de sortie est :

ek (n) = dk (n) − yk (n)

Où dk (n) est la valeur désirée et yk (n) la valeur obtenue.

5.2.2 Erreur globale

Attention !
On ne peut pas simplement additionner les erreurs car elles peuvent s’annuler !
Exemple : e1 = +2, e2 = −3, e3 = +1 ⇒ somme = 0 (illusion d’un réseau parfait !).

La solution : mettre les erreurs au carré pour éviter les annulations.

5
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

Formule clé
Erreur globale (fonction de coût) :
k c
1X
ξ(n) = e2 (n)
2 k=1 k

1
Le 2
simplifie les calculs de dérivées. Le but de l’apprentissage est de minimiser ξ.

Exemple
Avec 3 neurones de sortie ayant les erreurs e1 = 2, e2 = −3, e3 = 1 :
1 1
ξ = (22 + (−3)2 + 12 ) = (4 + 9 + 1) = 7
2 2

5.3 Dérivée de la fonction sigmoïde

La dérivée de la sigmoïde joue un rôle central dans la rétropropagation.

Formule clé
Démonstration :
φ(v) = (1 + e−v )−1
En posant u = 1 + e−v , on obtient u′ = −e−v , donc :

e−v
φ′ (v) =
(1 + e−v )2

En utilisant le fait que e−v = (1 + e−v ) − 1 :

 
′ 1 1 1 1
φ (v) = −v
− −v
= 1−
1+e (1 + e ) 2 1 + e−v 1 + e−v

φ′ (v) = φ(v) 1 − φ(v) = y(1 − y)

Définition
Interprétation : y(1 − y) mesure la sensibilité du neurone. Plus y est proche de
0 ou de 1, moins le neurone peut changer. La sensibilité maximale est atteinte pour
y = 0.5.

5.4 Mise à jour des poids — Couche de sortie

La règle de mise à jour des poids repose sur la descente de gradient :

6
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

Formule clé
∂ξ(n)
∆wkj (n) = −η = η δk (n) yj (n)
∂wkj
Avec :

δk (n) = ek (n) · yk (n) · 1 − yk (n)
Où :
— η : taux d’apprentissage (contrôle la vitesse de correction),
— δk : gradient local (responsabilité du neurone k),
— yj : sortie du neurone j de la couche précédente.

Analogie
Corriger les poids proportionnellement à leur responsabilité, c’est comme dans une
soupe trop salée : on réduit surtout le sel (le plus responsable), et peu les autres
ingrédients.

5.5 Mise à jour des poids — Couches cachées

Pour les couches cachées, le neurone ne connaît pas l’erreur directement. Il la reçoit
en remontant depuis la couche de sortie :

Formule clé

∆wji (n) = η δj (n) yi (n)

Avec : ck

X
δj (n) = yj (n) 1 − yj (n) δk (n) wkj
k=1
P
Le terme k δk · wkj représente l’erreur qui remonte depuis la couche de sortie
vers la couche cachée.

5.6 Algorithme complet de rétropropagation

Algorithme de rétropropagation
Répéter pour chaque objet n jusqu’à convergence :
1. Propagation avant : calculer les sorties de chaque couche, de l’entrée vers
la sortie.
2. Calcul de l’erreur : ek (n) = dk (n) − yk (n) pour chaque neurone de sortie.
3. Calcul des gradients locaux :
— Couche de sortie : δk = ek · yk (1 −P
yk )
— Couches cachées : δj = yj (1 − yj ) k δk wkj
4. Mise à jour des poids : w ← w + η δ y
Recommencer jusqu’à ce que ξ soit suffisamment petit.

7
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

6 Exemple Numérique Complet

On considère un réseau simple :
— 1 entrée : e = 2
— 1 neurone caché avec poids w1 = 0.5
— 1 neurone de sortie avec poids w2 = 0.3
— Valeur désirée : d = 1, taux d’apprentissage η = 0.1

6.1 Étape 1 : Propagation avant

Neurone caché :
v1 = w1 × e = 0.5 × 2 = 1
1
y1 = φ(1) = ≈ 0.73
1 + e−1
Neurone de sortie :

v2 = w2 × y1 = 0.3 × 0.73 = 0.219

1
y2 = φ(0.219) = ≈ 0.554
1 + e−0.219

6.2 Étape 2 : Calcul de l’erreur

e = d − y2 = 1 − 0.554 = 0.446
1 1
ξ = e2 = (0.446)2 ≈ 0.099
2 2

6.3 Étape 3 : Rétropropagation

Gradient local de la couche de sortie :

δ2 = e × y2 (1 − y2 ) = 0.446 × 0.554 × 0.446 ≈ 0.110

Correction de w2 :

∆w2 = η × δ2 × y1 = 0.1 × 0.110 × 0.73 ≈ 0.008

w2nouveau = 0.3 + 0.008 = 0.308

Gradient local de la couche cachée :

δ1 = y1 (1 − y1 ) × δ2 × w2 = 0.73 × 0.27 × 0.110 × 0.3 ≈ 0.0065

Correction de w1 :

∆w1 = η × δ1 × e = 0.1 × 0.0065 × 2 ≈ 0.0013

w1nouveau = 0.5 + 0.0013 = 0.5013

8
 Génie Informatique et Intelligence Artificielle Machine Learning — PMC

6.4 Résumé des corrections

Poids Avant Correction Après
w2 0.300 +0.008 0.308
w1 0.500 +0.001 0.501

Définition
w2 a été plus corrigé que w1 car il est plus proche de l’erreur (couche de sortie).
C’est le principe fondamental de la rétropropagation : correction proportionnelle à
la responsabilité.

7 Implémentation en Python
Voici l’implémentation complète des 3 classes représentant un PMC :

7.1 Classe Neurone

Listing 1 – Classe Neurone

1 import math
2 import random
3

4 class Neurone :
5 def __init__ ( self , nb_entrees ) :
6 # Poids aleatoires entre -1 et 1
7 self . poids = [ random . uniform ( -1 , 1) for _ in range (
nb_entrees ) ]
8 self . biais = random . uniform ( -1 , 1)
9 self . sortie = 0 # Memorise la sortie pour la
retropropagation
10

11 def calculSortie ( self , entrees ) :

12 # Etape 1 : somme ponderee
13 v = sum ( self . poids [ i ] * entrees [ i ]
14 for i in range ( len ( self . poids ) ) ) + self . biais
15 # Etape 2 : fonction sigmoide
16 self . sortie = 1 / (1 + math . exp ( - v ) )
17 return self . sortie

7.2 Classe Couche

Listing 2 – Classe Couche

1 class Couche :
2 def __init__ ( self , nb_neurones , nb_entrees ) :
3 # Une couche = liste de neurones
4 self . neurones = [ Neurone ( nb_entrees ) for _ in range (
nb_neurones ) ]

9
 Génie Informatique et Intelligence Artificielle Machine Learning — PMC

6 def calculSortie ( self , entrees ) :

7 # Chaque neurone calcule sa propre sortie
8 return [ neurone . calculSortie ( entrees ) for neurone in self .
neurones ]

7.3 Classe PMC

Listing 3 – Classe PMC (Perceptron Multi-Couches)

1 class PMC :
2 def __init__ ( self , nb_entrees , nb_neurones_cache ,
nb_neurones_sortie ) :
3 # Couche cachee : recoit les entrees
4 self . couche_cachee = Couche ( nb_neurones_cache , nb_entrees )
5 # Couche de sortie : recoit les sorties de la couche cachee
6 self . couche_sortie = Couche ( nb_neurones_sortie ,
nb_neurones_cache )
7

8 def calculSortie ( self , entrees ) :

9 # Etape 1 : propager dans la couche cachee
10 sorties_cachees = self . couche_cachee . calculSortie ( entrees )
11 # Etape 2 : propager dans la couche de sortie
12 sorties_finales = self . couche_sortie . calculSortie (
sorties_cachees )
13 return sorties_finales
14

15 # --- Test ---

16 reseau = PMC ( nb_entrees =2 , nb_neurones_cache =3 , nb_neurones_sortie
=1)
17 entrees = [0.5 , 0.8]
18 print ( reseau . calculSortie ( entrees ) )

Attention !
Les poids sont initialisés aléatoirement et non à zéro. Si tous les poids étaient
à zéro, tous les neurones apprendraient la même chose et le réseau serait inutile
(problème de symétrie).

10
Génie Informatique et Intelligence Artificielle Machine Learning — PMC

Conclusion
Résumé général
1. Un neurone artificiel calcule une somme pondérée de ses entrées et ap-
plique une fonction d’activation.
2. Un PMC enchaîne plusieurs couches de neurones pour résoudre des pro-
blèmes complexes.
3. La propagation avant calcule les sorties couche par couche.
4. La rétropropagation corrige les poids en remontant de la sortie vers l’en-
trée, proportionnellement à la responsabilité de chaque poids.
5. Le but est de minimiser l’erreur globale ξ en répétant ce processus sur
de nombreux exemples.

11