Qu'est-ce que le deep learning ?

Prérequis : aucun · Notions : IA, ML, DL, modèle de fondation, paramètres, perte, types d'apprentissage

Cours

Trois cercles emboîtés

L'intelligence artificielle (IA) est le champ le plus large : tout système qui accomplit une tâche qu'on associe à l'intelligence (jouer aux échecs, traduire, reconnaître un visage). Un programme d'échecs écrit entièrement à la main avec des règles est de l'IA.

Le machine learning (ML, apprentissage automatique) est un sous-ensemble de l'IA : au lieu d'écrire les règles, on écrit un programme qui trouve les règles tout seul à partir d'exemples. On lui montre des milliers de couples (entrée, réponse attendue) et il ajuste des nombres internes jusqu'à reproduire ces réponses.

Le deep learning (DL, apprentissage profond) est un sous-ensemble du ML qui utilise des réseaux de neurones composés de nombreuses couches empilées (d'où « profond »). Chaque couche transforme les données en une représentation un peu plus abstraite : pixels → bords → formes → objets.

Les modèles de fondation sont des réseaux profonds très grands, pré-entraînés sur d'énormes quantités de données générales (texte du web, images, code), puis adaptés à de nombreuses tâches. GPT, Claude, Llama, CLIP ou Stable Diffusion en font partie. Le terme a été popularisé en 2021 par un rapport de Stanford.

Qu'est-ce qu'« apprendre » pour une machine ?

Tout le deep learning tient dans une idée. On choisit une fonction paramétrée $f_{θ}$ : une machine qui prend une entrée $x$ et produit une sortie $\hat{y} = f_{θ} (x)$ . Les paramètres $θ$ (thêta) sont des millions, voire des milliards de nombres réels qu'on peut régler, comme les potentiomètres d'une console.

On définit ensuite une fonction de perte $L$ (loss) qui mesure à quel point la sortie $\hat{y}$ est loin de la bonne réponse $y$ . Apprendre, c'est chercher les paramètres qui rendent la perte moyenne la plus petite possible sur les données :

θ^{⋆} = \arg min_{θ} \frac{1}{N} \sum_{i = 1}^{N} L (f_{θ} (x_{i}), y_{i})

Lis cette formule de droite à gauche : pour chaque exemple $i$ parmi les $N$ exemples, on calcule la prédiction $f_{θ} (x_{i})$ , on mesure l'erreur avec $L$ , on fait la moyenne, et on cherche ( $\arg min$ = « l'argument qui minimise ») le $θ$ qui rend cette moyenne minimale. $θ^{⋆}$ se lit « thêta étoile » : les meilleurs paramètres.

Il y a donc toujours trois ingrédients :

Des données : des exemples $(x_{i}, y_{i})$ , ou seulement des $x_{i}$ dans certains cas.
Un modèle : la forme de $f_{θ}$ (un réseau de neurones avec une certaine architecture).
Une perte et un optimiseur : comment mesurer l'erreur, et comment modifier $θ$ pour la réduire (la descente de gradient, bloc MATH 15.1).

Les grandes familles d'apprentissage

Supervisé : chaque exemple a une étiquette $y$ fournie par un humain (photo → « chat »).
Non supervisé : pas d'étiquette ; on cherche une structure (groupes, compression).
Auto-supervisé : on fabrique l'étiquette à partir de la donnée elle-même. Exemple : cacher le mot suivant d'une phrase et demander de le deviner. C'est le moteur des modèles de fondation, car il ne demande aucun annotateur humain et se passe donc à l'échelle d'Internet.
Par renforcement : un agent agit, reçoit une récompense, et apprend à maximiser la récompense cumulée. Utilisé pour aligner les LLM (bloc FM 15.1).

Pourquoi maintenant ?

Les idées sont anciennes : perceptron (1958), rétropropagation popularisée en 1986, réseaux convolutifs (1989). Trois choses ont changé vers 2010 : les données (Internet, ImageNet en 2009), le calcul (les GPU, conçus pour le jeu vidéo, font des multiplications de matrices en parallèle) et quelques astuces (ReLU, dropout, bonne initialisation). AlexNet gagne ImageNet en 2012, le Transformer arrive en 2017, GPT-3 en 2020 montre qu'en grandissant un modèle de langage apprend des tâches qu'on ne lui a jamais enseignées.

Schéma du coursLes ensembles emboîtés : chaque cercle est un cas particulier du précédent.

Mon schémaLe renversement : en programmation classique on écrit les règles ; en apprentissage, ce sont elles qu'on obtient.

Exemple du cours

Classer des photos de chats et de chiens. L'entrée $x$ est une image de 224×224 pixels en couleur, donc $224 \times 224 \times 3 = 150528$ nombres entre 0 et 255. La sortie voulue est une probabilité : $\hat{y} = f_{θ} (x) = P (chien ∣ x)$ .

Écrire des règles à la main est sans espoir : « si oreilles pointues alors chat » échoue sur un berger allemand. On prend plutôt 25 000 photos étiquetées, un réseau convolutif (bloc CV 2.1) de quelques millions de paramètres et la perte d'entropie croisée (bloc MATH 13.1). Après entraînement, le réseau a « découvert » ses propres règles, codées dans ses poids. Personne ne les a écrites ; elles émergent de la minimisation de la perte.

Exemple inventé

Deviner le tempo d'un morceau. Imagine que tu veux qu'un programme donne le BPM d'un fichier audio.

Approche classique : tu codes un détecteur de pics d'énergie, tu mesures l'écart moyen entre les pics, tu le convertis en BPM. Ça marche sur de la techno, ça échoue sur un morceau de jazz où la grosse caisse est discrète.
Approche ML : tu rassembles 10 000 extraits dont tu connais le BPM ( $y$ ), tu donnes le spectrogramme ( $x$ ) à un réseau $f_{θ}$ , et tu minimises l'écart $(\hat{y} - y)^{2}$ . Le réseau apprend lui-même quels indices comptent (charleston, basse, accents), y compris ceux auxquels tu n'aurais pas pensé.
Approche « fondation » : un modèle audio pré-entraîné sur des millions d'heures de musique sans étiquette sait déjà représenter le rythme ; avec 200 exemples étiquetés seulement, tu l'adaptes à ta tâche.

TP · Ta première « machine qui apprend »

On te donne des couples $(x, y)$ générés par une règle cachée $y \approx w x$ . Sans connaître $w$ , écris un programme qui essaie toutes les valeurs de $w$ entre 0 et 5 (pas de 0,01) et garde celle qui minimise l'erreur quadratique moyenne $\frac{1}{N} \sum (w x_{i} - y_{i})^{2}$ . C'est de l'apprentissage par recherche exhaustive : idiot mais exact. On verra au bloc MATH 15.1 comment faire la même chose intelligemment avec le gradient.

import numpy as np
rng = np.random.default_rng(0)
x = rng.uniform(0, 10, size=50)
y = 2.7 * x + rng.normal(0, 1, size=50)   # la règle cachée est w = 2.7
# À toi : trouve w

Solution commentée

import numpy as np
rng = np.random.default_rng(0)
x = rng.uniform(0, 10, size=50)
y = 2.7 * x + rng.normal(0, 1, size=50)

candidats = np.arange(0, 5, 0.01)          # 500 valeurs de w à tester
pertes = []
for w in candidats:
    y_pred = w * x                          # le "modèle" f_w(x) = w x
    perte = np.mean((y_pred - y) ** 2)      # erreur quadratique moyenne
    pertes.append(perte)

meilleur = candidats[np.argmin(pertes)]
print(f"w appris = {meilleur:.2f}, perte = {min(pertes):.3f}")
assert abs(meilleur - 2.7) < 0.1           # on retrouve (presque) la règle cachée

Remarque : on ne retrouve pas exactement 2,7 à cause du bruit ajouté aux données. C'est normal : le modèle trouve le meilleur $w$ pour ces données-là. Avec 1 milliard de paramètres, tester toutes les combinaisons est impossible ; c'est pourquoi on a besoin du calcul différentiel.

À retenir

IA ⊃ ML ⊃ DL ⊃ modèles de fondation.
Apprendre = trouver les paramètres $θ$ qui minimisent une perte moyenne sur des données.
Trois ingrédients : données, modèle, perte + optimiseur.
L'auto-supervision (deviner une partie cachée de la donnée) permet d'apprendre sans annotateurs : c'est ce qui rend les modèles de fondation possibles.

Deep Learning

Le paysage

Qu'est-ce que le deep learning ?

Qu'est-ce que le deep learning ?

Trois cercles emboîtés

Qu'est-ce qu'« apprendre » pour une machine ?

Les grandes familles d'apprentissage

Pourquoi maintenant ?

À retenir

Bases du machine learning

Cadre supervisé et données

Données, découpage et normalisation

Le vocabulaire des données

L'hypothèse i.i.d. et la généralisation