Données, modèle, entraînement, inférence : les notions de base sur un seul exemple

Tout le chemin de l’apprentissage automatique sur l’estimation du prix d’un appartement : les données et leur partition, un modèle à paramètres, l’entraînement par descente de gradient, les hyperparamètres et le taux d’apprentissage, l’évaluation, l’inférence et un glossaire des termes avec des liens vers les parties de la série.

9 minutes Matěj Žalmánek 2026-10-16

Série Bases de l’IA Partie 3 sur 52

1. Carte de l’intelligence artificielle : qu’est-ce qui est quoi et comment tout s’emboîte
2. Brève histoire de l’intelligence artificielle : de Turing aux modèles de langage
3. Données, modèle, entraînement, inférence : les notions de base sur un seul exemple
4. Lire la notation mathématique : symboles, indices, sommes et quantificateurs
5. Ensembles et relations : les briques dont sont faites les définitions en IA
6. Fonctions et applications : pourquoi tout modèle d’IA est une fonction
7. Logique et démonstrations : les règles selon lesquelles on raisonne en IA
8. Graphes et arbres : la structure sur laquelle reposent la recherche et les réseaux de neurones
9. Algèbre linéaire pour l’apprentissage automatique : vecteurs, matrices et pourquoi l’IA multiplie surtout
10. Dérivées, gradient et règle de dérivation en chaîne : comment un modèle sait dans quelle direction apprendre
11. Descente de gradient : comment un modèle apprend
12. Qu’est-ce que la probabilité : du lancer de dé aux axiomes de Kolmogorov
13. Probabilité conditionnelle et théorème de Bayes : comment réviser une estimation quand on apprend du nouveau
14. Variable aléatoire et fonction de répartition : une seule fonction qui dit tout de la loi
15. Fonction de densité et fonction de masse : pourquoi une variable continue a une probabilité nulle en chaque point
16. Espérance, variance et covariance : où se situe une loi, quelle est sa largeur et ce qui varie avec quoi
17. Panorama des lois de probabilité : Bernoulli, binomiale, Poisson, uniforme, normale et exponentielle
18. Loi des grands nombres et théorème central limite : pourquoi les moyennes sont si prévisibles
19. Statistique et estimation de paramètres : maximum de vraisemblance, MAP et intervalles de confiance
20. Théorie de l’information : entropie, entropie croisée et divergence KL — d’où viennent les fonctions de perte
21. Recherche dans l’espace d’états : BFS, DFS, UCS et A* en animations
22. Jeux et adversaires : minimax, élagage alpha-bêta et Monte Carlo tree search
23. Satisfaction de contraintes : backtracking, propagation de contraintes et AC-3 sur un sudoku et une carte des régions tchèques
24. Logique et systèmes à base de connaissances : chaînage avant et arrière, résolution et systèmes experts
25. Planification : STRIPS, monde des blocs, heuristiques par relaxation et planification dans les agents IA
26. Recherche locale et recuit simulé : un voyageur de commerce à travers les chefs-lieux de région tchèques
27. Algorithmes génétiques : population, croisement, mutation et sélection sur un sac à dos de randonnée
28. Stratégies d’évolution et programmation génétique : de la règle du cinquième à la loi de Kepler
29. Optimisation par colonies de fourmis : comment une piste de phéromone trouve un chemin court
30. Optimisation par essaim de particules : inertie, expérience propre et expérience de l’essaim
31. Neuroévolution : faire évoluer les poids et la forme des réseaux de neurones, et l’algorithme NEAT
32. Ensembles flous et fonctions d’appartenance : comment écrire « un peu chaud »
33. Logique floue et probabilité : pourquoi « un peu chaud » ne veut pas dire « probablement chaud »
34. Logique floue : t-normes, implications et règles SI–ALORS
35. Commande floue : Mamdani et Sugeno, du ventilateur au pendule inversé sur un chariot
36. Clustering flou : l’algorithme fuzzy c-means et les points entre les clusters
37. Systèmes neuro-flous (ANFIS) : des règles floues qui apprennent à partir des données
38. Chaînes de Markov : matrice de transition, distribution stationnaire et PageRank
39. Modèles de Markov cachés : l’algorithme de Viterbi et le casino malhonnête
40. Réseaux bayésiens : pourquoi l’herbe est mouillée et ce que cela implique pour l’arroseur
41. Le filtre de Kalman : comment estimer, à partir de mesures imprécises, où se trouve une voiture et à quelle vitesse elle roule
42. Types d’apprentissage automatique : supervisé, non supervisé, semi-supervisé et plus
43. Prompts, contexte et RAG : comment donner au modèle les bonnes informations
44. Autoencodeurs variationnels (VAE) : de nouvelles images à partir d’un espace latent continu
45. Réseaux antagonistes génératifs (GAN) : le faussaire contre le détective
46. Modèles de diffusion : comment une image naît du bruit pur
47. Processus de décision markoviens : états, actions, récompenses et équations de Bellman
48. Q-learning et DQN : apprendre la valeur des actions, du tableau au réseau de neurones
49. Policy gradient et PPO : apprendre directement la politique
50. Comment fonctionne un agent IA : un modèle de langage en boucle avec des outils
51. Programmer avec des agents IA : consigne, tests et vérification
52. Évaluation et sécurité des systèmes d’IA : comment mesurer et comment surveiller

Programme complet de la série 52 sur 83 sujets publiés

Quatre mots reviennent tout au long de la série : données, modèle, entraînement et inférence. Qu’il s’agisse de reconnaître des chiffres, d’un filtre antispam ou d’un grand modèle de langage, le chemin est toujours le même : à partir d’exemples, on apprend une fonction qui répond ensuite à de nouvelles questions. Dans cette partie, nous parcourons tout le chemin sur le plus petit exemple possible — estimer le prix d’un appartement d’après sa surface — et, à chaque étape, nous disons à quoi cela ressemble dans les grands modèles. À la fin se trouve un glossaire des termes avec des liens vers les parties où vous en apprendrez davantage.

Cette partie fait suite à Carte de l’intelligence artificielle et à Brève histoire de l’IA.

1. Données : des exemples avec les bonnes réponses

Définition — données, caractéristiques et étiquettes

Les données sont les exemples dont le modèle apprend. Chaque exemple a des caractéristiques (les entrées que nous connaissons à son sujet) et, en apprentissage supervisé, aussi une étiquette (la bonne réponse). Les données se divisent en trois parties : entraînement (le modèle en apprend), validation (on s’en sert pour régler les paramètres de l’apprentissage et choisir le modèle) et test (utilisées une seule fois à la fin, pour que le résultat estime honnêtement comment le modèle se comportera sur de nouvelles données).

Nos données sont inventées : 60 appartements, chacun avec sa surface (la caractéristique) et son prix en millions de couronnes tchèques (l’étiquette). Le prix augmente avec la surface, mais pas exactement — deux appartements de même taille diffèrent par leur emplacement, leur état, leur étage. Nous les répartissons en 40 d’entraînement, 10 de validation et 10 de test.

Définition — un jeu de données, formellement

Un jeu de données est une suite finie de couples D = ((x⁽¹⁾, y⁽¹⁾), …, (x⁽ⁿ⁾, y⁽ⁿ⁾)), où x⁽ⁱ⁾ ∈ ℝ^d est le vecteur des d caractéristiques du i-ième exemple et y⁽ⁱ⁾ son étiquette — un nombre réel en régression, un élément d’un ensemble fini de classes en classification. On suppose que les exemples sont indépendants les uns des autres et qu’ils proviennent de la même distribution (inconnue) que les requêtes futures.

Une partition des données, ce sont trois parties disjointes D_tr, D_val, D_test qui, ensemble, forment D ; chaque exemple appartient à exactement l’une d’elles. Ici d = 1 (la surface), n = 60 et les parties comptent 40, 10 et 10 exemples.

Pour les grands modèles de langage, les données sont des milliers de milliards de tokens de texte issus du web, de livres et de code ; la caractéristique est le texte jusque-là et l’étiquette, le token suivant (la partie sur le pré-entraînement). Le principe est le même.

2. Modèle : une fonction à paramètres

Définition — modèle et paramètres

Un modèle est une fonction qui calcule une sortie à partir d’une entrée et qui contient des nombres réglables — les paramètres (dans les réseaux de neurones, les poids). La forme de la fonction, c’est nous qui la choisissons ; les valeurs des paramètres, c’est l’apprentissage qui les trouve. Notre modèle est une droite : prix = w · surface + b, avec deux paramètres, w (de combien le prix augmente à chaque mètre) et b (où la droite commence).

ŷ = w · x + b

ŷ

le prix prédit ; le chapeau le distingue du prix réel y, auquel on le compare ensuite

w

la pente — combien de millions ajoute chaque mètre supplémentaire ; sans elle, le prix ne dépendrait pas du tout de la surface

x

la surface en m², la seule caractéristique ; la seule chose que le modèle sait de l’appartement

b

l’ordonnée à l’origine — « le prix d’un appartement de surface nulle » ; sans elle, la droite devrait passer par l’origine, et les prix des appartements ne tendent pas vers zéro

3. Entraînement : régler les paramètres

Définition — fonction de perte et entraînement

La fonction de perte est un nombre qui indique à quel point le modèle se trompe sur les données d’entraînement — ici la moyenne des carrés des erreurs (MSE). L’entraînement cherche les paramètres dont la perte est la plus petite possible, le plus souvent par descente de gradient : il calcule dans quelle direction la perte augmente et déplace les paramètres d’un petit pas dans le sens opposé. Un passage sur toutes les données d’entraînement est une époque.

Notre fonction de perte, l’erreur quadratique moyenne (MSE), écrite en entier :

J(w, b) = (1/n) ∑_i=1ⁿ ( w x_i + b − y_i )²

J(w, b)

la perte comme fonction des paramètres — les données sont fixes, nous ne pouvons changer que w et b, c’est pourquoi eux seuls sont entre parenthèses

(1/n) ∑

la moyenne sur les n = 40 appartements d’entraînement — pour que la perte soit comparable entre des jeux de tailles différentes et qu’aucun appartement ne soit privilégié

w x_i + b − y_i

l’erreur sur le i-ième appartement : la prédiction ŷ_i moins le prix réel ; positive quand le modèle surestime, négative quand il sous-estime

²

le carré — pour que les erreurs positives et négatives ne s’annulent pas, que les grosses erreurs pèsent plus que les petites et que la perte se dérive sans accroc

Théorème — le gradient de la MSE pour une droite

Pour J comme ci-dessus et ŷ_i = w x_i + b, on a

∂J/∂w = (2/n) ∑_i (ŷ_i − y_i) · x_i,   ∂J/∂b = (2/n) ∑_i (ŷ_i − y_i).

Démonstration. La dérivée d’une somme est la somme des dérivées. Pour un seul terme, par la règle de dérivation des fonctions composées : ∂/∂w (w x_i + b − y_i)² = 2 (w x_i + b − y_i) · x_i, car l’intérieur de la parenthèse a pour dérivée x_i par rapport à w ; par rapport à b, sa dérivée vaut 1. ∎

Un pas de descente de gradient déplace alors les deux paramètres à l’opposé du gradient :

w ← w − η · ∂J/∂w

w

le paramètre avant et après le pas — la flèche ← signifie « remplacer par la nouvelle valeur », pas une égalité

−

nous allons à l’opposé du gradient, donc vers le bas : nous voulons réduire la perte, pas l’augmenter

η

taux d’apprentissage — la longueur du pas ; le gradient ne vaut qu’au voisinage du point, le pas doit donc être petit (voir la section suivante)

∂J/∂w

le gradient — dans quelle direction et avec quelle pente la perte augmente quand on augmente w

Tout l’entraînement sous forme d’algorithme (exactement comme le calcule la figure ci-dessous) :

w, b = 0, 0                                  # paramètres initiaux
for epocha in range(200):                    # hyperparamètre : nombre d’époques
    gw = gb = 0
    for plocha, cena in trenovaci_data:      # une époque = toutes les données
        x = plocha / 100                     # surface en centaines de m²
        chyba = (w * x + b) - cena           # ŷ − y
        gw += 2 * chyba * x / n              # ∂J/∂w
        gb += 2 * chyba / n                  # ∂J/∂b
    w, b = w - eta * gw, b - eta * gb        # pas vers le bas, eta = taux d’apprentissage

Nous entrons la surface en centaines de m² (52 m² → 0,52). En mètres, le gradient par rapport à w serait des dizaines de fois plus grand que par rapport à b, et un seul taux d’apprentissage ne conviendrait pas aux deux paramètres à la fois. Cette mise à l’échelle des caractéristiques est courante en pratique. C’est pourquoi w est exprimé ci-dessous en millions pour 100 m².

Exemple — le premier pas de la descente

Au point w = b = 0, le modèle prédit 0 partout, donc l’erreur sur chaque appartement vaut −y_i. Le gradient est donc

∂J/∂w = −2 · (1/n) ∑ x_i y_i = −2 · 5,678 = −11,36,   ∂J/∂b = −2 · ȳ = −2 · 6,88 = −13,76,

où 5,678 est la moyenne des produits de la surface (en centaines de m²) par le prix et ȳ = 6,88 le prix moyen en millions. Avec un taux d’apprentissage η = 0,5 :

w ← 0 − 0,5 · (−11,36) = 5,68,   b ← 0 − 0,5 · (−13,76) = 6,88.

(w est ici en millions pour 100 m².) La perte passe de 54,2 à 17,7. Les deux gradients étaient négatifs (le modèle sous-estimait partout), donc les deux paramètres ont augmenté.

Nous partons de w = 0 et b = 0 (le modèle dit « tout coûte zéro », perte 54,2) et faisons 200 époques de descente de gradient. Résultat : w = 0,0910 million par m², soit environ 91 000 CZK par mètre supplémentaire, et b = 0,35 million. La solution exacte par la méthode des moindres carrés (pour une droite, elle se calcule par une formule, voir la partie sur la régression linéaire) ne diffère qu’à la quatrième décimale. La descente est arrivée là où elle devait.

4. Hyperparamètres : ce que nous réglons nous-mêmes

Définition — hyperparamètres

Les hyperparamètres sont des réglages de l’apprentissage que le modèle ne peut pas apprendre lui-même et que nous choisissons : la forme et la taille du modèle, le taux d’apprentissage (la taille d’un pas de descente de gradient), le nombre d’époques, la taille du lot (batch) (le nombre d’exemples utilisés pour un pas). On les règle d’après les résultats sur les données de validation, jamais sur celles de test.

Avec un taux de 0,05, le modèle apprend lentement — après 200 époques, sa perte est de 0,48 et il n’est toujours pas arrivé. Avec 0,5, il atteint 0,165 en quelques dizaines d’époques. Avec 1,6, les pas sont si grands que le modèle saute par-dessus la vallée de plus en plus loin et la perte explose — après cinq époques, elle vaut 46 310 590. Le bon taux d’apprentissage est l’un des réglages les plus fréquents de tout l’apprentissage automatique.

Pour une droite et la MSE, on peut calculer exactement où se trouve la frontière entre « lentement » et « explose ». La perte est une fonction quadratique des paramètres, sa courbure est donc la même partout et deux nombres la décrivent — la courbure dans la direction raide et dans la direction plate de la vallée (les valeurs propres λ de la matrice hessienne, le tableau des dérivées secondes).

e_t+1 = (1 − η λ) · e_t

e_t+1

la distance des paramètres aux meilleures valeurs après l’époque suivante (dans l’une des deux directions) — c’est elle que nous voulons amener à zéro

1

sans pas, la distance resterait la même ; le pas lui retire la fraction η λ. Si |1 − η λ| < 1, la distance diminue ; si c’est plus que 1, elle croît selon une suite géométrique

η

taux d’apprentissage — la seule chose que nous choisissons ici

λ

la courbure de la perte dans la direction donnée — fixée par les données, pas par nous ; dans la direction raide, le gradient est grand, et le pas donc long

e_t

la distance avant l’époque ; la formule se répète, donc après t époques e_t = (1 − η λ)^t e₀

Théorème — quand la descente de gradient converge

Si la perte est quadratique, de matrice hessienne H dont les valeurs propres sont 0 < λ_min ≤ λ_max, alors la descente de gradient avec un taux d’apprentissage constant η converge vers le minimum depuis tout point de départ si et seulement si 0 < η < 2 / λ_max.

Démonstration. Dans les coordonnées des vecteurs propres de H, l’écart au minimum évolue composante par composante selon e_t+1 = (1 − η λ) e_t. Toutes les composantes tendent vers zéro si et seulement si |1 − η λ| < 1 pour les deux λ, c’est-à-dire 0 < η λ < 2 ; la condition la plus stricte est celle pour λ_max. ∎

Exemple — la limite pour nos appartements

Pour la MSE d’une droite, H = (2/n) · [[∑x_i², ∑x_i], [∑x_i, n]] = [[1,193, 1,435], [1,435, 2]] (surface en centaines de m²). Les valeurs propres valent λ_max = 3,087 et λ_min = 0,106, donc la descente converge pour η < 2 / 3,087 = 0,648.

η = 0,05 : le multiplicateur dans la direction plate est 1 − 0,05 · 0,106 = 0,9947 ; après 200 époques, il reste 0,9947²⁰⁰ ≈ 35 % de l’écart initial — c’est pourquoi le modèle n’est pas arrivé.

η = 0,5 : les multiplicateurs sont 0,544 et 0,947 ; après 200 époques, il reste 0,947²⁰⁰ ≈ 2 · 10⁻⁵ de l’écart — pratiquement rien.

η = 1,6 > 0,648 : dans la direction raide, |1 − 1,6 · 3,087| = 3,94. L’écart est à peu près multiplié par quatre à chaque époque, et la perte, qui croît avec son carré, par 15,5 — sur le graphique, de 801 à 12 395.

5. Le modèle est-il bon ?

L’erreur sur une partie quelconque des données D′ de m exemples se mesure par la racine de l’erreur quadratique moyenne (RMSE) :

RMSE = √(1/m) ∑_{(x, y) ∈ D′} (ŷ(x) − y)²

√

la racine ramène le résultat des (M CZK)² aux millions de couronnes — le nombre se lit comme l’« erreur typique »

(1/m) ∑_D′

la moyenne sur la partie choisie — entraînement, validation ou test ; chacune répond à une autre question

(ŷ(x) − y)²

le carré de l’erreur sur un appartement, comme dans la perte — nous mesurons avec ce que nous avons minimisé

L’erreur moyenne (la racine de la MSE) est de 0,41 million sur les données d’entraînement, 0,60 sur celles de validation et 0,51 million sur celles de test, soit environ un demi-million de couronnes. Avec une seule caractéristique, on ne peut pas faire mieux : le bruit que nous avons ajouté aux prix (emplacement, état) a exactement cette ampleur et ne se devine pas à partir de la surface. Qui veut une estimation plus précise a besoin de plus de caractéristiques — pas d’une droite plus maligne. Si, à l’inverse, nous rendions le modèle trop souple, il apprendrait par cœur le bruit des données d’entraînement (surapprentissage) et se tromperait davantage sur de nouveaux appartements.

6. Inférence : le modèle en service

Définition — inférence

L’inférence est l’utilisation d’un modèle entraîné : les paramètres sont fixes et le modèle ne fait que calculer la sortie pour une nouvelle entrée. Il n’apprend pas pendant ce temps (sauf si nous le ré-entraînons explicitement). Pour les modèles de langage, chaque réponse est une inférence — le modèle génère token après token et, pour chaque token, effectue un passage dans le réseau.

Pour un appartement de 65 m², notre modèle estime 6,27 millions. Cela coûte 3 opérations arithmétiques. L’entraînement en a coûté environ 72 000. Pour les grands modèles, le rapport est semblable, seulement à une autre échelle : l’entraînement dure des mois sur des milliers de cartes graphiques, une réponse quelques secondes. Mais les réponses se comptent par milliards, si bien que pour les modèles les plus utilisés l’inférence peut, au total, coûter plus de calcul que leur entraînement — d’où tous les efforts pour rendre les modèles plus petits et plus rapides.

Exemple — inférence et nombre d’opérations

Nous substituons les paramètres appris w = 9,0957 millions pour 100 m² (soit 0,0910 par m²) et b = 0,3538 ; la surface en centaines de m², x = 0,65 :

ŷ = 9,0957 · 0,65 + 0,3538 = 5,9122 + 0,3538 = 6,2660 ≈ 6,27 millions.

Cela fait 3 opérations : une conversion d’unités (division par cent), une multiplication et une addition. Une époque d’entraînement fait, pour chacun des 40 appartements, une prédiction, une erreur et les deux contributions au gradient — nous comptons environ 9 opérations par appartement (le nombre exact dépend de ce que l’on considère comme une opération), soit 40 · 9 · 200 = 72 000 opérations pour tout l’entraînement. Le rapport entraînement : une prédiction est de 24 000 : 1.

7. Glossaire

Les termes de cette partie et où, dans la série, vous en apprendrez davantage :

données

les exemples dont le modèle apprend — ici 60 appartements avec leur surface et leur prix — en détail

caractéristique

une donnée d’entrée qui décrit un exemple (la surface) ; une image a des milliers de caractéristiques — ses pixels — en détail

étiquette

la bonne réponse que l’on veut prédire (le prix) — en détail

données d’entraînement, de validation et de test

le modèle apprend sur les premières, on règle les paramètres de l’apprentissage sur les deuxièmes, les troisièmes ne servent qu’une fois, à la fin — en détail

modèle

une fonction à paramètres réglables qui calcule une sortie à partir d’une entrée — en détail

paramètre (poids)

un nombre à l’intérieur du modèle, qui est appris ; les modèles de langage en ont des milliards — en détail

fonction de perte

un nombre qui mesure à quel point le modèle se trompe ; l’apprentissage le réduit — en détail

entraînement (apprentissage)

la recherche de paramètres pour lesquels la perte sur les données d’entraînement est faible — en détail

gradient

la direction dans laquelle la perte croît le plus vite ; l’entraînement va dans le sens opposé — en détail

époque

un passage sur toutes les données d’entraînement — en détail

lot (batch)

le nombre d’exemples utilisés pour un pas d’apprentissage — en détail

hyperparamètre

un réglage que nous choisissons nous-mêmes et que le modèle n’apprend pas (taux d’apprentissage, nombre d’époques, taille du modèle) — en détail

surapprentissage

le modèle apprend par cœur les données d’entraînement et échoue sur de nouvelles données — en détail

inférence

l’utilisation d’un modèle entraîné sur une nouvelle entrée — ce qui se passe quand vous interrogez un chatbot — en détail

token

un morceau de texte avec lequel travaille un modèle de langage — en détail

embedding

un vecteur de nombres qui représente un mot, une image ou un autre objet — en détail

contexte et prompt

tout le texte que le modèle reçoit lors de l’inférence — en détail

8. Résumé

• Données = exemples avec caractéristiques et étiquettes, répartis en une partie d’entraînement, une de validation et une de test.
• Modèle = fonction à paramètres ; l’entraînement cherche les paramètres de plus petite perte, typiquement par descente de gradient.
• Notre modèle a appris 91 000 CZK par m² — comme le calcul exact.
• Les hyperparamètres, c’est nous qui les choisissons : avec un petit taux d’apprentissage, l’entraînement est lent ; avec un grand, il s’effondre.
• L’erreur sur le test (0,51 million) correspond au bruit des données ; un meilleur modèle a besoin de plus de caractéristiques.
• Inférence = utilisation d’un modèle entraîné ; elle est bon marché par requête, mais les requêtes sont innombrables.

Envie de mettre la main à la pâte ? Demandez à un agent IA de télécharger des données réelles sur les prix des appartements dans votre ville, de les répartir en trois parties et d’entraîner la même droite — puis d’ajouter une deuxième caractéristique (par exemple la distance au centre) et de comparer l’erreur sur le test.

Vous voyez les choses autrement ? Écrivez à support@coden-app.com.