Les fondations du Machine Learning

Le machine learning a une réputation intimidante : des maths partout, du jargon, des équations grecques. La vérité, c'est que les idées derrière sont étonnamment intuitives, et que ce sont elles qui comptent. Une bibliothèque écrira les équations à ta place ; personne ne comprendra à ta place.

Ce cours te donne une carte mentale du domaine : ce qu'est l'apprentissage automatique, ses familles, et les mots que tout le monde emploie (« modèle », « feature », « sur-apprentissage », « métrique ») avec ce qu'ils veulent vraiment dire. Il est écrit pour toi si tu n'as jamais entraîné un modèle : ni code ni maths, seulement de la curiosité.

Un seul fil le traverse : ta boîte mail et son filtre anti-spam. Mails, chiffres et courbes des figures sont imaginés ou simulés ; ce qui est réel, ce sont les idées. Tu vas placer un seuil à la main, toucher la colonne qu'on veut prédire, tourner deux boutons, pousser un modèle jusqu'à l'absurde, et parier avant plusieurs révélations.

Qu'est-ce que le machine learning, vraiment ?

Des règles écrites à la main…

Pendant des décennies, programmer voulait dire écrire des règles. Si un mail contient beaucoup de MAJUSCULES, alors c'est un spam. L'ordinateur n'exécute, à la lettre, que ce qu'un humain a anticipé : ça marche tant qu'on sait écrire les règles et qu'elles couvrent les cas.

Voici la tienne : un indice compte les MAJUSCULES de chaque mail, et au-dessus d'un seuil, c'est un spam. Fais glisser le seuil sur ces 30 mails : combien peux-tu en classer juste, au mieux ? Puis laisse la machine chercher le sien, et teste-le sur 30 mails neufs.

Aucun seuil n'est parfait : les deux paquets se chevauchent, certains spams écrivent doucement et certains mails légitimes crient. La machine trouve le meilleur seuil en les essayant tous : 29 mails bien classés sur 30. Elle n'a reçu aucune règle, seulement des mails dont on connaissait la réponse. Mais la bande du bas raconte l'essentiel : sur 30 mails jamais vus, le même seuil n'en classe plus que 26. Et si tu as bougé le seuil en regardant ces mails neufs, tu as triché : ils ne sont plus neufs.

…ou apprendre à partir d'exemples

C'est le renversement du machine learning. En programmation classique, tu donnes à l'ordinateur des règles et des données, et il en tire des réponses. En machine learning, tu lui donnes des données et les réponses connues, et il en tire les règles : ces règles apprises forment le modèle.

Tu ne dis pas à l'ordinateur comment reconnaître un spam, ou un chat sur une photo. Tu lui montres des milliers d'exemples étiquetés, et il en déduit lui-même ce qui les distingue.

C'est comme un enfant : on ne lui récite pas la définition zoologique du chat, on pointe du doigt « ça, c'est un chat » jusqu'à ce qu'il généralise.

Pourquoi tout le monde en parle maintenant

L'idée n'est pas neuve : en juillet 1959, A. L. Samuel publie chez IBM Some Studies in Machine Learning Using the Game of Checkers, où un programme de jeu de dames sert de terrain d'étude à un programme qui apprend. Elle explose aujourd'hui parce que trois ingrédients se sont réunis :

• Les données. Le numérique produit des montagnes d'exemples (clics, photos, capteurs). Dans une messagerie, chaque clic sur « signaler comme spam » peut devenir un exemple étiqueté de plus.
• La puissance de calcul. Entraîner un modèle, c'est répéter des milliards d'opérations. Les cartes graphiques, conçues pour dessiner des images, font beaucoup de petits calculs en parallèle, ce que l'entraînement demande.
• Les algorithmes. Des décennies de recherche ont produit des méthodes de plus en plus efficaces.

Les trois grandes familles d'apprentissage

On range les méthodes en trois familles, selon ce qu'on a entre les mains : des réponses connues, aucune réponse, ou des récompenses. Identifier la famille d'un problème, c'est déjà la moitié du travail. Essaie les trois mini-démos, et demande-toi pour chacune ce que la machine a reçu avant de commencer : qu'est-ce qui manque quand on passe d'une famille à l'autre ?

Les trois démos ne reçoivent pas la même chose, et c'est toute la différence. En supervisé, tu as posé un mail nouveau et ses trois plus proches voisins ont voté : sans étiquettes, personne n'aurait voté. En non supervisé, tu as choisi le nombre de groupes et le modèle a coupé les points sans savoir lesquels : à toi de leur donner un sens. En renforcement, il n'y avait aucun exemple, seulement des essais.

L'apprentissage supervisé : prédire une réponse connue

C'est de loin la famille la plus utilisée. On dispose d'exemples étiquetés : pour chacun, on connaît la bonne réponse. Le modèle apprend le lien entre les caractéristiques d'un exemple et sa réponse, pour prédire des cas qu'il n'a jamais vus : des mails déjà marqués « spam » ou « légitime » pour juger un nouveau mail, des logements vendus pour estimer le prix d'un autre. On parle de supervisé parce qu'on peut comparer la prédiction à la vraie réponse et corriger le modèle, comme un élève qui s'entraîne avec le corrigé. Le cours L'apprentissage supervisé, de bout en bout en fait le tour complet.

L'apprentissage non supervisé : trouver de la structure

Ici, pas d'étiquettes. On donne au modèle des données brutes et on lui demande d'y trouver une structure : il ne s'agit plus de prédire, mais de découvrir. Le cas le plus courant est le clustering, qui regroupe les exemples qui se ressemblent : une messagerie peut ainsi découvrir des familles de mails (travail, newsletters, proches) que personne n'avait définies. Le cours L'apprentissage non supervisé les détaille.

L'apprentissage par renforcement : apprendre par essais et erreurs

La troisième famille est la plus différente. Pas d'exemples figés : un agent agit dans un environnement et reçoit des récompenses, et il cherche la stratégie qui en rapporte le plus sur la durée. C'est le dilemme de la démo : retourner chez le meilleur restaurant connu (exploiter), ou en tester un autre, peut-être meilleur (explorer). Le cours L'apprentissage par renforcement y revient.

Dans le reste de ce cours, on se concentre sur l'apprentissage supervisé : c'est le plus répandu et le plus directement utile.

Les briques de base

Données, exemples, features et cible

Tout part d'un jeu de données : le plus souvent, un tableau. Chaque ligne est un exemple (un mail, une maison, une transaction), chaque colonne une feature (ou variable). Et, en apprentissage supervisé, une colonne joue un rôle spécial : la cible (ou label), ce qu'on cherche à prédire.

Voici six mails décrits par quatre colonnes. Touche l'en-tête d'une colonne pour la prendre comme cible : que devient la question posée au modèle, et de quel type de problème s'agit-il ?

La cible est un choix, pas une propriété des données. La même table pose des questions très différentes, « ce mail est-il un spam ? » (une catégorie) comme « combien contient-il de liens ? » (un nombre), et ce choix décide du type de problème : cible numérique, régression ; cible en catégories, classification. Une grande partie du métier consiste aussi à construire de bonnes features : donner le nombre brut de liens, c'est bien ; signaler « expéditeur inconnu » ou « plus de cinq liens », c'est souvent mieux. Le modèle ne voit que ce qu'on lui donne.

Un modèle, c'est une fonction avec des boutons

Un modèle est une fonction : on lui donne les features d'un exemple, elle ressort une prédiction.

prédiction = modèle(features)

Cette fonction a des paramètres, des nombres qui déterminent son comportement. Au début ils sont quelconques : le modèle prédit n'importe quoi. Entraîner, c'est les ajuster pour que les prédictions collent de mieux en mieux aux vraies réponses, en réduisant une erreur (une perte).

Prenons un modèle minuscule, une droite à deux boutons, qui prédit les glaces vendues chaque jour par un petit stand selon la température. Saurais-tu régler la pente et l'ordonnée mieux que l'entraînement automatique ? Essaie à la main, puis lance « Entraîner ».

À la main, tu fais ce que fait l'entraînement, en moins efficace. Quand tu le lances, l'ordinateur ajuste les deux paramètres petit à petit dans la direction qui réduit l'erreur : c'est la descente de gradient. Remarque que l'erreur ne tombe jamais à zéro : même la meilleure droite garde environ 8 glaces d'erreur, parce que les points sont bruités et qu'une droite ne les suit pas tous. Un grand modèle, c'est la même chose avec des millions de boutons au lieu de deux.

ŷ = a · x + b

E(a, b) = √( (1/n) · Σᵢ (a · xᵢ + b − yᵢ)² )

a ← a − η · (2/n) · Σᵢ (a · xᵢ + b − yᵢ) · xᵢ
b ← b − η · (2/n) · Σᵢ (a · xᵢ + b − yᵢ)

Entraînement et test : la règle d'or

Voici sans doute l'idée la plus importante du machine learning : le but d'un modèle n'est pas d'être bon sur les exemples qu'on lui a montrés, mais sur des cas nouveaux. C'est la généralisation. Pour la mesurer honnêtement, on coupe les données en deux dès le départ :

• le jeu d'entraînement, sur lequel le modèle apprend ;
• le jeu de test, gardé de côté, qu'on ne sort qu'à la fin pour évaluer.

Évaluer un modèle sur ses données d'entraînement, c'est donner à un élève l'examen dont il a révisé les questions : il aura 20/20, et tu ne sauras pas s'il a compris ou appris par cœur. Tu l'as vu dans la première figure : 29 mails sur 30 pour ceux qui ont servi à choisir le seuil, 26 sur 30 pour les neufs. Domingos (2012) le dit sans détour : l'erreur la plus courante des débutants est de tester sur les données d'entraînement et d'avoir l'illusion du succès.

Règle d'or : on n'évalue jamais un modèle sur des données qui ont servi à l'entraîner, ni à le régler.

Le cœur du problème : généraliser

Sur-apprentissage et sous-apprentissage

Voici l'ennemi numéro un du praticien : le modèle qui brille à l'entraînement et s'effondre sur le test. Ici, le modèle est une courbe dont tu règles la complexité (son « degré »), ajustée sur dix points bruités et jugée sur douze points qu'elle n'a jamais vus. Si tu montes la complexité d'un cran à la fois, que devient l'erreur sur les points jamais vus ? Parie, puis vérifie.

Le degré 3 est le meilleur sur les points neufs (erreur d'environ 0,06). Le degré 9 passe exactement par les dix points d'entraînement, avec une erreur quasi nulle, et se trompe de près de 6 sur les points neufs : il a appris le bruit par cœur. À l'inverse, le degré 1 est une droite trop raide, mauvaise partout. Ce que tu viens de toucher, c'est le « U » de l'erreur de test, et la raison pour laquelle on ne choisit jamais un modèle sur son score d'entraînement.

Retrouve nos deux élèves. Le premier apprend tout par cœur : change une virgule à l'énoncé, il est perdu. C'est le sur-apprentissage (overfitting) : le modèle colle à ses données, bruit compris, et confond mémoriser et comprendre. Le second n'a pas assez travaillé : c'est le sous-apprentissage (underfitting), un modèle trop simple pour capter ce qui se passe.

Le compromis biais-variance

Derrière ces deux travers se cache un arbitrage. Un modèle trop simple a un fort biais : il se trompe de façon systématique, faute de souplesse. Un modèle trop complexe a une forte variance : ses prédictions partent dans tous les sens selon les données vues, car il réagit au moindre détail. Réduire l'un tend à augmenter l'autre ; on cherche le creux de la courbe d'erreur de test.

Comment on lutte, concrètement

• Plus de données : plus il y a d'exemples variés, plus il est difficile de tricher en mémorisant.
• Des modèles plus simples, ou volontairement bridés (la régularisation).
• La validation : un morceau des données d'entraînement, le jeu de validation, sert à régler le modèle sans jamais toucher au test.

Comment sait-on qu'un modèle est bon ?

Mais bon selon quoi ? Il faut un chiffre. Choisir ce chiffre, la métrique, est plus subtil qu'il n'y paraît, et s'y tromper donne des modèles qui semblent excellents tout en étant inutiles.

Mesurer une erreur

Pour chaque exemple du jeu de test, on compare la prédiction à la vraie réponse, et on agrège. Pour un nombre (un prix, des glaces vendues), on met l'écart au carré, pour que les grosses erreurs pèsent lourd et que les signes ne s'annulent pas, puis on fait la moyenne : c'est ce que mesurait la figure de la droite. Pour une catégorie (spam ou non, malade ou non), la première métrique qui vient à l'esprit est la justesse (accuracy) : la proportion de réponses correctes. C'est là qu'un piège célèbre attend les débutants.

Le piège de la justesse

Imagine un test de dépistage pour une maladie qui touche 1 personne sur 1 000. Je te propose un modèle redoutable : il répond toujours « en bonne santé ». Il a donc raison pour tous les bien-portants, et tort pour tous les malades. Avant de lancer la figure, parie : quelle part de ses réponses est juste ?

Presque toutes : 999 sur 1 000, soit 99,9 %, et pourtant ce modèle est inutile, puisqu'il ne détecte aucun malade, précisément ce qu'on lui demandait. Le détecteur, lui, en trouve 8 sur 10 mais affiche une justesse plus basse quand la maladie est rare : en changeant la rareté, tu as vu le piège se refermer, puis s'ouvrir quand la maladie devient fréquente. Ce sont les classes déséquilibrées : quand une réponse domine massivement, un modèle paresseux qui mise tout sur elle obtient un score flatteur sans rien comprendre. Le cours accéléré de Google donne le même exemple : un modèle qui prédit toujours « négatif » a 99 % de justesse quand la classe positive représente 1 % des cas.

Le même réflexe guette en régression : prédire toujours la moyenne des glaces vendues donne une erreur sans rien comprendre aux variations. C'est pourquoi on compare toujours un modèle à une baseline, une réponse volontairement bête (la classe la plus fréquente, la moyenne) qu'il doit battre pour que son gain veuille dire quelque chose.

Au-delà de la justesse

On regarde d'autres chiffres, ensemble. Le rappel : parmi les vrais spams, combien le modèle en a-t-il trouvé ? La précision : parmi ses alertes, combien étaient justes ? Il est facile d'exceller sur l'un en sacrifiant l'autre : un filtre qui range tout en spam a un rappel parfait et une précision déplorable, et tu ne retrouverais plus aucun mail important. Lequel compte le plus dépend du coût de chaque erreur. Quand un modèle rend une probabilité (« 80 % de chances que ce mail soit un spam »), on évalue la qualité de cette confiance, par exemple par le score de Brier. Le cours Évaluer un modèle : les métriques donne les outils pour choisir.

Choisir la bonne métrique fait partie du problème. Un modèle n'est jamais « bon » dans l'absolu : il est bon au regard de ce qu'on a décidé de mesurer.

Un tour des grandes familles d'algorithmes

Voici les grandes familles de tâches, en survol ; chacune mériterait son propre cours.

• La régression : prédire un nombre. Un prix, une température, des glaces vendues.
• La classification : prédire une catégorie. Spam ou légitime, chat / chien / oiseau, malade ou sain.
• Le regroupement (clustering) : regrouper sans étiquettes. Explorer des données, segmenter une clientèle.
• Les réseaux de neurones et le deep learning. Des modèles très flexibles, qui empilent des couches de calculs simples et apprennent eux-mêmes les bonnes features quand les données sont massives et complexes (images, son, texte). Le prix : beaucoup de données et de calcul, et des modèles difficiles à interpréter.

À toi de jouer : saurais-tu ranger ces situations dans la bonne famille ?

Ce que tu viens de faire est le premier réflexe d'un projet : avant de choisir un algorithme, regarder la forme de la réponse (un nombre, une catégorie, des groupes) et ce qu'on a en main (des étiquettes, rien, des récompenses). Une même donnée peut mener à deux problèmes : le prix d'un logement est une régression, mais « ce logement est-il cher ? » est une classification, et c'est la décision qu'on veut prendre qui tranche.

Penser un projet de machine learning

On a à peine parlé de code : entraîner un modèle tient en quelques lignes, car les bibliothèques font le gros du travail. La partie difficile n'est pas l'algorithme, c'est tout ce qui l'entoure. Pour un filtre anti-spam, par quoi commencerais-tu, et où t'attendrait le piège ? Touche une étape du cycle pour voir quoi te demander.

Ce cycle est une boucle, pas une ligne droite : on évalue, on apprend, on revient en arrière. Un filtre anti-spam la vit en permanence, car les expéditeurs de spam ont tendance à changer leurs messages dès qu'ils sont repérés, ce qui renvoie le projet à ses données. La compétence à développer est de piloter un projet de bout en bout : poser le problème, interroger les données, choisir la mesure, lire les résultats. Le code, les bibliothèques s'en chargent. Le jugement, c'est toi.

Ce qu'on oublie souvent

• Commence par la baseline la plus bête. Toujours « pas spam », toujours la moyenne : elle est le prix d'entrée de tout modèle, et elle bat parfois des modèles sophistiqués.
• Plus de données bat souvent un meilleur algorithme. Domingos en fait une règle de pouce : un algorithme bête avec beaucoup de données bat souvent un algorithme malin avec peu.
• Le jeu de test ne sert qu'une fois. Chaque réglage fait en le regardant le contamine, comme en bougeant le seuil sur les mails neufs. Pour régler, on garde un jeu de validation.
• Un modèle imite ses étiquettes, pas la vérité. Un mail légitime marqué spam par erreur, et il apprend l'erreur avec le reste.
• Une bonne feature vaut souvent mieux qu'un modèle plus savant. « Expéditeur inconnu » en dit plus qu'un gros modèle nourri de chiffres bruts.
• Le monde bouge. Un modèle apprend le monde à la date de ses exemples ; quand les données changent, il faut le réentraîner.

Teste-toi

Quelques questions pour vérifier ce que tu as compris, avant le vocabulaire. La raison s'affiche après chaque réponse.

Le vocabulaire en un coup d'œil

Ce qu'il faut retenir

• Le machine learning apprend des règles à partir d'exemples, là où la programmation classique les écrit à la main.
• Trois familles : supervisé (exemples étiquetés), non supervisé (trouver de la structure), renforcement (essais et récompenses).
• Un jeu de données, ce sont des exemples, des features et une cible ; la cible est un choix, qui décide du type de problème.
• Un modèle est une fonction à paramètres ; l'entraînement les ajuste pour réduire une erreur.
• Le but est la généralisation : on juge sur des données jamais vues, ni de l'entraînement ni du réglage.
• Trop simple, c'est du sous-apprentissage ; trop complexe, du sur-apprentissage.
• Choisir la métrique fait partie du problème : la justesse seule peut mentir.
• Un projet de ML est une boucle où le jugement compte plus que l'algorithme.

Pour aller plus loin

• A. L. Samuel (1959), Some Studies in Machine Learning Using the Game of Checkers, IBM Journal of Research and Development 3(3), consulté le 20 octobre 2026.
• Pedro Domingos (2012), A Few Useful Things to Know About Machine Learning, Communications of the ACM 55(10), consulté le 20 octobre 2026.
• Google, Machine Learning Crash Course : accuracy, precision and recall, mise à jour le 12 janvier 2026, consultée le 20 octobre 2026.
• Google, Machine Learning Crash Course : dividing the original dataset, mise à jour le 3 décembre 2025, consultée le 20 octobre 2026.
• scikit-learn 1.9.1, Underfitting vs. Overfitting, consulté le 20 octobre 2026.
• Richard Sutton et Andrew Barto (2018), Reinforcement Learning: An Introduction, 2ᵉ édition, MIT Press, consulté le 20 octobre 2026.