Thursday, September 24, 2026

Cours Intelligence Artificielle - Fondamentaux

L’intelligence artificielle : algorithmes, méthodes, construction et test d’un modèle

Cours pour BTS EII, 2ème année : comprendre l’IA, connaître les principaux algorithmes, construire un modèle pas à pas, le tester sérieusement, puis l’embarquer sur un microcontrôleur. Chaque animation a ses boutons d’étapes, et chaque exercice a sa correction.

Chapitre 1 : Qu’est-ce que l’intelligence artificielle ?

1.1 Définitions

L’intelligence artificielle (IA) regroupe les techniques qui permettent à une machine d’accomplir des tâches qui demandent normalement de l’intelligence humaine : reconnaître une image, comprendre une phrase, prévoir une valeur, prendre une décision. Aujourd’hui, la plupart des applications utilisent l’apprentissage automatique (machine learning, ML) : au lieu d’écrire les règles à la main, on laisse la machine les déduire d’exemples. Le deep learning (DL) est une famille de ML qui utilise des réseaux de neurones à nombreuses couches.

1.2 Qu’est-ce qu’un modèle ?

Un modèle est une fonction mathématique ŷ = f(x ; θ) qui transforme une entrée x (des mesures) en une sortie ŷ (une prédiction). Les paramètres θ sont les nombres que la machine ajuste pendant l’entraînement. L’entraînement consiste à trouver les paramètres qui minimisent une fonction de coût (l’erreur entre les prédictions et les bonnes réponses).

ModèleParamètres apprisExemple
Droite y = w·x + b2 (w et b)prévoir une consommation à partir de la température
Arbre de décisionles questions et les seuils« écart-type > 0,097 ? »
k plus proches voisinsaucun : il garde les exemplesclasser une mesure d’après ses voisins
Réseau de neuronesdes centaines à des millions de poidsreconnaître des chiffres, des mots, des gestes

1.3 Les types d’apprentissage

TypeDonnéesTâchesExemples
Superviséexemples avec la bonne réponse (étiquette)classification (une catégorie), régression (un nombre)défaut / pas défaut ; température de demain
Non superviséexemples sans étiquetteregroupement (clustering), détection d’anomaliesregrouper des profils de consommation
Par renforcementessais, erreurs et récompensesprendre des décisions successivesrobot qui apprend à marcher, jeu

Dans ce cours, on étudie surtout l’apprentissage supervisé (k-NN, régressions, arbres, réseaux de neurones) et un algorithme non supervisé (k-means).

1.4 L’IA en systèmes embarqués

  • Maintenance prédictive : détecter une vibration anormale d’un moteur (accéléromètre).
  • Reconnaissance de gestes ou d’activité : marche, repos, chute (MPU6050).
  • Détection de mots clés : un micro et un petit réseau de neurones.
  • Vision : classer des images avec une caméra sur Raspberry Pi.

Contrainte principale : la mémoire et la puissance de calcul. Un modèle pour la Black Pill (128 Ko de RAM) doit tenir en quelques Ko, d’où l’intérêt des modèles simples (arbre, petit réseau) : c’est l’objet du chapitre 6.

1.5 Les étapes d’un projet d’IA

Tu préfères commencer par la pratique ? Va directement au chapitre 5 : installation des outils, puis un premier modèle très simple (prédire si une équipe de football gagne un match) construit pas à pas.

1.6 Exercices

Exercice 1.1. Pour chaque problème, indique le type d’apprentissage et la tâche : (a) prévoir la température de demain, (b) décider si une pièce est « bonne » ou « défectueuse » d’après des mesures, (c) regrouper des clients d’après leurs achats sans catégories connues, (d) un robot qui apprend à marcher en recevant une récompense à chaque pas.

Exercice 1.2. Donne la différence entre la programmation classique et l’apprentissage automatique, avec un exemple.

Exercice 1.3. Quels sont les paramètres du modèle y = 2,5·x + 1 ? Que signifie « entraîner » un modèle ?

Chapitre 2 : Les données et leur préparation

La qualité d’un modèle dépend d’abord de la qualité des données : garbage in, garbage out (données mauvaises, résultats mauvais).

2.1 Échantillons, caractéristiques, étiquettes

Un jeu de données est un tableau : chaque ligne est un échantillon, chaque colonne une caractéristique (feature) ; la dernière colonne, l’étiquette (label), est la réponse à prédire. Exemple (jeu synthétique de vibrations, 1 s de mesures à 50 Hz par fenêtre, accélération en g) :

moyenne (g)écart-type (g)crête à crête (g)classe
1,0020,0150,082repos
0,9960,0150,064repos
0,9980,1870,592marche
0,9920,1760,676marche
1,0000,2321,120vibration
0,9900,2601,155vibration

On ne donne pas au modèle les 50 mesures brutes, mais des caractéristiques calculées sur la fenêtre (moyenne, écart-type, crête à crête) : c’est l’extraction de caractéristiques, une étape clé.

2.2 Qualité des données

ProblèmeConséquenceRemède
Valeurs manquantesle modèle plante ou se trompesupprimer la ligne ou remplacer par la moyenne ou la médiane
Valeurs aberrantes (capteur défaillant)fausse l’apprentissagefiltrer, vérifier le capteur
Classes déséquilibrées (99 % normal, 1 % défaut)le modèle ignore la classe rarecollecter plus de cas rares, pondérer, choisir une bonne métrique
Étiquettes faussesle modèle apprend des erreursvérifier les étiquettes
Peu de donnéessur-apprentissagecollecter plus, simplifier le modèle

2.3 Normaliser les caractéristiques

Si une caractéristique varie de 0 à 1000 et une autre de 0 à 1, la première domine les distances (k-NN) et ralentit la descente de gradient. On ramène les caractéristiques à des échelles comparables :

  • Min-max : x′ = (x − min) / (max − min), résultat entre 0 et 1.
  • Centrée réduite (z-score) : x′ = (x − moyenne) / écart-type, résultat de moyenne 0 et d’écart-type 1.
Valeurs (séparées par des virgules)

2.4 Séparer entraînement, validation et test

EnsembleRôleQuand l’utiliser
Entraînementajuster les paramètres du modèlependant l’apprentissage
Validationchoisir les réglages (k, profondeur, taux d’apprentissage…)pendant la mise au point, plusieurs fois
Testmesurer la performance finaleune seule fois, à la fin

Répartitions courantes : 60/20/20, 70/15/15 ou 80/0/20 (avec validation croisée). On mélange avant de séparer (sauf pour les séries temporelles) et on stratifie pour garder les mêmes proportions de classes dans chaque ensemble.

Nombre d’échantillons Répartition
Fuite de données (data leakage) : si le modèle voit, même indirectement, des informations du test pendant l’entraînement, la performance mesurée est trop optimiste. Erreur classique : normaliser tout le jeu avant de séparer. Il faut calculer la moyenne et l’écart-type sur l’entraînement seul, puis les appliquer au test (une pipeline le fait automatiquement).

2.5 Exercices

Exercice 2.1. Normalise la liste des températures 12, 15, 20, 18, 35 en min-max puis en centrée réduite (écart-type de la population).

Exercice 2.2. On a 1000 échantillons. Combien dans chaque ensemble avec une répartition 70/15/15 ? Pourquoi stratifier si 5 % des échantillons sont des défauts ?

Exercice 2.3. Un élève normalise toutes ses données (moyenne et écart-type sur tout le jeu), puis sépare entraînement et test. Quel est le problème ? Comment corriger ?

Chapitre 3 : Les principaux algorithmes

3.1 k plus proches voisins (k-NN)

Principe : pour classer un nouveau point, on cherche les k exemples d’entraînement les plus proches (distance euclidienne) et on prend la classe majoritaire. Il n’y a pas d’apprentissage au sens strict : le modèle est le jeu de données.

x du point y du point k

Choix de k (validation croisée sur le jeu Iris, voir le chapitre 5) : k = 1 : 94,7 %, k = 3 : 95,3 %, k = 5 : 96,0 %, k = 7 : 96,0 %, k = 9 : 96,0 %, k = 15 : 94,0 %. Un k trop petit suit le bruit, un k trop grand lisse trop.

AvantagesLimites
Très simple, aucun entraînementLent à l’utilisation (distance à tous les exemples), mémoire = tout le jeu
Fonctionne bien sur petits jeuxSensible à l’échelle des caractéristiques : normaliser

Exercice 3.1 (k-NN à la main). Exemples : A(1 ; 1), B(2 ; 3), C(3 ; 1) en rouge ; D(5 ; 4), E(6 ; 5), F(5 ; 6) en bleu. Classe le point Q(4 ; 3) avec k = 1, k = 3 et k = 5.

3.2 Régression linéaire et descente de gradient

Modèle : ŷ = w·x + b. Coût : l’erreur quadratique moyenne MSE = (1/n) Σ (ŷᵢ − yᵢ)². Descente de gradient : on part de w = 0 et b = 0, puis on répète :

w ← w − η × ∂L/∂w        avec  ∂L/∂w = (2/n) Σ (ŷᵢ − yᵢ) × xᵢ
b ← b − η × ∂L/∂b        avec  ∂L/∂b = (2/n) Σ (ŷᵢ − yᵢ)

η (« êta ») est le pas d’apprentissage : trop petit, l’apprentissage est lent ; trop grand, il diverge. Essaie les différentes valeurs :

Pas d’apprentissage η

Exercice 3.2 (un pas de gradient). Données (1 ; 2), (2 ; 4), (3 ; 5), modèle ŷ = w·x + b, w = 0, b = 0, MSE, η = 0,1. Calcule le gradient, les nouveaux w et b, et l’erreur avant et après.

3.3 Régression logistique

Pour classer avec un modèle linéaire, on passe la somme pondérée z = w₁x₁ + w₂x₂ + b dans la sigmoïde σ(z) = 1 / (1 + e⁻ᶻ), qui donne une probabilité entre 0 et 1. Si P > 0,5 on répond « classe 1 ». La frontière de décision est une droite. L’entraînement minimise l’entropie croisée par descente de gradient.

3.4 Arbres de décision

Un arbre pose une suite de questions simples (« x ≤ 4,9 ? »). À chaque nœud, il choisit la question qui rend les deux groupes les plus purs. L’impureté de Gini d’un nœud vaut G = 1 − Σ pₖ² (pₖ : proportion de la classe k) : 0 si le nœud est pur. Un arbre trop profond mémorise le bruit : on limite sa profondeur. Augmente la profondeur et compare les exactitudes d’entraînement et de test :

Arbre réel obtenu sur le jeu Iris (profondeur maximale 3, exactitude de test 96,7 %) :

|--- larg_petale <= 0.80
|   |--- class: 0
|--- larg_petale >  0.80
|   |--- larg_petale <= 1.65
|   |   |--- long_petale <= 4.95
|   |   |   |--- class: 1
|   |   |--- long_petale >  4.95
|   |   |   |--- class: 2
|   |--- larg_petale >  1.65
|   |   |--- long_petale <= 4.85
|   |   |   |--- class: 2
|   |   |--- long_petale >  4.85
|   |   |   |--- class: 2

Importance des caractéristiques : longueur du pétale 6,1 %, largeur du pétale 93,9 %, les deux autres 0 %. L’arbre est lisible : on peut le convertir en quelques if en C (chapitre 6).

Exercice 3.3 (Gini). Un nœud contient 6 exemples de la classe A et 4 de la classe B. Calcule son impureté de Gini. Une question le sépare en (5 A, 1 B) à gauche et (1 A, 3 B) à droite : calcule l’impureté pondérée et le gain.

3.5 k-means : regrouper sans étiquettes

Algorithme non supervisé : il cherche k groupes. Étapes : (1) choisir k centroïdes au hasard ; (2) affecter chaque point au centroïde le plus proche ; (3) déplacer chaque centroïde au centre de son groupe ; (4) recommencer (2) et (3) jusqu’à ce que les affectations ne changent plus. L’inertie J (somme des carrés des distances aux centroïdes) diminue à chaque étape. Le nombre de groupes k doit être choisi (méthode du coude : on trace J selon k).

Exercice 3.4 (une itération de k-means). Points P₁(1 ; 1), P₂(2 ; 1), P₃(4 ; 3), P₄(5 ; 4) ; centroïdes initiaux C₁(1 ; 1) et C₂(5 ; 4). Fais une itération complète et dis si l’algorithme a convergé.

3.6 Réseaux de neurones

Un neurone artificiel calcule une somme pondérée de ses entrées puis applique une fonction d’activation non linéaire :

Fonctions d’activation usuelles :

Un perceptron multicouche (MLP) empile des couches de neurones : entrées → couches cachées → sortie. Voici le calcul d’une prédiction (propagation avant) sur un petit réseau 2 → 2 → 1 :

x₁ x₂

Entraînement : on mesure l’erreur de sortie, puis la rétropropagation calcule, couche par couche, la contribution de chaque poids à l’erreur (le gradient), et la descente de gradient ajuste tous les poids. Pourquoi des couches cachées ? Une droite ne sépare pas les classes d’un « XOR » (deux groupes rouges en diagonale, deux bleus en diagonale), un réseau avec une couche cachée y arrive :

Le deep learning utilise beaucoup de couches ; les réseaux convolutifs (CNN) sont adaptés aux images et aux signaux, les réseaux récurrents aux séries temporelles.

Exercice 3.5 (propagation avant). Même réseau que dans l’animation (h₁ = ReLU(0,8·x₁ + 0,4·x₂ − 0,2), h₂ = ReLU(−0,5·x₁ + 1,0·x₂ + 0,1), y = σ(1,2·h₁ − 0,7·h₂ − 0,3)). Calcule y pour x₁ = 0 et x₂ = 1, puis la classe prédite.

3.7 Comparaison des algorithmes

AlgorithmeTypeAtoutsLimitesTaille du modèle
k-NNsupervisésimple, aucun entraînementlent, sensible à l’échelletout le jeu de données
Régression linéairesupervisé (nombre)rapide, interprétablene voit que les relations linéairesquelques paramètres
Régression logistiquesupervisé (classes)probabilités, rapidefrontière linéairequelques paramètres
Arbre de décisionsupervisélisible, peu de calculssur-apprentissage si profondquelques dizaines de seuils
k-meansnon superviséregroupe sans étiquettesk à choisir, groupes rondsk centroïdes
Réseau de neuronessupervisétrès expressif, images et sonsbeaucoup de données, boîte noirede 10² à 10⁸ poids

Chapitre 4 : Évaluer et tester un modèle

Un modèle n’est utile que s’il fonctionne sur des données qu’il n’a jamais vues. Tester sérieusement, c’est mesurer cette capacité de généralisation.

4.1 Sous-apprentissage et sur-apprentissage

  • Sous-apprentissage : le modèle est trop simple, il se trompe même sur l’entraînement.
  • Sur-apprentissage : le modèle est trop souple, il mémorise le bruit : excellent à l’entraînement, mauvais au test.

Ci-dessous, on ajuste un polynôme de degré croissant à 14 points d’entraînement (pleins) ; les points vides sont des données de test :

Remèdes au sur-apprentissage : plus de données, modèle plus simple, régularisation, arrêt anticipé, moins de caractéristiques.

4.2 La matrice de confusion et les métriques

Pour une classification binaire (positif = « défaut », par exemple) :

prédit positifprédit négatif
réel positifVP (vrai positif)FN (faux négatif : défaut raté)
réel négatifFP (faux positif : fausse alerte)VN (vrai négatif)
MétriqueFormuleQuestion à laquelle elle répond
Exactitude (accuracy)(VP + VN) / NQuelle proportion de réponses justes ?
PrécisionVP / (VP + FP)Quand il annonce un défaut, a-t-il raison ?
Rappel (recall)VP / (VP + FN)Trouve-t-il tous les défauts ?
SpécificitéVN / (VN + FP)Reconnaît-il bien les cas normaux ?
F12·P·R / (P + R)Compromis entre précision et rappel
VP FP FN VN
Piège de l’exactitude : sur 1000 pièces dont 10 défectueuses, un « modèle » qui répond toujours « bonne pièce » a 99 % d’exactitude mais un rappel de 0 % : il ne détecte aucun défaut. Avec des classes déséquilibrées, regarde la précision, le rappel et la matrice de confusion.

4.3 Le seuil de décision

Un modèle de classification donne souvent un score (une probabilité) ; on déclare « positif » si le score dépasse un seuil. Abaisser le seuil augmente le rappel mais baisse la précision, et inversement :

4.4 La validation croisée

Un seul découpage entraînement/test peut être chanceux ou malchanceux, surtout avec peu de données. La validation croisée à k plis répète l’évaluation k fois en changeant le pli de test, puis fait la moyenne :

4.5 Métriques de régression

MétriqueFormuleRemarque
MAE (erreur absolue moyenne)(1/n) Σ |ŷ − y|même unité que y, facile à lire
MSE(1/n) Σ (ŷ − y)²pénalise fortement les grosses erreurs
RMSE√MSEmême unité que y
R²1 − Σ(ŷ − y)² / Σ(y − ȳ)²1 : parfait ; 0 : pas mieux que la moyenne

4.6 Protocole de test complet

  1. Fixer l’objectif et la métrique avant de commencer (rappel pour une détection de panne, précision pour éviter les fausses alertes…).
  2. Mesurer une référence (baseline) : le modèle naïf « toujours la classe majoritaire ». Un vrai modèle doit faire mieux.
  3. Séparer correctement (mélange, stratification, pas de fuite de données).
  4. Régler sur la validation (ou par validation croisée), jamais sur le test.
  5. Tester une seule fois sur l’ensemble de test et rapporter la matrice de confusion.
  6. Tester la robustesse : bruit ajouté, autre capteur, autre jour, autres conditions.
  7. Tester sur la cible : mémoire, temps d’exécution, résultat identique à celui de l’ordinateur.
  8. Surveiller en service : les données réelles dérivent avec le temps (usure, saisons).

4.7 Exercices

Exercice 4.1 (métriques). Un modèle de détection de défauts donne VP = 40, FP = 10, FN = 5, VN = 45. Calcule l’exactitude, la précision, le rappel, la spécificité et le F1.

Exercice 4.2 (classes déséquilibrées). Sur 1000 pièces dont 10 défectueuses, un modèle répond toujours « bonne ». Donne son exactitude et son rappel. Conclusion ?

Exercice 4.3 (diagnostic). Un modèle a 99 % d’exactitude sur l’entraînement et 72 % sur le test. Que se passe-t-il ? Propose trois remèdes.

Exercice 4.4 (choisir la métrique). Quelle métrique privilégier : (a) dépistage d’une maladie grave, (b) filtre anti-spam qui ne doit pas supprimer de vrais mails, (c) prévoir la consommation électrique d’un bâtiment ?

Exercice 4.5 (validation croisée). Une validation croisée à 5 plis donne 93 %, 97 %, 90 %, 95 %, 95 %. Calcule la moyenne et l’écart-type. Pourquoi est-ce plus fiable qu’un seul test ?

Chapitre 5 : Construire et tester un modèle, pas à pas

Place à la pratique ! Chaque étape est courte : tu copies le code, tu l’exécutes, tu compares avec le résultat attendu (obtenu en exécutant vraiment ce code). Tu construiras un modèle qui prédit si une équipe de football gagne un match d’après ses statistiques (tirs cadrés, possession, fautes, cartons jaunes et rouges), puis tu le modifieras toi-même.

À savoir : les 80 matchs de cet exemple sont des données inventées (synthétiques), réalistes mais fabriquées pour l’exercice. Ces statistiques sont connues pendant ou après le match : le modèle explique un résultat (on pourrait l’utiliser en direct à la mi-temps). Plus loin, tu verras pourquoi on ne peut pas utiliser le score pour prédire le résultat, et comment utiliser de vraies données.

5.1 Choisir son environnement et installer les outils

Il te faut Python et trois bibliothèques : pandas (les tableaux de données), scikit-learn (les modèles d’IA) et numpy (le calcul, installé automatiquement avec les deux autres). Choisis une des options.

Option A : Google Colab (rien à installer, le plus simple)

  1. Ouvre un navigateur et va sur colab.research.google.com, puis connecte-toi avec un compte Google.
  2. Clique sur Nouveau notebook : une page avec une cellule de code apparaît.
  3. Clique dans la cellule, colle le code, puis appuie sur Maj + Entrée (ou clique sur le bouton ▶) pour l’exécuter. Le résultat s’affiche juste dessous.
  4. Pour chaque nouvelle étape, ajoute une nouvelle cellule avec le bouton + Code.

pandas et scikit-learn sont déjà installés dans Colab.

Option B : Python sur Windows

  1. Va sur python.org, menu Downloads, et télécharge la dernière version de Python 3.
  2. Lance le fichier téléchargé. Très important : coche la case « Add python.exe to PATH » en bas de la fenêtre, puis clique sur Install Now.
  3. Ouvre l’Invite de commandes : touche Windows, tape cmd, Entrée.
  4. Vérifie l’installation :
    python --version
    Tu dois voir un numéro de version, par exemple Python 3.12.x.
  5. Installe les bibliothèques (il faut une connexion internet) :
    pip install pandas scikit-learn
  6. Crée un dossier ia, puis un fichier essai.py avec le Bloc-notes (ou VS Code). Colle le code, enregistre, puis dans l’invite de commandes :
    cd chemin\vers\le\dossier\ia
    python essai.py
Si Windows répond « python n’est pas reconnu », écris py à la place de python (py --version, py -m pip install pandas scikit-learn, py essai.py) ou réinstalle Python en cochant bien « Add python.exe to PATH ».

Option C : Linux ou Raspberry Pi

sudo apt install python3-pandas python3-sklearn
python3 --version

5.2 Vérifier que tout fonctionne

Exécute ce petit programme :

import pandas as pd
import sklearn
print("pandas", pd.__version__)
print("scikit-learn", sklearn.__version__)

Tu dois voir deux lignes avec des numéros de version (les numéros peuvent différer des miens, ce n’est pas grave). En cas d’erreur :

MessageCauseSolution
ModuleNotFoundError: No module named 'pandas'la bibliothèque n’est pas installéerefais pip install pandas scikit-learn
python n’est pas reconnuPython n’est pas dans le PATHutilise py, ou réinstalle en cochant « Add python.exe to PATH »
SyntaxErrorcode mal copié (guillemets, indentation)recopie exactement, sans modifier les espaces en début de ligne

5.3 Exemple 1 : prédire la victoire d’une équipe de football

Objectif : à partir des statistiques d’un match de notre équipe, prédire victoire (1) ou pas de victoire (0). C’est un problème de classification supervisée. Les étapes sont celles du chapitre 1 : données, séparation, entraînement, test.

Étape 1 : charger les données

Copie ce bloc dans ta première cellule (ou dans essai.py) et exécute-le. Il contient 80 matchs ; chaque ligne est un match avec : tirs_cadres, possession (en %), fautes, jaunes (cartons jaunes), rouges (cartons rouges) et victoire (1 si notre équipe a gagné, sinon 0).

import io
import pandas as pd

texte = """tirs_cadres,possession,fautes,jaunes,rouges,victoire
3,50,18,4,0,0
4,56,14,3,0,0
5,42,16,5,0,0
6,55,8,1,0,1
1,56,14,4,0,0
3,50,16,4,0,0
3,48,8,2,0,0
7,57,10,2,1,1
8,52,8,2,0,1
2,62,8,3,1,0
3,70,9,3,0,0
4,49,18,3,0,0
5,46,14,3,0,0
3,57,13,5,0,0
7,40,6,1,1,1
9,55,15,3,0,1
7,52,11,2,0,1
6,53,16,4,1,0
4,60,9,2,0,1
6,59,10,3,1,1
3,57,11,3,0,0
6,58,11,3,0,0
5,42,14,3,0,0
5,57,11,3,0,1
9,54,9,1,0,1
3,43,12,2,0,1
2,56,7,1,0,0
3,52,10,2,0,0
11,55,8,2,0,1
3,35,14,3,0,0
2,56,9,0,0,0
2,40,18,5,0,0
6,51,15,4,0,0
9,65,18,5,0,1
6,64,8,2,0,1
6,53,10,1,0,1
8,59,12,3,0,1
4,61,7,2,0,1
6,58,9,3,0,1
2,51,13,2,0,0
6,55,13,3,0,0
6,54,18,5,0,0
7,46,22,4,0,0
4,45,13,3,0,0
5,41,9,3,0,0
7,52,5,1,0,1
7,51,9,4,1,0
3,58,14,4,0,0
2,38,8,2,0,0
3,53,8,3,0,0
1,65,10,4,0,0
4,59,15,4,0,0
2,62,14,3,0,0
7,70,12,4,0,1
3,62,9,1,0,0
6,42,11,2,0,1
3,42,10,2,0,0
9,59,9,2,0,1
3,57,14,4,0,0
7,63,11,3,0,1
5,47,11,4,0,0
5,49,11,3,1,0
4,49,12,2,0,1
7,45,11,2,0,1
3,42,11,3,0,0
5,40,13,3,0,0
4,67,7,2,0,1
5,54,7,2,0,1
4,50,11,3,0,1
5,56,12,3,0,1
9,38,10,2,0,0
5,52,15,4,0,0
3,54,12,3,0,0
3,44,14,5,0,0
3,41,10,3,0,0
7,44,10,3,0,1
3,43,15,3,0,0
8,41,14,4,0,1
7,52,10,4,0,1
5,56,10,2,0,1
"""

df = pd.read_csv(io.StringIO(texte))
print(df.shape)

Résultat attendu :

(80, 6)

(80 lignes, 6 colonnes.)

Étape 2 : regarder les données

Avant tout modèle, on regarde toujours les données.

print(df.head())
print("Part de victoires :", df["victoire"].mean())

Résultat attendu :

   tirs_cadres  possession  fautes  jaunes  rouges  victoire
0            3          50      18       4       0         0
1            4          56      14       3       0         0
2            5          42      16       5       0         0
3            6          55       8       1       0         1
4            1          56      14       4       0         0
Part de victoires : 0.4125

Notre équipe gagne dans 33 matchs sur 80 (41,2 %).

Étape 3 : séparer ce qu’on connaît (X) de ce qu’on veut prédire (y)

X = df[["tirs_cadres", "possession", "fautes", "jaunes", "rouges"]]
y = df["victoire"]

X contient les 5 statistiques ; y contient la bonne réponse (la colonne victoire). Rien ne s’affiche : c’est normal.

Étape 4 : garder des matchs pour le test

On cache 25 % des matchs au modèle pour vérifier ensuite s’il sait prédire des matchs qu’il n’a jamais vus (chapitre 4).

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)
print("Entraînement :", len(X_train), "matchs, test :", len(X_test), "matchs")

Résultat attendu :

Entraînement : 60 matchs, test : 20 matchs

test_size=0.25 : 25 % pour le test. random_state=42 : mélange toujours identique (tu retrouves les mêmes résultats que moi). stratify=y : mêmes proportions de victoires dans les deux groupes.

Étape 5 : créer et entraîner le modèle

from sklearn.linear_model import LogisticRegression

modele = LogisticRegression(max_iter=1000)
modele.fit(X_train, y_train)

Trois lignes : on choisit l’algorithme (la régression logistique, chapitre 3), puis fit lance l’entraînement sur les 60 matchs. Rien ne s’affiche : le modèle a simplement appris.

Étape 6 : tester le modèle

from sklearn.metrics import confusion_matrix

print("Exactitude sur le test :", modele.score(X_test, y_test))
print("Si on répondait toujours pas de victoire :", 1 - y_test.mean())
print(confusion_matrix(y_test, modele.predict(X_test)))

Résultat attendu :

Exactitude sur le test : 0.8
Si on répondait toujours pas de victoire : 0.6
[[11  1]
 [ 3  5]]

Lecture : le modèle a raison dans 80 % des 20 matchs de test, alors qu’un modèle qui répondrait toujours « pas de victoire » aurait 60 % : le modèle apprend quelque chose d’utile. La matrice de confusion (lignes : réalité, colonnes : prédiction) dit : 11 non-victoires bien prédites, 1 fausse alerte, 3 victoires ratées, 5 victoires bien prédites.

Étape 7 : comprendre ce que le modèle a appris

for nom, coef in zip(X.columns, modele.coef_[0]):
    print(nom, round(coef, 2))

Résultat attendu :

tirs_cadres 0.95
possession 0.11
fautes -0.16
jaunes -0.74
rouges -0.38

Lecture : un nombre positif aide à gagner (les tirs cadrés), un nombre négatif nuit (les cartons jaunes et rouges). Plus le nombre est grand en valeur absolue, plus la statistique pèse. Les fautes pèsent peu directement : elles agissent surtout à travers les cartons jaunes.

Étape 8 : prédire un nouveau match

nouveau = pd.DataFrame([[8, 55, 12, 2, 0]], columns=X.columns)
print("Prédiction :", modele.predict(nouveau)[0])
print("Probabilité de victoire :", round(modele.predict_proba(nouveau)[0][1], 3))

Résultat attendu :

Prédiction : 1
Probabilité de victoire : 0.959

Un match avec 8 tirs cadrés, 55 % de possession, 12 fautes, 2 jaunes et aucun rouge : le modèle prédit une victoire (classe 1) avec une probabilité de 95,9 %.

Joue avec le modèle

Ce simulateur utilise exactement le modèle que tu viens d’entraîner. Déplace les curseurs et observe la probabilité de victoire.

Le programme complet

Après le bloc de données de l’étape 1, tout le reste tient en quelques lignes :

# (après le bloc de données de l'étape 1 : df = pd.read_csv(...))
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X = df[["tirs_cadres", "possession", "fautes", "jaunes", "rouges"]]
y = df["victoire"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)

modele = LogisticRegression(max_iter=1000)
modele.fit(X_train, y_train)
print("Exactitude sur le test :", modele.score(X_test, y_test))

5.4 À toi de jouer : modifie le modèle

Pour chaque tâche, modifie une seule chose dans ton programme, note ce que tu observes, puis ouvre la correction pour comparer avec mes résultats.

Tâche 1 : change le mélange. Remplace random_state=42 par 0, 1, 2, 3, 4, puis 5. Note l’exactitude de test à chaque fois. Que remarques-tu ?

Tâche 2 : retire une statistique. Retire une colonne de X (par exemple "rouges"), garde random_state=42 et compare l’exactitude. Fais-le pour chaque colonne : laquelle est la plus utile ?

Tâche 3 : prédis tes propres matchs. Crée trois matchs imaginaires (comme à l’étape 8) et note la prédiction : un match dominé avec beaucoup de fautes, un match équilibré, un match avec un carton rouge. Les prédictions te semblent-elles logiques ?

Tâche 4 : fais plusieurs tests d’un coup (validation croisée). Ajoute ces lignes et note la moyenne :

from sklearn.model_selection import cross_val_score
scores = cross_val_score(LogisticRegression(max_iter=1000), X, y, cv=5)
print(scores)
print("Moyenne :", scores.mean())
Pourquoi cette valeur est-elle plus fiable que la tâche 1 ?

Tâche 5 : change d’algorithme. Remplace la régression logistique par DecisionTreeClassifier(max_depth=3, random_state=0) (importer depuis sklearn.tree) puis par un k-NN (make_pipeline(StandardScaler(), KNeighborsClassifier(5))). Compare avec la validation croisée. Quel modèle choisir ?

Tâche 6 : ajoute des données. Ajoute à la fin du texte de l’étape 1 trois matchs que tu inventes (ou que tu observes vraiment) puis relance tout. Le modèle s’améliore-t-il ? Pourquoi un modèle a-t-il besoin de beaucoup de données ?

5.5 Exemple 2 : prédire le nombre de cartons jaunes (régression)

Autre type de problème : prédire un nombre (pas une catégorie). Plus une équipe commet de fautes, plus l’arbitre sort de cartons jaunes : on cherche la droite jaunes = a × fautes + b. C’est la régression linéaire du chapitre 3. On repart du même df.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error

X = df[["fautes"]]
y = df["jaunes"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

modele = LinearRegression()
modele.fit(X_train, y_train)
print("Cartons jaunes en plus par faute :", round(modele.coef_[0], 3))
print("Valeur de départ :", round(modele.intercept_, 3))
print("Prédiction pour 15 fautes :", round(modele.predict(pd.DataFrame([[15]], columns=["fautes"]))[0], 2))
print("Erreur moyenne (MAE) :", round(mean_absolute_error(y_test, modele.predict(X_test)), 3))
print("Erreur si on répond toujours la moyenne :", round(mean_absolute_error(y_test, [y_train.mean()] * len(y_test)), 3))

Résultat attendu :

Cartons jaunes en plus par faute : 0.212
Valeur de départ : 0.444
Prédiction pour 15 fautes : 3.62
Erreur moyenne (MAE) : 0.661
Erreur si on répond toujours la moyenne : 1.02

Lecture : chaque faute de plus ajoute environ 0,21 carton jaune ; pour 15 fautes le modèle annonce environ 3,6 cartons jaunes. Son erreur moyenne (MAE) est de 0,66 carton, contre 1,02 pour un modèle qui répondrait toujours la moyenne : la régression apporte donc un vrai gain. (R² = 0,57 : une bonne partie, mais pas toute, de la variation est expliquée.)

Tâche 7 (régression). Prédis le nombre de cartons jaunes pour 6 fautes et pour 22 fautes. Puis essaie de prédire "fautes" à partir de "jaunes" (on inverse X et y) : est-ce aussi bien ?

5.6 Exercices pour construire et tester un modèle

Maintenant que tu sais faire, voici des exercices pour t’entraîner. Pour chacun : (1) regarde les données, (2) sépare entraînement et test, (3) entraîne, (4) teste et compare avec une référence (la baseline), (5) conclus avec tes mots.

Exercice P1 (lire un résultat). Pour l’exemple 1, la matrice de confusion est [[11, 1], [3, 5]] (lignes : réalité, colonnes : prédiction ; victoire = positif). Calcule l’exactitude, la précision et le rappel de la victoire. Le modèle rate-t-il plus de victoires qu’il n’en invente ?

Exercice P2 (la référence). Pourquoi compare-t-on l’exactitude du modèle à 60 % ? Que penser d’un modèle qui obtiendrait 60 % ?

Exercice P3 (la fuite de données). On ajoute au tableau une colonne diff_buts (buts marqués moins buts encaissés). L’exactitude monte à 100 %. Est-ce une bonne nouvelle ?

Exercice P4 (mini-projet : réussite à l’examen). Mini-projet : prédire la réussite d’un étudiant à un examen d’après ses heures d’étude et ses absences. Les 30 étudiants ci-dessous (données inventées) ont heures_etude, absences et reussite (1 = réussi). Construis le modèle comme à l’exemple 1, calcule la baseline, mesure l’exactitude avec la validation croisée (cv=5) et prédis la réussite d’un étudiant qui a étudié 8 heures et fait 1 absence.

heures_etude,absences,reussite
3,3,0
4,0,1
9,5,1
2,1,0
6,2,1
1,2,0
5,2,1
2,1,0
8,3,1
5,1,0
7,6,0
7,3,1
4,3,0
6,7,0
2,4,0
5,6,0
6,1,1
4,2,0
6,2,1
7,0,1
3,6,0
4,5,1
6,1,1
10,4,1
7,5,0
5,4,1
4,2,0
7,5,1
7,5,1
5,0,1

Exercice P5 (vraies données de football). Télécharge un fichier de résultats d’un championnat sur football-data.co.uk (au format CSV). Les colonnes utiles : HST et AST (tirs cadrés domicile et extérieur), HF et AF (fautes), HY et AY (cartons jaunes), HR et AR (cartons rouges), FTR (résultat final : H = victoire à domicile, D = nul, A = victoire à l’extérieur). Construis un modèle qui prédit la victoire à domicile, compare-le à la baseline « toujours victoire à domicile » et conclus.

Exercice P6 (ton projet). Choisis un autre sujet qui te motive : (a) prédire si un joueur marque d’après ses tirs, (b) prédire un retard de bus d’après la météo, (c) prédire la consommation d’un appareil. Écris : la question, les colonnes (X), la colonne à prédire (y), le type de problème (classification ou régression), la métrique et la baseline.

Modèle de compte rendu de TP. (1) Question posée. (2) Données : taille, colonnes, valeurs manquantes. (3) Séparation choisie. (4) Modèle et paramètres. (5) Résultats : exactitude, baseline, matrice de confusion, validation croisée. (6) Interprétation (quelles statistiques pèsent ?). (7) Limites (peu de données ? fuite possible ?). (8) Amélioration proposée.

Pour aller plus loin

Les paragraphes suivants approfondissent : un jeu classique (Iris) avec k-NN et arbre, un jeu de capteurs (utilisé au chapitre 6) et un réseau de neurones. Ils servent surtout de référence ; passe-les si tu débutes.

5.7 Classer des fleurs (jeu Iris) avec un k-NN

Le jeu Iris contient 150 fleurs de 3 espèces, décrites par 4 mesures (longueur et largeur des sépales et des pétales).

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
import joblib

# 1. Données : X = caractéristiques, y = étiquettes (0, 1, 2)
X, y = load_iris(return_X_y=True)

# 2. Séparation : 80 % entraînement, 20 % test, mélangée et stratifiée
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# 3. Modèle : normalisation + k-NN dans une pipeline (pas de fuite de données)
modele = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5))
modele.fit(Xtr, ytr)

# 4. Évaluation sur le test
pred = modele.predict(Xte)
print("Exactitude :", accuracy_score(yte, pred))
print(confusion_matrix(yte, pred))
print(classification_report(yte, pred, target_names=["setosa", "versicolor", "virginica"]))

# 5. Validation croisée à 5 plis sur l'ensemble des données
scores = cross_val_score(make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5)), X, y, cv=5)
print("Validation croisée :", scores, "moyenne", scores.mean(), "écart-type", scores.std())

# 6. Sauvegarde du modèle
joblib.dump(modele, "iris_knn.joblib")

Résultats obtenus : 120 exemples d’entraînement, 30 de test ; exactitude = 0,9333.

Matrice de confusion (lignes : réel, colonnes : prédit)
[10, 0, 0]
[0, 10, 0]
[0, 2, 8]

              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        10
  versicolor       0.83      1.00      0.91        10
   virginica       1.00      0.80      0.89        10

    accuracy                           0.93        30
   macro avg       0.94      0.93      0.93        30
weighted avg       0.94      0.93      0.93        30

Validation croisée : [0.967, 0.967, 0.933, 0.933, 1.0]
moyenne 0.96, écart-type 0.025

Lecture : les 10 setosa et les 10 versicolor sont bien classées ; 2 virginica sur 10 sont prises pour des versicolor (rappel de 80 % pour virginica, précision de 83 % pour versicolor). Le modèle se trompe donc sur les deux espèces les plus proches. La validation croisée donne une estimation plus stable : 96,0 % ± 2,5 point.

5.8 Régler un paramètre (choisir k)

for k in (1, 3, 5, 7, 9, 15):
    s = cross_val_score(make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k)), X, y, cv=5).mean()
    print(k, round(s, 3))
k1357915
exactitude moyenne94,7 %95,3 %96,0 %96,0 %96,0 %94,0 %

La meilleure plage est k = 5 à 9 (96 %). On choisit k par validation croisée, jamais sur le test.

5.9 Un arbre de décision sur Iris

from sklearn.tree import DecisionTreeClassifier, export_text
arbre = DecisionTreeClassifier(max_depth=3, random_state=0).fit(Xtr, ytr)
print("Exactitude test :", arbre.score(Xte, yte))
print(export_text(arbre, feature_names=["long_sepale", "larg_sepale", "long_petale", "larg_petale"]))
print(arbre.feature_importances_)

Résultat : exactitude de test = 0,9667, l’arbre affiché au chapitre 3, et importances [0.0, 0.0, 0.061, 0.939]. Sans limite de profondeur, l’arbre atteint 1,000 sur l’entraînement et 0,967 sur le test : sur ce jeu simple l’écart reste faible, mais sur des données plus bruitées il grandirait (voir l’animation du chapitre 3).

5.10 Un jeu de capteurs : repos, marche ou vibration

On simule 200 fenêtres par classe d’un accéléromètre (1 s à 50 Hz) et on en extrait trois caractéristiques. Attention : les données sont synthétiques ; avec de vraies mesures tu remplacerais cette partie par ta propre collecte.

rng = np.random.default_rng(42)
t = np.arange(50) / 50.0                       # 1 seconde à 50 Hz
def caracteristiques(a):                       # a : 50 mesures d'accélération (en g)
    return [a.mean(), a.std(), a.max() - a.min()]

lignes, etiquettes = [], []
for classe in range(3):                        # 0 = repos, 1 = marche, 2 = vibration
    for _ in range(200):
        if classe == 0: a = 1.0 + rng.normal(0, 0.02, 50)
        elif classe == 1: a = 1.0 + 0.25*np.sin(2*np.pi*2*t + rng.uniform(0, 6.28)) + rng.normal(0, 0.05, 50)
        else: a = 1.0 + rng.normal(0, 0.25, 50)
        lignes.append(caracteristiques(a)); etiquettes.append(classe)

X = np.array(lignes); y = np.array(etiquettes)
Xa, Xb, ya, yb = train_test_split(X, y, test_size=0.25, random_state=1, stratify=y)
arbre = DecisionTreeClassifier(max_depth=3, random_state=0).fit(Xa, ya)
print("Exactitude test :", arbre.score(Xb, yb))
print(confusion_matrix(yb, arbre.predict(Xb)))
print(export_text(arbre, feature_names=["moyenne", "ecart_type", "crete_a_crete"], decimals=3))

Résultat : 450 fenêtres d’entraînement, 150 de test, exactitude de test = 1,00 (matrice de confusion diagonale : [[50, 0, 0], [0, 50, 0], [0, 0, 50]]).

|--- ecart_type <= 0.097
|   |--- class: 0
|--- ecart_type >  0.097
|   |--- crete_a_crete <= 0.815
|   |   |--- moyenne <= 0.972
|   |   |   |--- class: 2
|   |   |--- moyenne >  0.972
|   |   |   |--- class: 1
|   |--- crete_a_crete >  0.815
|   |   |--- class: 2
Esprit critique : 100 % de réussite est suspect. Ici les classes sont synthétiques et bien séparées : l’écart-type suffit presque à décider. Avec de vraies mesures (bruit, usure, capteur différent, orientation de la carte), les classes se chevauchent et la performance sera plus basse. Un 100 % doit toujours donner envie de vérifier la fuite de données et la difficulté réelle du problème.

5.11 Un réseau de neurones avec Keras (exemple non exécuté ici)

Pour du deep learning on utilise TensorFlow/Keras. Ce code n’a pas été exécuté dans mon environnement (TensorFlow n’y est pas installé) : lance-le par exemple sur Google Colab et vérifie les résultats.

import tensorflow as tf
from sklearn.preprocessing import StandardScaler
sc = StandardScaler().fit(Xtr)
modele = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(4,)),
    tf.keras.layers.Dense(8, activation="relu"),
    tf.keras.layers.Dense(3, activation="softmax"),
])
modele.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
histo = modele.fit(sc.transform(Xtr), ytr, epochs=200, validation_split=0.2, verbose=0)
print(modele.evaluate(sc.transform(Xte), yte))      # perte et exactitude sur le test
modele.save("iris_mlp.keras")

5.12 Erreurs fréquentes

ErreurConséquenceComment l’éviter
Normaliser avant de séparerfuite de donnéespipeline scikit-learn
Régler les paramètres sur le testperformance trop optimistevalidation croisée
Pas de graine aléatoirerésultats non reproductiblesrandom_state fixé
Juger sur l’exactitude seuleclasses rares ignoréesmatrice de confusion, rappel, précision
Trop peu de données de testmesure imprécisevalidation croisée
Oublier la baselineon ne sait pas si le modèle sert à quelque chosecomparer à « toujours la classe majoritaire »

5.13 Exercices avancés

Exercice A1. Reprends le code 5.7 et remplace le k-NN par une régression logistique (LogisticRegression(max_iter=1000)). Compare l’exactitude et la matrice de confusion. Quelle erreur retrouve-t-on le plus souvent ?

Exercice A2. Modifie test_size (0,1 puis 0,4) et random_state (0, 1, 2, 3). L’exactitude de test change-t-elle ? Que faut-il en conclure ?

Exercice A3. Avec le jeu de capteurs 5.10, que se passe-t-il si tu entraînes l’arbre avec max_depth=1 ? Et si tu ajoutes un bruit supplémentaire (par exemple un écart-type de 0,12 pour la classe « repos ») ?

Chapitre 6 : IA embarquée sur microcontrôleur (STM32 Black Pill)

La Black Pill (STM32F411) offre 512 Ko de flash, 128 Ko de RAM et un processeur Cortex-M4 avec unité de calcul flottant (FPU) à 100 MHz : suffisant pour un arbre de décision ou un petit réseau. On entraîne sur l’ordinateur, puis on exporte le modèle en C.

6.1 Combien de mémoire pour un modèle ?

Un réseau dense de tailles de couches n₀ → n₁ → … contient, pour chaque couche, nᵢ × nᵢ₊₁ poids et nᵢ₊₁ biais. Chaque paramètre occupe 4 octets en float (32 bits) ou 1 octet après quantification en int8.

Tailles des couches

6.2 Exporter un arbre de décision en C

Le script Python génère automatiquement une fonction C à partir de l’arbre du chapitre 5.10. Cette fonction a été compilée avec gcc et comparée à scikit-learn : les 150 prédictions du jeu de test sont identiques.

int classer(float moyenne, float ecart_type, float crete)
{
  if (ecart_type <= 0.0966f) {
    return 0;
  } else {
    if (crete <= 0.8152f) {
      if (moyenne <= 0.9724f) {
        return 2;
      } else {
        return 1;
      }
    } else {
      return 2;
    }
  }
}
/* Génération du code C à partir de l'arbre scikit-learn */
tr = arbre.tree_; noms = ["moyenne", "ecart_type", "crete"]; lignes = []
def rec(n, ind):
    p = "  " * ind
    if tr.children_left[n] == -1:
        lignes.append(p + "return %d;" % int(np.argmax(tr.value[n]))); return
    lignes.append(p + "if (%s <= %.4ff) {" % (noms[tr.feature[n]], tr.threshold[n])); rec(tr.children_left[n], ind + 1)
    lignes.append(p + "} else {"); rec(tr.children_right[n], ind + 1); lignes.append(p + "}")
rec(0, 1)
print("int classer(float moyenne, float ecart_type, float crete)\n{\n" + "\n".join(lignes) + "\n}")

6.3 Exporter un petit réseau de neurones en C

Réseau 4 → 8 → 3 (ReLU) entraîné sur Iris avec MLPClassifier(hidden_layer_sizes=(8,), activation="relu", max_iter=3000, random_state=0) : exactitude de test 0,9667, 67 paramètres (soit 268 octets en float32). La normalisation est intégrée à la fonction. Le code C ci-dessous a été compilé et comparé : les 30 prédictions sont identiques à celles de scikit-learn.

/* Modèle 4-8-3 entraîné avec scikit-learn (Iris) */
#define NE 4
#define NC 8
#define NS 3
static const float MOY[NE] = {5.84167f, 3.04833f, 3.77000f, 1.20500f};
static const float ECT[NE] = {0.83742f, 0.44665f, 1.76114f, 0.75948f};
static const float W1[NE][NC] = {
  {-0.12261f, 0.34280f, 0.02544f, -0.16111f, -0.26821f, 0.22473f, -0.37001f, 0.51906f},
  {0.67808f, -0.67306f, -0.36534f, -0.55610f, -0.11384f, 0.30797f, -0.10578f, -0.89632f},
  {-0.84077f, 0.90671f, 1.47189f, 0.86096f, 1.48322f, 0.64502f, -0.48701f, 0.30748f},
  {-0.69794f, 0.73138f, 0.72448f, 1.00633f, 1.00399f, -0.40676f, -0.81204f, 0.10864f}
};
static const float B1[NC] = {0.09865f, 0.43640f, -0.86472f, 0.78549f, -0.51499f, 0.53127f, 1.35351f, 1.11635f};
static const float W2[NC][NS] = {
  {0.17479f, -0.70020f, 0.02300f},
  {-1.19300f, 0.14249f, 0.49832f},
  {-0.37770f, -1.69424f, 1.00501f},
  {-0.80339f, 0.05963f, 0.13105f},
  {0.32864f, -1.14928f, 0.09767f},
  {-0.27758f, 0.26694f, -0.75201f},
  {0.57807f, -0.18020f, -1.08710f},
  {-1.07608f, 0.54422f, -0.56576f}
};
static const float B2[NS] = {-0.10421f, 0.21276f, -0.16341f};

int predire(const float x[NE])
{
  float h[NC], s[NS];
  for (int j = 0; j < NC; j++) {                    /* couche cachée : ReLU */
    float a = B1[j];
    for (int i = 0; i < NE; i++) a += ((x[i] - MOY[i]) / ECT[i]) * W1[i][j];
    h[j] = a > 0.0f ? a : 0.0f;
  }
  int best = 0;
  for (int k = 0; k < NS; k++) {                    /* couche de sortie */
    float a = B2[k];
    for (int j = 0; j < NC; j++) a += h[j] * W2[j][k];
    s[k] = a;
    if (s[k] > s[best]) best = k;                   /* argmax : pas besoin de softmax */
  }
  return best;
}

6.4 Intégration sur la Black Pill : détecter repos, marche et vibration

On réutilise le MPU6050 du chapitre 11 (I2C, adresse 0x68, sensibilité 16384 LSB/g). Toutes les 20 ms on mesure l’accélération, on remplit une fenêtre de 50 mesures (1 s), on calcule les trois caractéristiques et on appelle classer().

#include <math.h>
#define MPU_ADR (0x68 << 1)
#define N 50

/* + la fonction classer() générée à l'étape 6.2 */

float mesure_g(void)                                   // accélération totale en g
{
  uint8_t d[6];
  HAL_I2C_Mem_Read(&hi2c1, MPU_ADR, 0x3B, I2C_MEMADD_SIZE_8BIT, d, 6, 100);
  float ax = (int16_t)((d[0] << 8) | d[1]) / 16384.0f;
  float ay = (int16_t)((d[2] << 8) | d[3]) / 16384.0f;
  float az = (int16_t)((d[4] << 8) | d[5]) / 16384.0f;
  return sqrtf(ax*ax + ay*ay + az*az);
}

/* Réveiller le capteur au démarrage : registre 0x6B = 0 */
float fen[N];
while (1)
{
  for (int i = 0; i < N; i++) { fen[i] = mesure_g(); HAL_Delay(20); }   // 50 mesures = 1 s

  float somme = 0, mn = fen[0], mx = fen[0];
  for (int i = 0; i < N; i++) { somme += fen[i]; if (fen[i] < mn) mn = fen[i]; if (fen[i] > mx) mx = fen[i]; }
  float moy = somme / N, var = 0;
  for (int i = 0; i < N; i++) var += (fen[i] - moy) * (fen[i] - moy);
  float ect = sqrtf(var / N);                            // écart-type de la population, comme numpy

  int classe = classer(moy, ect, mx - mn);               // 0 repos, 1 marche, 2 vibration
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, classe == 2 ? GPIO_PIN_RESET : GPIO_PIN_SET);   // LED allumée si vibration
  printf("classe = %d\r\n", classe);                     // vers l'USART (chapitre 9)
}
Les caractéristiques calculées sur la carte doivent être exactement celles de l’entraînement (même formule d’écart-type, mêmes unités, même fréquence d’échantillonnage). Un écart de définition suffit à fausser toutes les prédictions.

6.5 Tester le modèle sur la cible

  1. Même entrées, même sorties : envoie à la carte quelques fenêtres connues (par l’USART) et compare avec les prédictions de Python.
  2. Mesurer le temps : relève HAL_GetTick() avant et après classer() (très court pour un arbre).
  3. Mesurer la mémoire : lis la taille de la flash et de la RAM affichée par CubeIDE après la compilation.
  4. Tester en conditions réelles : carte posée à plat (repos), portée en marchant, posée sur une machine qui vibre. Note les erreurs dans une matrice de confusion et compare avec celle de l’ordinateur.

6.6 Pour aller plus loin : TinyML et outils

  • Quantification : convertir les poids de float32 en int8 divise la taille par 4, au prix d’une petite perte de précision à mesurer.
  • TensorFlow Lite for Microcontrollers et STM32Cube.AI (X-CUBE-AI) convertissent un modèle Keras en code pour STM32. Leurs interfaces changent d’une version à l’autre : suis la documentation de la version installée.
  • Raspberry Pi : on peut exécuter directement le modèle sauvegardé avec joblib (Python), ou des réseaux plus gros avec TensorFlow Lite.
# Sur Raspberry Pi : charger et utiliser le modèle sauvegardé
import joblib
modele = joblib.load("iris_knn.joblib")
print(modele.predict([[5.1, 3.5, 1.4, 0.2]]))      # [0] -> setosa

6.7 Exercices

Exercice 6.1 (mémoire). Un réseau 4 → 16 → 8 → 3 : combien de paramètres, de multiplications-accumulations par prédiction ? Quelle taille en float32 et en int8 ? Tient-il dans la Black Pill (512 Ko de flash, 128 Ko de RAM) ?

Exercice 6.2 (limite). Un réseau de 250 000 paramètres convient-il à la Black Pill ? Et en int8 ?

Exercice 6.3 (arbre en C). Avec le code C du paragraphe 6.2, quelle classe renvoie classer(1.0f, 0.05f, 0.2f) ? Et classer(1.0f, 0.3f, 1.4f) ?

Exercice 6.4 (cohérence). Pourquoi la fonction classer() peut-elle donner des résultats faux sur la carte alors qu’elle est exacte sur l’ordinateur ?

Chapitre 7 : Synthèse

7.1 Quel algorithme choisir ?

SituationPiste
Peu de données, besoin d’explicationsarbre de décision, régression logistique
Prévoir un nombre à partir d’une relation simplerégression linéaire
Petit jeu, essai rapidek-NN (avec normalisation)
Pas d’étiquettesk-means, détection d’anomalies
Images, sons, signaux complexesréseau de neurones (CNN)
Microcontrôleur très limitéarbre, régression, petit MLP quantifié

7.2 Les cinq réflexes

  1. Comprendre les données avant l’algorithme.
  2. Séparer entraînement, validation et test, sans fuite de données.
  3. Comparer à une baseline.
  4. Choisir la métrique selon le coût des erreurs.
  5. Tester sur la cible dans des conditions réelles.

7.3 QCM

7.4 Projet de synthèse

Projet : détecteur de vibration pour moteur. Cahier des charges : une Black Pill et un MPU6050 doivent allumer une LED quand le moteur vibre trop.

  1. Collecter au moins 100 fenêtres par classe (moteur à l’arrêt, normal, vibration forte) en notant l’étiquette.
  2. Calculer les caractéristiques (moyenne, écart-type, crête à crête) et séparer entraînement et test (stratifié).
  3. Entraîner un arbre de profondeur 3, relever la matrice de confusion et comparer avec une baseline.
  4. Valider par validation croisée.
  5. Exporter en C, intégrer dans le programme de la carte et comparer les prédictions carte et ordinateur.
  6. Tester dans des conditions différentes et rédiger un court rapport (métriques, limites, améliorations).