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èle | Paramètres appris | Exemple |
|---|---|---|
| Droite y = w·x + b | 2 (w et b) | prévoir une consommation à partir de la température |
| Arbre de décision | les questions et les seuils | « écart-type > 0,097 ? » |
| k plus proches voisins | aucun : il garde les exemples | classer une mesure d’après ses voisins |
| Réseau de neurones | des centaines à des millions de poids | reconnaître des chiffres, des mots, des gestes |
1.3 Les types d’apprentissage
| Type | Données | Tâches | Exemples |
|---|---|---|---|
| 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 étiquette | regroupement (clustering), détection d’anomalies | regrouper des profils de consommation |
| Par renforcement | essais, erreurs et récompenses | prendre des décisions successives | robot 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
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,002 | 0,015 | 0,082 | repos |
| 0,996 | 0,015 | 0,064 | repos |
| 0,998 | 0,187 | 0,592 | marche |
| 0,992 | 0,176 | 0,676 | marche |
| 1,000 | 0,232 | 1,120 | vibration |
| 0,990 | 0,260 | 1,155 | vibration |
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ème | Conséquence | Remède |
|---|---|---|
| Valeurs manquantes | le modèle plante ou se trompe | supprimer la ligne ou remplacer par la moyenne ou la médiane |
| Valeurs aberrantes (capteur défaillant) | fausse l’apprentissage | filtrer, vérifier le capteur |
| Classes déséquilibrées (99 % normal, 1 % défaut) | le modèle ignore la classe rare | collecter plus de cas rares, pondérer, choisir une bonne métrique |
| Étiquettes fausses | le modèle apprend des erreurs | vérifier les étiquettes |
| Peu de données | sur-apprentissage | collecter 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.
2.4 Séparer entraînement, validation et test
| Ensemble | Rôle | Quand l’utiliser |
|---|---|---|
| Entraînement | ajuster les paramètres du modèle | pendant l’apprentissage |
| Validation | choisir les réglages (k, profondeur, taux d’apprentissage…) | pendant la mise au point, plusieurs fois |
| Test | mesurer la performance finale | une 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.
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).
Min-max : 0,000, 0,130, 0,348, 0,261, 1,000.
Centrée réduite : -1,003, -0,627, 0,000, -0,251, 1,881.
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 ?
make_pipeline(StandardScaler(), modèle) de scikit-learn).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.
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.
| Avantages | Limites |
|---|---|
| Très simple, aucun entraînement | Lent à l’utilisation (distance à tous les exemples), mémoire = tout le jeu |
| Fonctionne bien sur petits jeux | Sensible à 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.
k = 1 : rouge 0, bleu 1 → bleu.
k = 3 : rouge 2, bleu 1 → rouge.
k = 5 : rouge 2, bleu 3 → bleu.
Le résultat change avec k : un k trop petit est sensible au bruit, un k trop grand lisse trop.
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 :
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.
∂L/∂w = (2/3) × Σ (ŷ − y) × x = (2/3)(−2 − 8 − 15) = -16,667 ; ∂L/∂b = (2/3)(−2 − 4 − 5) = -7,333.
w = 0 − 0,1 × (-16,667) = 1,667 ; b = 0 − 0,1 × (-7,333) = 0,733.
Nouvelle erreur : L = 0,234 : elle a bien diminué (de 15 à 0,234).
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.
Gauche (5 A, 1 B) : G = 1 − ((5/6)² + (1/6)²) = 0,278. Droite (1 A, 3 B) : G = 1 − ((1/4)² + (3/4)²) = 0,375.
Impureté pondérée = (6/10) × 0,278 + (4/10) × 0,375 = 0,317. Gain = 0,480 − 0,317 = 0,163 : le découpage réduit l’impureté, il est utile.
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é.
Mise à jour : C₁ = moyenne de P₁ et P₂ = (1,5 ; 1,0) ; C₂ = moyenne de P₃ et P₄ = (4,5 ; 3,5).
Itération 2 : les affectations sont les mêmes : identiques, 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 :
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.
ReLU : h₁ = 0,20, h₂ = 1,10.
z = 1,2×0,20 − 0,7×1,10 − 0,3 = -0,83 ; y = σ(-0,83) = 0,304 → comme y < 0,5, le réseau répond « classe 0 ».
3.7 Comparaison des algorithmes
| Algorithme | Type | Atouts | Limites | Taille du modèle |
|---|---|---|---|---|
| k-NN | supervisé | simple, aucun entraînement | lent, sensible à l’échelle | tout le jeu de données |
| Régression linéaire | supervisé (nombre) | rapide, interprétable | ne voit que les relations linéaires | quelques paramètres |
| Régression logistique | supervisé (classes) | probabilités, rapide | frontière linéaire | quelques paramètres |
| Arbre de décision | supervisé | lisible, peu de calculs | sur-apprentissage si profond | quelques dizaines de seuils |
| k-means | non supervisé | regroupe sans étiquettes | k à choisir, groupes ronds | k centroïdes |
| Réseau de neurones | supervisé | très expressif, images et sons | beaucoup de données, boîte noire | de 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 positif | prédit négatif | |
|---|---|---|
| réel positif | VP (vrai positif) | FN (faux négatif : défaut raté) |
| réel négatif | FP (faux positif : fausse alerte) | VN (vrai négatif) |
| Métrique | Formule | Question à laquelle elle répond |
|---|---|---|
| Exactitude (accuracy) | (VP + VN) / N | Quelle proportion de réponses justes ? |
| Précision | VP / (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 ? |
| F1 | 2·P·R / (P + R) | Compromis entre précision et rappel |
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étrique | Formule | Remarque |
|---|---|---|
| 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 | √MSE | même unité que y |
| R² | 1 − Σ(ŷ − y)² / Σ(y − ȳ)² | 1 : parfait ; 0 : pas mieux que la moyenne |
4.6 Protocole de test complet
- Fixer l’objectif et la métrique avant de commencer (rappel pour une détection de panne, précision pour éviter les fausses alertes…).
- Mesurer une référence (baseline) : le modèle naïf « toujours la classe majoritaire ». Un vrai modèle doit faire mieux.
- Séparer correctement (mélange, stratification, pas de fuite de données).
- Régler sur la validation (ou par validation croisée), jamais sur le test.
- Tester une seule fois sur l’ensemble de test et rapporter la matrice de confusion.
- Tester la robustesse : bruit ajouté, autre capteur, autre jour, autres conditions.
- Tester sur la cible : mémoire, temps d’exécution, résultat identique à celui de l’ordinateur.
- 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.
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)
- Ouvre un navigateur et va sur colab.research.google.com, puis connecte-toi avec un compte Google.
- Clique sur Nouveau notebook : une page avec une cellule de code apparaît.
- 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.
- 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
- Va sur python.org, menu Downloads, et télécharge la dernière version de Python 3.
- 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.
- Ouvre l’Invite de commandes : touche Windows, tape
cmd, Entrée. - Vérifie l’installation :
python --version
Tu dois voir un numéro de version, par exemplePython 3.12.x. - Installe les bibliothèques (il faut une connexion internet) :
pip install pandas scikit-learn
- Crée un dossier
ia, puis un fichieressai.pyavec 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
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 :
| Message | Cause | Solution |
|---|---|---|
| ModuleNotFoundError: No module named 'pandas' | la bibliothèque n’est pas installée | refais pip install pandas scikit-learn |
| python n’est pas reconnu | Python n’est pas dans le PATH | utilise py, ou réinstalle en cochant « Add python.exe to PATH » |
| SyntaxError | code 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 ?
tirs_cadres → 0,65, sans possession → 0,80, sans fautes → 0,75, sans jaunes → 0,75, sans rouges → 0,80. Retirer une statistique ne change pas beaucoup le résultat ici, car plusieurs statistiques se recoupent (fautes et jaunes par exemple) et les cartons rouges sont rares (7 matchs sur 80). Attention : sur 20 matchs de test ces petites différences ne sont pas significatives.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 ?
Exactitude = (5 + 11) / 20 = 80 %. Précision = VP / (VP + FP) = 5 / 6 = 83,3 % (quand il annonce une victoire, il a raison 5 fois sur 6). Rappel = VP / (VP + FN) = 5 / 8 = 62,5 %.
Oui : il rate 3 victoires et n’en invente que 1 : il est prudent. Pour un entraîneur qui veut ne rien manquer, on baisserait le seuil de décision (chapitre 4).
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
test_size=0.3, random_state=42, stratify : 21 étudiants pour l’entraînement, 9 pour le test, exactitude de test = 1,00 (baseline 0,56). Ne te fie pas à ce chiffre : avec seulement 9 étudiants de test, il est très instable. La validation croisée donne 0,83. Coefficients : heures d’étude 0,73 (aide), absences -0,40 (nuit). L’étudiant à 8 heures et 1 absence : prédiction = réussite (probabilité 95,6 %).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.
import pandas as pd
df = pd.read_csv("E0.csv") # fichier téléchargé (les noms peuvent varier selon la saison : vérifie sur le site)
df["victoire_domicile"] = (df["FTR"] == "H").astype(int)
X = df[["HST", "AST", "HF", "AF", "HY", "AY", "HR", "AR"]]
y = df["victoire_domicile"]
# suite : train_test_split, LogisticRegression, score, comparaison à la baseline
Je ne peux pas te donner « le » résultat : il dépend du fichier que tu choisis. Points à vérifier : (1) compare toujours à la baseline (la victoire à domicile est le résultat le plus fréquent) ; (2) ces statistiques sont celles du match terminé : elles expliquent le résultat mais ne permettent pas de prédire un match avant son coup d’envoi ; (3) n’utilise pas les buts (FTHG, FTAG), qui sont le résultat lui-même (fuite de données) ; (4) le football est très imprévisible : même de bons modèles restent modestes quand on prédit avant le match.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.
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))
| k | 1 | 3 | 5 | 7 | 9 | 15 |
|---|---|---|---|---|---|---|
| exactitude moyenne | 94,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
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
| Erreur | Conséquence | Comment l’éviter |
|---|---|---|
| Normaliser avant de séparer | fuite de données | pipeline scikit-learn |
| Régler les paramètres sur le test | performance trop optimiste | validation croisée |
| Pas de graine aléatoire | résultats non reproductibles | random_state fixé |
| Juger sur l’exactitude seule | classes rares ignorées | matrice de confusion, rappel, précision |
| Trop peu de données de test | mesure imprécise | validation croisée |
| Oublier la baseline | on ne sait pas si le modèle sert à quelque chose | comparer à « 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.
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)
}
6.5 Tester le modèle sur la cible
- 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.
- Mesurer le temps : relève
HAL_GetTick()avant et aprèsclasser()(très court pour un arbre). - Mesurer la mémoire : lis la taille de la flash et de la RAM affichée par CubeIDE après la compilation.
- 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 ?
| Situation | Piste |
|---|---|
| Peu de données, besoin d’explications | arbre de décision, régression logistique |
| Prévoir un nombre à partir d’une relation simple | régression linéaire |
| Petit jeu, essai rapide | k-NN (avec normalisation) |
| Pas d’étiquettes | k-means, détection d’anomalies |
| Images, sons, signaux complexes | réseau de neurones (CNN) |
| Microcontrôleur très limité | arbre, régression, petit MLP quantifié |
7.2 Les cinq réflexes
- Comprendre les données avant l’algorithme.
- Séparer entraînement, validation et test, sans fuite de données.
- Comparer à une baseline.
- Choisir la métrique selon le coût des erreurs.
- 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.
- Collecter au moins 100 fenêtres par classe (moteur à l’arrêt, normal, vibration forte) en notant l’étiquette.
- Calculer les caractéristiques (moyenne, écart-type, crête à crête) et séparer entraînement et test (stratifié).
- Entraîner un arbre de profondeur 3, relever la matrice de confusion et comparer avec une baseline.
- Valider par validation croisée.
- Exporter en C, intégrer dans le programme de la carte et comparer les prédictions carte et ordinateur.
- Tester dans des conditions différentes et rédiger un court rapport (métriques, limites, améliorations).