Cours 2 · 2026–2027

Apprentissage machine

Fil rougeUn seul mécanisme — sommer, activer, corriger les poids — construit tout le cours, du perceptron de 1958 aux réseaux profonds.

2.1 · Neurones biologiques

Un neurone reçoit, intègre, transmet

Dendritesreçoivent les signaux des autres neurones — les entrées Somale corps cellulaire intègre les signaux reçus — la somme Seuilsi le signal intégré dépasse un seuil, un potentiel d'action est déclenché — l'activation Axonetransmet le signal vers d'autres neurones — la sortie Synapsesla force de chaque connexion module le signal — les poids

LectureChaque élément du neurone biologique a son équivalent dans le neurone artificiel de la diapositive suivante.

2.1 · Neurones biologiques

Des neurones artificiels connectés en couches

À retenirUn réseau de neurones artificiels est une collection d'unités interconnectées appelées neurones artificiels.

2.1 · Neurones biologiques

Biologique et artificiel, point par point (1/2)

À retenirPoids = synapse, somme pondérée = intégration dans le soma.

2.1 · Neurones biologiques

Biologique et artificiel, point par point (2/2)

À retenirApprendre, dans les deux cas, c'est modifier la force des connexions.

2.1 · Neurones biologiques

Un réseau de neurones : connexions, signaux, activation

2.1 · Neurones biologiques

Ce qui s'apprend : des poids, et un seuil

À retenirLe neurone artificiel ne garde du neurone biologique qu'une idée : sommer des entrées pondérées et décider par un seuil.

2.2 · Perceptron

Le perceptron : un neurone qui apprend à classer en deux

2.2 · Perceptron

La frontière se déplace à chaque exemple

À retenirChaque erreur de classification déplace la droite ; quand plus aucun exemple n'est mal classé, l'apprentissage s'arrête.

2.2 · Perceptron

Anatomie du perceptron

À retenirEntrées pondérées, somme, fonction échelon : la sortie vaut 1 si la somme dépasse le seuil, 0 sinon.

2.2 · Perceptron · définition formelle

Les notations : exemples, caractéristiques, poids

Convention\(x_{j,0} = 1\) fait entrer le biais dans le vecteur de poids : \(w_0\) joue le rôle du seuil.

2.2 · Perceptron · algorithme

L'algorithme du perceptron en quatre étapes

À retenirPrédiction juste : \(d_j - y_j = 0\), rien ne bouge ; sinon les poids glissent vers l'exemple.

2.2 · Perceptron · activation

La fonction d'échelon décide : 1 au-dessus du seuil, 0 sinon

ConséquenceLa sortie est binaire et la fonction n'est pas dérivable au seuil : c'est ce que les réseaux multicouches abandonneront.

2.2 · Perceptron · Python

Un perceptron en NumPy : les paramètres

import numpy as np

class Perceptron:
    def __init__(self, taux_apprentissage=0.01, n_iterations=1000):
        self.taux_apprentissage = taux_apprentissage
        self.n_iterations = n_iterations
        self.poids = None
        self.biais = None

RepèreLe biais est stocké à part plutôt que comme \(w_0\) : même modèle, autre convention.

2.2 · Perceptron · Python

ajuster() : l'algorithme, ligne par ligne

class Perceptron:
    def ajuster(self, X, y):
        n_exemples, n_caracteristiques = X.shape
        self.poids = np.zeros(n_caracteristiques)
        self.biais = 0
        for _ in range(self.n_iterations):
            for i in range(n_exemples):
                ligne = X[i]
                y_calculé = np.dot(ligne, self.poids) + self.biais
                prediction = 1 if y_calculé >= 0 else 0
                erreur = y[i] - prediction
                # Mise à jour des poids et biais
                self.poids += self.taux_apprentissage * erreur * ligne
                self.biais += self.taux_apprentissage * erreur

À retenirLa ligne poids += r · erreur · ligne est toute la règle d'apprentissage du perceptron.

2.2 · Perceptron · Python

predire(), puis un essai sur six points

class Perceptron:
    def predire(self, X):
        y_calculé = np.dot(X, self.poids) + self.biais
        return np.where(y_calculé >= 0, 1, 0)

# Données d'exemple
X = np.array([[1, 1], [2, 2], [1.5, 1.5], [0, 0], [0.5, 0.5], [1, 0]])
y = np.array([1, 1, 1, 0, 0, 0])
# Création et entraînement du perceptron
perceptron = Perceptron(taux_apprentissage=0.1, n_iterations=10)
perceptron.ajuster(X, y)
# Prédiction
print(perceptron.predire(np.array([[1, 1], [0, 0]])))

LimiteLe perceptron n'apprend que des séparations linéaires : il ne peut pas résoudre XOR — d'où les couches cachées.

2.3 · Perceptron multicouches

Un MLP empile des couches entièrement connectées

DéfinitionChaque neurone d'une couche est connecté à tous les neurones de la couche suivante — d'où le nom de « réseau entièrement connecté ».

2.3 · Perceptron multicouches · initialisation

Entre deux couches : une matrice de poids et un vecteur de biais

À retenirUn réseau [3, 5, 4, 1] a 15 + 20 + 4 poids et 5 + 4 + 1 biais : 49 paramètres à apprendre.

2.3 · Perceptron multicouches · initialisation

En NumPy : une liste de matrices, une liste de vecteurs

import numpy as np

# Initialisation de la structure du réseau
couches = [3, 5, 4, 1]  # 3 entrées, 2 couches cachées de 5 et 4 neurones, 1 sortie

# Initialisation des poids et biais aléatoires
poids = [np.random.rand(couches[i], couches[i + 1]) for i in range(len(couches) - 1)]
biais = [np.random.rand(1, couches[i + 1]) for i in range(len(couches) - 1)]

2.3 · Perceptron multicouches · propagation avant

La propagation avant : combinaison linéaire, puis activation, couche après couche

2.3 · Perceptron multicouches · propagation avant

L'entrée nette d'une couche est une combinaison linéaire de la précédente

LectureUne ligne de \(a^{(l)}\) par exemple, une colonne de \(W^{(l)}\) par neurone de la couche suivante : le produit matriciel traite tout le lot d'un coup.

2.3 · Perceptron multicouches · propagation avant

ReLU dans les couches cachées, sigmoïde en sortie

À retenirLa sortie \(a^{(L)}\) est une probabilité entre 0 et 1 ; les couches cachées gardent des activations non bornées.

2.3 · Perceptron multicouches · propagation avant

Deux fonctions d'activation, deux lignes de NumPy

# Fonction d'activation Sigmoïde
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Fonction d'activation ReLU
def relu(x):
    return np.maximum(0, x)

2.3 · Perceptron multicouches · propagation avant

propagation_avant() garde toutes les activations pour la suite

# Propagation avant à travers le réseau
def propagation_avant(entree, poids, biais):
    activation = entree
    activations = [activation]  # stocke les activations de chaque couche pour le backprop
    # Propagation à travers chaque couche cachée
    for i in range(len(poids) - 1):
        z = np.dot(activation, poids[i]) + biais[i]
        activation = relu(z)  # on utilise ReLU pour les couches cachées
        activations.append(activation)
    # Couche de sortie (par ex., sigmoid pour une tâche de classification binaire)
    z = np.dot(activation, poids[-1]) + biais[-1]
    activation = sigmoid(z)
    activations.append(activation)
    return activations

2.3 · Perceptron multicouches · erreur

L'entropie croisée binaire mesure l'écart entre prédiction et étiquette

LectureSi \(y = 1\), seul \(\log \hat{y}\) compte : prédire 0,01 coûte très cher, prédire 0,99 presque rien.

2.3 · Perceptron multicouches · erreur

La perte en NumPy

# Fonction de perte (Binary Cross-Entropy)
def calcul_perte(y_pred, y_vrai):
    m = y_vrai.shape[0]
    perte = -np.sum(y_vrai * np.log(y_pred) + (1 - y_vrai) * np.log(1 - y_pred)) / m
    return perte

2.3 · Perceptron multicouches · rétropropagation

La rétropropagation remonte l'erreur de la sortie vers l'entrée

À retenirLa rétropropagation calcule le gradient de la perte par rapport à \(W\) et \(b\) ; la descente de gradient s'en sert pour les ajuster.

2.3 · Perceptron multicouches · rétropropagation

Couche de sortie : l'erreur est simplement la prédiction moins l'étiquette

Pourquoi si simpleAvec la sigmoïde en sortie et l'entropie croisée, les dérivées se simplifient exactement en \(a^{(L)} - y\).

2.3 · Perceptron multicouches · rétropropagation

Couches cachées : le delta se propage à travers les poids et la dérivée de l'activation

À retenirC'est la règle de la chaîne : chaque couche multiplie le delta reçu par ses poids, puis par la pente de sa propre activation.

2.3 · Perceptron multicouches · rétropropagation

La descente de gradient fait un pas contre le gradient

À retenir\(\alpha\) trop petit : on avance à peine ; trop grand : on dépasse le minimum. C'est le premier hyperparamètre à régler.

2.3 · Perceptron multicouches · rétropropagation

Les dérivées des deux activations

# Fonction de dérivée pour Sigmoïde et ReLU
def derivee_sigmoid(x):
    return x * (1 - x)

def derivee_relu(x):
    return np.where(x > 0, 1, 0)

2.3 · Perceptron multicouches · rétropropagation

retropropagation() : les deltas, puis la mise à jour

def retropropagation(activations, poids, biais, y_vrai, taux_apprentissage=0.01):
    # Étape 1 : Calculer le gradient de la perte pour la couche de sortie
    erreur = activations[-1] - y_vrai
    deltas = [erreur * derivee_sigmoid(activations[-1])]
    # Étape 2 : Calculer les gradients pour chaque couche cachée
    for i in reversed(range(len(poids) - 1)):
        delta = np.dot(deltas[-1], poids[i + 1].T) * derivee_relu(activations[i + 1])
        deltas.append(delta)
    # Inverser les deltas pour qu'ils correspondent à chaque couche du réseau
    deltas = deltas[::-1]
    # Mise à jour des poids et biais
    for i in range(len(poids)):
        poids[i] -= taux_apprentissage * np.dot(activations[i].T, deltas[i])
        biais[i] -= taux_apprentissage * np.sum(deltas[i], axis=0, keepdims=True)

À retenirLa liste deltas est construite de la sortie vers l'entrée, puis inversée pour s'aligner sur poids.

2.3 · Perceptron multicouches · entraînement

Entraîner, c'est répéter : avant, perte, arrière

def entrainer_mlp(X, y, couches, epochs=1000, taux_apprentissage=0.01):
    # Initialisation des poids et biais
    poids = [np.random.rand(couches[i], couches[i + 1]) for i in range(len(couches) - 1)]
    biais = [np.random.rand(1, couches[i + 1]) for i in range(len(couches) - 1)]
    # Boucle d'entraînement
    for epoch in range(epochs):
        activations = propagation_avant(X, poids, biais)      # Propagation avant
        perte = calcul_perte(activations[-1], y)               # Calcul de la perte
        retropropagation(activations, poids, biais, y, taux_apprentissage)  # Rétropropagation
        if epoch % 100 == 0:
            print(f"Epoch {epoch}, Perte: {perte:.4f}")
    return poids, biais

2.3 · Perceptron multicouches · prédiction

Prédire, c'est propager en avant et trancher à 0,5

# Fonction de prédiction
def predire(X, poids, biais):
    activations = propagation_avant(X, poids, biais)
    return activations[-1]

# puis, pour une classe :
classes = (predire(X_test, poids, biais) >= 0.5).astype(int)

2.3 · Perceptron multicouches

Les six étapes d'un MLP

À retenirPropagation avant pour prédire, rétropropagation pour corriger, et on répète : c'est tout l'entraînement d'un réseau.

2.4 · Réseaux de neurones artificiels

Trois types de couches

2.4 · Réseaux de neurones artificiels

Transformations, propagation, architecture

2.4 · Réseaux de neurones artificiels · entraînement

L'entraînement vise la généralisation, pas la mémorisation

2.4 · Réseaux de neurones artificiels · entraînement

Descente de gradient, époques, optimisation

2.4 · Réseaux de neurones artificiels · composants

Trois composants : neurones, connexions pondérées, propagation

2.4 · Réseaux de neurones artificiels · composants

Dans un neurone : somme pondérée, biais, activation

À retenirChaque neurone produit une seule sortie, envoyée à plusieurs autres neurones.

2.4 · Réseaux de neurones artificiels · composants

Les connexions portent le signal ; les poids le dosent

À retenirCette structure de connexion et de pondération permet au réseau d'apprendre des représentations complexes et d'ajuster ses paramètres pendant l'entraînement.

2.4 · Réseaux de neurones artificiels · propagation

L'entrée d'un neurone : somme des sorties des prédécesseurs, pondérées, plus un biais

2.4 · Réseaux de neurones artificiels · propagation

Quatre fonctions d'activation courantes

RôleAprès le calcul de l'entrée du neurone, la fonction d'activation introduit une non-linéarité : le réseau peut capturer des relations complexes et apprendre des modèles non linéaires.

2.4 · Fonction d'activation · fonction d'identité

Identité : la sortie est l'entrée

UsageCouche de sortie d'une régression ; empiler des couches linéaires reste linéaire.

2.4 · Fonction d'activation · pas binaire

Pas binaire : la fonction du perceptron

LimiteDérivée nulle partout et indéfinie en 0 : la descente de gradient n'a rien à suivre.

2.4 · Fonction d'activation · fonction sigmoïde

Sigmoïde : une probabilité entre 0 et 1

UsageSortie d'une classification binaire ; la dérivée s'écrit avec la sortie elle-même, d'où x * (1 - x) dans le code.

2.4 · Fonction d'activation · TanH

Tangente hyperbolique : une sigmoïde centrée en 0

UsageCouches cachées des réseaux récurrents ; sorties entre −1 et 1, moyenne nulle.

2.4 · Fonction d'activation · Rectified Linear Unit

ReLU : nulle à gauche, identité à droite

À retenirReLU dans les couches cachées, sigmoïde ou softmax en sortie : c'est le choix par défaut aujourd'hui.

2.4 · Fonction d'activation · Gaussien

Gaussienne : une bosse centrée en 0

UsageRéseaux à fonctions de base radiales (RBF) ; rare dans les réseaux profonds.

2.4 · Perceptron multiclasse

Le perceptron se généralise à plusieurs classes par un argmax

À retenirUne erreur renforce la représentation de la bonne classe et affaiblit celle de la classe prédite.

Références

Pour aller plus loin

Références · Wikipédia

Entrées Wikipédia

CréditsImages : Wikimedia Commons · Couleurs : Material Design Color Tool · Licence CC BY-SA 4.0.